QuantumSymbolics.jl reference

CNOT

CNOT gate

CPHASE

CPHASE gate

Create

Creation operator, also available as the constant âꜛ, in an infinite dimension Fock basis. There is no unicode dagger superscript, so we use the uparrow

Destroy

Annihilation operator, also available as the constant â, in an infinite dimension Fock basis.

Single photon state

H

Hadamard gate

Identity operator in qubit basis

N

Number operator, also available as the constant n̂, in an infinite dimension Fock basis.

Pm

Pauli "minus" operator, also available as the constant σ₋

Pp

Pauli "plus" operator, also available as the constant σ₊

X

Pauli X operator, also available as the constant σˣ

X1

Basis state of σˣ

X2

Basis state of σˣ

Y

Pauli Y operator, also available as the constant σʸ

Y1

Basis state of σʸ

Y2

Basis state of σʸ

Z

Pauli Z operator, also available as the constant σᶻ

Z1

Basis state of σᶻ

Z2

Basis state of σᶻ

vac

Single-mode vacuum state

AmplifierCPTP(r::Number, noise::Int)

Amplification CPTP map, defined by the squeezing amplitude parameter r and thermal noise parameter noise.

AttenuatorCPTP(theta::Number, noise::Int)

Attenuation CPTP map, defined by the beam splitter rotation parameter theta and thermal noise parameter noise.

Two-mode beamsplitter operator in defined Fock basis.

Thermal bosonic state in defined Fock basis.

struct CoherentState <: QuantumSymbolics.AbstractSingleBosonState

Coherent state in defined Fock basis.

struct CreateOp <: QuantumSymbolics.AbstractSingleBosonOp

Creation (raising) operator.

julia> f = FockState(2)|2⟩julia> create = CreateOp()a†julia> qsimplify(create*f, rewriter=qsimplify_fock)(sqrt(3))|3⟩

Single-qubit dephasing CPTP map

struct DestroyOp <: QuantumSymbolics.AbstractSingleBosonOp

Annihilation (lowering or destroy) operator in defined Fock basis.

julia> f = FockState(2)|2⟩julia> destroy = DestroyOp()ajulia> qsimplify(destroy*f, rewriter=qsimplify_fock)(sqrt(2))|1⟩

struct DisplaceOp <: QuantumSymbolics.AbstractSingleBosonGate

Displacement operator in defined Fock basis.

julia> f = FockState(0)|0⟩julia> displace = DisplaceOp(im)D(im)julia> qsimplify(displace*f, rewriter=qsimplify_fock)|im⟩

struct FockState <: QuantumSymbolics.AbstractSingleBosonState

Fock state in defined Fock basis.

A unitary gate followed by a CPTP map

The identity operator for a given basis

julia> IdentityOp(X1⊗X2)
𝕀

julia> express(IdentityOp(Z2))
Operator(dim=2x2)
  basis: Spin(1/2)sparse([1, 2], [1, 2], ComplexF64[1.0 + 0.0im, 1.0 + 0.0im], 2, 2)

Kraus representation of a quantum channel

julia> @op A₁; @op A₂; @op A₃;julia> K = kraus(A₁, A₂, A₃)𝒦(A₁,A₂,A₃)julia> @op ρ;julia> K*ρA₁ρA₁†+A₂ρA₂†+A₃ρA₃†

struct MixedState <: SymQObj{QuantumInterface.AbstractOperator}

Completely depolarized state

julia> MixedState(X1⊗X2)𝕄julia> express(MixedState(X1⊗X2))Operator(dim=4x4)  basis: [Spin(1/2) ⊗ Spin(1/2)] 0.25 + 0.0im        ⋅             ⋅             ⋅            ⋅       0.25 + 0.0im        ⋅             ⋅       ⋅             ⋅       0.25 + 0.0im        ⋅       ⋅             ⋅             ⋅       0.25 + 0.0imjulia> express(MixedState(X1⊗X2), CliffordRepr())𝒟ℯ𝓈𝓉𝒶𝒷 𝒳ₗ━━+ X_+ _X𝒮𝓉𝒶𝒷 𝒵ₗ━━+ Z_+ _Z

struct NumberOp <: QuantumSymbolics.AbstractSingleBosonOp

Number operator.

julia> f = FockState(2)|2⟩julia> num = NumberOp()njulia> qsimplify(num*f, rewriter=qsimplify_fock)2|2⟩

struct PauliNoiseCPTP <: QuantumSymbolics.NoiseCPTP

Single-qubit Pauli noise CPTP map

julia> apply!(express(Z1), [1], express(PauliNoiseCPTP(1/4,1/4,1/4)))Operator(dim=2x2)  basis: Spin(1/2) 0.5+0.0im  0.0+0.0im 0.0+0.0im  0.5+0.0im

struct PhaseShiftOp <: QuantumSymbolics.AbstractSingleBosonGate

Phase-shift operator in defined Fock basis.

