Structural layer¶

Pauli strings and Pauli sums: exact Pauli algebra without operator construction.

Coefficients are complex numbers; the Pauli algebra is entered after the parameters have been bound. Two Pauli strings commute if and only if they differ in an even number of tensor positions, the product of two strings is a string times a phase, and the commutator of two Pauli sums is a Pauli sum. No Hilbert space is constructed.

The single-qubit conventions are shared with qsimod.realise.hilbert:

• the local basis index is the occupation number, |0> is empty and |1> is occupied;
• Z = 2n - 1 = diag(-1, +1), X = [[0,1],[1,0]], Y = [[0,i],[-i,0]];
• hence n = (Z + 1)/2, sigma^+ = |1><0| = (X + iY)/2, sigma^- = (X - iY)/2 and XY = iZ; the axes are right-handed.

IDENTITY_STRING = PauliString()

mapping: dict[int, PauliAxis]

support: frozenset[int]

weight: int

is_identity: bool

sort_key: tuple[int, tuple[tuple[int, str], ...]]

of(axes: Mapping[int, PauliAxis]) -> PauliString

single(qubit: int, axis: PauliAxis) -> PauliString

commutes_with(other: PauliString) -> bool

times(other: PauliString) -> tuple[PauliString, complex]

is_zero: bool

strings: tuple[PauliString, ...]

support: frozenset[int]

max_weight: int

one_norm: float

from_terms(
    terms: Iterable[tuple[PauliString, complex]],
    name: str = "",
) -> PauliSum

zero(name: str = '') -> PauliSum

scaled(factor: complex) -> PauliSum

times(other: PauliSum) -> PauliSum

adjoint() -> PauliSum

renamed(name: str) -> PauliSum

is_hermitian(tolerance: float = 1e-12) -> bool

internally_commuting() -> bool

commutes_with(other: PauliSum) -> bool

identity_coefficient() -> complex

weight_histogram() -> dict[int, int]

commutator(left: PauliSum, right: PauliSum) -> PauliSum

nested_commutator(operands: list[PauliSum]) -> PauliSum

pauli_sum_from_operator(
    hamiltonian: OperatorSum,
    environment: Mapping[str, float],
    structure: StructureType | None = None,
    name: str = "",
) -> PauliSum

Suzuki-Trotter product formulas, their a-priori error bounds and their resource summary.

The package implements the digital simulator model of the article, the product formula U_approx. It is generic over any Hamiltonian given as a layer decomposition of a Pauli sum: the a-priori error bound is computed from the commutators of the layers, and the resource summary counts gates and circuit depth in layers. Both are derived from the term structure by Pauli algebra.

Layer decompositions of a Hamiltonian and the commutation structure between layers.

A layer is a group of Pauli terms that mutually commute; each layer therefore exponentiates exactly into a product of one rotation per term. A decomposition is either declared (declared_layers) or derived by first-fit greedy grouping (derive_layers). Whether two layers commute is decided by computing their commutator.

support: frozenset[int]

term_count: int

one_norm: float

is_internally_commuting() -> bool

is_diagonal() -> bool

names: tuple[str, ...]

support: frozenset[int]

qubit_count: int

one_norm: float

total() -> PauliSum

layer_commutator(first: int, second: int) -> PauliSum

commuting_pairs() -> frozenset[tuple[int, int]]

non_commuting_pairs() -> tuple[tuple[int, int], ...]

commutation_report() -> str

layer_named(name: str) -> Layer

declared_layers(
    groups: Sequence[tuple[str, PauliSum]],
) -> LayerDecomposition

derive_layers(
    hamiltonian: PauliSum, name_prefix: str = "layer"
) -> LayerDecomposition

Suzuki-Trotter product formulas as stage schedules independent of the Hamiltonian.

A stage schedule is an ordered list of (layer index, coefficient) pairs whose coefficients sum to one on every layer; qsimod.trotter.schedule applies a schedule to a layer decomposition. The first-order Lie-Trotter formula, the second-order Strang formula and the Suzuki recursion for any even order 2k >= 4 are provided, with

S_2k(tau) = S_2k-2(p tau)**2 . S_2k-2((1 - 4p) tau) . S_2k-2(p tau)**2, p = 1 / (4 - 4**(1/(2k-1))).

