Pith. sign in

REVIEW 3 major objections 6 minor 26 references

A recursive bipartition plus stabilizer frames can simulate structured near-Clifford circuits tens to thousands of times faster than monolithic frames or dense state vectors, while staying exact.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · grok-4.5

2026-07-30 11:55 UTC pith:HUYQMCI7

load-bearing objection Solid systems paper: multilevel stabilizer-frame Schrödinger–Feynman with a real cost model and honest structured-vs-adversarial numbers; incremental but referee-worthy. the 3 major comments →

arxiv 2607.27075 v1 pith:HUYQMCI7 submitted 2026-07-29 quant-ph

Adaptive Multi-Backend Simulation of Near-Clifford Quantum Circuits via Spatial Stabilizer-Frame Partitioning

H\'ector J. Garc\'ia This is my paper
classification quant-ph
keywords stabilizer simulationstabilizer framesnear-Clifford circuitsSchrödinger-Feynman simulationclassical simulation of quantum circuitsFeynman path sumadaptive multi-backend
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

Near-Clifford circuits (Clifford gates plus a modest number of T gates) are hard for classical simulators once the T-count grows, because stabilizer-frame methods explode with magic and dense state vectors explode with qubit count. This paper argues that many practical circuits concentrate their T gates in identifiable sub-registers, so a spatial cut of the qubits into two halves, each simulated with its own smaller stabilizer frame and joined by a Feynman sum over the cross-cut gates, can keep both halves cheap. The method extends that idea into a multilevel binary tree of cuts, automatically falls back to dense state-vector simulation at any leaf that would be too expensive, and chooses partitions with an explicit cost model rather than the usual “minimize the number of cut gates” heuristic. On structured hierarchical 16-qubit benchmarks the recursive simulator is dramatically faster than both monolithic stabilizer frames and a production state-vector engine; on unstructured random circuits the cost model correctly predicts when dense simulation wins instead. The dominant work is an embarrassingly parallel path sum with almost no communication between workers.

Core claim

Exact single-amplitude simulation of Clifford+T circuits can be made practical for structured workloads by recursively bipartitioning the qubits, running independent stabilizer-frame (or dense) leaves on each half, and summing Feynman paths over the cross-cut Clifford gates—provided partitions are chosen by a cost model that tracks per-half effective frame size and readout cost, not merely cut count. On a hierarchical n=16 suite this yields 92×–17,645× speedups over monolithic frames and up to ~48× (median ~5×) over a production state-vector simulator, while remaining exact.

What carries the argument

Quipu-Cut: a multilevel Schrödinger–Feynman tree whose leaves are adaptively chosen among stabilizer frames, dense state vectors, and optional approximate backends, with path factors joined by a Feynman sum; partition and slice/inline decisions are driven by a wall-clock predictor that substitutes the stabilizer-frame bound 2^w for the dense 2^n ceiling and charges end-of-path amplitude extraction explicitly.

Load-bearing premise

The method wins only when the circuit’s T gates are clustered enough that some balanced cut keeps both per-half frame growth and the number of cross-cut gates small; without that structure, dense simulation overtakes it.

What would settle it

Run the same multilevel cut and cost-model selector on a family of random Clifford+T circuits with T gates placed uniformly and cross-cut depth near n/2: if the recursive simulator still beats dense state-vector simulation end-to-end at those sizes, the structural premise is wrong; the paper’s own adversarial suite already shows the opposite past that crossover.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Structured fault-tolerant and hierarchical algorithms with clustered T blocks become classically simulable far past the monolithic stabilizer-frame wall.
  • Cut-count minimization alone is an unreliable partition heuristic; selectors must track per-half frame size and readout cost.
  • The outer Feynman path sum is embarrassingly parallel with constant communication, so large cross-cut or batch amplitude jobs can scale across workers without a sequential contraction bottleneck.
  • Adaptive leaf backends give a never-worse-than-dense guarantee, so the cut can be applied safely without prior knowledge of T placement.
  • An adaptive slice-versus-inline policy is required on high-cross-cut adversarial inputs; slice-all can be orders of magnitude worse than a partial-inline schedule.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same cost-model-driven bipartition could be reused as a front-end for other leaf oracles (tensor networks, low-rank stabilizer decompositions) wherever magic is spatially localized.
  • Expectation-value and sampling queries that amortize the path enumeration across many targets may be where the parallel structure pays more than single-amplitude verification.
  • If T-clustering and low cutwidth often coincide in real workloads, automatic structure detection could decide when to invoke Quipu-Cut versus a pure dense or MPS engine without user tuning.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 6 minor

