List of functions

Basic

Ket.ket — Function

ket([T=ComplexF64,] i::Integer, d::Integer = 2)

Produces a ket of dimension d with nonzero element i.

source

Ket.ketbra — Function

ketbra(v::AbstractVector)

Produces a ketbra of vector v.

source

Ket.proj — Function

proj([T=ComplexF64,] i::Integer, d::Integer = 2)

Produces a projector onto the basis state i in dimension d.

source

Ket.shift — Function

shift([T=ComplexF64,] d::Integer, p::Integer = 1)

Constructs the shift operator X of dimension d to the power p.

Reference: Generalized Clifford algebra

source

Ket.clock — Function

clock([T=ComplexF64,] d::Integer, p::Integer = 1)

Constructs the clock operator Z of dimension d to the power p.

Reference: Generalized Clifford algebra

source

Ket.pauli — Function

pauli([T=ComplexF64,], ind::Vector{<:Integer})

Constructs the Pauli matrices: 0 or "I" for the identity, 1 or "X" for the Pauli X operation, 2 or "Y" for the Pauli Y operator, and 3 or "Z" for the Pauli Z operator. Vectors of integers between 0 and 3 or strings of I, X, Y, Z automatically generate Kronecker products of the corresponding operators.

source

Ket.gellmann — Function

gellmann([T=ComplexF64,], d::Integer = 3)

Constructs the set G of generalized Gell-Mann matrices in dimension d such that G[1] = I and Tr(G[i]*G[j]) = 2 δ_ij.

Reference: Generalizations of Pauli matrices

source

gellmann([T=ComplexF64,], i::Integer, j::Integer, d::Integer = 3)

Constructs the set i,jth Gell-Mann matrix of dimension d.

Reference: Generalizations of Pauli matrices

source

Ket.gellmann! — Function

gellmann!(res::AbstractMatrix{T}, i::Integer, j::Integer, d::Integer = 3)

In-place version of gellmann.

source

Ket.partial_trace — Function

partial_trace(X::AbstractMatrix, remove::AbstractVector, dims::AbstractVector = _equal_sizes(X))

Takes the partial trace of matrix X with subsystem dimensions dims over the subsystems in remove. If the argument dims is omitted two equally-sized subsystems are assumed.

source

partial_trace(X::AbstractMatrix, remove::Integer, dims::AbstractVector = _equal_sizes(X)))

Takes the partial trace of matrix X with subsystem dimensions dims over the subsystem remove. If the argument dims is omitted two equally-sized subsystems are assumed.

source

Ket.partial_transpose — Function

partial_transpose(X::AbstractMatrix, transp::AbstractVector, dims::AbstractVector = _equal_sizes(X))

Takes the partial transpose of matrix X with subsystem dimensions dims on the subsystems in transp. If the argument dims is omitted two equally-sized subsystems are assumed.

source

partial_transpose(X::AbstractMatrix, transp::Integer, dims::AbstractVector = _equal_sizes(X))

Takes the partial transpose of matrix X with subsystem dimensions dims on the subsystem transp. If the argument dims is omitted two equally-sized subsystems are assumed.

source

Ket.permute_systems! — Function

permute_systems!(X::AbstractVector, perm::AbstractVector, dims::AbstractVector = _equal_sizes(X))

Permutes the order of the subsystems of vector X with subsystem dimensions dims in-place according to the permutation perm. If the argument dims is omitted two equally-sized subsystems are assumed.

source

Ket.permute_systems — Function

permute_systems(X::AbstractMatrix, perm::AbstractVector, dims::AbstractVector = _equal_sizes(X))

Permutes the order of the subsystems of the square matrix X, which is composed by square subsystems of dimensions dims, according to the permutation perm. If the argument dims is omitted two equally-sized subsystems are assumed.

source

permute_systems(X::AbstractMatrix, perm::Vector, dims::Matrix)

Permutes the order of the subsystems of the matrix X, which is composed by subsystems of dimensions dims, according to the permutation perm. dims should be a n x 2 matrix where dims[i, 1] is the number of rows of subsystem i, and dims[i,2] is its number of columns.

