Parameters and coefficients

The coefficients of an operator expression are scalars: exact numbers or symbolic expressions from Symbolics.jl. They multiply operators without touching the operator algebra, and simplify applies symbolic identities to them.

Symbolic parameters
Unit phases
Coefficient identities
Substitution
Taking expressions apart
Harmonic projection

Symbolic parameters

Parameters are declared with @variables, which is re-exported from Symbolics. A plain declaration is real, so it is its own complex conjugate.

using SecondQuantizedAlgebraa = Destroy(FockSpace(:cavity), :a)@variables ω η::Number ζ::Complex(ω * a)'

\[\omega a^{\dagger}\]

A parameter declared ::Number is complex but stays a single symbol.

(η * a)'

\[\mathrm{conj}\left( \eta \right) a^{\dagger}\]

A parameter declared ::Complex is split into independent real and imaginary parts.

(ζ * a)'

\[\left(\mathrm{real}\left( \zeta \right) - \mathrm{imag}\left( \zeta \right) ~ \mathit{i}\right) a^{\dagger}\]

In summary:

Declaration	`conj`	Representation
`@variables ω` (or `ω::Real`)	`ω`	one real symbol
`@variables η::Number`	`conj(η)`	one complex symbol
`@variables ζ::Complex`	`real(ζ) - im*imag(ζ)`	independent real and imaginary parts

A complex amplitude such as a drive is best declared ::Number, which keeps every product to a single symbol. ::Complex carries both parts through every product, and suits a parameter whose real and imaginary parts are wanted as independent unknowns.

Unit phases

Time-dependent drives and rotating frames produce phase factors $e^{i\phi}$. These are written with expim, which keeps them exact. The argument has to be real, since the identities $\overline{e^{ix}} = e^{-ix}$ and $|e^{ix}| = 1$ hold only for real $x$.

SecondQuantizedAlgebra.expim — Method

expim(x)

Exact unit phase with real argument x.

expim(x) stands for $e^{ix}$ and is kept as an exact symbol rather than a generic exponential. Multiplying phases adds their arguments and opposite phases cancel, so the factors produced by drives and frame changes do not pile up.

The argument has to be real; for a complex exponent use exp. Fractional powers are refused, since they would have to pick a branch.

Examples

julia> @variables ω t θ;julia> expim(ω * t) * expim(θ)exp(im*(θ + t*ω))julia> conj(expim(ω * t)) * expim(ω * t)1julia> a = Destroy(FockSpace(:cavity), :a);julia> expim(ω * t) * expim(-ω * t) * aa

source

The same phase is recognized however its argument is written.

using SecondQuantizedAlgebrausing SecondQuantizedAlgebra: exponential_form, trigonometric_formimport Symbolics@variables ω t θ ra = Destroy(FockSpace(:cavity), :a)expim((ω + 2θ) * t) == expim(ω * t + 2θ * t)

true

Integer powers, negative ones included, and division also stay a single phase.

expim(θ)^3 / expim(ω * t), expim(θ)^-2

(exp(im*(3θ - t*ω)), exp(-im*2θ))

