{"id":"8e2a63a6-29bc-4e59-b4f4-4f38864c5cb7","arxiv_id":"2411.10986","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"A unitary whose first row is uniform over M entries is built as the inverse of a prior uniform-superposition circuit, placing the partial sum of the first M amplitudes in the |0> amplitude with O(log M) gates.","lead":"This paper proposes quantum circuits that compute the sum of the first M amplitudes of a quantum state, placing the result into the amplitude of the |0> state with O(log M) gates. The authors position this as a building block for quantum numerical integration and cumulative probability calculations.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The numerical-integration example in §7.1.2 is miscalculated: for the normalized state defined there, S_12(|v⟩)×√12 equals ≈3.078, not 0.544262837, so the paper's demonstration of numerical integration does not follow from the stated formula.","rationale":"The most concrete and verifiable flaw in the manuscript is the miscalculated numerical-integration example in §7.1.2. This is a factual error in a claimed demonstration of the algorithm's application, and it is easily settled by recomputation. It does not by itself show that Algorithm 1 is wrong: checking a small non-power-of-two case (M=3, n=2) with the prescribed X gates and positive RY angles confirms that the inverse-unitary construction maps |0⟩ to the uniform superposition over the first three basis states, so the central unitary construction is plausible. The proof's reliance on [22] is an external dependency but not a contradiction, and the state-preparation caveat is explicitly acknowledged as outside scope. The reader's own rationale already noted the normalization error, though their weakest_assumption focused on state preparation; the present stress test identifies the integration example as the more immediately load-bearing issue because it is an actual computational mistake in the paper's demonstration. Since the flaw is localized and fixable, the verdict remains CONDITIONAL rather than ACCEPT or REJECT.","tokens_in":10519,"tokens_out":16972,"duration_ms":170345,"concrete_test":"Recompute the example in §7.1.2 with the stated formula: given ev_k = sin((2k+1)π/32), v_k = ev_k/‖ev‖, and ‖ev‖ = √(Σ_{k=0}^{15} sin²((2k+1)π/32)) = √8, evaluate S_12(|v⟩)×√12 = (Σ_{k=0}^{11} sin((2k+1)π/32))/√8 ≈ 8.708/2.828 ≈ 3.078. Compare this with the claimed 0.5442628374252914. If the recomputation reproduces ≈3.078 (as it does, by a factor-of-16/√8 discrepancy), the example's formula is incorrect, and the numerical-integration demonstration must be corrected or annotated with the missing normalization and interval-width factors.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section 7.1.2 claims ∫_0^{0.75} sin(πx)dx ≈ S_12(|v⟩)×√12 ≈ 0.5442628374252914, where v is the normalized vector v_k = sin((2k+1)π/32)/‖ev‖. By the definition of S_M in Section 7, S_12(|v⟩)×√12 = Σ_{k=0}^{11} v_k = Σ_{k=0}^{11} sin((2k+1)π/32) / ‖ev‖. For the N=16 midpoint samples, ‖ev‖ = √(Σ_{k=0}^{15} sin²((2k+1)π/32)) = √8, and Σ_{k=0}^{11} sin((2k+1)π/32) ≈ 8.708. The expression therefore evaluates to ≈8.708/2.828 ≈ 3.078, not 0.544262837. The displayed value is actually Σ_{k=0}^{11} sin((2k+1)π/32) / 16, i.e., the unnormalized midpoint sum multiplied by the interval width Δx=1/16. The missing factor is ‖ev‖/16 ≈ 0.177. This error does not by itself refute the unitary construction in Algorithm 1, but it invalidates the claimed numerical-integration demonstration and indicates that the extraction formula in Section 7 is not the one actually used.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes a quantum algorithm that, given a normalized n-qubit state |f⟩ and an integer M ≤ 2^n, constructs a unitary U whose first row is (1/√M)(1,...,1,0,...,0), so that the amplitude of |0⟩ after applying U to |f⟩ equals (1/√M)∑_{k=0}^{M-1} f_k. For M = 2^r the construction is simply Hadamards; for arbitrary M it gives a sequence of controlled-Hadamard and controlled-RY gates adapted from the authors' earlier uniform-superposition algorithm [22]. Algorithms 1 and 2 are stated with claimed gate complexity and circuit depth O(log_2 M), and applications are given to partial sums, cumulative distributions, weighted sums, and numerical integration.","tokens_in":10859,"tokens_out":6837,"duration_ms":67424,"significance":"If the unitary construction is correct, the paper's approach is a useful way to embed a partial sum in an amplitude with logarithmic-depth circuits, avoiding the overhead of a swap-test inner product and allowing downstream quantum processing. The paper has clear strengths: explicit circuits are given (Figs. 1–3), the power-of-two case is cleanly separated from the general case, and the text honestly acknowledges in Section 7 that state preparation and classical amplitude estimation are outside the advertised O(log M) cost. However, the correctness of the arbitrary-M case is largely inherited from the authors' own prior work [22] rather than proved here, and the numerical examples contain concrete normalization errors, including a miscalculated integration result. These issues are local and fixable, but they are load-bearing for the paper's demonstrations.","major_comments":[{"comment":"The numerical-integration example is miscalculated as printed. With v_k = sin((2k+1)π/32)/∥ev∥ and ∥ev∥ = √8, the quantity S_12(|v⟩)×√12 equals (1/√8)∑_{k=0}^{11} sin((2k+1)π/32) ≈ 3.078, not 0.544262837. The quoted value instead equals (1/16)∑_{k=0}^{11} sin((2k+1)π/32), i.e., the unnormalized midpoint sum times Δx. Thus the extraction formula S_M(|v⟩)×√M stated in Section 7 is not the formula actually used in the example. The demonstration must be corrected, for example by explicitly including the missing factor ∥ev∥/16 or by redefining what is being approximated.","section":"7.1.2"},{"comment":"The correctness of Algorithm 1 for arbitrary M is not proved in this paper. Section 3 asserts that the circuit generated by lines 6–16 is the inverse of Algorithm 1 in [22] and says this 'can be easily verified', but no verification or induction is supplied. Since [22] is the authors' own prior work and this unitary property is the central algorithmic claim, the paper should provide a self-contained proof (e.g., an induction on the binary decomposition of M) that the control structure and rotation angles in lines 6–16 produce the first row (1/√M)(1,...,1,0,...,0). As written, the proof is an appeal to another paper.","section":"3"},{"comment":"The partial-sum example for M = 13 contains a normalization error. The state |v⟩ has amplitude 1/√8 on both |12⟩ and |13⟩, so the sum of the first 13 components is 1 + 1/√2 + 1/√2 = 1 + √2, whereas the text gives 1 + 1/√2 + 1/√8. Consequently the displayed c_0 = (1/√13)(1+1/√2+1/√8) does not equal the partial sum defined by Eq. (1.1). This does not invalidate the general algorithm, but it means the example does not illustrate the stated formula correctly.","section":"7.1.1"}],"minor_comments":[{"comment":"The summation bounds in Eq. (4.2) and Eq. (4.3) are garbled; for example, the first summation should run from j = S_{k-1} to S_k - 1, not as printed. Please rewrite these equations with unambiguous indices.","section":"4"},{"comment":"The expression ⟨0|U⊗I|f⟩ is a vector in the second register, not a scalar equal to S_E. The intended identity should be written using a partial inner product or explicit coefficients.","section":"8"},{"comment":"The heading 'comutation of weighted partial sums' contains a typo; it should read 'computation'.","section":"4"},{"comment":"The abstract and introduction should state explicitly that the O(log M) cost excludes input state preparation and classical amplitude estimation, as Section 7 later acknowledges, to avoid overstatement.","section":"7"}],"recommendation":"major_revision","confidential_remarks":"The paper relies heavily on the authors' own previous work [22] for the key arbitrary-M construction, and the proof is delegated rather than included. This is a completeness and novelty concern that should be addressed by either proving the required lemma here or clearly delineating what is new beyond [22]. The numerical errors in Sections 7.1.1 and 7.1.2 must also be corrected before publication."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things worth knowing. The actual new idea is thin but checkable: the inverse of their own uniform-superposition circuit [22] has first row [1…1 0…0]/√M, and applying that inverse to |f⟩ puts the partial sum into the |0⟩ amplitude. The overlap identity behind it is standard linear algebra; the contribution is a qubit-efficient, O(log M)-depth way to compute that overlap without a swap test. Algorithm 2's weighted generalization is a reasonable extension, and the paper is honest that state preparation is out of scope and that classical extraction needs amplitude estimation on top. The complexity claim is conditional but stated fairly.\n\nThe soft spots, in order of severity. First, the numerical integration example in Section 7.1.2 is miscalculated. With the paper's own definition, S_12(|v⟩)×√12 equals Σ_{k=0}^{11} sin((2k+1)π/32)/‖ev‖ ≈ 8.708/√8 ≈ 3.08, not 0.544262837. The printed value is the unnormalized midpoint sum times 1/16 — the ordinary midpoint rule with Δx = 1/16 — so the stated extraction formula is missing a factor of ‖ev‖/16. The number happens to approximate the true integral, but not via the equation printed. This is a concrete error in the paper's headline application and it has to be fixed.\n\nSecond, correctness of the main construction is delegated to the authors' own [22] with \"can be easily verified.\" That is heavy self-reliance, though not circular — nothing is fit to a target. Still, a referee should insist the key lemma be stated and proved in this paper, or at least given a real proof sketch. Third, novelty is narrow: it is a new application of an existing primitive, not a new principle, and the payoff is capped by amplitude-estimation cost when a classical number is needed.\n\nOn balance, the core construction is plausible and probably correct, the paper is honest about its assumptions, and the error, while embarrassing, is local. It deserves a serious referee — this is a revise-and-resubmit, not a desk reject. I would not cite it as-is, and I would want [22]'s correctness checked and the example fixed before trusting the integration claim.","headline":"Thin but checkable idea — invert their own uniform-superposition circuit so the partial sum lands in the |0⟩ amplitude — and the worked numerical-integration example is wrong as printed: S_12(|v⟩)×√12 ≈ 3.08, not 0.544.","tokens_in":11341,"tokens_out":6648,"would_cite":false,"duration_ms":67041,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P68","65D32"],"pacs":["03.67.Ac"],"model":"deepseek-v4-flash","headline":"A quantum circuit of O(log M) gates embeds any M-term partial sum of a state's amplitudes into the |0> amplitude.","keywords":["quantum algorithm","partial sums","numerical integration","uniform superposition","amplitude encoding","circuit depth","weighted sums"],"falsifier":"Apply Algorithm 1 for a non-power-of-two M (e.g., M=13 on four qubits) to each computational basis state |k> in simulation, and verify that the amplitude of |0> in the output equals 1/sqrt(M) for k<M and 0 for k>=M; any deviation from this first-row pattern disproves the central construction.","tokens_in":10331,"feed_emoji":"⚛️","tokens_out":5136,"duration_ms":45312,"temperature":0.7,"pith_summary":"This paper claims that any partial sum of the first M amplitudes of a quantum state can be computed by a quantum circuit whose gate count and depth grow only logarithmically in M, provided the input state is already available. The key move is to construct a unitary whose first row is the uniform vector with M ones followed by zeros, so that the partial sum (up to a known normalization) lands in the amplitude of |0>. For M a power of two this is a row of Hadamards; for arbitrary M the paper gives a construction that reverses a uniform-superposition preparation algorithm, using controlled rotations whose angles come from the binary expansion of M. The authors show the same gadget yields weighted partial sums, even/odd sums, and midpoint-rule numerical integration, and they argue the O(log M) cost compares favorably with Monte Carlo integration approaches.","feed_headline":"Log-depth circuit embeds any partial sum into an amplitude","feed_subtitle":"A unitary built by reversing superposition preparation computes M-term sums with O(log M) gates.","key_machinery":"The central object is the unitary matrix U whose first row is the uniform partial-sum pattern chi = [1 ... 1 0 ... 0]/sqrt(M). It is constructed as the inverse of the uniform-superposition-preparation circuit that the authors previously gave for arbitrary M; the binary decomposition of M fixes the positions and angles of controlled-Hadamard and controlled-RY gates. Acting on |f>, this unitary transfers S_M/sqrt(M) into the amplitude of the basis state |0>.","core_discovery":"The central discovery is that the partial sum S_M = sum_{k=0}^{M-1} f_k of a normalized vector f can be recovered as the amplitude of |0> after applying a unitary U whose first row is [1 ... 1 0 ... 0]/$\\sqrt$(M). The construction is explicit: decompose M into powers of two, then run the reverse of the authors' uniform-superposition-preparation circuit, with controlled-Hadamard gates and RY rotations whose angles satisfy cos($\\theta$/2) = $\\sqrt$($2^{{l_j}}$/(M - M_{j-1})) and a final rotation with cos(theta_0/2) = $\\sqrt$(M_0/M). This yields U with gate count and depth O(log_2 M) for arbitrary M, not just powers of two. The same circuit family, with the rotation angles freed, produces weighted partial sums with arbitrary weight vectors; applying the unitary to a subset of qubits gives even or odd partial sums and other structured weighted sums.","pith_inferences":["If state preparation is included, the end-to-end complexity is dominated by preparation and, for classical output, amplitude estimation; so the O(log M) claim does not by itself translate to an end-to-end speedup for producing a classical number.","The gate count is l_k + 2k for the binary expansion, which is O(log M) but with a constant that grows with the number of 1-bits in M, so circuits for M with many 1-bits have larger constant factors.","The same inverse-preparation trick might apply to non-uniform target rows: any state-preparation circuit that produces a target superposition with a known control structure can be reversed to build a unitary with a desired first row, potentially yielding other integral transforms at logarithmic depth.","A natural testable extension is to use this gadget inside amplitude-estimation loops for Monte Carlo integration where the integrand is encoded in the amplitudes of a prepared state; the logarithmic-depth partial-sum box would reduce the cost per sample compared with coherently summing on a larger register."],"forward_implications":["Partial sums, and hence numerical integrals via midpoint rules with weights, can be embedded in a quantum amplitude in O(log M) circuit depth, so they can be chained into later quantum processing without mid-circuit measurement.","Weighted partial sums with independently chosen real weights (subject to normalization) can be generated by the same construction, enabling computation of cumulative probabilities, moving averages, and weighted integrals over intervals.","Even and odd partial sums, and more generally weighted sums over strided index sets, follow by applying the gadget to a subset of qubits, with the same logarithmic scaling.","If the input state is prepared beforehand, the O(log M) gate count beats the O(N) cost of classical Monte Carlo summation over N points, as the paper compares against existing integration algorithms."],"supporting_citations":[{"why":"Supplies the uniform-superposition-preparation circuit whose inverse gives the first-row pattern [1 ... 1 0 ... 0]/sqrt(M); the correctness proof in Sec. 3 runs through this inversion.","marker":"[22]"},{"why":"The standard amplitude estimation technique cited for extracting the classical partial-sum value from the |0> amplitude when a classical number is required.","marker":"[18]"},{"why":"Provides the comparative complexity table for quantum integration algorithms, used to argue the O(log_2 M) cost is favorable against Monte Carlo approaches with O(N).","marker":"[16]"},{"why":"Earlier quantum algorithm for numerical integrals that the present approach distinguishes itself from; cited as part of the Monte Carlo / integration landscape.","marker":"[15]"}],"fun_headline_variants":["Log-depth quantum circuit for any partial sum","Arbitrary M partial sums in O(log M) gates","Reversing superposition yields weighted sum amplitude","Quantum integration via log-depth sum circuit","Partial sums at log depth for arbitrary M"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The O(log M) complexity claim assumes the input quantum state is already prepared; if preparing that state is expensive, the overall computation is not O(log M).","fun_headline_variants_meta":{"raw":{"variants":["Log-depth quantum circuit for any partial sum","Arbitrary M partial sums in O(log M) gates","Reversing superposition yields weighted sum amplitude","Quantum integration via log-depth sum circuit","Partial sums at log depth for arbitrary M"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000841,"raw_usage":{"total_tokens":3630,"prompt_tokens":876,"completion_tokens":2754,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":492,"completion_tokens_details":{"reasoning_tokens":2685}},"tokens_in":492,"tokens_out":2754,"duration_ms":21587,"temperature":1.0,"reasoning_tokens":2685,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T19:05:01.529572+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Apply Algorithm 1 for a non-power-of-two M (e.g., M=13 on four qubits) to each computational basis state |k> in simulation, and verify that the amplitude of |0> in the output equals 1/sqrt(M) for k<M and 0 for k>=M; any deviation from this first-row pattern disproves the central construction.","supporting_citations":[{"cited_title":"An e fficient quantum algorithm for preparation of uniform quan- tum superposition states","cited_arxiv_id":null,"evidence_quote":"Supplies the uniform-superposition-preparation circuit whose inverse gives the first-row pattern [1 ... 1 0 ... 0]/sqrt(M); the correctness proof in Sec. 3 runs through this inversion."}],"review_version":1}