Library

Representing an entanglement analyzed Bell diagonal state.

• coordState: The analyzed CoordState
• kernel: true if kernel check successful, else false. missing if entanglement check not applied.
• spinrep: true if spinrep check successful, else false. missing if entanglement check not applied.
• ppt: true if ppt check successful, else false. missing if entanglement check not applied.
• realign: true if realignment check successful, else false. missing if entanglement check not applied.
• concurrence: true if concurrence check successful, else false. missing if entanglement check not applied.
• mub: true if mub check successful, else false. missing if entanglement check not applied.
• numericEW: true if numericEW check successful, else false. missing if entanglement check not applied.

Specification which entanglement checks to use.

• kernel_check
• spinrep_check
• ppt_check
• realignment_check
• concurrenceqpcheck
• mub_check
• numericewcheck
• useSymmetries

Represents an entanglement witness $W$ with extrema to detect entangled Bell diagonal states.

• coords: Coordinates in Bell basis.
• upperBound: Upper bound of $tr W \rho$ satisfied by all separable states $\rho$. Violation detects entanglement.
• lowerBound: Lower bound of $tr W \rho$ satisfied by all separable states $\rho$. Violation detects entanglement.
• checkedIterations: Number of iterations used in the optimization of bounds.

Exception for conflicts in analysis results.

• state: The AnalysedCoordState for which a conflict occurs.

Represents a Bell diagonal state in Bell basis.

• coords: Coordinates in Bell basis.
• eClass: Entanglement class of the represented state.

Represents a Bell diagonal state.

• coords: Coordinates in Bell basis.
• densityMatrix: Hermitian density matrix in computational basis.
• eClass: Entanglement class of the represented state.

Represents a Bell basis related to Weyl operators.

• basis: Array with elements containing Bell basis density matrices, Weyl- and flat indices.

analyse_coordstate(
    d,
    coordState::CoordState,
    anaSpec::AnalysisSpecification,
    stdBasis::StandardBasis=missing,
    kernelPolytope::Union{HPolytope{Float64,Array{Float64,1}},VPolytope{Float64,Array{Float64,1}},Missing}=missing,
    bipartiteWeylBasis::Union{Vector{Array{Complex{Float64},2}},Missing}=missing,
    dictionaries::Union{Any,Missing}=missing,
    mubSet::Union{Vector{Vector{Vector{ComplexF64}}},Missing}=missing,
    boundedEWs::Union{Array{BoundedCoordEW},Missing}=missing,
    precision=10,
    relUncertainity=0.0
)

Return an AnalysedCoordState for a coordState in d dimensions based on the given anaSpec and corresponding analysis objects.

If an entanglement check should not be carried out or if an analysis object in not passed as variable, the corresponding property in anaSpec needs to be false. In this case, return the corresponding property of the AnalysedCoordState as missing.

classify_analyzed_states!(anaCoordStates::Array{AnalysedCoordState})

Set entanglement class for array of analysedCoordStates.

create_bipartite_weyloperator_basis(d)

Return vector of length $d^4$, containing the product basis of two Weyl operator bases as basis for the $(d^2,d^2)$ matrix space.

create_densitystate(coordState::CoordState, standardBasis::StandardBasis)

Return DensityStatecontaining the density matrix in computational basis based oncoordStatecoordinates in BellstandardBasis`.

create_dictionary_from_basis(stdBasis)

Return vector containing a dictionary and it's inverse, relating the $d^2$ flat indices to the double indices of stdBasis.

create_kernel_polytope(d, standardBasis::StandardBasis)

Return LazySets.HPolytope representation of the kernel polytope for dimension d and Bell basis standardBasis.

create_random_bounded_ews(
    d,
    standardBasis::StandardBasis,
    n,
    sphericalOnly::Bool,
    iterations::Integer,
    method=Optim.NelderMead,
    useConstrainedOpt=false
)

Return array of n BoundedEW with $d^2$ standardBasis coordinates uniformly distributed in [-1, 1] if sphericalOnly is false or uniformly distributed on unit sphere otherwise.

Use iterations runs to improve optimizatio with Optim.jl optimization method method.

create_random_coordstates(nSamples, d, object=:magicSimplex, precision=10, roundToSteps::Int=0, nTriesMax=10000000)

Return an array of nSamples $d^2$ dimensional CoordStates.

Use the object to specify the coordinate ranges to [0,1] for 'magicSimplex' or [0, 1/d] for 'enclosurePolytope'. If roundToSteps > 0, round the coordinates to the vertices that divide the range in roundToSteps` equally sized sections. Be aware that the resulting distribution of points is generally not uniform.

