Full API

CNOT gate

CPHASE gate

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

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

Single photon state

Hadamard gate

Identity operator in qubit basis

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

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

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

Pauli X operator, also available as the constant σˣ

Basis state of σˣ

Basis state of σˣ

Pauli Y operator, also available as the constant σʸ

Basis state of σʸ

Basis state of σʸ

Pauli Z operator, also available as the constant σᶻ

Basis state of σᶻ

Basis state of σᶻ

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.

Coherent state in defined Fock basis.

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

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

julia> f = FockState(2)
|2⟩

julia> destroy = DestroyOp()
a

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

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⟩

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₃†

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.0im

julia> express(MixedState(X1⊗X2), CliffordRepr())
𝒟ℯ𝓈𝓉𝒶𝒷
 
𝒳ₗ━━
+ X_
+ _X
𝒮𝓉𝒶𝒷
 
𝒵ₗ━━
+ Z_
+ _Z

Number operator.

julia> f = FockState(2)
|2⟩

julia> num = NumberOp()
n

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

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

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*k
A|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)

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*B
AB

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))B

julia> @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⟩)A

julia> mixed_state = (A⊗(k*b)) + ((k*b)⊗B)
(A⊗|k⟩⟨b|)+(|k⟩⟨b|⊗B)

julia> ptrace(mixed_state, 1)
(0 + ⟨b||k⟩)B+(tr(A))|k⟩⟨b|

julia> ptrace(mixed_state, 2)
(0 + ⟨b||k⟩)A+(tr(B))|k⟩⟨b|

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*k
2|k⟩

julia> @op A
A

julia> 2*A
2A

Symbolic application of a superoperator on an operator

julia> @op A; @superop S;

julia> S*A
S[A]

Symbolic superoperator

Trace of an operator

julia> @op A; @op B;

julia> tr(A)
tr(A)

julia> tr(commutator(A, B))
0

julia> @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⟩ᵀ

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

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.

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 ket

julia> 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.0im

julia> express(X1, CliffordRepr())
𝒟ℯ𝓈𝓉𝒶𝒷
+ Z
𝒮𝓉𝒶𝒷
+ X

julia> express(QuantumSymbolics.X)
Operator(dim=2x2)
  basis: Spin(1/2)
      ⋅       1.0 + 0.0im
 1.0 + 0.0im       ⋅

julia> express(QuantumSymbolics.X, CliffordRepr(), UseAsOperation())
sX

julia> 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.

The anticommutator of two operators.

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+AB

julia> 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)Z

julia> 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 A
A

julia> @op B FockBasis(2)
B