source

Ket.cleanup! — Function

cleanup!(M::AbstractArray{T}; tol = Base.rtoldefault(real(T)))

Zeroes out real or imaginary parts of M that are smaller than tol.

source

Ket.symmetric_projection — Function

symmetric_projection(dim::Integer, n::Integer; partial::Bool=true)

Orthogonal projection onto the symmetric subspace of n copies of a dim-dimensional space. By default (partial=true) it returns an isometry (say, V) encoding the symmetric subspace. If partial=false, then it returns the actual projection V * V'.

Reference: Watrous' book, Sec. 7.1.1

source

Ket.orthonormal_range — Function

orthonormal_range(A::AbstractMatrix{T}; mode::Integer=nothing, tol::T=nothing, sp::Bool=true) where {T<:Number}

Orthonormal basis for the range of A. When A is sparse (or mode = 0), uses a QR factorization and returns a sparse result, otherwise uses an SVD and returns a dense matrix (mode = 1). Input A will be overwritten during the factorization. Tolerance tol is used to compute the rank and is automatically set if not provided.

source

Ket.permutation_matrix — Function

permutation_matrix(dims::Union{Integer,AbstractVector}, perm::AbstractVector)

Unitary that permutes subsystems of dimension dims according to the permutation perm. If dims is an Integer, assumes there are length(perm) subsystems of equal dimensions dims.

source

Ket.n_body_basis — Function