create_standard_indexbasis(d, precision)

Return indexed Bell basis for d dimensions as StandardBasis rounded to precision digits.

create_standard_mub(d)

Return vector of mutually unbiased bases for dimensions d three or four.

extend_vpolytope_by_densitystates(
    sepPolytope::VPolytope{Float64,Array{Float64,1}},
    sepDensityStates::Array{DensityState},
    precision::Integer
)

Return an extended Lazysets.VPolytope representation of polytope of separable states based on given polytope sepPolytope and new separable sepDensityStates as new vertices.

generate_symmetries(stdBasis::StandardBasis, d, orderLimit=0)

Return array of Permutations.Permutation of all symmetries up to order orderLimit in d dimensions generated by the generators represented in standardBasis.

get_bounded_coordew(bEw::BoundedEW)::BoundedCoordEW

Map BoundedEW bEw to corresponding BoundedCoordEW.

get_symcoords(coords::Array{Float64,1}, symPermutations::Array{Permutation})

Return array containing all symmetric Bell coordinates of given symmetries symPermutations applied to Bell coordinates coords.

sym_analyse_coordstate(
    d,
    coordState::CoordState,
    symmetries::Array{Permutation},
    anaSpec::AnalysisSpecification,
    stdBasis::StandardBasis=missing,
    kernelPolytope::Union{HPolytope{Float64,Array{Float64,1}},VPolytope{Float64,Array{Float64,1}},Missing}=missing,
    bipartiteWeylBasis::Union{Vector{Array{Complex{Float64},2}},Missing}=missing,
    dictionaries::Union{Any,Missing}=missing,
    mubSet::Union{Vector{Vector{Vector{ComplexF64}}},Missing}=missing,
    boundedCoordEWs::Union{Array{BoundedCoordEW},Missing}=missing,
    precision=10,
    relUncertainity=0.0
)

Return an AnalysedCoordState for a coordState in d dimensions based on the given anaSpec and corresponding analysis objects and symmetry analysis.

If an entanglement check should not be carried out or if an analysis object in not passed as variable, the corresponding property in anaSpec needs to be false. In this case, return the corresponding property of the AnalysedCoordState as missing.

uniform_bell_sampler(n, d, object=:magicSimplex, precision=10)

Create array of n uniformly distributed $d^2$ Bell diagonal states represented as CoordState rounded to precision digits.

Use object=:enclosurePolytope to create CoordStates in the enclosure polytope, having all $coords \leq 1/d$.

Represents an entanglement witness $W$ with extrema and extremizers to detect entangled Bell diagonal states.

• coords: Coordinates in Bell basis.
• upperBound: Upper bound of $tr W \rho$ satisfied by all separable states $\rho$. Violation detects entanglement.
• lowerBound: Lower bound of $tr W \rho$ satisfied by all separable states $\rho$. Violation detects entanglement.
• maximizingDensityMatrix: Density matrix of separable state $\rho$ in computational basis, maximizing $tr W \rho$.
• minimizingDensityMatrix: Density matrix of separable state $\rho$ in computational basis. minimizing $tr W \rho$.
• checkedIterations: Number of iterations used in the optimization of bounds.

Represents an operator to detect Bell diagonal entangled states.

• coords: Coordinates in Bell basis
• operatorMatrix: Hermitian matrix representing the linear operator in computational basis.