Summary. The paper presents Quipu-Cut, an exact single-amplitude simulator for Clifford+T circuits that bipartitions the qubit register, runs independent stabilizer-frame (or adaptive) leaves on each half, and sums a Feynman path integral over rank-2 decompositions of the cross-cut Clifford gates. It extends prior Schrödinger–Feynman / stabilizer hybrids with (i) recursive multilevel bipartition trees, (ii) adaptive leaf backends (frame, dense, MPS, Bravyi–Gosset rank) under an error-budget composition theorem, and (iii) a wall-clock cost predictor that scores partitions and slice-vs-inline decisions using an F_eff-aware gate cost plus calibrated inline/readout constants, rather than cut-count minimization alone. Correctness ingredients (Algorithms 1–2, magnitude-at-LEAF, Propositions 2–6, Theorem 1) are stated with appendix proofs. Empirically, on a structured hierarchical n=16 grid (81 measurements) multilevel Quipu-Cut beats monolithic stabilizer frames by 92–17,645× and qsim by up to 47.9× (median ~5×), with a 79× per-path leaf advantage under a matched cut; on adversarial RCT circuits dense wins past the d≈n/2 crossover the cost model predicts, with honest timeouts.

Significance. If the results hold, this is a useful and carefully engineered extension of the practical near-Clifford simulation toolkit: it widens stabilizer-frame methods from global F_eff ≪ 2^t to per-half structure, gives a deployability guarantee (never asymptotically worse than dense via adaptive leaves), and replaces a known-bad cut-count heuristic with an F_eff-aware predictor that also exposed and fixed a real O(2^n) readout bottleneck. Strengths include appendix proofs, amplitude cross-checks to 10^{-5}/10^{-8}, an ablation against monolithic frames, external baselines (qsim, and corpus-wide Aer/NWQ-Sim/quimb/Maestro), micro-benchmarked (not fitted) cost constants, and explicit adversarial failure modes. The embarrassingly parallel path structure is a genuine systems advantage over sequential STN-style contraction. The work is incremental relative to Markov–Shi / qsim / Huang–Love but the multilevel + adaptive multi-backend + cost-model package, with measured hierarchical wins, is a solid contribution for a methods/systems quantum-computing venue.

major comments (3)
  1. [§7.1, §7.4, Table 4] §7.1 and §7.4 state that an offline op-count analysis finds slice-all up to ~7.7×10^6× worse than optimal partial-slice on adversarial n∈{12,16}, t=20 RCT inputs, and that a hybrid slice-vs-inline selector is “implemented and shipped,” yet “a realised (as opposed to predicted) wall-clock measurement of the shipped selector on this same adversarial suite” remains open. Table 4’s timeouts and the abstract’s crossover claim are therefore only half-closed: the cost model’s main advertised fix for the regime where cut-count fails is not yet backed by end-to-end wall-clock numbers. A revised manuscript should either report those realized timings (even on a reduced grid) or clearly demote the adversarial selector claims to “predicted only” in the abstract and §6.2.
  2. [§4.2, §6.1, Table 3] §4.2 and §3 describe cost-model-driven partition/slice selection over a candidate pool (KL, spectral, multi-start, random), and §6 says “the evaluation uses these selected partitions,” but also defers “a controlled comparison of selector-driven partitioning against plain graph bisection” to future work. Without that ablation, it is unclear how much of Table 3’s speedups is due to the F_eff-aware predictor versus hierarchical structure that any reasonable bisection would find. A short controlled comparison on the same 27-cell grid (selector vs. pure KL cut-count) would make the central “cut-count is an unreliable proxy” claim load-bearing rather than motivational.
  3. [§6.3, Tables 5–6] §6.3’s 571-cell corpus and HaPPY suite (Tables 5–6) substantially broaden the empirical story, including the important finding that backend mixing is rare below the dense ceiling and common only on deliberately heterogeneous large-n halves. As written, methodology is “outside this paper’s scope,” baselines and timeouts are only partially specified, and the HaPPY 376× geomean vs Aer can dominate a casual reading of significance relative to the primary n=16 hierarchical evidence. Either integrate a self-contained corpus protocol (timeouts, hardware, what “win” means for sampling vs amplitude) or move §6.3 to a clearly marked supplement so the primary claims rest on Table 3–4.
