Hilbert spaces and operators

HilbertSpace

Supertype of all Hilbert spaces.

The concrete spaces are FockSpace, NLevelSpace, CollectiveNLevelSpace, PauliSpace, SpinSpace, PhaseSpace and their tensor product ProductSpace. The type is public but not exported.

Examples

julia> FockSpace(:cavity) ⊗ NLevelSpace(:atom, 2) isa SecondQuantizedAlgebra.HilbertSpacetrue

See also ProductSpace, ⊗.

FockSpace(name::Symbol) <: HilbertSpace

Hilbert space of a bosonic mode, home of the ladder operators Destroy and Create. The name is a label used for printing.

Examples

julia> h = FockSpace(:cavity)ℋ(cavity)julia> a = Destroy(h, :a);julia> a * a'1 + a' * a

See also Destroy, PhaseSpace, ⊗.

NLevelSpace(name::Symbol, n::Int)
NLevelSpace(name::Symbol, n::Int, ground_state::Int)
NLevelSpace(name::Symbol, levels::Tuple{Vararg{Symbol}})

Hilbert space of a system with n discrete levels, home of the Transition operators.

Levels are numbered 1:n, or named by a tuple of symbols in the order of the basis. The ground_state (default 1; the first name for named levels) marks the projector $|g\rangle\langle g|$ that expand_completeness can eliminate through $|g\rangle\langle g| = 1 - \sum_{k \neq g}|k\rangle\langle k|$.

Examples

julia> h = NLevelSpace(:atom, (:g, :e))ℋ(atom)julia> σ = Transition(h, :σ, :g, :e);julia> σ' * σσ₂₂julia> h3 = NLevelSpace(:atom, 3, 2);julia> expand_completeness(Transition(h3, :σ, 2, 2))1 - σ₁₁ - σ₃₃

See also Transition, expand_completeness, PauliSpace.

PauliSpace(name::Symbol) <: HilbertSpace

Hilbert space of a two-level system written with Pauli matrices, home of the Pauli operators.

Examples

julia> h = PauliSpace(:qubit)ℋ(qubit)julia> σz = Pauli(h, :σ, 3);julia> σz * σz1

See also Pauli, NLevelSpace, SpinSpace.

SpinSpace(name::Symbol) <: HilbertSpace

Hilbert space of an angular momentum, home of the Spin operators.

The spin length $S$ does not enter the algebra. It is fixed only by the basis chosen for numerics, so the same expressions hold for every $S$.

Examples

julia> h = SpinSpace(:S)ℋ(S)julia> Sz = Spin(h, :S, 3)Sz

See also Spin, PauliSpace.

PhaseSpace(name::Symbol) <: HilbertSpace

Hilbert space of one mode in quadrature form, home of Position and Momentum.

A PhaseSpace holds a single canonical pair. The quadrature names are only labels: a second Position under another name is the same observable. Several modes therefore need several spaces combined with ⊗.

Examples

julia> h = PhaseSpace(:osc)ℋ(osc)julia> x = Position(h, :x); y = Position(h, :y); p = Momentum(h, :p);julia> commutator(x, p), commutator(y, p)(im, im)

See also Position, Momentum, FockSpace.

⊗(space::HilbertSpace, spaces::HilbertSpace...)

Tensor product of Hilbert spaces, returning a ProductSpace.

Nested products are flattened, so (A ⊗ B) ⊗ C == A ⊗ (B ⊗ C) and the factors are always numbered left to right. Type it as \otimes<tab>, or use the ASCII alias tensor.

Examples

julia> A = FockSpace(:a); B = FockSpace(:b); C = NLevelSpace(:atom, 2);julia> A ⊗ B ⊗ Cℋ(a) ⊗ ℋ(b) ⊗ ℋ(atom)julia> (A ⊗ B) ⊗ C == A ⊗ (B ⊗ C)true

See also ProductSpace, tensor.