calculate_mub_correlation(d, mubSet::Vector{Vector{Vector{ComplexF64}}}, ρ, s=-1)

Based on complete set of mutually unbiased bases mubSet, return sum of mutual predictibilities, shifted by s, for density matrix ρ in d dimensions.

classify_entanglement(analysedCoordState)

Return entanglement class of analysedCoordState.

Entanglement class can be "UNKNWON", "PPT_UNKNOWN" for PPT states that can be separable or entangled, "SEP" for separable states, "BOUND" for PPT/bound entangled states or "NPT" for NPT/free entangled states.

concurrence_qp_check(coordState::CoordState, d, dictionaries, precision=10)

Return true if the quasi-pure concurrence (see concurrence.jl) is positive for a coordState and given basis dictionaries in the given precision.

create_basis_state_operators(d, bellStateOperator, precision)

Use maximally entangled Bell state bellStateOperator of dimension d to create Bell basis and return with corresponding flat and Weyl indices.

create_bipartite_maxentangled(d)

Return maximally entangled pure state of a bipartite system of dimension $d^2$.

create_comppar_unitary(λ, d)

Return d dimensional prameterized unitary matrix from parameter matrix λ.

create_dimelement_sublattices(d)

Return all sublattices with d elements represented as vector of tuples in the $d^2$ elements discrete phase space induced by Weyl operators.

create_halfspheric_witnesses(standardBasis::StandardBasis, n)

Return array of n uniformly distributed random EntanglementWitness on unit sphere represented in Bell basis standardBasis.

create_index_sublattice_state(standardBasis::StandardBasis, subLattice)

Return collection of standardBasis elements contributing to the state corresponding to the sublattice, coordinates in Bell basis and density matrix in computational basis.

create_kernel_hpolytope(vertexCoordinates)

Return LazySets.HPolytope representation of polytope defined by vertexCoordinates.

create_kernel_vertexstates(d, standardBasis::StandardBasis)

Return array containing collections of corresponding standardBasis indices, coordinates and density matrices for all d element sublattices in discrete phase space.

create_random_witnesses(standardBasis::StandardBasis, n)

Return array of n uniformly distributed random EntanglementWitness represented in Bell basis standardBasis.

create_red_parmatrix_from_parvector(x, d)

Return parameter matrix for pure state parameterization from parameter vector x of length $2(d-1)$.

create_weyloperator_basis(d)

Return vector of length $d^2$, containing the Weyl operator basis for the $(d,d)$ dimensionalmatrix space.

direct_optimization(f, negf, method, d, iterations, constrainedOpt=false)

Return total (minimum, minimizer) and (maximum, maximizer) of iterations optimization runs of function f and its negative negf over the set of separale states using Optim.jl optimization mehtod method.

Optim.jl is used for optimazation based on parameterization.jl, so f and negf are defined for $2(d-1)$ parameters. Supported methods include NelderMead, LBFGS and NewtonTrustRegion.

generic_vectorproduct(A,B)

For any vectors of equal length, return $\sum_i A[i]B[i]$, the sum of all products of elements with the same index.

get_bounded_ew(d, wit::EntanglementWitness, iterations, method=Optim.NelderMead, useConstrainedOpt=false)

Return BoundedEW in d dimensions based on EntanglementWitness wit and iterations optimization runs of lower and upper bound for separable states.

get_comppar_unitary_from_parvector(x, d)

Return parameterized unitatry matrix U of dimension d and rank 1 from parameter vector x with $2(d-1)$ elements.

Using the first basis state of the computational basis with density matrix $e_1$, any pure state $\rho$ can be generated as $\rho = U e_1 U^\dagger$.

get_concurrence_qp(coords, d, dictionaries)

Return quasi-pure approximation of the concurrence for a Bell diagonal state represented by coordinates coords with respect to a StandardBasis and corresponding dictionaries in d dimensions.

get_direct_functions_for_wit_traceoptimization(wit::EntanglementWitness, d)

Return the function and its negative that calculates $tr \rho$ wit.coords, the trace of the given witness wit multiplied by a parameterized seperable state $\rho$ in d dimensions.