n_body_basis(
n::Integer,
n_parties::Integer;
sb::AbstractVector{<:AbstractMatrix} = [pauli(1), pauli(2), pauli(3)],
sparse::Bool = true,
eye::AbstractMatrix = I(size(sb[1], 1))

Return the basis of n nontrivial operators acting on n_parties, by default using Pauli matrices.

For example, n_body_basis(2, 3) generates all products of two Paulis and one identity, so ${X ⊗ X ⊗ 1, X ⊗ 1 ⊗ X, ..., X ⊗ Y ⊗ 1, ..., 1 ⊗ Z ⊗ Z}$.

Instead of Paulis, a basis can be provided by the parameter sb, and the identity can be changed with eye. If sparse is true, the resulting basis will use sparse matrices, otherwise it will agree with sb.

This function returns a generator, which can then be used e.g. in for loops without fully allocating the entire basis at once. If you need a vector, call collect on it.

source

Entropy

Ket.entropy — Function

entropy([base=2,] ρ::AbstractMatrix)

Computes the von Neumann entropy -tr(ρ log ρ) of a positive semidefinite operator ρ using a base base logarithm.

Reference: von Neumann entropy.

source

entropy([base=2,] p::AbstractVector)

Computes the Shannon entropy -Σᵢpᵢlog(pᵢ) of a non-negative vector p using a base base logarithm.

Reference: Entropy (information theory).

source

Ket.binary_entropy — Function

binary_entropy([base=2,] p::Real)

Computes the Shannon entropy -p log(p) - (1-p)log(1-p) of a probability p using a base base logarithm.

Reference: Entropy (information theory).

source

Ket.relative_entropy — Function

relative_entropy([base=2,] ρ::AbstractMatrix, σ::AbstractMatrix)

Computes the (quantum) relative entropy tr(ρ (log ρ - log σ)) between positive semidefinite matrices ρ and σ using a base base logarithm. Note that the support of ρ must be contained in the support of σ but for efficiency this is not checked.

Reference: Quantum relative entropy.

source

relative_entropy([base=2,] p::AbstractVector, q::AbstractVector)

Computes the relative entropy D(p||q) = Σᵢpᵢlog(pᵢ/qᵢ) between two non-negative vectors p and q using a base base logarithm. Note that the support of p must be contained in the support of q but for efficiency this is not checked.

Reference: Relative entropy.

source

Ket.binary_relative_entropy — Function

binary_relative_entropy([base=2,] p::Real, q::Real)

Computes the binary relative entropy D(p||q) = p log(p/q) + (1-p) log((1-p)/(1-q)) between two probabilities p and q using a base base logarithm.

Reference: Relative entropy.

source

Ket.conditional_entropy — Function

conditional_entropy([base=2,] pAB::AbstractMatrix)

Computes the conditional Shannon entropy H(A|B) of the joint probability distribution pAB using a base base logarithm.

Reference: Conditional entropy.

source

conditional_entropy([base=2,], rho::AbstractMatrix, csys::AbstractVector, dims::AbstractVector)

Computes the conditional von Neumann entropy of rho with subsystem dimensions dims and conditioning systems csys, using a base base logarithm.

Reference: Conditional quantum entropy.

source

Entanglement

Ket.schmidt_decomposition — Function

schmidt_decomposition(ψ::AbstractVector, dims::AbstractVector{<:Integer} = _equal_sizes(ψ))

Produces the Schmidt decomposition of ψ with subsystem dimensions dims. If the argument dims is omitted equally-sized subsystems are assumed. Returns the (sorted) Schmidt coefficients λ and isometries U, V such that kron(U', V')*ψ is of Schmidt form.

Reference: Schmidt decomposition.

source

Ket.entanglement_entropy — Function

entanglement_entropy(ψ::AbstractVector, dims::AbstractVector{<:Integer} = _equal_sizes(ψ))

Computes the relative entropy of entanglement of a bipartite pure state ψ with subsystem dimensions dims. If the argument dims is omitted equally-sized subsystems are assumed.

source

entanglement_entropy(ρ::AbstractMatrix, dims::AbstractVector = _equal_sizes(ρ), n::Integer = 1)

Lower bounds the relative entropy of entanglement of a bipartite state ρ with subsystem dimensions dims using level n of the DPS hierarchy. If the argument dims is omitted equally-sized subsystems are assumed.

source

Ket.random_robustness — Function

random_robustness(
ρ::AbstractMatrix{T},
dims::AbstractVector{<:Integer} = _equal_sizes(ρ),
n::Integer = 1;
ppt::Bool = true,
verbose::Bool = false,
solver = Hypatia.Optimizer{_solver_type(T)})

Lower bounds the random robustness of state ρ with subsystem dimensions dims using level n of the DPS hierarchy. Argument ppt indicates whether to include the partial transposition constraints.

source

Ket.schmidt_number — Function

schmidt_number(
    ρ::AbstractMatrix{T},
    s::Integer = 2,
    dims::AbstractVector{<:Integer} = _equal_sizes(ρ),
    n::Integer = 1;
    ppt::Bool = true,
    verbose::Bool = false,
    solver = Hypatia.Optimizer{_solver_type(T)})

Upper bound on the random robustness of ρ such that it has a Schmidt number s.

If a state $ρ$ with local dimensions $d_A$ and $d_B$ has Schmidt number $s$, then there is a PSD matrix $ω$ in the extended space $AA′B′B$, where $A′$ and $B^′$ have dimension $s$, such that $ω / s$ is separable against $AA′|B′B$ and $Π† ω Π = ρ$, where $Π = 1_A ⊗ s ψ^+ ⊗ 1_B$, and $ψ^+$ is a non-normalized maximally entangled state. Separabiity is tested with the DPS hierarchy, with n controlling the how many copies of the $B′B$ subsystem are used.

References: Hulpke, Bruss, Lewenstein, Sanpera arXiv:quant-ph/0401118Weilenmann, Dive, Trillo, Aguilar, Navascués arXiv:1912.10056

source

Ket.ppt_mixture — Function

function ppt_mixture(
ρ::AbstractMatrix{T},
dims::AbstractVector{<:Integer};
verbose::Bool = false,
solver = Hypatia.Optimizer{_solver_type(T)})

Lower bound on the white noise such that ρ is still a genuinely multipartite entangled state and a GME witness that detects ρ.

The set of GME states is approximated by the set of PPT mixtures, so the entanglement across the bipartitions is decided with the PPT criterion. If the state is a PPT mixture, returns a 0 matrix instead of a witness.

Reference: Jungnitsch, Moroder, Guehne arXiv:quant-ph/0401118

source

function ppt_mixture(
ρ::AbstractMatrix{T},
dims::AbstractVector{<:Integer},
obs::AbstractVector{<:AbstractMatrix} = Vector{Matrix}();
verbose::Bool = false,
solver = Hypatia.Optimizer{_solver_type(T)})

Lower bound on the white noise such that ρ is still a genuinely multipartite entangled state that can be detected with a witness using only the operators provided in obs, and the values of the coefficients defining such a witness.

More precisely, if a list of observables $O_i$ is provided in the parameter obs, the witness will be of the form $∑_i α_i O_i$ and detects ρ only using these observables. For example, using only two-body operators (and lower order) one can call

julia> two_body_basis = collect(Iterators.flatten(n_body_basis(i, 3) for i ∈ 0:2))
julia> ppt_mixture(state_ghz(2, 3), [2, 2, 2], two_body_basis)

Reference: Jungnitsch, Moroder, Guehne arXiv:quant-ph/0401118

source

Measurements

Ket.sic_povm — Function

sic_povm([T=ComplexF64,] d::Integer)

Constructs a vector of d² vectors |vᵢ⟩ such that |vᵢ⟩⟨vᵢ| forms a SIC-POVM of dimension d. This construction is based on the Weyl-Heisenberg fiducial.

Reference: Appleby, Yadsan-Appleby, Zauner, arXiv:1209.1813

source

Ket.test_sic — Function

test_sic(vecs)

Checks if vecs is a vector of d² vectors |vᵢ⟩ such that |vᵢ⟩⟨vᵢ| forms a SIC-POVM of dimension d.

source

Ket.test_povm — Function

test_povm(A::Vector{<:AbstractMatrix{T}})

Checks if the measurement defined by A is valid (hermitian, semi-definite positive, and normalized).

source

Ket.dilate_povm — Function

dilate_povm(vecs::Vector{Vector{T}})

Does the Naimark dilation of a rank-1 POVM given as a vector of vectors. This is the minimal dilation.

source

dilate_povm(E::Vector{<:AbstractMatrix})

Does the Naimark dilation of a POVM given as a vector of matrices. This always works, but is wasteful if the POVM elements are not full rank.

source

Ket.povm — Function

povm(B::Vector{<:AbstractMatrix{T}})

Creates a set of (projective) measurements from a set of bases given as unitary matrices.

source

Ket.tensor_to_povm — Function

tensor_to_povm(A::Array{T,4}, o::Vector{Int})

Converts a set of measurements in the common tensor format into a matrix of (hermitian) matrices. By default, the second argument is fixed by the size of A. It can also contain custom number of outcomes if there are measurements with less outcomes.

source

Ket.povm_to_tensor — Function

povm_to_tensor(Axa::Vector{<:Measurement})

Converts a matrix of (hermitian) matrices into a set of measurements in the common tensor format.

source

Ket.mub — Function

mub([T=ComplexF64,] d::Integer)

Construction of the standard complete set of MUBs. The output contains 1+minᵢ pᵢ^rᵢ bases, where d = ∏ᵢ pᵢ^rᵢ.

Reference: Durt, Englert, Bengtsson, Życzkowski, arXiv:1004.3348.

source

Ket.test_mub — Function

test_mub(B::Vector{Matrix{<:Number}})

Checks if the input bases are mutually unbiased.

source

Incompatibility

Ket.incompatibility_robustness — Function

incompatibility_robustness(A::Vector{Measurement{<:Number}}, measure::String = "g")

Computes the incompatibility robustness of the measurements in the vector A. Depending on the noise model chosen, the second argument can be "d" (depolarizing), "r" (random), "p" (probabilistic), "jm" (jointly measurable), or "g" (generalized), see the corresponding functions below. Returns the parent POVM if return_parent = true.