tensor(space::HilbertSpace, spaces::HilbertSpace...)

ASCII alias for ⊗, the tensor product of Hilbert spaces.

Examples

julia> tensor(FockSpace(:a), FockSpace(:b))ℋ(a) ⊗ ℋ(b)

See also ⊗, ProductSpace.

ProductSpace{T} <: HilbertSpace

Tensor product of Hilbert spaces, built with ⊗ or tensor.

The factors are numbered 1, 2, … from left to right. An operator on a product space names the factor it acts on by this number, e.g. Destroy(h, :a, 1). The number may be left out when only one factor has the right type; otherwise the constructor throws an ArgumentError.

Examples

julia> h = FockSpace(:cavity) ⊗ NLevelSpace(:atom, 2)ℋ(cavity) ⊗ ℋ(atom)julia> a = Destroy(h, :a, 1); σ = Transition(h, :σ, 1, 2);julia> a * σa * σ₁₂

See also ⊗, acts_on.

@qnumbers ops...

Define operators and bind each to a variable of the same name.

Each argument reads name::Constructor(space, args...) and stands for name = Constructor(space, :name, args...), so the operator name is written once. Several operators can be declared in one call.

Examples

julia> h = FockSpace(:cavity) ⊗ NLevelSpace(:atom, 2);julia> @qnumbers a::Destroy(h, 1) σ::Transition(h, 1, 2, 2)(a, σ₁₂)julia> a' * σa' * σ₁₂

See also Destroy, Transition, Pauli, Spin, Position, Momentum, CollectiveTransition.

Destroy(h::FockSpace, name::Symbol)
Destroy(h::ProductSpace, name::Symbol, [subsystem::Int])

Annihilation operator of the bosonic mode name.

The operator $a$ obeys $[a, a^\dagger] = 1$, and products come out normal ordered. The adjoint a' is the Create operator. Modes with different names are independent. On a ProductSpace, subsystem selects the FockSpace factor and may be omitted when there is only one.

Examples

julia> h = FockSpace(:cavity) ⊗ NLevelSpace(:atom, 2);julia> a = Destroy(h, :a);julia> a * a'1 + a' * a

See also Create, FockSpace, @qnumbers.

Create(h::FockSpace, name::Symbol)
Create(h::ProductSpace, name::Symbol, [subsystem::Int])

Creation operator of the bosonic mode name.

The operator $a^\dagger$ is the adjoint of Destroy, and usually written as a' instead. Arguments are as for Destroy.

Examples

julia> h = FockSpace(:cavity);julia> a = Destroy(h, :a);julia> Create(h, :a) == a'true

See also Destroy, FockSpace.

Transition(h::NLevelSpace, name::Symbol, i, j)
Transition(h::ProductSpace, name::Symbol, i, j, [subsystem::Int])

Transition operator from level j to level i.

The operator is $\sigma^{ij} = |i\rangle\langle j|$. The levels are integers or the symbolic names of the NLevelSpace; either way it prints with level numbers. Transitions on the same system compose, $\sigma^{ij}\sigma^{kl} = \delta_{jk}\sigma^{il}$, and the adjoint swaps the levels. The ground-state projector $\sigma^{gg}$ is kept as it is; call expand_completeness to rewrite it in terms of the other projectors. On a ProductSpace, subsystem selects the factor and may be omitted when only one NLevelSpace is present.

Examples

julia> h = FockSpace(:cavity) ⊗ NLevelSpace(:atom, 2);julia> σ = Transition(h, :σ, 1, 2);julia> σ * σ', σ' * σ, σ * σ(σ₁₁, σ₂₂, 0)

See also NLevelSpace, expand_completeness, @qnumbers.

transition_levels(o::Op) -> Tuple{Int, Int}

The levels (i, j) of a Transition $|i\rangle\langle j|$. Throws an ArgumentError for any other operator.

Examples

