Efficient Classical Simulation of Heuristic Peaked Quantum Circuits

Abstract: Peaked quantum circuits, whose output distribution is sharply concentrated on a single bitstring, have emerged as a promising candidate for verifiable quantum advantage, as the correctness of the quantum output can be checked by simply comparing against the known peak. Recent work by Gharibyan et al. arXiv:2510.25838 claimed heuristic quantum advantage using peaked circuits executed on Quantinuum's 56-qubit H2 processor. These peaked circuits concentrate their output on a single hidden bitstring by training a shallow simulable circuit variationally and inserting an obfuscated permutation to increase the depth to a level that makes classical simulation intractable, with estimated runtimes of years for the largest instances. We show that these circuits can be efficiently simulated classically. We describe a method that efficiently performs a full tensor network contraction, allowing near-exact sampling and extraction of the peaked bitstring. The method exploits the mirrored structure of the circuit and iteratively cancels both halves into a Matrix Product Operator (MPO), and avoids the obfuscated permutation by greedily reducing the MPO bond dimension through a process we call unswapping. The method can fully contract and extract the peak of the largest circuit in approximately one hour on a single GPU, around half the time it took to run on the quantum hardware.

• The paper introduces a middle-MPO contraction method with greedy unswapping to remove hidden permutation structure from obfuscated mirror circuits.
• The method simulates the largest published HQAP instance—56 qubits and 1,917 two-qubit gates—in 4,059 seconds on one Nvidia A100 GPU, about half the reported quantum runtime.
• The simulation recovers the designed peak with roughly 11% probability, showing that HQAP’s mirror-based peaking mechanism remains vulnerable to structure-exploiting classical algorithms.

Background and motivation

Peaked circuits, introduced by Aaronson and Zhang (Aaronson et al., 2024), are quantum circuits whose output distribution is sharply concentrated on a single bitstring known at construction time but, in principle, hard to extract from the circuit description. Because verification reduces to a single comparison against the known peak, they have been proposed as a candidate for verifiable quantum advantage. Gharibyan et al. (Gharibyan et al., 29 Oct 2025) recently claimed heuristic quantum advantage using such circuits on Quantinuum's 56-qubit H2 trapped-ion processor. Their construction (HQAP) builds a variational peaked circuit and then inflates its depth by embedding it in an obfuscated $UU^\dagger$ mirror block, applying tensor patch optimization, angle sweeping, masking, and swap insertions to prevent classical methods from detecting the identity structure. The authors benchmarked MPS simulation, tensor network belief propagation, and Pauli path methods, reporting that all fail beyond roughly 700 two-qubit gates.

This paper by Kremer and Dupuis demonstrates that these circuits can nevertheless be efficiently simulated classically. The central observation is that the swap-based obfuscation inflates MPO bond dimension without introducing genuine entanglement: the permutations it encodes can be identified and factored out during contraction. The result directly overturns the claimed advantage for the published instances.

Method

The simulation proceeds in three phases. First, the circuit is transpiled to linear connectivity and split at its temporal midpoint into left and right halves, with an identity Matrix Product Operator (MPO) inserted between them — the same "Middle MPO Attack" strategy considered and dismissed in Ref. (Gharibyan et al., 29 Oct 2025). Second, an iterative loop alternates three stages:

• Absorption: innermost layers of both halves are contracted into the central MPO, with SVD compression using a small singular value cutoff $\epsilon$ as the only source of approximation.
• Unswapping: when the total MPO tensor element count exceeds a threshold $\tau$, a greedy heuristic extracts hidden permutations. It repeatedly selects the bond with largest dimension, tests SWAPs applied from the left, right, or both sides, and accepts any swap that reduces the bond dimension. This decomposes the MPO as $M = P_L \tilde{M} P_R$, where $\tilde{M}$ has low permutation content.
• Rewiring: the extracted permutations $P_L$, $P_R$ are propagated into the remaining circuits by stripping transpilation SWAPs, reindexing qubits, and re-transpiling to linear connectivity, restoring alignment for further absorption.