minor comments (6)
  1. [§8 Reproducibility] Reproducibility paragraph promises a project repository and raw CSVs but the PDF gives no URL, commit hash, or DOI. Please add an archival link (Zenodo/Software Heritage) and the 2026-05-21 benchmark commit.
  2. [References] Reference [21] still has “TODO: fill in author list before submission.”
  3. [§4 Proposition 4; Appendix A.3] Proposition 4’s displayed inequality and the appendix rewrite (A2) are easy to misread (n/2 vs n−log2(ℓA+ℓB)); a single clarified display equation would help.
  4. [Fig. 1, Table 3] Fig. 1 y-axis is log wall time with mixed units in Table 3 (SF in seconds, Rec/qsim in ms). State units consistently in the figure caption.
  5. [Abstract; §3.3] Table 1 lists four leaf backends including approximate MPS/rank; the abstract still says “exact amplitude simulator.” Clarify early that exactness holds when Select only admits error-0 backends (or ε_tot=0).
  6. [Throughout] Minor typos/notation: “Schr¨ odinger” spacing, “T able” broken headers, and occasional double-angle ⟨⟨ in amplitude notation.

Circularity Check

0 steps flagged

No significant circularity: speedups are measured against external baselines; cost-model constants are hardware-microbenchmarked, not fitted to claimed ratios.

full rationale

The paper’s load-bearing claims are an algorithmic construction (Algorithms 1–2), asymptotic cost bounds (Propositions 2–6, Theorem 1) derived from path enumeration and leaf costs, and wall-clock comparisons against external tools (qsim, Aer, NWQ-Sim, quimb, Maestro) plus an ablation (monolithic stabilizer frame). Self-citations [1–3] supply the stabilizer-frame leaf oracle—standard substrate reuse by the same author, not a uniqueness theorem or ansatz that forces the multilevel/cut results. K_inline and K_readout are calibrated on standalone gate/tensor/readout micro-benchmarks, not on the hierarchical speedup tables; the cost predictor then selects partitions rather than “predicting” quantities it was fit to. Crossover conditions (Prop. 4) and the never-worse-than-dense guarantee (Prop. 6) follow from comparing 2^d·(leaf costs) to 2^n with dense always in the selector set. Empirical wins and adversarial timeouts are reported as measurements, including the regime where dense wins. Nothing reduces by construction to its own fitted inputs or to an unverified self-citation chain.

Axiom & Free-Parameter Ledger

4 free parameters · 5 axioms · 1 invented entities

The work is an algorithms/systems paper. Correctness rests on standard stabilizer and path-sum mathematics plus engineering assumptions about gate sets, partition heuristics, and calibrated microbenchmark constants. No new physical entities. Free parameters are hardware calibration multipliers and selector search limits, not physics fits.

free parameters (4)
  • K_inline = ≈6.3 on Apple M2 Pro (paper)
    Micro-benchmarked multiplier for tensor-and-first-inline-apply cost relative to per-op leaf cost; enters wall-clock predictor Eq. 5 and partition selection.
  • K_readout (post-fix ≈1) = ≈1 after fix; ~40 before
    Readout-to-apply cost ratio in the predictor; originally ~40 before switching to O(F·s·n) single-amplitude inner product.
  • Leaf error share ε_leaf = ε_tot / sqrt(2N)
    Theorem 1 allocates total amplitude tolerance across N leaves via worst-case Cauchy–Schwarz; governs when approximate MPS/rank backends are admissible.
  • Partition candidate pool and d≤14 brute-force slice threshold = d≤14 brute force; fixed candidate pool (§4.2)
    Selector enumerates KL, spectral, multi-start KL, random bipartitions; brute-force 2^d slice subsets only for d≤14 else greedy+annealing—engineering cutoffs that can change chosen (π,S).
