symop.polynomial.channels.primitives.bogoliubov¶

Bogoliubov rewrites for CCR polynomial representations.

This module implements active linear bosonic transformations that mix creation and annihilation operators. In an ordered basis of modes, the transformation is specified by matrices X and Y such that

\[a_k^\dagger \;\mapsto\; \sum_j X_{j k}\, a_j^\dagger + Y_{j k}\, a_j,\]

with the annihilation transformation determined by adjunction,

\[a_k \;\mapsto\; \sum_j \overline{Y_{j k}}\, a_j^\dagger + \overline{X_{j k}}\, a_j.\]

When Y = 0, the transformation reduces to a passive linear mode map.

Notes

This primitive is naturally suited for density and operator polynomial rewrites. For ket polynomials, substitution may generate annihilation operators even when acting on creator-only expressions, so an additional CCR reduction step is required after rewriting.

Functions

`apply_to_densitypoly`(rho, *, bmap)	Apply a Bogoliubov rewrite to a density polynomial.
`apply_to_ketpoly`(poly, *, bmap, reduce_ketpoly)	Apply a Bogoliubov rewrite to a ket polynomial and reduce the result.
`apply_to_oppoly`(op, *, bmap)	Apply a Bogoliubov rewrite to an operator polynomial.
`make_right_substitution`(bmap)	Construct the bra-side substitution induced by a Bogoliubov map.
`make_substitution`(bmap)	Construct the ladder-operator substitution induced by a Bogoliubov map.

Classes

BogoliubovMap(modes, X, Y[, check_ccr, atol])

Represent an active linear bosonic map on an ordered mode basis.

class BogoliubovMap(modes: tuple[ModeOp, ...], X: ndarray, Y: ndarray, check_ccr: bool = False, atol: float = 1e-10) → None¶

Bases: object

Represent an active linear bosonic map on an ordered mode basis.

The ordered tuple modes defines the basis in which the matrices X and Y are interpreted. Column k of these matrices gives the image of input mode k in the ordered output basis.

In the Heisenberg picture, the ladder operators transform as

\[a_k^\dagger \;\mapsto\; \sum_j X_{j k}\, a_j^\dagger + Y_{j k}\, a_j,\]

and

\[a_k \;\mapsto\; \sum_j \overline{Y_{j k}}\, a_j^\dagger + \sum_j \overline{X_{j k}}\, a_j.\]

Optional CCR validation checks the bosonic constraints

\[X^\dagger X - Y^\dagger Y = I,\]

and

\[X^T Y - Y^T X = 0,\]

within the numerical tolerance atol.

Parameters:

modes (tuple[ModeOp, ...]) – Ordered mode basis used for the matrix representation.
X (ndarray) – Matrix multiplying creation operators in the Bogoliubov transformation.
Y (ndarray) – Matrix mixing creation and annihilation operators in the Bogoliubov transformation.
check_ccr (bool) – If True, validate the bosonic CCR consistency conditions.
atol (float) – Absolute tolerance used for optional CCR validation.

Notes

When Y = 0, this object describes an ordinary passive linear mode transformation.

X: ndarray¶

Y: ndarray¶

atol: float = 1e-10¶

check_ccr: bool = False¶

modes: tuple[ModeOp, ...]¶

apply_to_densitypoly(rho: DensityPoly, *, bmap: BogoliubovMap) → DensityPoly¶

Apply a Bogoliubov rewrite to a density polynomial.

The density polynomial is rewritten as the symbolic adjoint action

rho -> S rho S^dagger

by using the ket-side substitution on the left monomials and the corresponding bra-side substitution on the right monomials.

Parameters:

rho (DensityPoly) – Input density polynomial.
bmap (BogoliubovMap) – Bogoliubov transformation to apply.

Returns:

Rewritten density polynomial after the active linear bosonic transformation.

Return type:

DensityPolyProtocol

apply_to_ketpoly(poly: KetPoly, *, bmap: BogoliubovMap, reduce_ketpoly: Callable[[KetPoly], KetPoly]) → KetPoly¶

Apply a Bogoliubov rewrite to a ket polynomial and reduce the result.

The ket polynomial is first rewritten by substituting ladder operators according to the Bogoliubov transformation. Because active transformations may generate annihilation operators even when acting on creator-only expressions, the rewritten polynomial must then be reduced using a caller-supplied CCR reduction routine.

Parameters:

poly (KetPoly) – Input ket polynomial.
bmap (BogoliubovMap) – Bogoliubov transformation to apply.
reduce_ketpoly (Callable[[KetPoly], KetPoly]) – Callback that performs the required CCR reduction or normal ordering after substitution.

Returns:

Reduced ket polynomial after substitution and CCR reduction.

Return type:

KetPoly

Notes

Unlike passive linear mode maps, a Bogoliubov transformation cannot in general be handled by simply discarding annihilator-containing terms. The reduction callback is responsible for applying the CCR relations and returning a valid ket representation.

apply_to_oppoly(op: OpPoly, *, bmap: BogoliubovMap) → OpPoly¶

Apply a Bogoliubov rewrite to an operator polynomial.

Each ladder operator in the operator polynomial is rewritten according to the Bogoliubov transformation defined by bmap.

Parameters:

op (OpPoly) – Input operator polynomial.
bmap (BogoliubovMap) – Bogoliubov transformation to apply.

Returns:

Rewritten operator polynomial after the active linear bosonic transformation.

Return type:

OpPolyProtocol

make_right_substitution(bmap: BogoliubovMap) → Callable[[LadderOp], list[tuple[complex, LadderOp]]]¶

Construct the bra-side substitution induced by a Bogoliubov map.

This is the substitution used on the right monomial of a density term, corresponding to the adjoint-side action needed for

rho -> S rho S^dagger.

Parameters:: bmap (BogoliubovMap)
Return type:: Callable[[LadderOp], list[tuple[complex, LadderOp]]]

make_substitution(bmap: BogoliubovMap) → Callable[[LadderOp], list[tuple[complex, LadderOp]]]¶

Construct the ladder-operator substitution induced by a Bogoliubov map.

The returned substitution function rewrites ladder operators according to the Heisenberg action of bmap. If an operator acts on a mode not present in bmap.modes, it is left unchanged.

For creation operators, the substitution is

\[a_k^\dagger \;\mapsto\; \sum_j X_{j k}\, a_j^\dagger + Y_{j k}\, a_j.\]

For annihilation operators, the substitution is

\[a_k \;\mapsto\; \sum_j \overline{Y_{j k}}\, a_j^\dagger + \sum_j \overline{X_{j k}}\, a_j.\]

Parameters:: bmap (BogoliubovMap) – Bogoliubov transformation specification.
Returns:: Substitution function mapping a ladder operator to a list of (coefficient, operator) pairs.
Return type:: callable

Notes

The substitution acts only on operators whose mode signatures are present in bmap.modes. Other operators pass through unchanged.