get_intertwiner(d, k, l)

Return the tensor product $W_{k,l} \otimes \mathbb{1}_d$.

get_permutation_from_momentuminversion(stdBasis::StandardBasis, d)

Return Permutations.Permutation of momentum inversion for $d^2$ dimensional vector of coordinates in Bell basis standardBasis.

get_permutation_from_quarterrotation(stdBasis::StandardBasis, d)

Return Permutations.Permutation of qurater rotation for $d^2$ dimensional vector of coordinates in Bell basis standardBasis.

get_permutation_from_translation(translation::Tuple{Int,Int}, stdBasis::StandardBasis, d)

Return Permutations.Permutation of translation for $d^2$ dimensional vector of coordinates in Bell basis standardBasis.

get_permutation_from_verticalshear(stdBasis::StandardBasis, d)

Return Permutations.Permutationof vertical shear ford^2dimensional vector of coordinates in Bell basisstandardBasis`.

get_properdivisors(k:Int)

Return vector of proper divisors of k.

get_witness_extrema(d, wit::EntanglementWitness, iterations, method, useConstrainedOpt=false)

Return optimization (see optimization.jl) results for lower and upper bound of d dimensional EntanglementWitness wit using iterations runs and Optim.jl optimization method method.

isPPTP(ρ, d, precision)

Return true if the partial transposition of the Hermitian matrix based on the upper triangular of ρ is positive semi-definite in precision.

ispsd(M, precision)

Return true if the smallest eingenvalue of matrix M rounded to precision precision is not negative.

kernel_check(coordState::CoordState, kernelPolytope::Union{HPolytope{Float64,Array{Float64,1}},VPolytope{Float64,Array{Float64,1}}})

Return true if the Euclidean coordinates of the coordStateare contained in thekernelPolytope` represented in V- or H-representation.

map_indices_to_normcoords(indices, D)

Return D element normalized coordinate vector with equal nonzero values at given indices.

mub_check(coordState::CoordState, d, stdBasis::StandardBasis, mubSet::Vector{Vector{Vector{ComplexF64}}})

Return true if the sum of mutual predictibilities for a mubSet (see mub.jl) of dimension d exceeds $2$ for a coordState and given standardBasis.

numeric_ew_check(coordState::CoordState, boundedEWs::Array{BoundedCoordEW}, relUncertainity::Float64)

Return true if any entanglement witness of boundedEWs detects the density matrix ρ as entangled.

An entanglement witness $E$ of boundedEWs detects ρ, if the scalar product $\rho$.coords $\cdot E$.coords is not in [lowerBound, upperBound]. If a relUncertainity is given, the violation relative to upperBound-lowerBound needs to exceed relUncertainity` to detect entanglement.

ppt_check(coordState::CoordState, standardBasis::StandardBasis, precision=10)

Return trueif thecoordStatedefined via thestandardBasishas positive partial transposition in the givenprecision`.

realignment_check(coordState::CoordState, standardBasis::StandardBasis, precision=10)

Return trueif the realignedcoordStatedefined via thestandardBasishas trace norm> 1in the givenprecision`.

rounddigits(A, precision)

Return A with all elemets rounded up to precision digits.

spinrep_check(coordState::CoordState, stdBasis::StandardBasis, bipartiteWeylBasis::Vector{Array{Complex{Float64},2}}, precision=10)

Return true and detects a coordState for a standardBasis as separbale, if its coefficiencts in the bipartiteWeylBasis have 1-norm smaller than $2$ in given precision.

weyloperator(d, k, l)

Return the $(d,d)$- dimensional matrix representation of Weyl operator $W_{k,l}$.

weyltrf(d, ρ, k, l)

Apply the $(k,l)$-th Weyl transformation of dimension d to the density matrix ρ. Return $W_{k,l} \rho W_{k,l}^\dagger$.

δ(n,m)

Return 1 if n==m

δ_mod(n,m,x)

Return 1 if n and m are congruent modulo x.