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.

ADGJ_routine(ρ, n, d, stdbasis)

Applies one iteration of ADGJ routine to the n-copy input state 'rho in d dimensions. Returns the output state and the probabilies of success with respect to the stdbasis.

BBPSSW_routine(ρ, n, d, stdbasis)

Applies one iteration of BBPSSW routine to the n-copy input state 'rho in d dimensions. Returns the output state and the probabilies of success with respect to the stdbasis.

DEJMPS_routine(ρ, n, d, stdbasis)

Applies one iteration of DEJMPS routine to the n-copy input state 'rho in d=2 dimensions. Returns the output state and the probabilies of success with respect to the stdbasis.

FIMAX_routine(ρ, n, d, stdbasis)

Applies one iteration of FIMAX routine to the n-copy input state 'rho in d dimensions. Returns the output state and the probabilies of success with respect to the stdbasis.

P1_P2_routine(ρ, n, d, stdbasis)

Applies one iteration of P1_P2 routine to the n-copy input state 'rho in d dimensions. Returns the output state and the probabilies of success with respect to the stdbasis.

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.

concurrence_qp_gendiagonal_check(coordState, d, basisStates, precision=10)

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

create_alt_indexbasis(d, l, α, precision)

Return alternative indexed Bell basis for d dimensions as StandardBasis rounded to precision digits. Elements of secondary index l are replaced by alternative Bell state defined by d-element vector of phases α.

