A standard way to simulate a quantum system whose Hamiltonian changes in time is to stop treating time as a parameter. Instead, one adds a "clock" register and writes the whole trajectory into a single static object, the history state. This is the superposition of every time slice $|\psi(t_k)\rangle$, each paired with its clock label $|k\rangle$, and it is the lowest-energy state of a time-independent "clock Hamiltonian". This removes the time-ordering problem. It also turns simulation into ground-state preparation, which is the hardest step in most quantum algorithms, and it works on a space that is $K+1$ times larger than the original one. This note asks when that initialization cost is the real bottleneck of the clock route, and it proposes a way to pay it cheaply. First, build a rough history state from a coarse, inexpensive time propagator. Then, remove its errors with eigenstate filtering on the fine clock Hamiltonian. Eigenstate filtering means repeated controlled evolutions plus measurements that keep only the target energy component.
The key observation is simple. The overlap between a rough history state and the exact one is an average of the per-slice overlaps over the clock. It is not a product of per-step fidelities, as it would be if errors compounded multiplicatively. Early slices are nearly exact because the coarse propagator starts from the true initial state, so the guide keeps substantial overlap even when late slices have drifted. The "orthogonality catastrophe" is the collapse of overlap with system size that plagues ground-state preparation. It is therefore partly defused along the time axis. The open question is whether that is enough to make the whole pipeline cheaper than simply building the history state step by step at full accuracy, and this note treats that comparison as the decisive test.
Core Claim
Define the exact history state over $K+1$ slices, and a guide built from coarse slices $|\tilde\psi_k\rangle$, as in Feynman's clock, a new variational principle, and parallel-in-time quantum dynamics. Their overlap is
$$\langle \tilde\Psi_{\rm hist}|\Psi_{\rm hist}\rangle=\frac{1}{K+1}\sum_{k=0}^{K}\langle\tilde\psi_k|\psi_k\rangle ,$$
so the number of filtering repetitions scales as the inverse square of this clock-averaged amplitude. It does not scale as the inverse of the worst late-time fidelity. There is one caveat. Relative phase drift between coarse and exact slices can make the terms cancel, so phase coherence of the coarse propagator is an empirical question, not a given. The second claim concerns how big the object really is. The entanglement between clock and system, measured by the Schmidt rank $r$ across that cut, equals the rank of the trajectory matrix $[\psi_0,\dots,\psi_K]$. Many driven problems explore a low-dimensional subspace, so $r$ stops growing once new slices fall inside the span of earlier ones. This mirrors the "cutoff" in Petri-net unfoldings from Using Unfoldings to Avoid the State Explosion Problem in the Verification of Asynchronous Circuits. There, a branch stops being expanded when it reaches no new marking, and the structure stays polynomial even though the interleaved state space is exponential. When $r$ saturates, the history state is a tensor network of bounded bond dimension across the clock–system cut, even though the space it lives in has dimension $K\cdot 2^n$.
The three directions play unequal roles. The time-to-static transformation is the object under study. State initialization is the bottleneck being attacked. State-space explosion from verification is the constraint and design lens: the guide must be built without enumerating the product space, and rank saturation tells us when a classical guide exists at all.
Relation to Prior Work
Three works motivate the problem. McClean, Parkhill and Aspuru-Guzik build the history state as the null ground state of a clock Hamiltonian and solve for it classically, using conjugate gradients preconditioned by a coarse propagator (Feynman's clock). They report higher peak parallel speedup than the parareal method on $H_2$ vibrational dynamics, but they build the full monolithic matrix, which they note becomes prohibitive for long times. We reuse their coarse-propagator idea as the source of a quantum guide rather than as a classical preconditioner. Watkins, Wiebe, Roggero and Lee use a discrete clock register to obtain time-dependent qubitization and multiproduct formulas (Time Dependent Hamiltonian Simulation Using Discrete Clock Constructions). A multiproduct formula is a weighted combination of product-formula runs that cancels error terms. Watkins et al. start the clock in a Gaussian wavepacket to avoid boundary reflections, and they treat state preparation as an external primitive. They evolve under the static Hamiltonian; we prepare its ground state, which is a different task with different costs. The Sambe–Howland formulation of Unifying framework for quantum simulation algorithms for time-dependent Hamiltonian dynamics and the continuous dilation of Quantum simulation for time-dependent Hamiltonians—with applications to non-autonomous ordinary and partial differential equations likewise leave initialization aside.
Four works supply the method. The filtering step is the rodeo algorithm demonstrated in Demonstration of the rodeo algorithm on a quantum computer. On a one-qubit Hamiltonian it reached 0.08% relative error on eigenvalues, against 5% and 0.6% for direct preparation. Its authors state that small initial overlap in larger systems is the obstacle and that preconditioning is needed; our coarse guide is such a preconditioner, specialized to clock Hamiltonians. The compressed-guide variant borrows the circuit construction of Efficient state preparation for the quantum simulation of molecules in first quantization. That work turns a low-bond-dimension tensor train (a chain-structured tensor network) into isometry-based circuits and reports $10^2$ to $10^5$ fewer Toffoli gates on water. Here the chain includes the clock qubits. The overlap-guarantee logic parallels High ground state overlap via quantum embedding methods, which shows that a small active space around the strongly correlated core yields a guide with overlap above 0.9. That result is for static states. Our analogue works along the time axis instead of the spatial one and does not address system-size decay. The two could be combined, but combining them is out of scope.
Several works constrain the design. The general hardness results in A Full Characterization of Quantum Advice and the overlap-decay arguments in Eigenvalue estimation of differential operators with a quantum algorithm and Drug design on quantum computers mean we cannot promise a guide for arbitrary systems. Our claim only concerns the extra difficulty contributed by the clock dimension. We also borrow a moral from McMillan's unfolding paper. There, the size of the structure was small but deciding deadlock on it remained NP-complete. By analogy, a small bond dimension does not guarantee that the classical guide is cheap to find, so we measure the cost of finding it as well as its size.
Research Program
The first component is analytic. We will bound the guide overlap in terms of the coarse propagator's local error and its phase error. We will then derive the total cost of the coarse-then-filter pipeline, counted in controlled one-step propagator calls. That cost is guide cost plus (repetitions) × (filtering depth), where filtering depth is set by the clock Hamiltonian's spectral gap. The gap shrinks with $K$ in Feynman-type clock constructions, and we will measure how fast rather than assume it. The second component is the preparation itself, done in two variants. In the quantum-native variant, the clock is put in uniform superposition and each coarse step is applied controlled on the clock value, with a coarse step spanning several fine slices. In the classical-guide variant, used for moderate systems, the rank-truncated trajectory is compiled into a tensor-train circuit. A saturation test sets the clock–system bond dimension: the rank grows until new slices fall inside the existing span within tolerance, which is our analogue of an unfolding cutoff. The third component is certification. The history state's energy under the clock Hamiltonian is a residual that McClean et al. showed tracks trajectory error. Filtering drives this residual toward zero, so the output comes with a built-in accuracy check that plain forward simulation lacks.
Baselines
The naive reference point is the product guide, a uniform clock superposition times $|\psi_0\rangle$. Its overlap is the average of $\langle\psi_0|\psi_k\rangle$ and should collapse once the system moves away from its start. We will run the same rodeo filtering from this guide with the same filtering schedule and repetition budget, and the coarse guide must cut total controlled-step count by at least an order of magnitude to count as a real gain.
The strongest competitor for preparing the history state is exact sequential construction. This is the same controlled-step circuit as our quantum-native guide, but with fine steps and a high-order product formula, so no filtering is needed. It is strongest because it has no repetition overhead and no gap dependence. It is compared at equal target trajectory fidelity and equal product-formula order, and we count total controlled one-step calls and circuit depth. Beating it means lower total cost or lower depth at matched fidelity for some identifiable regime of $K$ and target error. If no such regime exists, that is the headline result. No reported gate count exists in the file for this construction; no reported result found on Lacuna for sequential history-state preparation cost.
The strongest existing method for the underlying simulation task is the discrete-clock multiproduct formula of Watkins et al.. They report errors "orders of magnitude lower than standard Trotter methods for the same computational cost" on the rotating-field spin and the interaction-picture XX chain, but give no absolute figure in the file; no reported result found on Lacuna for exact MPF gate counts on these benchmarks. We will reimplement it on the same Hamiltonians and error targets. Its output is only the final state, while ours is the full trajectory, so we compare it on its own metric (final-state error per query) and on the cost of estimating a trajectory-averaged observable. For the latter it must be rerun once per time slice or sampled over slices.
The classical baseline is McClean's time-embedded discrete variational principle (TEDVP) with coarse-propagator preconditioning on $H_2$. It was reported to beat parareal in parallel speedup, with no numeric value in the file. We use it to check that our classical-guide variant reproduces its trajectories, and to measure how much truncating the bond dimension saves over its monolithic matrix. Two ablations isolate the ingredients: the coarse guide without rank truncation, which isolates the saturation cutoff, and the coarse guide with its relative phases randomized, which tests whether coherent phase alignment is what carries the overlap.
Why not just…?
Why not just forward-simulate with a multiproduct formula or Trotter and skip the history state? For the final state alone, this is probably cheaper, and we expect it to win on that metric. The history route is worth its cost only for trajectory-wide quantities and for its self-certifying residual. The Watkins comparison is designed to show where that trade-off falls rather than to claim a blanket win.
Why not just build the history state exactly with fine controlled steps? This is the real threat, because it needs no filtering at all. Coarse-then-filter wins only if coarse steps plus a few filtering rounds cost less than fine steps. That can happen when the fine accuracy target is stringent and the clock gap is not too small, and the head-to-head comparison at matched fidelity settles it directly.
Why not just use the naive product guide and filter longer? Its overlap is the clock-average of $\langle\psi_0|\psi_k\rangle$, which vanishes for dynamics that leave the initial state. The rodeo authors already flag small overlap as the failure mode for larger systems (Qian et al.). The naive-guide baseline quantifies this failure.
Why not just import partial-order reduction to give each subsystem its own clock? If subsystem drives commute exactly, the propagator factorizes and ordinary simulation already exploits this without any clock. The weakly coupled case is interesting but separate. Here we borrow only the cutoff principle from verification, which applies even without commuting parts.
Proposed Experiments
All numerics are exact classical emulation. The first benchmark is the spin-1/2 in a rotating field from Watkins et al., used as a sanity check where everything is small. The second is the interaction-picture XX chain from 4 to 12 sites with $K$ from $2^4$ to $2^{10}$, which is the main test of how overlap and cost scale. The third is McClean's $H_2$ vibrational model, which tests the classical-guide variant. For each we report the guide overlap against $K$ and chain length, the phase-coherence ablation, the trajectory rank against $K$ with its saturation point, the filtering repetitions and gap, the total controlled-step count against the sequential and multiproduct baselines at matched fidelity, and the correlation of the certifying residual with the true trajectory error.
The decisive checks are three. The measured overlap should track the averaged amplitude in the displayed formula and not the late-time fidelity; if phase randomization destroys it, the coherent-average mechanism is confirmed. A crossover regime should exist in which coarse-then-filter beats exact sequential construction; if none appears across the XX-chain sweep, the proposal's main claim fails, and that negative result is itself informative for the clock literature. Finally, rank saturation should occur for the driven chain at bond dimensions far below $K$, which determines whether classical guides are viable beyond toy sizes.
References
- Feynman’s clock, a new variational principle, and parallel-in-time quantum dynamics
- Using Unfoldings to Avoid the State Explosion Problem in the Verification of Asynchronous Circuits
- Time-Dependent Hamiltonian Simulation Using Discrete-Clock Constructions
- Unifying framework for quantum simulation algorithms for time-dependent Hamiltonian dynamics
- Quantum simulation for time-dependent Hamiltonians—with applications to non-autonomous ordinary and partial differential equations
- Demonstration of the rodeo algorithm on a quantum computer
- Efficient State Preparation for the Quantum Simulation of Molecules in First Quantization
- High Ground State Overlap via Quantum Embedding Methods
- A full characterization of quantum advice
- Eigenvalue estimation of differential operators with a quantum algorithm
- Drug design on quantum computers