Lesson 38 · 95 min · advanced
Hamiltonian-Evolution Encoding & Trotterisation
Hamiltonian-evolution encoding writes a data point into the generator of a time evolution, . This lesson proves that a Hamiltonian built from products of Pauli- operators is diagonal and that its evolution factorises exactly into commuting pieces, compiles every piece with the identity , its CNOT-ladder generalisation and the basis changes , , proves the first-order Trotter bound and the second-order bound from the variation-of-parameters formula, and derives the ZZ feature map of Havlíček et al. together with an honest account of its conjectured classical hardness.
Prerequisites: Angle & Phase Encoding, Postulate 2: Unitary Evolution & the Schrödinger Equation
Objectives and key results
Define Hamiltonian-evolution encoding and show that angle encoding is its special case .
Prove that commuting exponentials multiply, for , and that generates a diagonal evolution with phases .
Prove the exact compilation , extend it to by induction, and handle and factors by basis change with the correct time order.
Prove the first-order Trotter–Suzuki bound via the variation-of-parameters (Duhamel) formula and the telescoping lemma.
Prove the second-order (symmetric) bound and explain why the second-order term cancels.
Write the ZZ feature map in the Qiskit convention, relate , and state precisely what is and is not known about the classical hardness of its kernel.
- definition · Hamiltonian-evolution encoding
- identity · ZZ rotation
- identity · Basis changes
- theorem · First-order Trotter bound
- theorem · Second-order Trotter bound
- formula · ZZ feature map (Qiskit convention)
Data in the generator of a time evolution#
The encodings of the previous lessons place data directly into amplitudes or rotation angles. A more general and physically natural idea is to let the data define a Hamiltonian and to prepare the state reached after evolving under it for some time. By the unitary-evolution postulate, a closed system with Hamiltonian evolves as (with ); if depends on a data point , the final state is a feature vector of . This is the encoding behind the IQP and ZZ feature maps used in quantum-kernel methods, behind quantum reservoir computing (which drives a spin system with the input signal), and behind the simulation algorithms that motivate quantum computers in the first place.
Definition
Hamiltonian-evolution encoding
Let be a data domain and a map into the Hermitian operators on qubits, the feature Hamiltonian. For an evolution time and a fixed initial state the Hamiltonian-evolution encoding is where is a spectral decomposition. is unitary because every has modulus . Typically is a real combination of Pauli strings with data-dependent coefficients .
Two examples. (i) Angle encoding is the simplest case. For and , the terms act on different qubits and commute, so (by the theorem below) , the product encoding of the previous lesson. (ii) Covariance-matrix exponentiation. For a data matrix with covariance one may take the normalised operator (positive semi-definite, trace ) as a Hamiltonian; then imprints the principal components and variances as phases, which phase estimation can read out. Lloyd, Mohseni and Rebentrost showed that can be applied to a register using copies of the state itself (density-matrix exponentiation), the basis of quantum principal component analysis. In both cases the task is the same: compile into gates. This lesson solves it exactly for commuting Pauli- Hamiltonians and approximately, with proven error bounds, for non-commuting ones.
Definition
Z-type (diagonal) feature Hamiltonian
For a subset write , the Pauli string with on the qubits of and elsewhere (). A Z-type feature Hamiltonian is with a family of subsets and real coefficient functions . The interaction order is ; order (single-qubit fields and pair couplings ) gives the ZZ feature map.
Commuting exponentials multiply
Let be complex matrices with . Then . In particular, if with pairwise commuting Hermitian , then in any order. The hypothesis cannot be dropped: for , one has .
Proof (7 steps)
- Step 1:The exponential series converges absolutely in the operator norm, because the norm is submultiplicative () and the scalar exponential series converges.
- Step 2:The binomial theorem holds for commuting matrices: expanding gives all words in and of length , and commutation lets each word with letters be reordered to ; there are such words.
- Step 3:Insert the binomial expansion into the series of and cancel .
- Step 4:The right-hand side is the Cauchy product of two absolutely convergent series (Mertens' theorem, valid in any Banach algebra), whose sum is the product of the sums.
- Step 5:Exchanging the roles of and gives the same matrix.
- Step 6:Induction on the number of terms: commutes with , so the theorem splits off one factor at a time; the order is arbitrary because all factors commute.
- Step 7:Counterexample: the worked example of the Trotter section evaluates this norm exactly. The source of the discrepancy is visible in the expansion in a time parameter : , since .
∎
Z-type Hamiltonians generate diagonal evolutions
For every bit string and every Z-type feature Hamiltonian, Hence is diagonal in the computational basis, and it factorises exactly as in any order.
Proof (6 steps)
- Step 1:in the basis .
- Step 2:Mixed-product rule on the product state : the factors with are identities.
- Step 3:Linearity: every computational basis state is an eigenvector of every , hence of their real linear combination.
- Step 4:The computational basis is an orthonormal eigenbasis, so this is a spectral decomposition; a function of a Hermitian operator acts on each eigenvector by the function of its eigenvalue.
- Step 5:Diagonal matrices commute: both orders multiply every basis state by the same sign.
- Step 6:Apply the commuting-exponentials theorem to the pairwise commuting terms ; each factor is itself diagonal, and multiplying the phases of all factors reproduces .
∎
Quick check
For on two qubits and , the evolution maps . What is ?
Compiling Pauli exponentials exactly#
The ZZ rotation identity
For every , Equivalently, : after the CNOT, the eigenvalue of qubit is the eigenvalue of the original state.
Proof (8 steps)
- Step 1:Definition of CNOT with control and target ; applying it twice adds twice modulo .
- Step 2:Diagonal-evolution theorem with ; and have the same parity, so .
- Step 3:The evolution acts on each eigenvector by the exponential of its eigenvalue.
- Step 4:, the same formula with one qubit.
- Step 5:The first CNOT writes the parity onto qubit ; on qubit multiplies by the phase of the bit .
- Step 6:The second CNOT restores qubit , since .
- Step 7:Two linear maps that agree on a basis are equal. Reading off gives the diagonal .
- Step 8:The same computation with in place of gives the operator identity; exponentiating it with (proved in the basis-change corollary) is a second proof of the theorem.
∎
Unitary verified: (max deviation 0.0e+0)
Numerical check of the ZZ identity at θ = 0.7
- Step 1:repeats the diagonal once for each value of qubit .
- Step 2:The permutation matrix that exchanges the basis vectors and (indices and ).
- Step 3:Conjugating a diagonal matrix by a permutation permutes its diagonal entries: entries and are exchanged.
- Step 4:Apply the exchange to .
- Step 5:Euler's formula; this is the matrix displayed above, and the lesson tests confirm it against computed by the spectral theorem to .
Result
Circuit · 2 qubits
The exact ZZ gadget on qubit ; . Its unitary is , the target of the lab.
Exponentials of Z⊗k by a CNOT ladder
For let (so acts first). Then with prefix parities , and The circuit uses CNOTs and one ; the same construction applies to for any subset , laddering only over the qubits of .
Proof (7 steps)
- Step 1:Base case of the prefix-parity claim (the ZZ theorem).
- Step 2:The ladder on qubits is the ladder on the first qubits followed by one more CNOT from qubit to the new qubit .
- Step 3:Induction hypothesis for , then the CNOT adds the parity held by qubit to ; . By induction the claim holds for all .
- Step 4:Diagonal-evolution theorem with ; the last prefix parity is the parity of the whole string.
- Step 5:maps to a basis state whose last bit is ; on the last qubit contributes the phase of that bit; because is unitary.
- Step 6:Both operators agree on the computational basis.
- Step 7:The adjoint reverses products and every CNOT is Hermitian and unitary, so the "unladder" is the ladder in reverse order. Counting gates: CNOTs in , in , one .
∎
Circuit · 3 qubits
Parity ladder for three qubits: on qubit ; . Its unitary is , with diagonal phase on even-parity and on odd-parity basis states.
Rotating Z about the x-axis
For every , In particular and . Moreover .
Proof (6 steps)
- Step 1:Split the exponential series into even and odd powers using ; the adjoint conjugates the coefficients, which flips the sign of .
- Step 2:Move to the left through each term; anticommutation flips the sign of the term.
- Step 3:Rotations about the same axis compose by adding angles (commuting exponentials), and the formula of the first step with angle .
- Step 4:Pauli product rule: .
- Step 5:and .
- Step 6:, and .
∎
Exponentials of X, Y and arbitrary Pauli strings
For a unitary and a Hermitian , . Consequently i.e. in time order the rotation is , then , then . For a Pauli string with , let for and ; then with the parity ladder over .
Proof (6 steps)
- Step 1:Inner factors cancel.
- Step 2:Insert into the exponential series; multiplication by fixed matrices is continuous, so and pass through the convergent sum.
- Step 3:Lemma with .
- Step 4:Lemma with and . The rightmost factor acts first.
- Step 5:Each factor is rotated separately (mixed-product rule); off and for .
- Step 6:Lemma, then the parity-ladder theorem for (with on the last qubit of ). In time order: basis change , ladder, , unladder, basis change back .
∎
The Y rotation as an explicit 2×2 product
- Step 1:in .
- Step 2:A diagonal matrix on the left scales the rows.
- Step 3:Row-by-column products, e.g. entry : .
- Step 4:and .
- Step 5:; the two matrices coincide exactly, with no global phase.
- Step 6:The opposite sandwich conjugates to (lemma with ) and rotates the wrong way.
Result
Circuit · 2 qubits
by basis change: on qubit and on qubit map the eigenbases of and to the computational basis, the ZZ gadget applies the phase, and , map back.
Quick check
Which gate sequence, listed in time order (first gate applied first), implements exactly?
Non-commuting terms: Trotter–Suzuki product formulas#
When the feature Hamiltonian contains non-commuting terms, for example a coupling together with transverse fields , the exponential no longer factorises, and each factor can only be compiled separately. The idea of Trotter (1959) and Suzuki (1976, 1991), used by Lloyd (1996) to show that quantum computers can efficiently simulate local Hamiltonians, is to alternate short evolutions under each term. We now prove how large the resulting error is.
Definition
First- and second-order product formulas
Let be Hermitian, , . The first-order (Lie–Trotter) step and the second-order (symmetric, Strang) step are With steps of size the approximations of are and . The Trotter error is , measured in the operator norm, which bounds the error on every input state: for unit .
Variation of parameters (Duhamel formula)
Let be Hermitian, , and let be continuously differentiable with and for a continuous . Then and if every is unitary, .
Proof (6 steps)
- Step 1:Interpolate between the exact and the approximate evolution.
- Step 2:Differentiate the exponential series term by term; commutes with every power of itself.
- Step 3:Product rule; the terms with cancel.
- Step 4:Fundamental theorem of calculus, applied entry by entry.
- Step 5:The integral is a limit of Riemann sums, and the triangle inequality holds for every sum; the norm is continuous.
- Step 6:Submultiplicativity of the operator norm and for unitary .
∎
Taylor expansion of a conjugated operator
For Hermitian , any matrix and real , let . Then (i) , and (ii) with .
Proof (6 steps)
- Step 1:Product rule with .
- Step 2:Fundamental theorem of calculus; the operator norm is invariant under unitary conjugation.
- Step 3:Statement (i).
- Step 4:Apply the first step to in place of .
- Step 5:Taylor's formula with integral remainder, obtained by integrating by parts.
- Step 6:Statement (ii), again by unitary invariance of the norm.
∎
One-step error of the first-order formula
For Hermitian and ,
Proof (5 steps)
- Step 1:Product rule.
- Step 2:Insert between and , then add and subtract .
- Step 3:Duhamel lemma with , which is unitary.
- Step 4:Conjugation lemma (i) with .
- Step 5:Integrate. For commuting the bound is , in agreement with the commuting-exponentials theorem.
∎
The leading error term −(δ²/2)[A,B] (Baker–Campbell–Hausdorff)
- Step 1:Multiply the second-order Taylor polynomials; the cross term is .
- Step 2:Expand without commuting and .
- Step 3:Subtract: everything up to first order agrees.
- Step 4:Baker–Campbell–Hausdorff formula with , : the same term appears as the first correction to the exponent.
- Step 5:The rigorous bound of the theorem is attained to leading order, so the constant cannot be improved. The lesson tests confirm numerically at .
Telescoping lemma
For unitaries and every integer ,
Proof (4 steps)
- Step 1:Distribute the product.
- Step 2:Telescoping sum: all intermediate terms cancel.
- Step 3:Triangle inequality and submultiplicativity.
- Step 4:Powers of unitaries are unitary; there are terms. Errors of the individual steps can at worst add up.
∎
First-order Trotter–Suzuki bound
For Hermitian , and , Hence steps guarantee , and the gate count grows as .
Proof (5 steps)
- Step 1:is a product of copies of by the commuting-exponentials theorem ( commutes with itself).
- Step 2:Telescoping lemma.
- Step 3:One-step theorem with .
- Step 4:Combine.
- Step 5:Solve for . Each step costs a fixed number of gates (two compiled exponentials), so the total is proportional to .
∎
Worked example: A = X⊗I, B = Z⊗I at t = 1
- Step 1:, ; . Both terms act on qubit only, so the computation reduces to matrices tensored with .
- Step 2:satisfies , so .
- Step 3:The last term is .
- Step 4:; , , and the products , are traceless and , so only two products survive.
- Step 5:; has determinant and trace , so its eigenvalues are , and is normal with eigenvalues .
- Step 6:The values for are computed from in the lesson tests; each doubling of roughly halves the error, the scaling predicted by the theorem.
Result
The widget evaluates and for maxSteps on log–log axes, together with the two bounds. For the transverse-field Ising pair , one computes and : the first-order curve has slope , the second-order curve slope , both below their bounds.
Second-order (symmetric) Trotter–Suzuki bound
For Hermitian and , and therefore These are the commutator constants of Childs, Su, Tran, Wiebe and Zhu (2021).
Proof (9 steps)
- Step 1:Product rule on the three factors of ; insert in the middle term and write in the last one.
- Step 2:Add and subtract and .
- Step 3:The outer factors of commute with ; factor out of both brackets, using , and drop it by unitary invariance.
- Step 4:Conjugation lemma (ii) with : .
- Step 5:Conjugation lemma (ii) with the roles of and exchanged and .
- Step 6:The first-order terms cancel: the half step of before and after contributes symmetrically. This is the source of the extra order.
- Step 7:Triangle inequality.
- Step 8:Duhamel lemma with (unitary) and .
- Step 9:Telescoping lemma with ; .
∎
Why the second-order term cancels
- Step 1:Second-order Taylor polynomials of the three factors.
- Step 2:Second-order terms of single factors, plus the three products of first-order terms (first·second, first·third, second·third factor), e.g. .
- Step 3:Collect terms: the coefficients agree, so , whereas for they differ by .
- Step 4:Symmetry: the inner factors cancel pairwise, so .
- Step 5:For small , is near and has a unique logarithm near ; forces to be odd, so all even orders vanish.
- Step 6:Symmetric BCH formula with , ; the constants , of the theorem are exactly those of the leading term (checked numerically in the lesson tests at ).
In the commuting preset, and commute (each of and commutes with , since the two anticommuting factors give two signs that cancel), so both errors and both bounds vanish identically for every : product formulas are only needed for genuinely non-commuting terms. The Z-type feature Hamiltonians of the next section are of this commuting kind, which is why they can be compiled exactly.
Quick check
For the Ising pair , with and , what is the smallest number of first-order steps for which the bound guarantees an error of at most ?
The ZZ feature map#
Definition
ZZ feature map (Havlíček et al. 2019; Qiskit convention)
For let and . One repetition of the ZZ feature map is and the map with reps repetitions prepares . Qiskit's ZZFeatureMap uses and all pairs by default. The fidelity kernel is .
The ZZ feature map is an exact Hamiltonian evolution
(i) ; in particular . (ii) The diagonal part of equals with exactly, with no Trotter error. (iii) The fidelity kernel does not depend on the global phase , nor on the sign convention used by Havlíček et al.
Proof (6 steps)
- Step 1:Factor out of both diagonal entries. With : .
- Step 2:Pull the scalar out and apply the ZZ rotation identity with on the qubit pair (identity on the other qubits).
- Step 3:Part (i) on every qubit.
- Step 4:All factors are diagonal and commute (diagonal-evolution theorem), so the commuting-exponentials theorem merges them into a single exponential of , exactly.
- Step 5:With repetitions the phase becomes , still a global phase of the state; it drops out of the squared modulus.
- Step 6:A real diagonal exponent makes the entrywise complex conjugate of ; Hadamard matrices and are real, so the whole state is conjugated, and conjugation preserves the modulus of the overlap.
∎
Circuit · 2 qubits
Two-qubit ZZ feature map (one repetition, Qiskit convention) at : , then on qubit and on qubit , then , on qubit , .
The platform's implementation. The function zzFeatureMap in the QML library builds the same circuit with in place of and in place of the phase-gate sandwich, that is, exactly per repetition, without the global phase. Its defaults are reps and entanglement linear (pairs only), whereas Qiskit's default is all pairs; for the two coincide. By part (ii) the two circuits differ by the global phase , and by part (iii) they define the same kernel. The lesson tests verify this statevector identity for the example above.
With one repetition the kernel is classically estimable
For reps write . Then with uniform on . Averaging independent samples gives an estimate with with probability at least , in classical time .
Proof (6 steps)
- Step 1:Part (ii) of the proposition and the diagonal-evolution theorem with .
- Step 2:Orthonormality of the basis; is a bounded random variable when is uniform.
- Step 3:Hoeffding's inequality for i.i.d. samples with values in (range ): the bound is . The same holds for the imaginary part.
- Step 4:Union bound over the two parts; both errors at most give a complex error at most .
- Step 5:and the sample mean both lie in the unit disc; reverse triangle inequality.
- Step 6:Evaluating sums one signed term per subset in : fields and at most pairs.
∎
Quick check
Why does the circuit of the ZZ feature map implement exactly, with no Trotter error, although has terms?
The following TypeScript cell uses only the simulator library: it checks the ZZ gadget and the basis change against matrix exponentials computed by the spectral theorem, and evaluates the first-order Trotter error of the worked example against its bound.
import { circuitUnitary, expmIHermitian, hamiltonianToMatrix, eigvalsh, matrix } from '@/lib/quantum-simulator';
const gate = (name, targets, params) => (params ? { kind: 'gate', gate: name, targets, params } : { kind: 'gate', gate: name, targets });
const unitaryOf = (n, ops) => circuitUnitary({ version: 1, numQubits: n, numClbits: 0, ops });
// (1) ZZ gadget: CNOT(0,1); RZ(1, 0.7); CNOT(0,1) equals exp(-i (0.7/2) Z x Z) exactly.
const theta = 0.7;
const gadget = unitaryOf(2, [gate('CNOT', [0, 1]), gate('RZ', [1], [theta]), gate('CNOT', [0, 1])]);
const ZZ = hamiltonianToMatrix([{ coeff: 1, ops: 'ZZ' }], 2);
console.log('ZZ gadget = exp(-0.35i ZZ): ' + (matrix.maxAbsDiff(gadget, expmIHermitian(ZZ, theta / 2)) < 1e-12));
const phases = [0, 1, 2, 3].map((k) => matrix.get(gadget, k, k)).map((z) => Math.atan2(z.im, z.re).toFixed(2));
console.log('diagonal phases: ' + phases.join(' '));
// (2) Y by basis change: time order RX(pi/2), RZ(theta), RX(-pi/2) gives exp(-i theta Y / 2).
const yRot = unitaryOf(1, [gate('RX', [0], [Math.PI / 2]), gate('RZ', [0], [theta]), gate('RX', [0], [-Math.PI / 2])]);
const Y = hamiltonianToMatrix([{ coeff: 1, ops: 'Y' }], 1);
console.log('RX(pi/2), RZ(0.7), RX(-pi/2) = exp(-0.35i Y): ' + (matrix.maxAbsDiff(yRot, expmIHermitian(Y, theta / 2)) < 1e-12));
// (3) First-order Trotter error for A = X x I, B = Z x I at t = 1 against the bound t^2 ||[A,B]|| / (2r).
const opNorm = (M) => Math.sqrt(Math.max(0, ...eigvalsh(matrix.mul(matrix.adjoint(M), M))));
const A = hamiltonianToMatrix([{ coeff: 1, ops: 'XI' }], 2);
const B = hamiltonianToMatrix([{ coeff: 1, ops: 'ZI' }], 2);
const t = 1;
const exact = expmIHermitian(matrix.add(A, B), t);
const commNorm = opNorm(matrix.sub(matrix.mul(A, B), matrix.mul(B, A)));
console.log('||[A,B]|| = ' + commNorm.toFixed(6));
for (const r of [1, 2, 4]) {
const step = matrix.mul(expmIHermitian(A, t / r), expmIHermitian(B, t / r));
let product = matrix.identity(4);
for (let k = 0; k < r; k++) product = matrix.mul(step, product);
const err = opNorm(matrix.sub(exact, product));
const bound = ((t * t) / (2 * r)) * commNorm;
console.log('r = ' + r + ': error ' + err.toFixed(6) + ' <= bound ' + bound.toFixed(6) + ': ' + (err <= bound));
}Expected output
ZZ gadget = exp(-0.35i ZZ): true diagonal phases: -0.35 0.35 0.35 -0.35 RX(pi/2), RZ(0.7), RX(-pi/2) = exp(-0.35i Y): true ||[A,B]|| = 2.000000 r = 1: error 0.799214 <= bound 1.000000: true r = 2: error 0.362410 <= bound 0.500000: true r = 4: error 0.176261 <= bound 0.250000: true
The NumPy cell repeats the gadget check and tabulates the first- and second-order errors of the Ising pair for : the first-order error halves and the second-order error quarters with each doubling of , always below the proven bounds.
import numpy as np
I2 = np.eye(2)
X = np.array([[0, 1], [1, 0]], dtype=complex)
Z = np.diag([1.0, -1.0]).astype(complex)
def evolve(H, t):
"""exp(-iHt) for Hermitian H via the spectral theorem."""
w, V = np.linalg.eigh(H)
return V @ np.diag(np.exp(-1j * w * t)) @ V.conj().T
def comm(P, Q):
return P @ Q - Q @ P
# ZZ gadget: CNOT (I x RZ(0.7)) CNOT = exp(-0.35i Z x Z)
CNOT = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]], dtype=complex)
RZ = np.diag(np.exp([-0.35j, 0.35j]))
gadget = CNOT @ np.kron(I2, RZ) @ CNOT
print(bool(np.allclose(gadget, evolve(np.kron(Z, Z), 0.35))), np.round(np.angle(np.diag(gadget)), 2))
# Transverse-field Ising pair: A = Z x Z, B = (X x I + I x X)/2
A = np.kron(Z, Z)
B = (np.kron(X, I2) + np.kron(I2, X)) / 2
c1 = np.linalg.norm(comm(A, B), 2)
cAAB = np.linalg.norm(comm(A, comm(A, B)), 2)
cBBA = np.linalg.norm(comm(B, comm(B, A)), 2)
print(f"||[A,B]|| = {c1:.6f}, ||[A,[A,B]]|| = {cAAB:.6f}, ||[B,[B,A]]|| = {cBBA:.6f}")
t = 1.0
exact = evolve(A + B, t)
for r in [1, 2, 4, 8, 16]:
d = t / r
first = np.linalg.matrix_power(evolve(A, d) @ evolve(B, d), r)
second = np.linalg.matrix_power(evolve(A, d / 2) @ evolve(B, d) @ evolve(A, d / 2), r)
e1 = np.linalg.norm(exact - first, 2)
e2 = np.linalg.norm(exact - second, 2)
b1 = t**2 / (2 * r) * c1
b2 = t**3 / (12 * r**2) * cBBA + t**3 / (24 * r**2) * cAAB
print(f"r={r:2d} first {e1:.6f} <= {b1:.6f} second {e2:.6f} <= {b2:.6f}")Expected output
True [-0.35 0.35 0.35 -0.35] ||[A,B]|| = 2.000000, ||[A,[A,B]]|| = 4.000000, ||[B,[B,A]]|| = 4.000000 r= 1 first 0.799214 <= 1.000000 second 0.313666 <= 0.500000 r= 2 first 0.362410 <= 0.500000 second 0.071130 <= 0.125000 r= 4 first 0.176261 <= 0.250000 second 0.017273 <= 0.031250 r= 8 first 0.087513 <= 0.125000 second 0.004286 <= 0.007812 r=16 first 0.043679 <= 0.062500 second 0.001070 <= 0.001953
References
- V. Havlíček, A. D. Córcoles, K. Temme, A. W. Harrow, A. Kandala, J. M. Chow and J. M. Gambetta, Supervised learning with quantum-enhanced feature spaces, Nature 567, 209–212 (2019).doi:10.1038/s41586-019-0980-2
- H. F. Trotter, On the product of semi-groups of operators, Proceedings of the American Mathematical Society 10, 545–551 (1959).doi:10.1090/S0002-9939-1959-0108732-6
- M. Suzuki, Generalized Trotter's formula and systematic approximants of exponential operators and inner derivations with applications to many-body problems, Communications in Mathematical Physics 51, 183–190 (1976).doi:10.1007/BF01609348
- M. Suzuki, General theory of fractal path integrals with applications to many-body theories and statistical physics, Journal of Mathematical Physics 32, 400–407 (1991).doi:10.1063/1.529425
- S. Lloyd, Universal quantum simulators, Science 273, 1073–1078 (1996).doi:10.1126/science.273.5278.1073
- A. M. Childs, Y. Su, M. C. Tran, N. Wiebe and S. Zhu, Theory of Trotter error with commutator scaling, Physical Review X 11, 011020 (2021).doi:10.1103/PhysRevX.11.011020
- M. J. Bremner, R. Jozsa and D. J. Shepherd, Classical simulation of commuting quantum computations implies collapse of the polynomial hierarchy, Proceedings of the Royal Society A 467, 459–472 (2011).doi:10.1098/rspa.2010.0301
- M. J. Bremner, A. Montanaro and D. J. Shepherd, Average-case complexity versus approximate simulation of commuting quantum computations, Physical Review Letters 117, 080501 (2016).doi:10.1103/PhysRevLett.117.080501
- S. Lloyd, M. Mohseni and P. Rebentrost, Quantum principal component analysis, Nature Physics 10, 631–633 (2014).doi:10.1038/nphys3029
- M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information, 10th anniversary ed., Cambridge University Press (2010), §4.7 "Simulation of quantum systems".doi:10.1017/CBO9780511976667
Hands-on labs
Compile the ZZ evolution from CNOT and RZ
1 step · auto-gradedOpen labImplement the two-qubit evolution exactly, using at most three gates from . This is the elementary building block of every diagonal (IQP-type) feature map, including the ZZ feature map of Havlíček et al.