create_altbellstate(state(d,k,l,α, returnDensity)

Return an alternative Bell state in the computational basis. Return denisty matrix unless returnDensity=false, in which case return state vector.

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.

efficiency(distillable, iterations, successProbs, n)

Returns efficiency of n-copy distillation protocol with iterations iterations of success probabilities successProbs.

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.

iterative_ADGJ_protocol(ρ, targetFid, n, d, stdBasis, maxIts)

Applies iterations of the ADGJ routine to the n-copy input state ρ in d dimensions. Iterates until targetFid or maximal number of iterations maxIts is reached. Returns distillable=true if targetFid could be reached and fidelities and success probabilies with respect to the stdbasis for each iteration.

iterative_BBPSSW_protocol(ρ, targetFid, n, d, stdBasis, maxIts)

Applies iterations of the BBPSSW routine to the n-copy input state ρ in d dimensions. Iterates until targetFid or maximal number of iterations maxIts is reached. Returns distillable=true if targetFid could be reached and fidelities and success probabilies with respect to the stdbasis for each iteration.

iterative_DEJMPS_protocol(ρ, targetFid, n, d, stdBasis, maxIts)

Applies iterations of the DEJMPS routine to the n-copy input state ρ in d=2 dimensions. Iterates until targetFid or maximal number of iterations maxIts is reached. Returns distillable=true if targetFid could be reached and fidelities and success probabilies with respect to the stdbasis for each iteration.

iterative_FIMAX_protocol(ρ, targetFid, n, d, stdBasis, maxIts)

Applies iterations of the FIMAX routine to the n-copy input state ρ in d dimensions. Iterates until targetFid or maximal number of iterations maxIts is reached. Returns distillable=true if targetFid could be reached and fidelities and success probabilies with respect to the stdbasis for each iteration.

iterative_P1_P2_protocol(ρ, targetFid, n, d, stdBasis, maxIts)

Applies iterations of the P1_P2 routine to the n-copy input state ρ in d dimensions. Iterates until targetFid or maximal number of iterations maxIts is reached. Returns distillable=true if targetFid could be reached and fidelities and success probabilies with respect to the stdbasis for each iteration.

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.

FT_OP(d)

Returns the d-dimensional Fourier gate.

GXOR_OP_ADD(d)

Returns the d-dimensional generalization of the GXOR gate acting as |i>k|j> => |i>|i+j>.

GXOR_OP_SUB(d)

Returns the d-dimensional generalization of the GXOR gate acting as |i>k|j> => |i>|i-j>.

P1_routine(ρ, n, d, stdbasis)

Applies one iteration of P1 routine to the n-copy input state 'rho in d dimensions. Returns the output state and the probabilies of success with respect to the stdbasis.

P2_routine(ρ, n, d, stdbasis)

Applies one iteration of P2 routine to the n-copy input state 'rho in d dimensions. Returns the output state and the probabilies of success with respect to the stdbasis.

add_errorkeys(x,y,d,n)

Adds two error elements mod d.

altbell_creatingoperator(d, k, l, α)

Return the $(d,d)$- dimensional matrix representation of an alternative operator that is used to create Bell states $V_{k,l}$. $V_{k,l} ⊗ Id Ω_00$ creates $1/√d * ∑ω^(ks)*α_(s,l) ket{s-l} ⊗ ket{s}$

belldiagonal_projection(stdbasis, ρ)

Projects any density matrix to the set of Bell-diagonal densitystates of corresponding dimension as defined by the stdbasis.

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.

canonic_eigenbasis_weylprime(d, E)

Create array of eigenvectors-eigenvalue tuples for Weyl operator indexed by tuple E in dimension d.

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.

createProjectorOperator(d)

Return concurrence related operator in arbitrary dimension d.

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_canonic_enconding(g, d)

Return unitary matrix as encoding for generating stabilizer element g in demensiond.

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.

depolarize_coords(coords)

Return depolarized elements of a coord probability vector. Leaves the first element invariant. Remaining elements are replaced by their average value.

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_abelian_subgroup_generators(d, n)

Return all generators of abelian subgroups for the n-copy weyl-Heisenberg group in d dimensions.

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_codespace_errorops_for_meas(U, gVec, aVec, bVec)

For given encoding U of a stabilizer with generating elements gVec and measurement outcomes aVec and bVec, return Dict of error elements (keys) and error action operators (values).

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_concurrence_qp_gendiagonal(coords, d, basisStates)

Return quasi-pure approximation of the concurrence for a d-dimensional Bell diagonal state represented by coordinates coords with respect to a set of basisStates.

get_coset_partition(gVec, n, d)

Return coset partition of error elements defined by stabilizer generating elements gVec of n-copies in d dimensions.

get_cosets_prob_s(ρ, gVec, n, d, stdbasis)

Return vector of tuples containing the cosets defined by stabilizer generating elements gVec for n-copies ind dimensions together with its s-value and probabilies in the stdbasis.

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_erroraction_from_encoding(U, W, bVec, sVec, d )

Create error action operator for an error W in encoding U for measurment outcomes bVec and sVec in dimension d.

get_erroroperator_from_errorelement(E, d)

Return error operator in computational basis from error element E in dimension d.

get_intertwiner(d, k, l)

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

get_max_fidelity_stabilizer_coset(ρ, n, d, stdbasis)

Returns stabilizer generator, coset of maximal normalized probability and corresponding s-value, coset probabily and s-value probabily for n-copy input state ρ in d dimensions with respect to stdbasis.

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_prob_for_E(ρ, E, stdBasis)

Return probability of measurment of stdBasis corresponding to error element E in state ρ.

get_prob_for_errorkeys(ρ, errorKeys, n, stdBasis)

Get total error probability for n-copy errorKeys defined by stdBasis in rho.

get_properdivisors(k:Int)

Return vector of proper divisors of k.

get_s_dict_for_generators(gVec, n, d)

Create Dict containing the s-values for each error element (keys) for stabilizer generating elements gVec for n-copies in dimension d.

get_s_errorkeys(gVec, sVec, n, d)

Return all errors with sValue for n-cope stabilizer generators gVec in d dimenions.

get_s_for_generator(g, E)

Return s-value of error element Efor stabilzer generatorgin dimensiond`.

get_s_normalized_coset_probs(ρ, gVec, n, d, stdbasis)

Return array of tuples containing the cosets and s-values defined by generating n-copy stabilizer elements gVec and the coset probabilitiies, normalized coset probabilites and the s-value probabilies for the stdbasis in d dimensions.

get_s_prob_dict(ρ, gVec, n, d, stdbasis)

Return Dict of stdbasis probabilities (values) for each s-value (keys) in n-copy state rho of subsystem dimension d.

get_stdbasis_probabilities(ρ, stdBasis, precision)

Return probability of measuring a Bell stdBasis state for ρ in precision.

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.

iterative_specific_stabilizer_protocol(ρ, targetFid, gVec, aVec, bVec, U, n, d, stdBasis, maxIts)

Applies iterations of the stabilizer routine to the n-copy input state 'rho in d dimensions for stabilizer generating elements gVec, encoding U and measurement outcomes aVec andbVec. Iterates until targetFid or maximal number of iterations maxIts is reached. Returns distillable=true if targetFid could be reached and fidelities and success probabilies with respect to the stdbasis for each iteration.

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.

modbra(k,d)

Return the kth bra vector modulo d.

modket(k,d)

Return the kth ket vector modulo d.

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.

stabilizer_routine((ρ, gVec, aVec, bVec, Uenc, n, d, stdbasis)

Return output state and probability of success for one iteration of the stabilizer distillation routine.

The routine is defined by the input state ρ, the stabilizer generating element gVec, the measurement outcomes aVec and bVec, the encoding operator Uenc, the number of copies n, the dimension of the subsystems d and the standard Bell bases stdbasis.

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.