Once all layers are absorbed, the MPO is applied to $|0\rangle^{\otimes N}$ to yield an MPS from which sampling is exact via sequential conditional contraction. The implementation includes practical refinements described in the appendix: parallelized swap selection over parity-partitioned non-overlapping bonds, an optional relaxed acceptance criterion that admits dimension-preserving swaps to escape local minima, and adaptive side selection that greedily chooses which half to absorb from based on resulting MPO size. Hyperparameters used were $\epsilon = 2\times10^{-3}$, $\chi_{\max} = 8192$, and $\epsilon$0; no systematic hyperparameter search was performed.

Results

The method was applied to peaked_circuit_P9_Hqap_56x1917, the largest circuit claimed in Ref. (Gharibyan et al., 29 Oct 2025): 56 qubits with 1,917 two-qubit RZZ gates. Full contraction completed in 4,059 seconds (~1 hour 10 minutes) on a single Nvidia A100 GPU, roughly half the wall-clock time of the quantum execution on the H2 processor (under 2 hours). This is the paper's headline result: classical simulation is not merely feasible but faster than the hardware run itself.

The contraction dynamics exhibit a characteristic sawtooth pattern in MPO size, with three regimes. In the first phase (roughly 0–300 unitaries consumed), unswapping achieves only partial reduction, causing frequent unswapping calls that dominate the first ~1,000 seconds of runtime. A transition phase follows (300–700 unitaries), after which unswapping reduces the MPO almost completely at each iteration, enabling long absorption runs. The authors offer two candidate explanations for the slow start: native obfuscation (permutation encoded implicitly in variationally trained blocks rather than explicit SWAP gates) may be concentrated near the circuit midpoint and not decompose cleanly into nearest-neighbor swaps; alternatively, splitting at the temporal midpoint of the transpiled circuit may misalign with the true mirror center, with absorption gradually correcting this offset. These interpretations are offered as plausible rather than established.

Peak recovery confirms distributional fidelity: of 1,000 samples drawn from the contracted MPS, the peak bitstring appears ~110 times (~11%), consistent with the designed peak weight of ~10% reported in Ref. (Gharibyan et al., 29 Oct 2025), with all other bitstrings below 20 occurrences. This agreement also serves as empirical evidence that the SVD cutoff introduces negligible error at this scale.

Discussion

The paper articulates a structural tension in mirror-based peaked circuits: the $\epsilon$1 block is simultaneously what makes the circuit peaked and what makes it classically simulable, since contracting both halves into a central MPO lets the cancellation occur implicitly regardless of obfuscation. Obfuscation must hide the mirror well enough to defeat classical simulation while preserving it well enough to maintain the peak; the results show this balance was not achieved for HQAP. Notably, the vulnerability lies not in weak obfuscation per se but in the peaking mechanism being too structured — any modification preserving the mirror leaves exploitable cancellation structure, though such modifications could raise the constant prefactor of classical runtime enough that quantum execution wins in wall-clock terms.

Scope and limitations

The authors are careful to delimit what their result does and does not show. Ref. (Gharibyan et al., 29 Oct 2025) proves that deciding whether a circuit is peaked is QCMA-complete in the worst case and conjectures peak-finding hardness for quantum algorithms given only the circuit description; this work contradicts neither claim. It shows only that the specific HQAP construction fails to realize that hardness. The method is tailored to mirror structure: applied to a random circuit without permutation content, unswapping would fail and the MPO would grow uncontrollably, stalling the algorithm. Whether peaked circuits can be constructed to resist all classical attacks remains open. The hyperparameter choices were not optimized, and sensitivity analysis is deferred. The interpretation of the initial slow contraction phase remains conjectural.

Conclusion

Kremer and Dupuis show that the obfuscated mirror circuits advanced as evidence of heuristic quantum advantage are efficiently classically simulable: full tensor network contraction of the largest published instance (56 qubits, 1,917 two-qubit gates) completes in about one hour on a single GPU, recovering the peak bitstring with the expected ~10–11% weight. The key algorithmic contribution — greedy unswapping of permutation structure from the central MPO — neutralizes precisely the obfuscation that defeated prior classical attacks. The result reinforces a recurring pattern in which advantage claims built on obfuscation yield to structure-exploiting classical algorithms, and it redirects attention toward constructions whose hardness derives from an underlying computational problem rather than from hidden mirror symmetry.