julia> c = CoherentState(im)|im⟩julia> phase = PhaseShiftOp(pi)U(π)julia> qsimplify(phase*c, rewriter=qsimplify_fock)|1.2246467991473532e-16 - 1.0im⟩

Representation using kets, bras, density matrices, and superoperators governed by QuantumToolbox.jl.

Addition of quantum objects (kets, operators, or bras).

julia> @ket k₁; @ket k₂;julia> k₁ + k₂|k₁⟩+|k₂⟩

Symbolic anticommutator of two operators.

julia> @op A; @op B;julia> anticommutator(A, B){A,B}

Symbolic application of an operator on a bra (from the right).

julia> @bra b; @op A;julia> b*A⟨b|A

Symbolic application of an operator on a ket (from the left).

julia> @ket k; @op A;julia> A*kA|k⟩

Symbolic bra

Symbolic inner product of a bra and a ket.

julia> @bra b; @ket k;julia> b*k⟨b||k⟩

Symbolic commutator of two operators.

julia> @op A; @op B;julia> commutator(A, B)[A,B]julia> commutator(A, A)𝟎

Complex conjugate of quantum objects (kets, bras, operators).

julia> @op A; @ket k;julia> conj(A)Aˣjulia> conj(k)|k⟩ˣ

Dagger, i.e., adjoint of quantum objects (kets, bras, operators).

julia> @ket a; @op A;julia> dagger(2*im*A*a)(0 - 2im)|a⟩†A†julia> @op B;julia> dagger(A*B)B†A†julia> ℋ = SHermitianOperator(:ℋ); U = SUnitaryOperator(:U);julia> dagger(ℋ)ℋjulia> dagger(U)U⁻¹

Exponential of a symbolic operator.

julia> @op A; @op B;julia> exp(A)exp(A)

struct SHermitianOperator <: SymQObj{QuantumInterface.AbstractOperator}

Symbolic Hermitian operator

Symbolic Hermitian and unitary operator

Inverse of an operator.

julia> @op A;julia> inv(A)A⁻¹julia> inv(A)*A𝕀

Symbolic ket

Symbolic application of operator on operator.

julia> @op A; @op B;julia> A*BAB

Symbolic operator

Symbolic outer product of a ket and a bra.

julia> @bra b; @ket k;julia> k*b |k⟩⟨b|

Partial trace over system i of a composite quantum system