A fractional power would have to pick a branch, so sqrt(expim(θ)) and expim(θ)^(1//2) have no method rather than being rewritten as expim(θ/2).

Substitution rebuilds the phase from its new argument.

substitute(expim(ω * t), Dict(ω => 2ω))

\[e^{i 2 ~ t ~ \omega}\]

Arguments are compared algebraically, not modulo $2\pi$, so expim(θ + 2π) is not recognized as expim(θ).

Differentiation follows the chain rule through the argument.

Symbolics.derivative(expim(ω * t), t)

\[e^{i t ~ \omega} ~ \omega ~ \mathit{i}\]

A coefficient that is exactly one unit phase has the familiar trigonometric projections.

real(expim(ω * t)), imag(expim(ω * t)), abs(expim(ω * t)), abs2(expim(ω * t))

(cos(t*ω), sin(t*ω), 1, 1)

A phase keeps the form it was written in, so positive and negative frequencies are not merged into a cosine.

(expim(ω * t) + expim(-ω * t)) * a

\[\left(e^{i t ~ \omega} + e^{-i t ~ \omega}\right) a\]

Switching between the exponential and the trigonometric form is explicit, in both directions. Neither conversion is applied by display or by simplify, and expim(cos(θ)) stands for $e^{i\cos\theta}$, not for a conversion of the cosine.

SecondQuantizedAlgebra.exponential_form — Function

exponential_form(x)

Rewrite cosines and sines in x as unit phases.

x can be a coefficient or a whole operator expression. The function is not exported.

Examples

julia> using SecondQuantizedAlgebra: exponential_formjulia> @variables ω t;julia> a = Destroy(FockSpace(:cavity), :a);julia> exponential_form(cos(ω * t) * a)((1//2)*exp(im*t*ω) + (1//2)*exp(-im*t*ω)) * a

Coefficient identities

Symbolic identities are applied only by simplify. It covers trigonometric and hyperbolic identities, also with composite arguments, and leaves a coefficient unchanged when an identity cannot be applied without blowing up the expression.

simplify((cosh(r)^2 - sinh(r)^2) * (a + a'))

\[a + a^{\dagger}\]

Substitution

Parameters and operators are replaced in a single call, with all rules applied at once. Shifting a mode by a coherent amplitude while fixing a frequency gives the displaced Hamiltonian.

@variables α::Numbersubstitute(ω * a' * a, Dict(a => a + α, ω => 2))

\[2 ~ \mathrm{conj}\left( \alpha \right) ~ \alpha + 2 ~ \mathrm{conj}\left( \alpha \right) a + 2 ~ \alpha a^{\dagger} + 2 a^{\dagger}a\]

SymbolicUtils.substitute — Method

substitute(expr::QField, rules::AbstractDict; replace_adjoint=true)

Replace parameters and operators in expr according to rules.

Keys may be parameters or operators, mixed freely. Operator rules act on the original expression all at once, so a rule whose replacement contains its own key, such as the shift a => a + α, is applied exactly once. A rule for a also covers a', unless a' has a rule of its own or replace_adjoint = false.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables Δ α::Number;julia> substitute(Δ * a' * a, Dict(Δ => 2))2 * a' * ajulia> substitute(a' * a, Dict(a => a + α))conj(α)*α + conj(α) * a + α * a' + a' * a

Taking expressions apart

To hand an expression to other code, for instance to build a numerical function from its coefficients, its parts can be read off directly. An expression first splits into its terms, and each term into a coefficient and operators.

using SecondQuantizedAlgebra: sorted_argumentsterms = sorted_arguments(ω * a' * a + η * a)

\[ \left[ \begin{array}{c} \eta a \\ \omega a^{\dagger}a \\ \end{array} \right] \]

get_prefactor(terms[2]), get_operators(terms[2])

(ω, Op[a, a'])

SecondQuantizedAlgebra.sorted_arguments — Function

sorted_arguments(expr)

Terms of expr, each as an expression of its own, in a fixed order.

Each term can then be read with get_prefactor and get_operators. The function is not exported.

Examples

julia> using SecondQuantizedAlgebra: sorted_argumentsjulia> a = Destroy(FockSpace(:cavity), :a);julia> @variables ω g;julia> foreach(println, sorted_arguments(ω * a' * a + g * (a + a')))g * ag * a'ω * a' * a

source

SecondQuantizedAlgebra.get_prefactor — Function

get_prefactor(expr)

Coefficient of a single-term expression expr, as a Complex{Num}.

An expression with more than one term throws an ArgumentError.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables g;julia> get_prefactor(2g * a' * a)2g

source

SecondQuantizedAlgebra.get_operators — Function

get_operators(expr)

Distinct operators occurring in expr, in canonical order.

An operator and its adjoint count as two entries, and repeated factors appear once.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables g;julia> get_operators(g * a' * a + a)2-element Vector{Op}: a a'

source

Symbolics.get_variables — Method

get_variables(expr)

Symbolic parameters occurring in the coefficients of expr.

The result can be passed to Symbolics functions such as build_function. An optional second argument restricts it to a given list of variables.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables ω g;julia> H = ω * a' * a + g * (a + a');julia> length(get_variables(H))2

source

Iterating an expression gives its terms as pairs of an operator product and a coefficient, kept in exact form. to_num converts a coefficient to Symbolics.

using SecondQuantizedAlgebra: to_num[(term.ops, to_num(c)) for (term, c) in 3ω * a' * a]

1-element Vector{Tuple{Vector{Op}, Complex{Symbolics.Num}}}:
 ([a', a], 3ω)

SecondQuantizedAlgebra.QTerm — Type

QTerm

Operator product of one term of an expression.

Iterating an expression gives pairs term => coefficient of a QTerm and a Coeff. The field ops holds the operators in canonical order, and ne the pairs of indices the term requires to differ. It is public but not exported.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> [term.ops for (term, c) in 2 * a' * a]1-element Vector{Vector{Op}}: [a', a]

Harmonic projection

harmonics splits an expression into its Fourier components in a base frequency ω, the step behind a rotating-wave or secular approximation. harmonic returns one component, the coefficient of expim(n * ω * t), and secular the static one:

using SecondQuantizedAlgebrah = FockSpace(:harmonic_example)@qnumbers a::Destroy(h)@variables ω::Real t::Realimport SecondQuantizedAlgebra: harmonic, harmonics, secular@variables ω0::Real ωd::Real F::Real τ::RealH = ω0 * a' * a - F * (a + a') * (expim(ωd * τ) + expim(-ωd * τ)) / 2Hrot = transform(H, Rotation(a, ωd * τ, τ))harmonics(Hrot, ωd, τ)

Dict{Int64, SecondQuantizedAlgebra.QAdd} with 3 entries:
  0  => (-1//2)*F * a - (1//2)*F * a' + (ω0 - ωd) * a' * a
  2  => (-1//2)*F * a'
  -2 => (-1//2)*F * a

secular(Hrot, ωd, τ)

\[ - \frac{1}{2} ~ F a - \frac{1}{2} ~ F a^{\dagger} + \left(\mathtt{{\omega}0} - \mathtt{{\omega}d}\right) a^{\dagger}a\]

The decomposition is exact: summing harmonic(x, ω, t, n) * expim(n * ω * t) over the returned orders gives exponential_form(x). A phase that is not an exact integer multiple of ω * t plus a constant, or a time dependence outside a phase, throws an ArgumentError rather than being dropped, because assigning it would assume a relation between frequencies. The same functions act on SuperOperators and Lindbladians.

SecondQuantizedAlgebra.harmonics — Function

harmonics(x, ω, t) -> Dict{Int}

Decompose x into its Fourier components in the base frequency ω, so that

x == sum(xₙ * expim(n * ω * t) for (n, xₙ) in harmonics(x, ω, t))

after exponential_form. x is a coefficient, a quantum expression, a SuperOperator or a Lindbladian; the components have the type of x (a Coeff for a scalar, a QAdd for an operator). Zero components are omitted.

Trigonometric factors are converted to expim first, as in phase_terms. Every phase must be n * ω * t + φ with an exact integer n and a t-independent offset φ, which stays in the component as expim(φ). Anything else throws an ArgumentError instead of being dropped or assigned to a guessed harmonic: a frequency that is not an exact integer multiple of ω (such as ω' or ω/2), a phase nonlinear in t, or a t-dependence outside a phase. Choose ω as the common base frequency of all phases.

For a Lindbladian the projection acts on the GKSL form, H, the rates and the jumps, and returns a Lindbladian; a jump J = Σ Jₘ expim(m ω t) with partner K = Σ Kₗ expim(l ω t) contributes 𝒟[Jₘ, Kₗ] to harmonic m - l. Only the secular (n = 0) part is again Hermiticity preserving in general.