axioms (5)
  • domain assumption Clifford gates update stabilizer tableaus in O(n^2); T gates cofactor frames with F_eff ≤ 2^t after merges (Gottesman–Knill / stabilizer-frame formalism).
    Background §2.1; leaf cost model and all F_eff claims rest on this.
  • domain assumption Cross-cut two-qubit gates considered are CZ/CNOT/SWAP with exact rank-2 Schmidt decompositions; T gates are single-qubit and never cross the cut.
    §3.1; path space size 2^d and Algorithm 1 structure depend on it. Rank-3 gates noted as limitation in §7.1.
  • standard math Standard linear algebra / Cauchy–Schwarz bound for composing per-leaf amplitude errors into a global ε_tot (Theorem 1).
    §4.1 error-budget composition for approximate backends.
  • ad hoc to paper Kernighan–Lin / spectral / multi-start graph bisection plus the cost predictor yield partitions good enough that reported speedups are representative of automated selection.
    §3.1 and §4.2; paper notes controlled selector-vs-plain-bisection comparison is left to future work.
  • domain assumption Adaptive leaf selection never asymptotically worse than dense simulation (Proposition 6), assuming partitions satisfy d_ℓ ≤ n_ℓ−1 as enforced by the implementation.
    Deployability guarantee §4; adversarial trees excluded by KL rejection rule in Appendix A.4.
invented entities (1)
  • Quipu-Cut multilevel adaptive multi-backend simulator (algorithm + cost-model selector) no independent evidence
    purpose: Name and organize the bipartition tree, leaf backend mix, and F_eff-aware partition/slice selection as a single exact amplitude method.
    Engineering construct, not a physical entity; independent evidence is the stated implementation and benchmarks (URL not in manuscript).

pith-pipeline@v1.2.0-daily-grok45 · 31217 in / 3820 out tokens · 89758 ms · 2026-07-30T11:55:37.204897+00:00 · methodology

0 comments
read the original abstract

We present an exact amplitude simulator for Clifford+T quantum circuits that combines a Feynman path sum across a balanced qubit bipartition with stabilizer-frame simulation on each half. The construction extends prior stabilizer-based Schr\"odinger-Feynman methods in three directions: recursive multilevel bipartition into a binary tree, automatic fallback to dense state-vector simulation when a leaf's stabilizer frame would exceed its memory ceiling, and a cost-model-driven partition selector that replaces the standard cut-count minimization heuristic. We show cut-count minimization is an unreliable proxy in practice: a globally cleaner partition can reduce cross-cut count yet increase wall-clock time, because it imbalances T-gate density across halves and inflates per-half stabilizer-frame size. Our cost model substitutes the stabilizer-frame bound 2w for the dense 2n ceiling per side and explicitly models per-amplitude readout cost; isolating that term uncovered a quadratic-asymptotic inefficiency in the leaf simulator's end-of-path amplitude extraction, fixed by replacing it with an existing O(F * s * n) single-amplitude inner product. On a structured hierarchical n=16 benchmark the recursive simulator beats monolithic stabilizer-frame simulation by 92x to 17,645x, wins by 79x per path against a dense half-state-vector baseline under an identical cut, and beats a production state-vector simulator end to end by up to 47.9x (median ~5x). On adversarial random Clifford+T circuits the dense state vector wins past a crossover near n/2 cross-cut gates -- the regime the cost model identifies. The dominant cost, the cross-cut Feynman sum, is embarrassingly parallel with constant inter-worker communication, unlike recent matrix-product-state stabilizer-tensor methods whose inner contraction loop is sequential.

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