julia> @op 𝒪 SpinBasis(1//2)⊗SpinBasis(1//2);julia> op = ptrace(𝒪, 1)tr1(𝒪)julia> QuantumSymbolics.basis(op)Spin(1/2)julia> @op A; @op B;julia> ptrace(A⊗B, 1)(tr(A))Bjulia> @ket k; @bra b;julia> factorizable = A ⊗ (k*b)A⊗|k⟩⟨b|julia> ptrace(factorizable, 1)(tr(A))|k⟩⟨b|julia> ptrace(factorizable, 2)(⟨b||k⟩)Ajulia> mixed_state = (A⊗(k*b)) + ((k*b)⊗B)(A⊗|k⟩⟨b|)+(|k⟩⟨b|⊗B)julia> ptrace(mixed_state, 1)(tr(A))|k⟩⟨b|+(⟨b||k⟩)Bjulia> ptrace(mixed_state, 2)(tr(B))|k⟩⟨b|+(⟨b||k⟩)A

struct SProjector <: SymQObj{QuantumInterface.AbstractOperator}

Projector for a given ket.

julia> projector(X1⊗X2)𝐏[|X₁⟩|X₂⟩]julia> express(projector(X2))Operator(dim=2x2)  basis: Spin(1/2)  0.5+0.0im  -0.5-0.0im -0.5+0.0im   0.5+0.0im

Scaling of a quantum object (ket, operator, or bra) by a number.

julia> @ket k|k⟩julia> 2*k2|k⟩julia> @op AAjulia> 2*A2A

Symbolic application of a superoperator on an operator

julia> @op A; @superop S;julia> S*AS[A]

Symbolic superoperator

Trace of an operator

julia> @op A; @op B;julia> tr(A)tr(A)julia> tr(commutator(A, B))0julia> @bra b; @ket k;julia> tr(k*b)⟨b||k⟩

Transpose of quantum objects (kets, bras, operators).

julia> @op A; @op B; @ket k;julia> transpose(A)Aᵀjulia> transpose(A+B)Aᵀ+Bᵀjulia> transpose(k)|k⟩ᵀ

struct SUnitaryOperator <: SymQObj{QuantumInterface.AbstractOperator}

Symbolic unitary operator

Vectorization of a symbolic operator.

julia> @op A; @op B;julia> vec(A)|A⟩⟩julia> vec(A+B)|A⟩⟩+|B⟩⟩

Symbolic zero bra

Symbolic zero ket

Symbolic zero operator

struct SqueezeOp <: QuantumSymbolics.AbstractSingleBosonGate

Squeezing operator in defined Fock basis.

julia> S = SqueezeOp(pi)S(π)julia> qsimplify(S*vac, rewriter=qsimplify_fock)|0,π⟩

Squeezed vacuum state in defined Fock basis.

struct StabilizerState{T} <: SymQObj{QuantumInterface.AbstractKet}

State defined by a stabilizer tableau

For full functionality you also need to import the QuantumClifford library.

julia> using QuantumClifford, QuantumOptics # needed for the internal representation of the stabilizer tableaux and the conversion to a ketjulia> StabilizerState(S"XX ZZ")𝒮₂julia> express(StabilizerState(S"-X"))Ket(dim=2)  basis: Spin(1/2)  0.7071067811865475 + 0.0im -0.7071067811865475 + 0.0im

Two-mode squeezing operator in defined Fock basis.

Two-mode squeezed vacuum state, or EPR state, in defined Fock basis.

conj(x::Symbolic{AbstractKet})
conj(x::Symbolic{AbstractBra})
conj(x::Symbolic{AbstractOperator})
conj(x::Symbolic{AbstractSuperOperator})

Symbolic complex conjugate operation. See also SConjugate.

exp(x::Symbolic{AbstractOperator})

Symbolic exponential of an operator. See also SExpOperator.

inv(x::Symbolic{AbstractOperator})

Symbolic inverse of an operator. See also SInvOperator.

transpose(x::Symbolic{AbstractKet})
transpose(x::Symbolic{AbstractBra})
transpose(x::Symbolic{AbstractOperator})

Symbolic transpose operation. See also STranspose.

vec(x::Symbolic{AbstractOperator})

Symbolic vector representation of an operator. See also SVec.

tr(x::Symbolic{AbstractOperator})

Symbolic trace operation. See also STrace.

dagger(x::Symbolic{AbstractBra})

Symbolic adjoint operation. See also SDagger.

dagger(x::Symbolic{AbstractKet})

Symbolic adjoint operation. See also SDagger.

dagger(x::Symbolic{AbstractOperator})

Symbolic adjoint operation. See also SDagger.

express(s, repr::AbstractRepresentation=QuantumOpticsRepr()[, use::AbstractUse])

The main interface for expressing symbolic quantum objects in various representations.

julia> express(X1)Ket(dim=2)  basis: Spin(1/2) 0.7071067811865475 + 0.0im 0.7071067811865475 + 0.0imjulia> express(X1, CliffordRepr())𝒟ℯ𝓈𝓉𝒶𝒷+ Z𝒮𝓉𝒶𝒷+ Xjulia> express(QuantumSymbolics.X)Operator(dim=2x2)  basis: Spin(1/2)      ⋅       1.0 + 0.0im 1.0 + 0.0im       ⋅julia> express(QuantumSymbolics.X, CliffordRepr(), UseAsOperation())sXjulia> express(QuantumSymbolics.X, CliffordRepr(), UseAsObservable())+ X

projector(x::Symbolic{AbstractKet})

Symbolic projection operation. See also SProjector.

ptrace(x::Symbolic{AbstractOperator})

Symbolic partial trace operation. See also SPartialTrace.

anticommutator(o1, o2)

The anticommutator of two operators.

commutator(o1, o2)

The commutator of two operators.

Pick a representation that is consistent with given representations and appropriate for the given state.

qexpand(s)

Manually expand a symbolic expression of quantum objects.

julia> @op A; @op B; @op C;julia> qexpand(commutator(A, B))-1BA+ABjulia> qexpand(A⊗(B+C))(A⊗B)+(A⊗C)julia> @ket k₁; @ket k₂;julia> qexpand(A*(k₁+k₂))A|k₁⟩+A|k₂⟩

qsimplify(s; rewriter=nothing)

Manually simplify a symbolic expression of quantum objects.

If the keyword rewriter is not specified, then qsimplify will apply every defined rule to the expression. For performance or single-purpose motivations, the user has the option to define a specific rewriter for qsimplify to apply to the expression. The defined rewriters for simplification are the following objects: - qsimplify_pauli - qsimplify_commutator - qsimplify_anticommutator - qsimplify_fock

julia> qsimplify(σʸ*commutator(σˣ*σᶻ, σᶻ))(0 - 2im)Zjulia> qsimplify(anticommutator(σˣ, σˣ), rewriter=qsimplify_anticommutator)2𝕀

@bra(name, basis=SpinBasis(1//2))

Define a symbolic bra of type SBra. By default, the defined basis is the spin-1/2 basis.

julia> @bra b₁⟨b₁|julia> @bra b₂ FockBasis(2)⟨b₂|

@ket(name, basis=SpinBasis(1//2))

Define a symbolic ket of type SKet. By default, the defined basis is the spin-1/2 basis.

julia> @ket k₁|k₁⟩julia> @ket k₂ FockBasis(2)|k₂⟩

@op(name, basis=SpinBasis(1//2))

Define a symbolic operator of type SOperator. By default, the defined basis is the spin-1/2 basis.

julia> @op AAjulia> @op B FockBasis(2)B