Classical computers cannot store the full state of a large quantum system. An $n$-qubit state needs $2^n$ complex numbers, which caps exact simulation at a few dozen qubits. One way around this limit is to describe the evolving state compactly as a matrix product state (MPS), a chain of small tensors whose size grows with entanglement rather than with $2^n$. The compact state is then compiled into a short quantum circuit with a gradient-based optimizer. This is approximate quantum compiling, and it has reached 100-qubit spin chains with an order of magnitude less circuit depth than standard methods. What it does not provide is any guarantee that the short circuit is right. Every stage approximates something. The compact description throws away small pieces of the state at each time step. The optimizer is trained on a "local" cost that only looks at one or a few qubits at a time, because the global cost has vanishing gradients. The reported fidelity compares the circuit against the already-truncated compact state, not against the true one.
We propose to make this pipeline produce a per-instance certificate: a computable, provably sound bound on how far the compiled circuit's state is from the intended one. We also propose to test a specific hypothesis about where the uncertified error hides. Optimizers have a known tendency to learn smooth, low-frequency structure first and fine structure last; this is spectral bias. Our hypothesis is that local-cost compiling shows the same tendency, with correlations spanning many qubits playing the role of high frequencies. The circuit would then reproduce few-qubit correlations well and leave many-qubit correlations under-fit, even when the headline fidelity looks excellent. If that is true, cheap acceptance checks are blind in a predictable direction. A verifier should spend its expensive effort exactly there.
Core Claim
The claim has two parts, and either can fail independently.
The first part is a construction. Gates are unitary, so they preserve the length of an error vector. Errors introduced at different stages therefore add rather than multiply. Let $|\phi\rangle = V|0\rangle$ be the compiled circuit's state, $|\psi\rangle$ the exact target (the ideal Trotterized evolution), $|\psi_{\mathrm{MPS}}\rangle$ the truncated compact target, and $\epsilon_t$ the norm of the piece discarded at truncation step $t$. Then
$$\big\|\, |\phi\rangle - |\psi\rangle \,\big\| \;\le\; \big\|\, |\phi\rangle - |\psi_{\mathrm{MPS}}\rangle \,\big\| \;+\; \sum_t \epsilon_t \;=:\; \delta .$$
The first term is computed by contracting the compiled circuit against the compact target, with any truncation during that contraction added to the sum in the same way. For any observable $P$ with operator norm at most one, such as a Pauli string, $|\langle P\rangle_\phi - \langle P\rangle_\psi| \le 2\delta$. The bound $\delta$ costs one tensor contraction and is sound by construction. Its open question is tightness, not validity.
The second part is an empirical hypothesis. Measure the residual $r_k$, the average error in expectation values of Pauli strings acting non-trivially on $k$ qubits (weight $k$). Under local-cost optimization, $r_k$ should decay more slowly as $k$ grows, and at convergence $r_k$ should be largest at high $k$. When the quantities of interest are small high-weight correlators (string order parameters, long-range connected correlations), the fidelity-derived bound $2\delta$ is sound but far too loose to be useful. A weight-resolved check is then needed. If the residual turns out to be flat in $k$, the second part is false. In that case global fidelity is the right acceptance criterion, and the contribution reduces to the certificate alone.
Position Relative to Prior Work
The method we build on is AQCtensor. It compiles time-evolved MPS states of the Heisenberg chain into constant-depth brickwork circuits using local cost functions and Trotter initialization. It reports comparable fidelities to Trotterized circuits at half the depth, and up to an order of magnitude depth reduction at 100 qubits. It evaluates against the truncated MPS and does not account for the truncation itself, provide a sound bound, or analyze which correlations the optimizer misses. We keep its compiler and add certification and weight-resolved diagnosis.
Two papers constrain the design. Escaping barren plateaus in approximate quantum compiling shows that the global cost stays flat. Its 8-qubit Heisenberg compilation stalls near fidelity 0.5, while a truncated local cost converges in fewer than 30 iterations on 24-qubit state preparation, with a hand-tuned Adam-then-L-BFGS schedule. So we cannot simply switch back to global training. The same paper's reliance on locality is what motivates our worry about many-qubit correlations.
Spectral Bias in Variational Quantum Machine Learning proves that in parameterized circuits the gradient at a data frequency is bounded by that frequency's redundancy, and that entangling gates flatten the bias. We borrow its logic, not its result. Our "frequency" is Pauli weight in the state being prepared, not frequency in an input feature. Whether a redundancy-style argument transfers is an open question we test empirically and do not assume. That paper's entanglement observation also creates a direct cost tension for us. Deeper, more entangling circuits may reduce the weight bias, but they raise the bond dimension needed to contract the circuit against the target, which makes certification more expensive. This is the memory wall described in Large-Scale Simulation of Quantum Computational Chemistry on a New Sunway Supercomputer.
On verification, the closest work is Quantum Circuit Transformations with a Multi-Level IR Compiler. It inserts mirror circuits (run, then un-run, then check the return to the start) as a pass in the QCOR/MLIR stack. On a deuteron ansatz it reports success probability $P' \approx 0.991$ on Honeywell H1 and 0.935 to 0.951 on IBM Falcon. That is a hardware-fidelity diagnostic, not a check that a compiled circuit matches its intended state. Enhancing Code Safety in Quantum Intermediate Representation checks discrete safety properties such as qubit reuse after release and cloning. It has no notion of numerical tolerance.
Our verifier follows the translation-validation idea of TVOC: check each compiled instance rather than prove the compiler correct for all inputs. It also follows the cheap-filter-then-sound-check structure used in The SemGuS Toolkit and in the interval-arithmetic validation of Sound and Automated Synthesis of Digital Stabilizing Controllers. We extend both to an approximate setting, where the verified property is "within $\delta$" rather than exact equivalence.
Research Program
We will build three things and run one analysis.
The first is the certifying pipeline. It runs TEBD, a standard routine that evolves an MPS step by step under a Hamiltonian. It records every discarded norm $\epsilon_t$, with renormalization handled conservatively. It compiles with the AQCtensor brickwork ansatz and local cost. It then contracts the compiled circuit against the target MPS with a bond-dimension budget, tracking contraction truncation in the same additive ledger. The output is $\delta$ together with a breakdown into its target-truncation, compilation and contraction components. That breakdown is itself a useful diagnostic, because it tells the user which stage to improve.
The second is a fast first-stage filter. For each candidate (different depths, initializations, or optimizer runs), it estimates $r_k$ by sampling Pauli strings of each weight $k$ and computing their expectation values from both MPSs. This is cheap, parallel and unsound, since it samples rather than enumerates. It is used inside the compile loop to reject candidates and to choose the depth. Only survivors go to the sound second stage. Following the known open problem of misaligned filters, we will measure this filter's false-accept and false-reject rates against the sound stage and, at small sizes, against exact state vectors.
The third is a weight-aware cost. We extend the dynamic weighting of local cost terms from the barren-plateau paper with a scheduled admixture of weight-$k$ correlator terms, which are cheap to estimate from the MPS target. The goal is to test whether pushing on high-weight residuals late in training closes the gap without bringing the barren plateau back.
Multi-level compiler infrastructure is the host, not the subject. We will implement compilation and certification as a lowering pass whose output operation carries a tolerance attribute, the certified $\delta$. Downstream passes then compose budgets additively, using the same unitarity argument. Any later approximate pass, such as lossy state-vector compression in the style of BMQSim, inherits a budget instead of an unexplained fidelity number. We will keep this engineering minimal and judge it only on whether budgets compose correctly across two chained approximate passes.
The analysis tracks $r_k(\text{iteration})$ throughout training to test whether convergence is ordered by weight. It does so separately for local cost, global cost (where it trains at all), and the weight-aware cost. It also varies depth, to measure the entanglement-versus-bias trade-off implied by the PQC spectral bias result.
Baselines
The naive reference is AQCtensor's own acceptance practice: accept a compiled circuit when its fidelity against the truncated MPS target is high, and implicitly treat all observables as fine. Against it we report how often that accepted circuit violates a stated tolerance on exact ground truth, overall and per weight $k$. Exact ground truth means a full state vector at 20 to 32 qubits, computed with a standard simulator such as SV-Sim from NWQ-Sim. The paper's reported figures are comparable fidelity to Trotterized circuits at half the depth, and an order-of-magnitude depth reduction up to 100 qubits. We rerun its brickwork ansatz, Trotter initialization and local cost with identical circuits, hyperparameters and iteration budgets, so that the only difference is acceptance and certification.
The strongest optimization baseline is the truncated local cost with Adam followed by L-BFGS from Escaping barren plateaus in approximate quantum compiling. It reports convergence in fewer than 30 iterations on 24-qubit state preparation, and a global-cost plateau near fidelity 0.5 on 8-qubit Heisenberg compilation. Our weight-aware cost gets the same total optimizer-evaluation budget and the same tuning budget over learning rate and weighting schedule. It beats this baseline only if it lowers the maximum high-weight residual $\max_{k \ge k_0} r_k$ at equal or better global fidelity and equal wall-clock time.
The verification baseline is the mirror-circuit pass of Quantum Circuit Transformations with a Multi-Level IR Compiler, run in simulation on the same compiled circuits. On a noiseless simulator it measures only how well $V^\dagger V$ returns the start, so we expect it to accept almost everything. Its role is to show what a standard compiler-integrated check misses.
For the certificate itself we found no reported result on Lacuna for sound per-instance error bounds in approximate quantum compiling. The comparison is therefore internal. We measure the gap between $\delta$ and the true error at sizes where the true error is computable, and we count the certificate useful if it is within a small constant factor of the truth on the Heisenberg benchmarks.
The key ablation runs the weight-aware cost with the weight-$k$ terms replaced by an equal number of randomly chosen low-weight terms. This separates "targeting high weight" from "adding more cost terms." A second ablation drops the $\sum_t \epsilon_t$ term to show how much of the certified budget comes from target truncation, which AQCtensor's reporting omits.
Why not just…?
Why not just report fidelity against the MPS target, as AQCtensor does? Fidelity against the truncated target omits the truncation error, so it is not a statement about the intended state. Even fidelity against the true state bounds each correlator only to within $2\sqrt{1-F}$. At $F = 0.99$ that is 0.2, which says nothing about correlators of size 0.01. This alternative is a real threat to the second half of the proposal. If the weight-resolved residuals turn out to be flat and small, fidelity plus our truncation term is all one needs. The trajectory and convergence measurements of $r_k$ settle this directly, and we will report a null result if that is what appears.
Why not just use mirror circuits, which already live inside an MLIR compiler? A mirror circuit checks that a circuit undoes itself, which on a noiseless simulator is nearly automatic. It never compares the circuit with the state it was supposed to prepare, and the cited work frames $P'$ as a hardware-fidelity proxy. Running it on our compiled circuits and showing that it accepts circuits our verifier rejects makes this concrete.
Why not just train on the global cost, or a deeper ansatz, so that many-qubit correlations are fit directly? The global cost plateaus, stalling near 0.5 fidelity on 8 qubits in the barren-plateau study. More depth adds entanglement, which the PQC spectral bias result suggests reduces frequency bias, but it also inflates the bond dimension of the circuit's state and therefore the cost of certifying it. We include a depth sweep that plots high-weight residual against certification memory, so a reader can see whether simply going deeper is the cheaper fix.
Why not just validate against an exact state vector? That works at 20 to 32 qubits, and we use it there as ground truth. Beyond that it is impossible: GPU simulators already lose performance once the state exceeds on-chip cache at 13 to 14 qubits, according to State of practice: Evaluating GPU performance of state vector and tensor network methods. Compressed simulators such as BMQSim reach 47 qubits only with lossy compression whose own error is reported as fidelity above 0.99, not as a bound. The certificate exists precisely for the 50-to-100-qubit regime.
Proposed Experiments and Decisive Checks
The benchmarks are time-evolved Heisenberg XXX chains, as used in AQCtensor and the barren-plateau study, at 20 to 100 qubits. We add the transverse-field Ising model from the NWQ-Sim evaluation as a second family, and the 24-qubit random-state preparation task. Exact state vectors serve as ground truth up to about 32 qubits. Above that, the only ground truth is the certificate plus an independent high-bond-dimension TEBD reference.
The first decisive check is soundness and tightness. On every instance with exact ground truth, $\delta$ must upper-bound the true error, with zero violations allowed. We report the ratio of $\delta$ to the true error.
The second check is the spectral hypothesis. We plot $r_k$ against iteration and against $k$ under local cost. The hypothesis is supported if high-weight residuals decay measurably later and remain larger at convergence, consistently across both model families. It is refuted if the curves are indistinguishable.
The third check measures the filter's false-accept rate on high-weight observables. We compare the naive fidelity criterion with the sampled first-stage filter, both scored against the sound stage.
The fourth check tests whether the weight-aware cost, against its random-term ablation, reduces high-weight residuals at matched budget.
The fifth check chains the compiled circuit with a second approximate pass and confirms that the propagated tolerance attribute still bounds end-to-end error.
If only the first check succeeds, we still deliver the first sound error budget for approximate quantum compiling at 100 qubits. If the second check also succeeds, we have shown that local-cost compiling has a predictable blind spot, and we know where verifiers should spend their effort.
References
- Approximate Quantum Compiling for Quantum Simulation: A Tensor Network based approach
- Escaping barren plateaus in approximate quantum compiling
- Spectral Bias in Variational Quantum Machine Learning
- Large-Scale Simulation of Quantum Computational Chemistry on a New Sunway Supercomputer
- Quantum Circuit Transformations with a Multi-Level Intermediate Representation Compiler
- Enhancing Code Safety in Quantum Intermediate Representation
- TVOC: A Translation Validator for Optimizing Compilers
- The SemGuS Toolkit
- Sound and Automated Synthesis of Digital Stabilizing Controllers for Continuous Plants
- BMQSim: Overcoming Memory Constraints in Quantum Circuit Simulation with a High-Fidelity Compression Framework
- Simulating Quantum Systems with NWQ-Sim on HPC
- State of practice: Evaluating GPU performance of state vector and tensor network methods