Unitary transformations

conjugate(A, U::UnitaryTransform)
conjugate(L, U::UnitaryTransform)

Image of an operator expression under a unitary transformation.

The result is $U^\dagger A U$, with every operator replaced by its exact image; no series is truncated. Formal operator functions are transformed through their arguments. For a Lindbladian or a superoperator L, every operator it contains is conjugated, so a channel $\mathcal{D}[J]$ becomes $\mathcal{D}[U^\dagger J U]$. For a Hamiltonian in a time-dependent frame use transform, which adds the term from the motion of the frame.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables α::Number;julia> conjugate(a' * a, Displace(a, α))conj(α)*α + conj(α) * a + α * a' + a' * a

See also transform, UnitaryTransform.

transform(H, U::UnitaryTransform)
transform(L, U::UnitaryTransform)

Hamiltonian in the frame of a unitary transformation.

The result is $U^\dagger H U + i (\partial_t U^\dagger) U$. The second term, returned by gauge_term, comes from the motion of a time-dependent frame. For a static transformation it vanishes and transform agrees with conjugate. For a Lindbladian L, the Hamiltonian is transformed and every jump is conjugated.

QuantumOpticsBase also exports a transform. With both packages loaded, import the name explicitly, using SecondQuantizedAlgebra: transform, or qualify it.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables ω g t;julia> transform(ω * a' * a + g * (a + a'), Rotation(a, ω * t, t))exp(-im*t*ω)*g * a + exp(im*t*ω)*g * a'

See also conjugate, gauge_term, RotatingFrame.

gauge_term(U::UnitaryTransform)

Term that the motion of a time-dependent frame adds to a Hamiltonian.

It is $i (\partial_t U^\dagger) U$, zero for a static transformation. transform adds it automatically.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables ω t;julia> gauge_term(Rotation(a, ω * t, t))-ω * a' * a

See also transform.

RotatingFrame(H0, t)

Frame rotating with a time-independent Hamiltonian H0, the interaction picture.

