Trotterized Hamiltonian simulation¶

Trotterization approximates Hamiltonian time evolution by applying exponentials of simpler terms:

\( H=\sum_{j=1}^{m}h_j, \qquad U(t)=e^{-iHt}. \)

Zixy Hamiltonians¶

Zixy stores a Hamiltonian as a sum of coefficient-weighted Pauli strings:

\( H=\sum_{j=1}^{m}a_jP_j, \qquad P_j\in\{I,X,Y,Z\}^{\otimes n}. \)

import zixy.qubit.pauli as zqp

pauli_string = zqp.String.from_str("Z0 X1", 2)
hamiltonian = zqp.RealTermSum.from_str(
    "(-0.5, Z0 X1), (-0.1, X0 Z1), (-0.2, Y0 Y1)"
)

zqp.String represents one tensor product of Pauli operators.
zqp.RealTermSum represents a Hermitian Pauli Hamiltonian by pairing those strings with real coefficients.
trotter_first_order converts every non-identity term into a Pauli exponential.

Pauli exponentials¶

pauli_exp constructs a Guppy function implementing a Pauli-string exponential:

\( U_P(\theta)=e^{-i\theta P/2}. \)

from guppyalgos.primitives.pauli.pauli_exp import cntrl_pauli_exp, pauli_exp

pauli_gadget = pauli_exp(pauli_string, n_qubits=2)
controlled_pauli_gadget = cntrl_pauli_exp(pauli_string, n_qubits=2)

The input may contain any tensor product of \(I\), \(X\), \(Y\), and \(Z\). Only its non-identity support participates in the parity ladder:

Pauli	Basis change before the parity ladder
\(I\)	None; this qubit is omitted from the ladder.
\(X\)	\(H\) maps \(X\) to \(Z\).
\(Y\)	Apply \(S^\dagger\), then \(H\), to map \(Y\) to \(Z\).
\(Z\)	None; it is already in the required basis.

For \(P = Z_0X_1\), the ordinary gadget is:

The controlled form uses the same basis changes and parity ladder, but the external qubit controls the central rotation:

\( C(U_P)=|0\rangle\!\langle 0|\otimes I +|1\rangle\!\langle 1|\otimes U_P(\theta). \)

Basis changes map every non-identity Pauli to the Z basis.
A CX ladder computes the joint parity onto its target qubit.
pauli_exp applies R_Z to the parity target.
cntrl_pauli_exp replaces it with CR_Z, leaving the target operation inactive when the external control is zero.
The CX ladder and basis changes are then uncomputed.
The uncontrolled factory rejects an identity string. The controlled factory preserves its observable relative phase by rotating the control qubit.

Choose the circuit construction¶

The Pauli string fixes the operator, but it does not fix the circuit used for the parity computation or terminal rotation. These inputs can be selected when the gadget is built:

Input	Default	Other supported use
`pauli_string`	Required `zqp.String`	Any \(I/X/Y/Z\) tensor product; `pauli_exp` requires at least one non-identity Pauli.
`n_qubits`	Required integer	May be larger than the Pauli support, provided every Pauli index is in range.
`cx_ladder`	`CXLadderLog`	`CXLadderLinear`, or another implementation of the `Ladder` protocol.
`rz_method`	`rz`	Any compatible `(qubit, angle) -> None` guppy function, including an RUS \(R_Z\) construction.
`controlled_rz_method`	`crz`	For `cntrl_pauli_exp`, any compatible `(control, target, angle) -> None` guppy function.

For example, this keeps the same \(e^{-i\theta P/2}\) operation while choosing a linear CX ladder and a repeat-until-success rotation:

from guppyalgos.primitives.rotations import (
    dummy_theta_resource_state, repeat_until_success_rz,
)
from guppyalgos.primitives.subroutines.ladders import CXLadderLinear

rus_rz = repeat_until_success_rz(dummy_theta_resource_state)
rus_pauli_gadget = pauli_exp(
    pauli_string,
    n_qubits=2,
    cx_ladder=CXLadderLinear,
    rz_method=rus_rz,
)

The RUS implementation changes how the central \(R_Z\) is synthesized. The basis changes, parity ladder, angle convention, and resulting Pauli exponential remain the same.

See the Pauli-exponential notebook for a complete executable example and alternative rotation implementations.

Constructing the Trotter simulation¶

A first-order Trotter simulation applies the Zixy term exponentials sequentially, then repeats the resulting step:

\( e^{-iHt} \approx \left(\prod_{j=1}^{m}e^{-ih_jt/r}\right)^r, \qquad \text{error}=O\!\left(\frac{t^2}{r}\right). \)

from guppyalgos.algorithms.time_evolution.trotter import ham_sim_trotter, trotter_first_order

n_state_qubits = len(hamiltonian.qubits)
trotter_step = trotter_first_order(hamiltonian, n_state_qubits)
simulation = ham_sim_trotter(
    trotter_step, n_steps=10, time_step=0.01,
    n_state_qubits=n_state_qubits,
)

The Hamiltonian and product-formula order determine the sequence of Pauli exponentials. The ladder and rotation inputs are passed to every term, so one choice changes the complete Trotter step consistently.

Builder	Input Hamiltonian or schedule	Result
`trotter_first_order`	`zqp.RealTermSum`	One forward pass through the non-identity terms.
`cntrl_trotter_first_order`	`zqp.RealTermSum`	Controlled forward pass; retains identity terms as relative phases.
`trotter_higher_order`	`zqp.RealTermSum` and even `order >= 2`	Symmetric Suzuki formula; higher orders recursively reduce product-formula error.
`cntrl_trotter_higher_order`	Same inputs plus controlled rotation methods	Controlled symmetric Suzuki formula.
`trotter_from_sequence`	Terms and `(term_index, time_factor)` pairs	Custom ordering, repeated terms, and signed time factors.

For example, a second-order step applies half steps forward and backward,

\[ S_2(t)= \prod_{j=1}^{m}e^{-i h_jt/2} \prod_{j=m}^{1}e^{-i h_jt/2}, \]

and is built with:

from guppyalgos.algorithms.time_evolution.trotter import trotter_higher_order

second_order_step = trotter_higher_order(
    hamiltonian,
    n_state_qubits,
    order=2,
    cx_ladder=CXLadderLinear,
)

At runtime, each term receives an angle equal to its coefficient multiplied by the sequence factor and time_step. Negative sequence factors implement backward evolution. ham_sim_trotter then repeats the completed step n_steps times.

See the Trotter Hamiltonian-simulation notebook for the complete construction, execution, and accuracy comparison.

Continue with Phase estimation to use controlled Trotter steps in QPE.