{"id":"1db72971-271d-411a-bd35-f601be3aea10","arxiv_id":"2502.03445","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"TensorQC replaces the expensive 4^|E| brute-force reconstruction of circuit cutting with tensor network contraction, achieving exponential savings in classical cost and large reductions in required QPU size and quality.","lead":"This paper presents TensorQC, which uses tensor network contraction instead of brute-force sums to reconstruct the outputs of circuit-cut quantum subcircuits, dramatically lowering the classical co-processing cost. The authors report up to 200-qubit benchmark outputs reconstructed on a single GPU and more than 10x reductions in QPU resource requirements.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The claimed exponential advantage over CutQC is not general: for star-shaped subcircuit topologies, every contraction sequence has Kmax = |E|, contradicting Section III-D's proof.","rationale":"The reader's weakest assumption correctly targeted the unproven assertion Kmax < |E|. My stress-test shows the assertion is not merely unproven but false in general: a star graph of m >= 4 subcircuits forces every contraction sequence to have a step touching all |E| edges. This is a concrete counterexample to the central exponential-advantage proof, so the paper's headline claim must be weakened to a statement about specific cut topologies. The tensor-network contraction framework, HSS protocol, and heuristic cut-finding remain plausible contributions, and the empirical cost ratios for the six benchmarks are internally consistent. However, the current version overclaims a general exponential improvement and the experiments substitute random subcircuit outputs for real QPU data, as the paper itself states in Section VII-A. These issues warrant conditional acceptance with mandatory revision: correct the theoretical analysis (e.g., characterize when Kmax < |E|), report the star-topology limitation explicitly, and clarify the proxy nature of the quantum execution. This does not change the reader's conditional verdict but sharpens the reason for it. No independent code or data was released, which further supports the need for a checkable revision.","tokens_in":18240,"tokens_out":9812,"duration_ms":93982,"concrete_test":"Construct a star-shaped tensor network with m = 4 subcircuits (center C1 with one cut edge to each of C2, C3, C4; |E| = 3). Enumerate all contraction sequences (or use CoTenGra to optimize) and record the maximum number of cut edges K at any contraction step. If the minimum achievable Kmax equals |E| = 3, Section III-D's claim that Kmax < |E| for more than three subcircuits is falsified. As a follow-up, compute the full multiplication counts for this topology under both TensorQC and CutQC to confirm that the ratio is constant, not exponential.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The central theoretical claim (Section III-D, Eqs. 4 and 5) asserts that for more than three subcircuits, Kmax < |E|, yielding an exponential advantage over CutQC. The proof's key step is that 'an edge connects only two subcircuits, so K1 < |E|' for the first contraction. This is false for star topologies. If subcircuit C1 is connected by cut edges to leaves C2,...,Cm (so |E| = m-1), then any contraction that merges C1 with any leaf has K = |E| because C1 touches every edge. Contracting two leaves first (when m > 3) uses K = 2 < |E|, but no cut edge is contracted in that tensor product, so the subsequent merge of the leaf pair with C1 still has K = |E|. Thus Kmax = |E| for all contraction orders. Example: m = 4, |E| = 3, optimal contraction width is 3. Therefore the exponential improvement over CutQC does not hold for arbitrary circuit-cutting networks; it depends on the cut topology (e.g., bounded treewidth). The paper's experiments on specific benchmarks may still show practical gains, but the abstract's general claim of 'exponential runtime advantage' is unsupported and contradicted by this counterexample.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"TensorQC proposes to replace the brute-force reconstruction step of quantum circuit cutting with tensor network contraction, together with a heavy-state-selection heuristic and a greedy graph-growing algorithm to locate cuts. The paper claims an exponential runtime advantage over prior parallelization (CutQC), formalized as O(4^{Kmax} m) versus O(4^{|E|} m), and reports benchmarks up to 200 qubits run on a single GPU with reduced quantum area requirements.","tokens_in":18537,"tokens_out":5291,"duration_ms":45728,"significance":"The tensor-network equivalence for circuit-cutting reconstruction is mathematically sound, and the cost model provides a useful framework for reasoning about hybrid quantum-classical runtime. The benchmark suite covers diverse circuits, and the reported contraction-time scaling on a GPU is a promising indicator. However, the general exponential-advantage claim is not established, and the experiments use synthetic subcircuit outputs rather than actual QPU execution, so the practical significance as stated is not yet demonstrated.","major_comments":[{"comment":"The claim that Kmax < |E| whenever there are more than three subcircuits is false. Consider a star topology with m=4 subcircuits: a central subcircuit C1 connected to leaves C2, C3, C4 by three cut edges, so |E|=3. Any contraction sequence that produces the final state must at some step merge the tensor containing C1 with the rest, and at that step all three cut edges are present as open indices; pre-contracting the leaves does not remove them. Hence every contraction order has Kmax=3=|E|, contradicting the proof in Section III-D. The exponential advantage over CutQC therefore does not hold for arbitrary cut networks; it can only be claimed for restricted topologies (e.g., bounded treewidth) or for the specific cut graphs arising in the benchmarks, and the manuscript should state and prove a conditional theorem.","section":"Section III-D, Eqs. (4)-(5)"},{"comment":"The abstract asserts that the benchmarks run \"using QPUs available nowadays,\" but Section VII-A states that QPUs are too small and noisy, and instead the authors \"use random numbers as the subcircuit output.\" The 200-qubit results are therefore classical post-processing demonstrations on synthetic vectors, not end-to-end hybrid executions on QPUs. This also undermines the HSS evaluation in Section VIII-D, because the L2 norms that drive Algorithm 1 are computed from random data rather than from true subcircuit probability distributions, so the reported amplitude-retention ratios do not validate the protocol for real circuit outputs.","section":"Section VII-A and Abstract"},{"comment":"The \"exponential classical overhead advantage\" is computed as a ratio of multiplication counts between the optimized tensor-network contraction and CutQC's brute-force reconstruction. Since the tensor-network cost is optimized by CoTenGra, the reported ratios depend on the cut graph structure and do not substantiate the general complexity-theoretic claim of Section III-D. The paper should either provide a rigorous bound on Kmax for the benchmark cut graphs or present Figure 10 as an empirical observation for those circuits only, without extrapolating to a universal exponential advantage.","section":"Section VIII-B, Figure 10"}],"minor_comments":[{"comment":"The cost of the prior method for m subcircuits is 4^{|E|} (m-1) scalar multiplications, not 4^{|E|} m; the factor m appears to be an overcount in the asymptotic complexity expression.","section":"Section III-C, Eq. (5)"},{"comment":"The QPU runtime model multiplies by 2^{wi} while also stating that the number of shots equals the number of states per subcircuit; the relationship between the shot count and the factor 2^{wi} should be clarified, since a single factor may be double-counting the number of subcircuit executions.","section":"Section V, Eq. (6)"},{"comment":"The loop description in lines 2-6 of Algorithm 1 is ambiguous: the statement \"Add arg max ||pj,i|| to xj\" does not specify the range of the argmax, and the \"Remove max\" step is unclear about whether the state is removed from the candidate set or from the subcircuit output.","section":"Algorithm 1"},{"comment":"Figure 7 includes error bars, but Figures 8-11 do not; the paper should state whether these are single runs or averages and, if averages, why error bars are omitted.","section":"Figures 7-11"},{"comment":"The assumption of ten QPUs is stated but not justified against actual cloud availability, and it is unclear whether the QPU runtime in Eq. (6) is divided by ten or treated as a total across all QPUs.","section":"Section VII-A"}],"recommendation":"major_revision","confidential_remarks":"The paper has a genuine technical flaw in the central theoretical claim, but the tensor-network formulation and the benchmark demonstrations may still be valuable if the claims are restricted appropriately. I recommend giving the authors the opportunity to revise the theorem into a conditional form (e.g., for cut graphs with bounded treewidth or for the specific benchmark topologies) and to clearly separate the synthetic-data post-processing results from actual QPU execution. If the authors cannot or will not restrain the general exponential-advantage claim, the paper may not be suitable for a general venue."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Let me give you the short version. TensorQC's core move—rewriting the circuit-cutting reconstruction sum as a tensor-network contraction and contracting in a good order—is correct and practically useful. The paper also includes a sensible cost model, a heavy-state-selection heuristic, and a greedy partitioner, and the reported runtime ratios between TensorQC and CutQC are internally consistent. I would not desk-reject this.\n\nThe problem is the paper's headline claim. Section III-D says that for more than three subcircuits, Kmax<|E| because an edge connects only two subcircuits. That argument is wrong. Consider a star: one center subcircuit connected by cut edges to m-1 leaves. |E|=m-1, and every contraction sequence has a step that touches all |E| edges—either the first contraction of the center with a leaf, or the final merge of a leaf-pair with the center. So Kmax=|E|. The cost is O(4^{|E|}m), the same exponential order as CutQC, differing only in the constant. The stress-test note is correct. The exponential advantage is real for low-treewidth cut graphs but not general.\n\nThe other soft spots are proportionate. The abstract says \"using QPUs available nowadays,\" but the experiments substitute random numbers for subcircuit outputs (Section VII-A). That validates post-processing runtime, not end-to-end hybrid execution with real noise. No code or data is released. And the tensor-network idea itself appears in the authors' earlier manuscript [47], so the novelty is the engineering evaluation more than the mathematics. These are fixable, and they don't erase the contribution: HSS is a nice practical addition, the partition heuristic is sensible, and 200-qubit post-processing on one GPU is a real demonstration of what the method can do on structured circuits.\n\nWho is this for? People building circuit-cutting post-processors and anyone thinking about classical co-processing in distributed quantum computing. It deserves a serious referee—I'd send it out with a clear request to fix the theoretical claim, analyze the topology dependence (treewidth or branchwidth would be the right frame), and relabel or rerun the experiments to match the claims. A revised version that is honest about where the speedup is and where it is not would be a useful paper.","headline":"A genuinely useful tensor-network method for circuit-cutting post-processing with a proof flaw that kills the general exponential-advantage claim; referee it with a mandate to fix the theory.","tokens_in":19015,"tokens_out":3950,"would_cite":true,"duration_ms":37550,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P68","68Q12"],"pacs":[],"model":"deepseek-v4-flash","headline":"TensorQC claims that using tensor network contraction for classical post-processing turns circuit cutting's exponential reconstruction cost into an exponential in a smaller quantity, and demonstrates 200-qubit benchmarks on a single GPU.","keywords":["quantum circuit cutting","tensor network contraction","distributed quantum computing","hybrid quantum-classical","circuit knitting","graph partitioning","heavy state selection","quantum benchmarking"],"falsifier":"Construct a partition with four subcircuits where two of the subcircuits jointly touch every cut edge, so that the first tensor contraction has $K_1 = |E|$; then TensorQC's cost is $O(4^{|E|})$ and the gap to the $O(4^{|E|} m)$ baseline becomes only the factor $m$. A wall-clock comparison on such a network, or a direct count of contractions, would settle whether the exponential advantage survives outside the paper's demonstrated benchmarks.","tokens_in":18012,"feed_emoji":"🔀","tokens_out":9149,"duration_ms":77913,"temperature":0.7,"pith_summary":"Quantum circuit cutting splits a large quantum circuit into smaller subcircuits that run on smaller QPUs and reconstructs the output classically, but prior reconstruction methods cost an exponential in the number of cut edges. TensorQC establishes that this reconstruction is mathematically identical to contracting a tensor network, where each subcircuit is a tensor and each cut edge is a shared index of dimension four. This re-framing lowers the multiplication cost from $O(4^{|E|} m)$ to $O(4^{K_{\\max}} m)$, with $K_{\\max}$ the maximum number of cut edges appearing in any single contraction step, an exponential advantage when the circuit splits into more than three subcircuits. The paper combines this with a heavy-state-selection routine that reconstructs only high-amplitude output states and a greedy graph-growing cut finder, and demonstrates six benchmarks up to 200 qubits using one GPU while cutting QPU size and quality requirements by more than tenfold.","feed_headline":"TensorQC makes circuit cutting exponentially cheaper","feed_subtitle":"Reconstruction cost drops from exponential in all cuts to exponential in fewer, letting 200-qubit benchmarks run on one GPU.","key_machinery":"The load-bearing object is the tensor network formed by the subcircuit outputs: each subcircuit's output is a tensor whose indices are the cut edges it touches, every cut edge has dimension four, one per Pauli basis $\\{I, X, Y, Z\\}$, and reconstructing the original output is a sequence of pairwise tensor contractions over shared cut edges. The cost identity is that each contraction step costs $4^{\\#\\text{cuts in that step}}$ multiplications, so the total is $O(4^{K_{\\max}} m)$ with $K_{\\max}$ the maximum number of cut edges at any one step, replacing the $O(4^{|E|} m)$ brute-force bound. Heavy state selection (HSS) keeps only the highest-L2-norm binary states of each subcircuit before contraction, reducing the output dimension substantially. The greedy graph-growing algorithm merges neighboring circuit fragments by an estimated merging cost that penalizes violations of QPU constraints and large contraction-edge counts, approximating a solution to the NP-complete constrained graph partitioning problem that finds cuts.","core_discovery":"The central discovery is that the classical co-processing step of circuit cutting is a tensor network contraction, so it inherits the cost savings of contraction-order optimization. Prior methods evaluate the reconstruction formula by iterating over all $4^{|E|}$ basis permutations of the cut edges and multiplying every subcircuit output from scratch, costing $O(4^{|E|} m)$ multiplications. TensorQC instead contracts subcircuit tensors pairwise along their shared cut edges, reusing intermediate products and exploiting the distributive property of multiplication, with total cost bounded by $O(4^{K_{\\max}} m)$; the paper argues that $K_{\\max} < |E|$ whenever more than three subcircuits are produced, which is the source of the exponential gap. On top of this, heavy state selection prunes each subcircuit's output to a few significant binary states, cutting the reconstructed dimension from $2^n$ to a product of small per-subcircuit sets, and a greedy graph-growing heuristic searches for cuts under QPU width, gate-count, and contraction-edge constraints. The paper reports end-to-end runtimes for six benchmarks up to 200 qubits on a single GPU, with QPU quantum-area requirements reduced by more than $10\\times$.","pith_inferences":["The exponential advantage is only guaranteed when no pair of subcircuits collectively touches all cut edges; partitionings in which a small cluster of subcircuits covers all cuts would reduce the speedup to roughly linear, a regime the paper does not analyze.","Because heavy state selection is most effective on skewed output distributions, the method suggests a practical workload-selection rule: prefer cutting circuits whose amplitude landscape concentrates on few states, such as optimization and state-preparation circuits.","The paper's multiplication-count cost model is a proxy for wall-clock runtimes; a GPU-profiling-aware cost model would likely change the cut-finding decisions and tighten the runtime estimates, as the paper itself notes.","Wire cutting along qubit wires is orthogonal to gate-level circuit knitting, so combining both would allow partitioning at arbitrary two-qubit gates and could expand the space of feasible, low-cost cuts."],"forward_implications":["Distributed hybrid quantum computing becomes practical for circuits that exceed any single QPU's capacity: the paper runs six benchmarks up to 200 qubits with one GPU for classical post-processing.","QPU resource requirements, measured as the quantum area of the largest subcircuit, shrink by more than $10\\times$, relaxing both qubit-count and error-rate demands on near-term hardware.","For output landscapes with a few dominant states, such as GHZ and W-state circuits, heavy state selection reconstructs nearly all probability mass while sampling far fewer than one part per million of the binary states.","For distributed output landscapes, such as random supremacy circuits, heavy state selection retains a smaller fraction of the amplitude but still approaches the maximum possible retention for a fixed state budget.","The classical post-processing cost advantage over the prior parallelized reconstruction method can exceed $10^9\\times$ on the demonstrated benchmarks."],"supporting_citations":[{"why":"It supplies the circuit-cutting theory and the reconstruction formula (Eq. 1) that TensorQC re-expresses as a tensor network contraction.","marker":"[36]"},{"why":"It provides the state-of-the-art parallelized reconstruction baseline whose $O(4^{|E|} m)$ cost is compared against.","marker":"[48]"},{"why":"It provides the hyper-optimized contraction-order search that TensorQC uses to minimize classical cost.","marker":"[18]"},{"why":"It establishes the graph-partitioning formulation and its complexity, motivating the greedy cut-finding heuristic.","marker":"[24]"},{"why":"It supplies the tensor-network contraction framework and the NP-hardness of contraction-order selection.","marker":"[29]"},{"why":"It provides the random-circuit Supremacy benchmarks used in the evaluation.","marker":"[5]"}],"fun_headline_variants":["Tensor nets slash circuit cutting cost exponentially","Quantum circuit cutting gets exponential speedup","TensorQC cuts the cost of cutting quantum circuits","Distributed quantum computing via tensor networks","Exponential win in circuit cutting with TensorQC"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The exponential speedup rests on the unproven assertion that $K_{\\max} < |E|$ whenever a circuit is split into more than three subcircuits, and the large-benchmark demonstrations assume that random subcircuit outputs faithfully reproduce the post-processing cost structure of real QPU data.","fun_headline_variants_meta":{"raw":{"variants":["Tensor nets slash circuit cutting cost exponentially","Quantum circuit cutting gets exponential speedup","TensorQC cuts the cost of cutting quantum circuits","Distributed quantum computing via tensor networks","Exponential win in circuit cutting with TensorQC"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000184,"raw_usage":{"total_tokens":1344,"prompt_tokens":999,"completion_tokens":345,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":615,"completion_tokens_details":{"reasoning_tokens":280}},"tokens_in":615,"tokens_out":345,"duration_ms":3698,"temperature":1.0,"reasoning_tokens":280,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-09T04:43:23.083303+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Construct a partition with four subcircuits where two of the subcircuits jointly touch every cut edge, so that the first tensor contraction has $K_1 = |E|$; then TensorQC's cost is $O(4^{|E|})$ and the gap to the $O(4^{|E|} m)$ baseline becomes only the factor $m$. A wall-clock comparison on such a network, or a direct count of contractions, would settle whether the exponential advantage survives outside the paper's demonstrated benchmarks.","supporting_citations":[{"cited_title":"Simulating large quantum circuits on a small quantum computer,","cited_arxiv_id":null,"evidence_quote":"It supplies the circuit-cutting theory and the reconstruction formula (Eq. 1) that TensorQC re-expresses as a tensor network contraction."},{"cited_title":"Cutqc: using small quantum computers for large quantum circuit evaluations,","cited_arxiv_id":null,"evidence_quote":"It provides the state-of-the-art parallelized reconstruction baseline whose $O(4^{|E|} m)$ cost is compared against."},{"cited_title":"A fast and high quality multilevel scheme for partitioning irregular graphs,","cited_arxiv_id":null,"evidence_quote":"It establishes the graph-partitioning formulation and its complexity, motivating the greedy cut-finding heuristic."},{"cited_title":"Simulating quantum computation by contract- ing tensor networks,","cited_arxiv_id":null,"evidence_quote":"It supplies the tensor-network contraction framework and the NP-hardness of contraction-order selection."}],"review_version":1}