Adjacent stages on the same layer are merged by the identity exp(-i a H) exp(-i b H) = exp(-i (a+b) H) at every level of the recursion; stages are not merged across step boundaries.

stage_count: int

one_norm_of_coefficients: float

is_symmetric: bool

lie_trotter(layer_count: int) -> ProductFormulaSchedule

strang(layer_count: int) -> ProductFormulaSchedule

suzuki_parameter(order: int) -> float

suzuki(
    order: int, layer_count: int
) -> ProductFormulaSchedule

supported_orders(maximum: int = 8) -> tuple[int, ...]

A-priori error bounds of product formulas in the spectral norm.

error_bound returns the minimum of the applicable bounds:

• for order 1, the commutator bound || exp(-iHt) - S_1(t/n)**n || <= (t**2 / 2n) sum_{g<g'} ||[H_g, H_g']||;
• for order 2, the commutator bound of Childs et al. with tau = t/n and the tail R_g = sum_{g'>g} H_g', per step (tau**3/12) sum_g ||[R_g, [R_g, H_g]]|| + (tau**3/24) sum_g ||[H_g, [R_g, H_g]]||;
• for every order, the stage-based Taylor-remainder bound t**(p+1) / (p+1)! / n**p * (||H|| + sum_s |c_s| ||H_g(s)||)**(p+1).

Norms are supplied by a NormEstimator; the default AdaptiveNormEstimator is exact up to DEFAULT_SPECTRAL_QUBIT_LIMIT qubits and uses the Pauli one-norm beyond.

norm(operator: PauliSum) -> float

is_exact() -> bool

norm(operator: PauliSum) -> float

is_exact() -> bool

norm(operator: PauliSum) -> float

is_exact() -> bool

norm(operator: PauliSum) -> float

is_exact() -> bool

commutator_bound(
    decomposition: LayerDecomposition,
    order: int,
    time: float,
    steps: int,
    estimator: NormEstimator,
) -> ErrorBound | None

taylor_remainder_bound(
    decomposition: LayerDecomposition,
    schedule: ProductFormulaSchedule,
    time: float,
    steps: int,
    estimator: NormEstimator,
) -> ErrorBound

error_bound(
    decomposition: LayerDecomposition,
    schedule: ProductFormulaSchedule,
    time: float,
    steps: int,
    estimator: NormEstimator | None = None,
) -> ErrorBound

The product-formula artifact, the digital simulator model U_approx of the article.

The artifact is an ordered sequence of k-local unitaries on a qubit register, parametrised by the simulated time t, the step count n and the order of the product formula. ProductFormulaModel stores the layer decomposition and the stage schedule; the (Pauli string, angle) factors of one step are derived on demand and the step is repeated n times. Factors are listed from left to right as written, so that the rightmost factor acts first on a state.

Depth convention: a depth layer is a maximal run of consecutive factors with pairwise disjoint support; the depth is computed for one step and multiplied by n, without packing across step boundaries. Resources are counted as k-local unitaries and depth layers only; no gate-set decomposition, CNOT count or routing is performed.

support: frozenset[int]

locality: int

as_row() -> dict[str, float | int | str]

kind: ArtifactKind

order: int

qubit_count: int

step_size: float

step_factors() -> tuple[UnitaryFactor, ...]

global_phase_per_step() -> float

support_structure() -> tuple[frozenset[int], ...]

resources(
    estimator: NormEstimator | None = None,
) -> ResourceSummary

error_bound(
    estimator: NormEstimator | None = None,
) -> ErrorBound

with_steps(steps: int) -> ProductFormulaModel

with_schedule(
    schedule: ProductFormulaSchedule,
) -> ProductFormulaModel

step_matrix() -> Array

matrix() -> Array

apply_to_state(state: Array) -> Array

factors_for(
    decomposition: LayerDecomposition,
    schedule: ProductFormulaSchedule,
    step_size: float,
) -> tuple[UnitaryFactor, ...]

global_phase_for(
    decomposition: LayerDecomposition,
    schedule: ProductFormulaSchedule,
    step_size: float,
) -> float

layer_depth_of(factors: Sequence[UnitaryFactor]) -> int

as_product_formula(
    artifact: Artifact, subject: str = "this operation"
) -> ProductFormulaModel