julia> using SecondQuantizedAlgebra: transition_levelsjulia> transition_levels(Transition(NLevelSpace(:atom, 3), :σ, 3, 1))(3, 1)

See also n_levels.

n_levels(o::Op) -> Int
ground_state(o::Op) -> Int

The number of levels and the ground level of the NLevelSpace a Transition acts on. Throws an ArgumentError for any other operator.

Examples

julia> using SecondQuantizedAlgebra: n_levels, ground_statejulia> σ = Transition(NLevelSpace(:atom, 3), :σ, 3, 1);julia> n_levels(σ), ground_state(σ)(3, 1)

See also transition_levels.

n_levels(o::Op) -> Int
ground_state(o::Op) -> Int

The number of levels and the ground level of the NLevelSpace a Transition acts on. Throws an ArgumentError for any other operator.

Examples

julia> using SecondQuantizedAlgebra: n_levels, ground_statejulia> σ = Transition(NLevelSpace(:atom, 3), :σ, 3, 1);julia> n_levels(σ), ground_state(σ)(3, 1)

See also transition_levels.

Pauli(h::PauliSpace, name::Symbol, axis::Int)
Pauli(h::ProductSpace, name::Symbol, axis::Int, [subsystem::Int])

Pauli matrix along axis, where 1, 2, 3 stand for x, y, z.

Pauli operators are Hermitian and multiply as $\sigma_j \sigma_k = \delta_{jk} + i \epsilon_{jkl} \sigma_l$, so every product on one qubit reduces to a single Pauli matrix or a number. On a ProductSpace, subsystem selects the PauliSpace factor and may be omitted when there is only one.

Examples

julia> h = PauliSpace(:s);julia> σx = Pauli(h, :σ, 1); σy = Pauli(h, :σ, 2);julia> σx * σyim * σzjulia> σx * σx1

See also PauliSpace, Spin.

Spin(h::SpinSpace, name::Symbol, axis::Int)
Spin(h::ProductSpace, name::Symbol, axis::Int, [subsystem::Int])

Angular momentum component along axis, where 1, 2, 3 stand for x, y, z.

Spin operators are Hermitian and obey $[S_j, S_k] = i \epsilon_{jkl} S_l$. Products are ordered by axis, $x$ before $y$ before $z$. Squares such as $S_x^2$ stay as they are, since the spin length is not fixed. On a ProductSpace, subsystem selects the SpinSpace factor and may be omitted when there is only one.

Examples

julia> h = SpinSpace(:S);julia> Sx = Spin(h, :S, 1); Sy = Spin(h, :S, 2);julia> Sy * Sx-im * Sz + Sx * Sy

See also SpinSpace, Pauli.

operator_axis(o::Op) -> Int

The axis 1, 2 or 3 of a Pauli or Spin operator. Throws an ArgumentError for any other operator.

Examples

julia> using SecondQuantizedAlgebra: operator_axisjulia> operator_axis(Pauli(PauliSpace(:q), :σ, 2))2

Position(h::PhaseSpace, name::Symbol)
Position(h::ProductSpace, name::Symbol, [subsystem::Int])

Position quadrature of a mode.

The operator $x = (a + a^\dagger)/\sqrt{2}$ is Hermitian and canonically conjugate to Momentum, $[x, p] = i$. Products are ordered with position to the left of momentum. On a ProductSpace, subsystem selects the PhaseSpace factor and may be omitted when there is only one.

Examples

julia> h = PhaseSpace(:osc);julia> @qnumbers x::Position(h) p::Momentum(h);julia> commutator(x, p)im

See also Momentum, PhaseSpace.

Momentum(h::PhaseSpace, name::Symbol)
Momentum(h::ProductSpace, name::Symbol, [subsystem::Int])

Momentum quadrature of a mode.

The operator $p = i(a^\dagger - a)/\sqrt{2}$ is Hermitian and canonically conjugate to Position. Arguments are as for Position.