26 extracted references · 1 canonical work pages

  1. [1]

    In: Proc

    Garc ´ ıa, H.J., Markov, I.L.: Quipu: high-performance simulation of quantum circuits using stabilizer frames. In: Proc. IEEE International Conference on Computer Design (ICCD), pp. 404–410 (2013)

    2013

  2. [2]

    IEEE Trans

    Garc ´ ıa, H.J., Markov, I.L.: Simulation of quantum circuits via stabilizer frames. IEEE Trans. Comput.64(8), 2323–2336 (2015) https://doi.org/10.1109/TC.2014. 2360532

    work page doi:10.1109/tc.2014 2015

  3. [3]

    arXiv preprint arXiv:1210.6646 (2012) arXiv:1210.6646

    Garc ´ ıa, H.J., Markov, I.L., Cross, A.W.: Efficient inner-product algorithm for stabilizer states. arXiv preprint arXiv:1210.6646 (2012) arXiv:1210.6646

    Pith/arXiv arXiv 2012

  4. [4]

    arXiv preprint quant-ph/9807006 (1998) arXiv:quant-ph/9807006

    Gottesman, D.: The Heisenberg representation of quantum computers. arXiv preprint quant-ph/9807006 (1998) arXiv:quant-ph/9807006

    Pith/arXiv arXiv 1998

  5. [5]

    Aaronson, S., Gottesman, D.: Improved simulation of stabilizer circuits. Phys. Rev. A70(5), 052328 (2004) https://doi.org/10.1103/PhysRevA.70.052328

    doi:10.1103/physreva.70.052328 2004

  6. [6]

    Nature Physics14(6), 595–600 (2018)

    Boixo, S., Isakov, S.V., Smelyanskiy, V.N., Babbush, R., Ding, N., Jiang, Z., Bremner, M.J., Martinis, J.M., Neven, H.: Characterizing quantum supremacy in near-term devices. Nature Physics14(6), 595–600 (2018)

    2018

  7. [7]

    Bravyi, S., Gosset, D.: Improved classical simulation of quantum circuits domi- nated by Clifford gates. Phys. Rev. Lett.116(25), 250501 (2016) https://doi.org/ 10.1103/PhysRevLett.116.250501 29

    doi:10.1103/physrevlett.116.250501 2016

  8. [8]

    Quantum3, 181 (2019) https://doi.org/10.22331/q-2019-09-02-181

    Bravyi, S., Browne, D., Calpin, P., Campbell, E., Gosset, D., Howard, M.: Sim- ulation of quantum circuits by low-rank stabilizer decompositions. Quantum3, 181 (2019) https://doi.org/10.22331/q-2019-09-02-181

    doi:10.22331/q-2019-09-02-181 2019

  9. [9]

    Coppersmith, D.: An approximate Fourier transform useful in quantum factoring. Tech. Rep. RC 19642, IBM Research Division (1994)

    1994

  10. [10]

    Markov, I.L., Shi, Y.: Simulating quantum computation by contracting ten- sor networks. SIAM J. Comput.38(3), 963–981 (2008) https://doi.org/10.1137/ 050644756

    2008

  11. [11]

    arXiv preprint arXiv:1710.05867 (2017) arXiv:1710.05867

    Pednault, E., Gunnels, J.A., Nannicini, G., Horesh, L., Magerlein, T., Solomonik, E., Wisnieff, R.: Pareto-efficient quantum circuit simulation using tensor contrac- tion deferral. arXiv preprint arXiv:1710.05867 (2017) arXiv:1710.05867

    Pith/arXiv arXiv 2017

  12. [12]

    Google Quantum AI; https:// quantumai.google/qsim (2020)

    Quantum AI team and collaborators: qsim. Google Quantum AI; https:// quantumai.google/qsim (2020). https://doi.org/10.5281/zenodo.4023103

    doi:10.5281/zenodo.4023103 2020

  13. [13]

    Huang, Y., Love, P.J.: Feynman-path-type simulation using stabilizer projector decomposition of unitaries. Phys. Rev. A103(2), 022428 (2021) https://doi.org/ 10.1103/PhysRevA.103.022428

    doi:10.1103/physreva.103.022428 2021

  14. [14]

    Bell System Technical Journal49(2), 291–307 (1970)

    Kernighan, B.W., Lin, S.: An efficient heuristic procedure for partitioning graphs. Bell System Technical Journal49(2), 291–307 (1970)

    1970

  15. [15]

    SIAM Journal on Matrix Analysis and Applications11(3), 430–452 (1990)

    Pothen, A., Simon, H.D., Liou, K.-P.: Partitioning sparse matrices with eigen- vectors of graphs. SIAM Journal on Matrix Analysis and Applications11(3), 430–452 (1990)

    1990

  16. [16]

    arXiv preprint arXiv:2403.08724 (2024) arXiv:2403.08724

    Masot-Llima, S., Garc ´ ıa-S´ aez, A.: Stabilizer tensor networks: universal quantum simulator on a basis of stabilizer states. arXiv preprint arXiv:2403.08724 (2024) arXiv:2403.08724

    Pith/arXiv arXiv 2024

  17. [17]

    Quantum5, 410 (2021)

    Gray, J., Kourtis, S.: Hyper-optimized tensor network contraction. Quantum5, 410 (2021)

    2021

  18. [18]

    In: Proc

    Smith, K.N., Perlin, M.A., Gokhale, P., Frederick, P., Owusu-Antwi, D., Rines, R., Omole, V., Chong, F.T.: Clifford-based circuit cutting for quantum simulation. In: Proc. 50th Annual International Symposium on Computer Architecture (ISCA) (2023). https://doi.org/10.1145/3579371.3589352

    arXiv 2023

  19. [19]

    Pastawski, F., Yoshida, B., Harlow, D., Preskill, J.: Holographic quantum error- correcting codes: toy models for the bulk/boundary correspondence. J. High Energy Phys. (6), 149 (2015) https://doi.org/10.1007/JHEP06(2015)149

    doi:10.1007/jhep06(2015)149 2015

  20. [20]

    In: Proceedings 30 of the 62nd ACM/IEEE Design Automation Conference (DAC) (2025)

    Herzog, L.S., Burgholzer, L., Ufrecht, C., Scherer, D.D., Wille, R.: Joint cutting for hybrid Schr¨ odinger–Feynman simulation of quantum circuits. In: Proceedings 30 of the 62nd ACM/IEEE Design Automation Conference (DAC) (2025)

    2025

  21. [21]

    arXiv preprint arXiv:2411.12482 (2024) arXiv:2411.12482

    Stabilizer Tensor Networks with Magic State Injection authors: Stabilizer ten- sor networks with magic state injection. arXiv preprint arXiv:2411.12482 (2024) arXiv:2411.12482. TODO: fill in author list before submission

    Pith/arXiv arXiv 2024

  22. [22]

    Peng, T., Harrow, A.W., Ozols, M., Wu, X.: Simulating large quantum circuits on a small quantum computer. Phys. Rev. Lett.125(15), 150504 (2020) https: //doi.org/10.1103/PhysRevLett.125.150504 Appendix A Cost proofs We expand the proof sketches of Propositions 2–6. Notation matches the main text; polynomial factors innare retained explicitly only where th...

    doi:10.1103/physrevlett.125.150504 2020

  23. [23]

    Construction of ˆCA, ˆCB appends one single-qubit Clifford or projector per cross-cut gate—O(d) time, dominated by what follows

  24. [24]

    two leaf amplitude calls, on the disjoint qubit subsetsAandB

  25. [25]

    The per-iteration cost is dominated by the two leaf calls

    a constant-time multiply-and-accumulate of ph α ·a A ·a B intoT. The per-iteration cost is dominated by the two leaf calls. The stabilizer-frame leaf onmqubits withGgates evolves a frame ofFelements: Clifford gates costO(F·m 2) amortized (the tableau update isO(m 2) and acts on all elements through a single rotation), and T gates costO(F) per element for ...

  26. [26]

    The rule

    Summing across alld:= P ℓ dℓ cross-cut gates in the tree, the mul- tilevel algorithm without the rule returns amplitudes scaled by 2 −d/2 relative to the exact⟨x|C|0 n⟩. The rule. Decompose phα = mag α ·sign α,mag α = Y g √pg,αg ,sign α = Y g sign(V αg b ). At an internal node of depthℓ, multiply child return values only by sign α; the mag α contribution ...