{"id":"230e2148-5216-44a9-b3b7-241fdfeb96a0","arxiv_id":"2501.15939","paper_version":1,"verdict":"CONDITIONAL","confidence":"HIGH","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":5,"one_line_summary":"MPS simulation in CUDA-Q extends single-GPU quantum circuit simulation from 33 qubits (state vector) to 60 to 90 qubits for the tested circuits, with linear or power-law runtime scaling.","lead":"This paper benchmarks CUDA-Q's matrix product state (MPS) quantum simulator on an Nvidia Grace Hopper GPU, comparing it with exact tensor network and state vector backends. It finds MPS can simulate 60 to 90 qubit circuits on a single GPU, but with approximation error and GPU underutilization.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Runtime feasibility at 60 qubits is established, but output correctness at those sizes is not: default-χ MPS may terminate while returning inaccurate distributions.","rationale":"The reader's weakest assumption (representativeness of the five circuits) is a fair generalization concern, and the reader's rationale already flags the single-instance correctness validation. My stress-test sharpens this into the specific load-bearing condition: default MPS parameters must keep truncation error negligible at n=60 for the circuits claimed. Runtime data alone cannot support 'simulate' in a strong sense. This does not overturn the paper's useful benchmark contribution, but it keeps the verdict CONDITIONAL: the runtime scaling result is solid, while the correctness of the high-qubit MPS outputs is unverified. I set UNCHANGED because the reader's verdict already captures the needed condition; no verdict adjustment is required. The concrete χ-convergence experiment would either close the gap or force the authors to weaken the claim to 'MPS terminates at 60 qubits, with accuracy demonstrated only at 10 qubits.'","tokens_in":12822,"tokens_out":3619,"duration_ms":35592,"concrete_test":"Run the 60-qubit QAOA and Quantum Volume circuits with CUDAQ_MPS_MAX_BOND set to 64, 128, 256, and 512 (keeping cutoffs fixed) and 10^5 shots. Compute the total variation distance or top-20 outcome overlap between successive χ values. If the sampled distribution does not stabilize as χ grows (e.g., top-20 overlap < 90% between χ=256 and χ=512), the default-χ result is not converged and the 'simulate 60 qubits' claim is unsupported. For GHZ, verify against the known analytic all-zero/all-ones distribution at n=60 as a sanity check that the pipeline itself is sound.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim in Section IV-B is that MPS 'is able to simulate 60-qubit circuits in all evaluated scenarios on a single GPU.' The evidence is exclusively wall-clock runtime (Fig. 5). No accuracy check is reported for n ≥ 35. The only correctness validation (Section V) is a single 10-qubit QAOA instance compared to exact state-vector sampling; it shows top-4 outcomes survive down to χmax = 16 for that instance, but it says nothing about QFT, GHZ, QV, or QAOA at 60 qubits, where entanglement and truncation error can grow with depth. The entanglement ratio in Table II / Fig. 3b is a gate-count proxy, not a bound on required bond dimension, and it is never connected to the actual MPS truncation error. Thus the paper conflates 'the simulation completes in reasonable time' with 'the simulation returns a meaningful result.' The load-bearing assumption is that default CUDAQ_MPS_MAX_BOND=64 and cutoffs 1e-5 keep the MPS approximation accurate for all four circuits at 60 qubits. This is plausible for GHZ (and perhaps QFT), but unverified for QV and QAOA, whose higher entanglement ratios make χ saturation likely. If this assumption fails, the headline result reduces to a runtime benchmark of an approximation whose error is unbounded.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"This paper evaluates CUDA-Q's matrix product state (MPS) and exact tensor network simulators on an NVIDIA Grace Hopper system, comparing them with the state vector backend for five circuits (GHZ, QFT, Quantum Volume, QAOA, and counterfeit coin). The authors measure runtime scaling from low qubit counts up to 60 qubits for four circuits and 90 qubits for GHZ, report that MPS runtime scales linearly or polynomially while state vector runtime scales exponentially, and profile MPS and tensor network executions to show that SVD iterations dominate and under-utilize the GPU. They also propose a correctness validation approach based on comparing the most likely sampled outcomes against state vector results for a single 10-qubit QAOA circuit with varying bond dimension limits.","tokens_in":12994,"tokens_out":5721,"duration_ms":49944,"significance":"The runtime measurements are credible and the public benchmark repository (Ref. [13]) is a valuable resource. The paper's main contribution, demonstrating that a single GPU can execute MPS simulations of 60-qubit circuits for four common circuit families, is directly supported by the wall-clock data. The honest discussion of limitations (the unverified 12-to-13 qubit gap, the application-dependence of the number of relevant outcomes, and the inability to identify the role of CPU-side tasks) is commendable. However, the significance of the headline claim is weakened by the absence of any accuracy validation at large n: the only correctness check is for one 10-qubit circuit, and the entanglement-ratio metric is never quantitatively linked to MPS truncation error. As a result, the paper establishes runtime feasibility but not that the large-scale simulations are accurate.","major_comments":[{"comment":"The claim that \"MPS simulation is able to simulate 60-qubit circuits in all evaluated scenarios on a single GPU\" is supported only by wall-clock runtime measurements; no accuracy check is reported for n ≥ 35. The only correctness validation (Section V) is a single 10-qubit QAOA instance with random parameters. Because MPS is approximate, a simulation that completes quickly may return an arbitrarily inaccurate distribution. The paper should either provide fidelity or truncation-error estimates at large n, or explicitly restrict the claim to runtime feasibility.","section":"Section IV-B, Fig. 5"},{"comment":"The default MPS parameters (CUDAQ_MPS_MAX_BOND=64, absolute and relative cutoffs 1e-5) are used throughout, and the correctness experiment shows that for one 10-qubit QAOA instance the top-4 outcomes are preserved down to χmax=16. This does not establish that χmax=64 is sufficient for QFT, QV, or QAOA at 60 qubits, where the required bond dimension depends on the entanglement structure and can grow with depth. The paper should report convergence checks (e.g., varying χmax at intermediate sizes or computing singular value spectra) to bound the approximation error.","section":"Section III-A and Section V"},{"comment":"The correctness assessment is restricted to the four most probable states from one instance, with no quantitative measure such as fidelity, total variation distance, or statistical confidence. The paper itself notes that the number of relevant outcomes is application-dependent. This is too narrow a basis for generalizing correctness to the large-scale simulations. A more robust validation (e.g., multiple circuits, varying sizes, and a proper distance metric) is needed.","section":"Section V-B, Table III"},{"comment":"The scaling \"models\" are empirical fits (t = αn^β, t = an+b) with parameters estimated from the measured data; calling this \"analytically model[ing] the scalability\" in the contribution list overstates the contribution. The fits have no uncertainty quantification, and the extrapolation of state vector runtime beyond the measured range relies on the exponential fit. The memory argument alone suffices to show state vector infeasibility at 60 qubits; the fitting language should be corrected.","section":"Section IV-B, Fig. 5"}],"minor_comments":[{"comment":"The legend spells \"Couterfeit Coin\" instead of \"Counterfeit Coin\"; the typo should be corrected.","section":"Section III-B, Fig. 3"},{"comment":"The performance gap from 12 to 13 qubits is speculatively attributed to \"cache\" or \"a change of behavior of the simulator,\" and the authors state they could not verify it in documentation; this should be presented as an unresolved observation rather than a conclusion.","section":"Section IV-A"},{"comment":"The statement that \"This property would allow us to correlate this metric with tensor network simulation performance\" is not followed by any actual correlation analysis; either add such an analysis or remove the implication.","section":"Section III-B"},{"comment":"The suggestion that CPU-side tasks are \"ill-suited for GPU parallelization\" is not directly evidenced by the profiling; it should be clearly presented as a hypothesis.","section":"Section IV-C2"},{"comment":"The table caption mentions \"Green color\" but the table may render in grayscale; ensure that the color coding is visible in print.","section":"Section V-B, Table III"},{"comment":"The expression \"the number of parameters to represent a tensor network is dnχ²\" is stated without specifying that it applies to an MPS; clarify that n is the number of qubits and the expression is for a fixed bond dimension.","section":"Section II-B"}],"recommendation":"major_revision","confidential_remarks":"The paper is a solid empirical contribution for a venue interested in quantum simulation performance. The main weakness is the gap between runtime feasibility and correctness at scale. The authors should be asked to add either fidelity checks at large n or a clear scope limitation. The public repository and the use of default parameters are strengths. The manuscript is within the journal's scope, and with revision addressing the accuracy concern, it would be appropriate."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things you should know. First, the paper delivers a clean, reproducible-looking benchmark of CUDA-Q's MPS simulator on one Grace Hopper node: 60 qubits for QAOA, QFT, QV, and GHZ (90 for GHZ), with runtime scalings and a Nsight breakdown. That part is real and useful. Second, the claim one might most want to lean on—that MPS returns meaningful answers at 60 qubits—is not supported by anything in the paper; the only accuracy check is a single 10-qubit QAOA instance. So read the headline result as 'the simulation completes fast enough,' not 'the simulation is accurate.'\n\nWhat is actually new: first published measurements of CUDA-Q's tensornet-mps backend on Grace Hopper; the observation that SVD phases dominate and hold GPU activity around 33%; the bond-dimension sensitivity table for QAOA showing top-4 outcomes survive down to χ=16 for that instance. The 'analytical model' is a misnomer—it is empirical least-squares fitting with R² values and no error bars. That overstates the contribution, but the fits are not used to extrapolate beyond the measured range, so it is a labeling problem, not a methodological one.\n\nSoft spots, in order: (1) no accuracy validation above ~35 qubits, so the stress-test concern is fair; GHZ and QFT likely fine, but QV and QAOA at χ=64 are unverified and the entanglement ratio is only a loose proxy, never tied to truncation error. The authors should either add small-scale or mid-scale checks or explicitly scope the conclusion to runtime. (2) No error bars or variance despite ten repetitions. (3) The 12-to-13-qubit jump is hand-waved. (4) The repo has no commit hash or version pins, so exact reproduction is not guaranteed. None of these invalidate the central runtime feasibility result. The paper is not circular; the state-vector comparison is an independent reference.\n\nWho it's for: practitioners choosing a simulator for low-entanglement circuits, and developers of tensor-network backends. It deserves a serious referee; the right outcome is revision, not rejection. I'd bring it to our group's benchmark-reading session, and I'd cite the runtime data if I were writing about CUDA-Q MPS.","headline":"A solid single-GPU benchmark of CUDA-Q MPS with useful runtime data, but the 60-qubit result is runtime-only; accuracy is validated for one 10-qubit circuit.","tokens_in":13613,"tokens_out":2543,"would_cite":true,"duration_ms":24024,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"CUDA-Q's matrix-product-state simulator runs 60-qubit circuits on a single GPU, where state-vector simulation cannot fit any existing system.","keywords":["quantum circuit simulation","matrix product state","tensor networks","GPU acceleration","CUDA-Q","bond dimension","state vector simulation","entanglement ratio"],"falsifier":"Run the same CUDA-Q MPS implementation on a 20- to 30-qubit version of each test circuit with the default max bond 64 and compare the sampled outcome distribution to an exact state-vector simulation; if the four most likely outcomes do not match the exact reference for any of the circuits, the default approximation is already untrustworthy at small scale, so the 60-qubit results would require a larger bond dimension that may not fit on the GPU. A cleaner test is to increase the max bond from 64 to, say, 256 at 60 qubits for one circuit: if the top outcomes change materially, the reported 60-qubit feasibility is not accompanied by stable results.","tokens_in":12487,"feed_emoji":"⚛️","tokens_out":9316,"duration_ms":84641,"temperature":0.7,"pith_summary":"This paper claims that approximate matrix-product-state (MPS) simulation, as implemented in CUDA-Q, can push quantum-circuit simulation far beyond the state-vector ceiling on a single GPU. On a 96 GB GPU the authors run all four main benchmark circuits—GHZ, quantum Fourier transform, quantum volume, and QAOA—at 60 qubits, and GHZ out to 90 qubits, while state-vector simulation of those circuits would not fit on any currently existing system. The reason is that MPS memory and runtime scale with the circuit's entanglement rather than with the full $2^n$ state; the measured runtime grows linearly for QFT and GHZ and as a power law for QAOA and quantum volume, not exponentially. Because MPS truncates singular values, the results are approximate, and the paper validates on a 10-qubit QAOA circuit that the four most likely measurement outcomes survive down to a bond dimension of 16. A sympathetic reader would take away that large-qubit classical simulation on a single GPU is realistic for low-entanglement algorithms, with accuracy the price and the main remaining risk.","feed_headline":"Tensor-network trick runs 60-qubit quantum circuits on one GPU","feed_subtitle":"Low-entanglement circuits pass the 33-qubit state-vector limit on a single GPU, trading exactness for scale.","key_machinery":"The load-bearing object is the matrix product state (MPS), a tensor network shaped as a chain of tensors in which each qubit corresponds to one tensor and adjacent tensors share a bond of dimension $\\chi$. Starting from a full state tensor, repeated singular value decompositions produce the MPS, and truncating singular values—here capped at max bond 64 with absolute and relative cutoffs of $10^{-5}$—yields a compact approximation whose memory cost is $d n \\chi^2$, only linear in the number of qubits $n$ for fixed $\\chi$. The same SVD truncation is what both enables large-qubit simulation and limits accuracy, since $\\chi$ must be large enough to capture the circuit's entanglement. The paper uses the entanglement ratio (two-qubit gates over total gates) to characterize circuits and finds constant asymptotic ratios between 0.25 and 1.0 across the five benchmarks, which lets it connect circuit structure to MPS scalability.","core_discovery":"The central discovery is that MPS simulation on a single GPU is able to simulate 60-qubit circuits in all evaluated scenarios, and 90 qubits for the GHZ circuit, whereas state-vector simulation would not be able to execute any of those simulations on any currently existing system. The paper establishes this empirically on a test system with 96 GB of GPU memory: state-vector simulation supports up to 33 qubits, while MPS reaches 60 qubits for QAOA, quantum volume, QFT, and GHZ, and 90 for GHZ. Runtime scaling in the high-qubit regime is either linear in the number of qubits (QFT, GHZ) or a power law $t = \\alpha n^\\beta$ (QAOA, quantum volume), in contrast to the exponential cost of state-vector simulation. The paper also shows that for qubit counts below about 12, state-vector simulation is faster, and that the SVD phase dominates MPS execution (about 70% of runtime) while leaving the GPU only about a third utilized. Correctness is checked on a 10-qubit QAOA circuit, where the four most probable sampled states match the state-vector reference down to bond dimension 16.","pith_inferences":["The paper's five benchmarks all have bounded entanglement ratios, so the 60-qubit result should be read as \"low-entanglement circuits,\" not as a general license: any real workload with volume-law entanglement will require a larger bond dimension and will eventually hit a memory wall, only at a different height.","The correctness check at 10 qubits does not by itself certify the 60-qubit outputs; a practical user should verify stability of top outcomes with respect to bond dimension on the target circuit before trusting a large MPS run.","Because each shot in MPS costs a fresh contraction, the method is most attractive when the number of samples is modest or when approximate samples can drive an outer optimization loop, as in variational algorithms; the paper notes but does not test this use.","If the GPU under-utilization seen in profiling is fixed, the constants in the runtime fits would improve substantially without changing the scaling laws, with the largest benefit going to the SVD-dominated MPS path."],"forward_implications":["A 96 GB single GPU can simulate 60-qubit versions of low-entanglement circuits, and 90-qubit GHZ, where no currently existing system could execute those as state-vector simulations.","For these circuits the per-shot MPS runtime grows linearly or polynomially with qubit count, so the practical limit is set by circuit structure rather than by the exponential state size.","State-vector simulation remains the right choice below roughly 12 to 13 qubits; tensor-network and MPS backends only win when the state vector no longer fits in memory.","Approximation is controllable through the bond dimension: the default max bond 64 preserved the top four QAOA outcomes, the top outcomes were still intact at bond 16, and they dropped to at most two matches at bond 8 or below.","GPU profiling shows the SVD phase dominates MPS time but under-utilizes the GPU, with about 33% average activity and less than 1% Tensor Core utilization, meaning current MPS implementations leave headroom for optimization."],"supporting_citations":[{"why":"It supplies the tensor-network and MPS formalism, including the SVD-based construction and truncation that the whole method rests on.","marker":"[14]"},{"why":"It establishes the 33-qubit memory ceiling on a 96 GB GPU that defines the state-vector baseline the paper must beat.","marker":"[15]"},{"why":"It names the underlying GPU libraries (cuTensorNet, cuStateVec) that implement the MPS, exact tensor network, and state-vector backends under evaluation.","marker":"[17]"},{"why":"It provides the entanglement-ratio metric and the QAOA circuit definition used to classify and benchmark the circuits.","marker":"[20]"},{"why":"It is the source of the counterfeit-coin circuit, whose conditional-gate structure explains its anomalously high runtime.","marker":"[21]"},{"why":"It is the source of the GHZ and QFT circuit definitions and of the CUDA-Q API used to implement the kernels.","marker":"[12]"}],"fun_headline_variants":["MPS on one GPU simulates 60 qubits, 90 for GHZ","Beyond 33-qubit limit: MPS reaches 60 on a single GPU","Approximate tensor net sims scale to 90 qubits on GPU","Sixty-qubit circuits on one GPU via CUDA-Q MPS","CUDA-Q MPS handles 60-qubit circuits on one GPU"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that the five benchmark circuits represent real quantum workloads well enough in entanglement structure; if a real target algorithm is more entangled, the fixed bond dimension of 64 will either produce wrong answers or require a bond dimension too large for a single GPU, and the 60-qubit feasibility claim will not carry over.","fun_headline_variants_meta":{"raw":{"variants":["MPS on one GPU simulates 60 qubits, 90 for GHZ","Beyond 33-qubit limit: MPS reaches 60 on a single GPU","Approximate tensor net sims scale to 90 qubits on GPU","Sixty-qubit circuits on one GPU via CUDA-Q MPS","CUDA-Q MPS handles 60-qubit circuits on one GPU"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000847,"raw_usage":{"total_tokens":3709,"prompt_tokens":993,"completion_tokens":2716,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":609,"completion_tokens_details":{"reasoning_tokens":2615}},"tokens_in":609,"tokens_out":2716,"duration_ms":19069,"temperature":1.0,"reasoning_tokens":2615,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T13:49:15.550880+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the same CUDA-Q MPS implementation on a 20- to 30-qubit version of each test circuit with the default max bond 64 and compare the sampled outcome distribution to an exact state-vector simulation; if the four most likely outcomes do not match the exact reference for any of the circuits, the default approximation is already untrustworthy at small scale, so the 60-qubit results would require a larger bond dimension that may not fit on the GPU. A cleaner test is to increase the max bond from 64 to, say, 256 at 60 qubits for one circuit: if the top outcomes change materially, the reported 60-qubit feasibility is not accompanied by stable results.","supporting_citations":[{"cited_title":"Harnessing integrated cpu-gpu system memory for hpc: a first look into grace hopper,","cited_arxiv_id":null,"evidence_quote":"It establishes the 33-qubit memory ceiling on a 96 GB GPU that defines the state-vector baseline the paper must beat."},{"cited_title":"cuquantum sdk documentation,","cited_arxiv_id":null,"evidence_quote":"It names the underlying GPU libraries (cuTensorNet, cuStateVec) that implement the MPS, exact tensor network, and state-vector backends under evaluation."},{"cited_title":"SupermarQ: A Scalable Quantum Benchmark Suite,","cited_arxiv_id":null,"evidence_quote":"It provides the entanglement-ratio metric and the QAOA circuit definition used to classify and benchmark the circuits."},{"cited_title":"QASM- Bench: A Low-Level Quantum Benchmark Suite for NISQ Evaluation and Simulation,","cited_arxiv_id":null,"evidence_quote":"It is the source of the counterfeit-coin circuit, whose conditional-gate structure explains its anomalously high runtime."},{"cited_title":"Cuda-q documentation,","cited_arxiv_id":null,"evidence_quote":"It is the source of the GHZ and QFT circuit definitions and of the CUDA-Q API used to implement the kernels."}],"review_version":1}