Examples

julia> h = PhaseSpace(:osc);julia> @qnumbers x::Position(h) p::Momentum(h);julia> p' == ptruejulia> p * x-im + x * p

See also Position, PhaseSpace.

QField

Supertype of every operator expression.

Operators (QSym), their polynomials (QAdd) and expressions with formal functions (QExpr) are all QFields. They support +, -, *, / by numbers, integer powers, adjoint, and comparison with == and isequal. A method written for QField accepts any of them.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> (a, a' * a, cos(a + a')) isa NTuple{3, SecondQuantizedAlgebra.QField}true

See also QSym, QAdd, QExpr.

QSym <: QField

Supertype of single operators.

Every operator, whatever its kind, is an Op, the only subtype; its kind is read with optype.

See also QField, Op.

Op <: QSym

Type of every single operator, whatever its kind.

Operators are made with Destroy, Create, Transition, CollectiveTransition, Pauli, Spin, Position and Momentum, never with Op directly. Since all of them share this type, use optype or the predicates such as is_destroy to tell them apart instead of isa.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> a isa Op, is_destroy(a), is_create(a')(true, true, true)

See also optype, operator_name, acts_on.

optype(o::Op) -> OpKind

Kind of the operator o.

The result is one of OP_DESTROY, OP_CREATE, OP_TRANSITION, OP_COLLECTIVE_TRANSITION, OP_PAULI, OP_SPIN, OP_POSITION or OP_MOMENTUM. These constants are public but not exported, so write them qualified, e.g. SecondQuantizedAlgebra.OP_DESTROY. For a single check the predicates such as is_destroy read better.

Examples

julia> σ = Transition(NLevelSpace(:atom, 2), :σ, 2, 1);julia> optype(σ) == SecondQuantizedAlgebra.OP_TRANSITIONtrue

See also Op, is_destroy.

OpKind

Kind of an operator, as returned by optype.

The values are OP_DESTROY, OP_CREATE, OP_TRANSITION, OP_COLLECTIVE_TRANSITION, OP_PAULI, OP_SPIN, OP_POSITION and OP_MOMENTUM. They are public but not exported.

Examples

julia> optype(Destroy(FockSpace(:cavity), :a)') === SecondQuantizedAlgebra.OP_CREATEtrue

See also optype, is_destroy.

is_destroy(o::Op) -> Bool

Whether o is an annihilation operator, see Destroy.

All operators share the type Op, so this predicate and its siblings take the place of isa checks.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> is_destroy(a), is_destroy(a')(true, false)

See also is_create, is_transition, is_collective_transition, is_pauli, is_spin, is_position, is_momentum, optype.

is_create(o::Op) -> Bool

Whether o is a creation operator, see Create.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> is_create(a'), is_create(a)(true, false)

See also is_destroy, optype.

is_transition(o::Op) -> Bool

Whether o is a transition operator, see Transition.

Examples

julia> σ = Transition(NLevelSpace(:atom, 2), :σ, 1, 2);julia> is_transition(σ)true

See also is_destroy, optype.

is_collective_transition(o::Op) -> Bool

Whether o is a collective transition operator, see CollectiveTransition.

Examples

julia> S = CollectiveTransition(CollectiveNLevelSpace(:atoms, 2), :S, 1, 2);julia> is_collective_transition(S), is_transition(S)(true, false)

See also is_destroy, optype.

is_pauli(o::Op) -> Bool

Whether o is a Pauli operator, see Pauli.

Examples

julia> σx = Pauli(PauliSpace(:qubit), :σ, 1);julia> is_pauli(σx)true

See also is_destroy, optype.

is_spin(o::Op) -> Bool

Whether o is a spin operator, see Spin.

Examples

julia> Sx = Spin(SpinSpace(:S), :S, 1);julia> is_spin(Sx)true

See also is_destroy, optype.

is_position(o::Op) -> Bool

Whether o is a position quadrature, see Position.

Examples

julia> x = Position(PhaseSpace(:osc), :x);julia> is_position(x), is_momentum(x)(true, false)

See also is_destroy, optype.

is_momentum(o::Op) -> Bool

Whether o is a momentum quadrature, see Momentum.

Examples

julia> p = Momentum(PhaseSpace(:osc), :p);julia> is_momentum(p)true

See also is_destroy, optype.

operator_name(op::Op) -> Symbol

Name of the operator op, as given at construction.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> operator_name(a), operator_name(a')(:a, :a)

See also operator_index, acts_on.

operator_index(o::Op) -> Index

Site Index of the operator o. An operator without an index returns a placeholder for which has_index is false.

Examples

julia> @variables N;julia> h = NLevelSpace(:atom, 2); i = Index(h, :i, N, h);julia> σ = Transition(h, :σ, 2, 1);julia> operator_index(IndexedOperator(σ, i)) == i, has_index(operator_index(σ))(true, false)

See also IndexedOperator, operator_name, acts_on.

acts_on(expr) -> Vector{Int}
acts_on(i::Index) -> Vector{Int}

Subsystems that expr acts on, as sorted positions in its ProductSpace.

Works on operators, operator expressions and their averages. A number acts on nothing and returns an empty vector. For an Index it returns the subsystem the index runs over.

Examples

julia> h = FockSpace(:a) ⊗ NLevelSpace(:b, 2);julia> @qnumbers a::Destroy(h, 1) σ::Transition(h, 1, 2, 2);julia> acts_on(a' * a), acts_on(a' * σ)([1], [1, 2])

See also operator_name, operator_index.

set_acts_on(op, subsystem::Int)

Copy of the operator op acting on another factor of a product space.

Name, kind, levels and index are kept. This reuses an operator built on a single space inside a product space, or moves it to another factor. The function is not exported.

Examples

julia> using SecondQuantizedAlgebra: set_acts_onjulia> σ = Transition(NLevelSpace(:atom, 2), :σ, 2, 1);julia> h = FockSpace(:cavity) ⊗ NLevelSpace(:atom, 2);julia> Destroy(h, :a, 1) * set_acts_on(σ, 2)a * σ₂₁

See also acts_on, rename.

dagger(x::QField)

Hermitian conjugate of an operator expression, the same as x'.

Coefficients are conjugated along with the operators. The name matches dagger from QuantumOptics.jl, so code can use it for symbolic and numeric operators alike.

Examples

julia> h = FockSpace(:cavity) ⊗ NLevelSpace(:atom, 2);julia> @qnumbers a::Destroy(h, 1) σ::Transition(h, 1, 2, 2);julia> dagger(2im * a' * σ)-2im * a * σ₂₁

See also qadjoint.

qadjoint(x)
qconj(x)

Hermitian conjugate of an operator expression or a coefficient.

For an operator expression this is x'. For a coefficient the conjugate is taken through the expression tree, so that it reaches the individual parameters instead of wrapping the whole expression in conj. An average becomes the average of the adjoint, as with inner_adjoint.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables g::Number;julia> qadjoint(2im * a), qadjoint(g)(-2im * a', conj(g))

See also dagger, inner_adjoint.

transition_superscript(x::Bool)

Choose whether transition levels are written as superscripts or subscripts in LaTeX.

With true, the default, $\sigma^{ij}$ is written; with false, $\sigma_{ij}$. The setting is global and applies to every later call of latexify. The function is not exported.

Examples

julia> using SecondQuantizedAlgebra: transition_superscriptjulia> using Latexifyjulia> σ = Transition(NLevelSpace(:atom, 2), :σ, 2, 1);julia> transition_superscript(false); latexify(σ)L"${\sigma}_{{21}}$"julia> transition_superscript(true); latexify(σ)L"${\sigma}^{{21}}$"

See also Transition.