The transformation is $U = e^{-i H_0 t}$. With transform, a Hamiltonian $H_0 + V$ becomes $U^\dagger V U$, since the motion of the frame cancels H0. H0 must be Hermitian and of a form that UnitaryTransform can exponentiate.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables ω g t;julia> transform(ω * a' * a + g * (a + a'), RotatingFrame(ω * a' * a, t))exp(-im*t*ω)*g * a + exp(im*t*ω)*g * a'

See also transform, Rotation.

Rotation(a, θ)
Rotation(a, b, θ)
Rotation(x, p, θ)
Rotation(S, axis::Int, θ)
Rotation(σ, W::AbstractMatrix)
Rotation(a, θ, t)
Rotation(a, b, θ, t)
Rotation(x, p, θ, t)
Rotation(S, axis::Int, θ, t)
Rotation(σ, W::AbstractMatrix, t)

Rotation of a mode, of a pair of modes or quadratures, of a spin, or of the levels of a finite-level system.

• Rotation(a, θ) turns the phase of a mode, $a \mapsto e^{-i\theta} a$.
• Rotation(a, b, θ) mixes two modes as a beam splitter, $a \mapsto \cos\theta\, a + \sin\theta\, b$ and $b \mapsto -\sin\theta\, a + \cos\theta\, b$.
• Rotation(x, p, θ) rotates a pair of quadratures in phase space in the same way.
• Rotation(S, axis, θ) rotates a spin or Pauli triple by θ about axis (1, 2 or 3); S is any component of the triple.
• Rotation(σ, W) changes the basis of a finite-level system, $\sigma^{ij} \mapsto W^\dagger \sigma^{ij} W$, acting on all transitions of the system; σ is any one of them. W is a square unitary matrix with one row per level; its size is checked, its unitarity is not.

With a final time variable t, the angle or matrix may depend on time and the transformation carries the gauge_term of the moving frame.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables θ;julia> conjugate(a, Rotation(a, θ))exp(-im*θ) * ajulia> Sx = Spin(SpinSpace(:S), :S, 1);julia> conjugate(Sx, Rotation(Sx, 3, θ))cos(θ) * Sx - sin(θ) * Sy

See also RotatingFrame, Squeeze, Displace.

DisplacementFrame(a, H)
DisplacementFrame(x, p, H)
DisplacementFrame(a, H, t)
DisplacementFrame(x, p, H, t)
DisplacementFrame(a, L)
DisplacementFrame(a, L, t)

Displacement to the classical steady state of a driven mode.

H is a Hamiltonian of one mode that is at most linear in the drive, such as $\Delta a^\dagger a + \eta a^\dagger + \eta^* a$. The transformation displaces the mode by its steady-state amplitude, here $-\eta/\Delta$, which removes the drive. The quadrature form accepts any Hermitian quadratic H. With a time variable t the drive may be a finite sum of phases expim(ω t), and the frame follows the steady driven response, without the transient free oscillation. A drive on resonance throws an ArgumentError, and symbolic denominators are kept as written.

With a damped linear Lindbladian L in place of H, the amplitude is the fixed point of the drift transpose(L)(a) = λ a + c, so loss and heating enter it as well.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables Δ η::Number;julia> H = Δ * a' * a + η * a' + conj(η) * a;julia> conjugate(H, DisplacementFrame(a, H))(-conj(η)*η) / Δ + Δ * a' * a

See also Displace, transform.

Displace(a, α)
Displace(x, p, dx, dp)
Displace(a, α, t)
Displace(x, p, dx, dp, t)

Displacement of a bosonic mode or of a pair of quadratures.

The mode a is shifted by the complex amplitude α, $a \mapsto a + \alpha$. A pair of quadratures is shifted by real amounts, $x \mapsto x + dx$ and $p \mapsto p + dp$. With a final time variable t, the amplitudes may depend on time and the transformation carries the gauge_term of the moving frame.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables α::Number;julia> conjugate(a' * a, Displace(a, α))conj(α)*α + conj(α) * a + α * a' + a' * ajulia> h = PhaseSpace(:mode); x = Position(h, :x); p = Momentum(h, :p);julia> @variables dx dp;julia> conjugate(x * p, Displace(x, p, dx, dp))dp*dx + dp * x + dx * p + x * p

See also DisplacementFrame, Rotation, Squeeze.

Squeeze(a, r, ϕ = 0)
Squeeze(a, b, r)
Squeeze(x, p, r)
Squeeze(a, r, ϕ, t)
Squeeze(a, b, r, t)
Squeeze(x, p, r, t)

Squeezing of a mode, of a pair of modes, or of a pair of quadratures.

• Squeeze(a, r, ϕ) squeezes one mode, $a \mapsto \cosh r\, a + e^{i\phi} \sinh r\, a^\dagger$.
• Squeeze(a, b, r) squeezes two modes jointly, $a \mapsto \cosh r\, a + \sinh r\, b^\dagger$ and the same with a and b exchanged.
• Squeeze(x, p, r) rescales a pair of quadratures, $x \mapsto e^{r} x$ and $p \mapsto e^{-r} p$.

With a final time variable t, the parameters may depend on time and the transformation carries the gauge_term of the moving frame. A time-dependent single-mode squeeze always gives the phase, Squeeze(a, r, 0, t), since the third argument is ϕ.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables r;julia> conjugate(a, Squeeze(a, r))cosh(r) * a + sinh(r) * a'julia> conjugate(a, inv(Squeeze(a, r)))cosh(r) * a - sinh(r) * a'

See also Bogoliubov, Rotation.

Bogoliubov(modes, S::AbstractMatrix)
Bogoliubov(modes, U::AbstractMatrix, V::AbstractMatrix)

General linear transformation of bosonic modes that mixes annihilation and creation operators.

modes is one annihilation operator, or a vector or tuple of them. The block form maps $a \mapsto U a + V a^\dagger$. The full form acts on $(a_1, \ldots, a_N, a_1^\dagger, \ldots, a_N^\dagger)$ with the matrix S, which must have the block structure [U V; conj(V) conj(U)]. For the result to be unitary the blocks must preserve the commutation relations, $S J S^\dagger = J$ with $J = \mathrm{diag}(1_N, -1_N)$. This is the caller's responsibility, also after substitute: the modes and the matrix dimensions are checked, but the condition is not, and a numeric matrix is used as given, without tolerance or projection. For squeezing and beam splitters, Squeeze and Rotation satisfy it by construction.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables u::Number v::Number;julia> B = Bogoliubov(a, [u v; conj(v) conj(u)]);julia> conjugate(a, B)u * a + v * a'julia> conjugate(a, substitute(B, Dict(u => 5//3, v => 4//3)))5//3 * a + 4//3 * a'

See also Squeeze, Rotation, UnitaryTransform.

generators(U::UnitaryTransform)

Operators that the transformation U acts on, in canonical order.

Examples

julia> h = FockSpace(:a) ⊗ FockSpace(:b);julia> @qnumbers a::Destroy(h, 1) b::Destroy(h, 2);julia> @variables θ;julia> generators(Rotation(a, b, θ))4-element Vector{Op}: a a' b b'

See also UnitaryTransform.

UnitaryTransform(G, θ)
inv(U)
U1 * U2

Exact change of frame generated by a Hermitian operator.

UnitaryTransform(G, θ) is the transformation $U = e^{-i\theta G}$. The image of each operator follows in closed form when the commutators with G close on a finite set of operators and their exponential is known exactly, as for displacements, phase rotations, beam splitters and squeezers with numeric rates; otherwise an ArgumentError is thrown. The named constructors Displace, Rotation, Squeeze, Bogoliubov, RotatingFrame and DisplacementFrame cover the common frames, also with symbolic parameters.

inv(U) is the inverse transformation, and in a product U1 * U2 the left factor is applied first. Parameters of a transformation are replaced with substitute.

Examples

julia> a = Destroy(FockSpace(:cavity), :a);julia> @variables θ;julia> conjugate(a, UnitaryTransform(a' * a, θ))exp(-im*θ) * ajulia> conjugate(a, Displace(a, 1//2) * Rotation(a, θ))1//2 + exp(-im*θ) * a

See also conjugate, transform, generators.

displacement(U::UnitaryTransform, o::Op)

Return the c-number part of conjugate(o, U) for a Fock or phase-space operator o: α for conjugate(a, U) = L(a) + α with L linear. For a moving frame the result is the time-dependent amplitude; a site U does not act on gives zero.