{"id":"22f7628d-70df-440c-8001-aef225eaa971","arxiv_id":"2506.21354","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":1,"one_line_summary":"A recursive quantum time-marching circuit for a second-order Lorenz discretization uses a linear number of initial-state copies but an exponential number of operations and exponentially small postselection probability.","lead":"Scientists built a quantum circuit that simulates the Lorenz equations, a classic chaotic system, by rewriting each nonlinear time step as a linear operation on an expanded set of qubits. The construction is a test case for whether quantum computers can eventually simulate weather and plasma turbulence, though the version here still needs exponentially many operations for long runs.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Postselection success probability decays doubly exponentially in N_t; even ideal amplitude amplification leaves an exponential number of repetitions, and the paper provides no reflection oracle or success-amplitude estimate. The numerical run is the classical RK2 scheme, not the quantum circuit.","rationale":"The reader's verdict already identifies the exponentially small postselection probability as the weakest assumption, and my analysis agrees. The concern is load-bearing because the entire quantum algorithm is a postselected circuit: without a way to observe the successful branch with non-negligible probability, the construction is a formal identity rather than a computational procedure. I sharpen the reader's objection in two ways. First, Eq. 67 underestimates the decay: each U_1 gate also includes the nonlinear-state preparation U_nl, whose success amplitude is state-dependent and not accounted for in the sigma_max factor. Second, amplitude amplification cannot be assumed to help without a concrete reflection oracle; the standard quadratic speedup still leaves a number of repetitions exponential in 3^{N_t}, so the algorithm is unusable for any reasonable N_t. The numerical section (Section 4) does not test the quantum circuit at all—it runs the classical difference scheme—so it provides no evidence on the success probability. A concrete calculation of P(N_t) along the actual RK2 trajectory, as proposed, would settle the question. The paper's other claims (linear copy count, recursive construction) appear internally coherent, and no further fatal flaw was found; hence the verdict stays CONDITIONAL.","tokens_in":20916,"tokens_out":20823,"duration_ms":226898,"concrete_test":"Using the classical RK2 trajectory from Section 4.1 (sigma=10, rho=28, beta=0.58, delta_t=2.5e-4), compute for each normalized step state |psi_n> the single-step postselection probability: the U_nl success norm ||psi_nl(n)||^2 and the block-encoding norm ||A2 psi_nl(n)||^2 / sigma_max^2. Then form the total success probability for an N_t-step run, P(N_t) = product_{m=0}^{N_t-1} [ ||psi_{n+m}^{nl}||^2 * ||A2 psi_{n+m}^{nl}||^2 / sigma_max^2 ]^{3^{N_t-1-m}}. Evaluate P(N_t) and the amplitude-amplified repetitions R(N_t) = pi / (4 sqrt(P(N_t))) for N_t = 5, 10, 15, 20. If R(N_t) grows as exp(c * 3^{N_t}) and exceeds 10^12 at N_t = 10, then the Section 3.4 claim that amplitude amplification makes the algorithm usable is false.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's recursive construction (Eq. 50) and re-usage scheme (Eqs. 52–58) give an exact postselected circuit for the RK2 Lorenz update, and the linear copy count is real. The load-bearing gap is that the algorithm is only meaningful if a successful final postselection can be obtained with a reasonable number of runs. Section 3.4 states the success probability is proportional to (1/sigma_max^2)^(3^{N_t}) (Eq. 67) and then says amplitude amplification is required, but gives no reflection operator, no oracle for the marked subspace, and no estimate of the resulting repetitions. This matters because the decay is not merely exponential in N_t but exponential in 3^{N_t}: for sigma_max ≈ 1.01 (Figure 9) and N_t = 10, (1/sigma_max^2)^(3^10) ≈ e^{-0.02·59049} ≈ 10^{-513}; even a quadratic speedup leaves ~10^256 repetitions. Moreover, Eq. 67 is an optimistic bound: each U_1 also contains the nonlinear-state preparation U_nl whose postselection amplitude ||psi_nl|| is state-dependent and can be much smaller than 1, so the true success probability is a product over the tree of U_1 gates, with the single-step probability varying along the RK2 trajectory. The paper never computes this product. The classical demonstrations in Section 4 simply evaluate the difference scheme (Eqs. 10–11) on a classical computer; they do not exercise the postselected circuit, so they provide no evidence that the success probability is manageable. Without a concrete amplitude-amplification protocol or a demonstration that the success amplitude stays bounded away from zero, the 'quantum algorithm' is an exponentially wasteful postselected computation whose output is never observed with non-negligible probability.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"This paper proposes a quantum time-marching algorithm for a second-order Runge-Kutta discretization of the Lorenz system. The single time step is written as a linear operator A_2 acting on an augmented nonlinear state, with the nonlinear state prepared via Hadamard products and LCU and the non-unitary evolution implemented by SVD-LCU block encoding. The multi-step evolution is organized recursively as U_j = U_1 U_{j-1}^{⊗3}, and the paper claims a linear number of copies of the initial state, O(3^{N_t}) total queries, and an exponential speed-up in dimensionality. Numerical sections compare a classical evaluation of the RK2 scheme with Mathematica solutions for chaotic and periodic attractors.","tokens_in":21225,"tokens_out":6943,"duration_ms":85110,"significance":"The recursive construction is a genuine contribution: the explicit circuit blocks for the Hadamard-product nonlinear preparation and the SVD-LCU block encoding are self-contained, and the copy-count result N_copies = 4N_t - 1 is a concrete structural improvement over earlier time-marching proposals. The classical validation against Mathematica demonstrates that the RK2 discretization itself reproduces the expected Lorenz attractors. However, the paper does not demonstrate that the postselected quantum circuit can be turned into a usable algorithm: the postselection success probability is exponentially small in 3^{N_t}, no amplitude-amplification protocol is supplied, and the numerical demonstrations exercise only the classical finite-difference scheme, not the quantum circuit. The central 'quantum algorithm' claim therefore needs substantial additional support or a major reframing.","major_comments":[{"comment":"The viability of the algorithm rests on Eq. (67), but that equation is not a complete success-probability expression. It counts only the (1/σ_max^2)^{3^{N_t}} factor from the repeated block-encoded A_2 gates and omits the state-dependent postselection amplitudes of the U_nl preparation in Eqs. (45)-(48), which multiply over the entire recursive tree. Even ignoring that omission, the stated bound is already fatal: for σ_max < 1.01 and N_t = 10, (1/σ_max^2)^{3^{10}} is below 10^{-500}, and a quadratic speedup from amplitude amplification would still require an exponential number of repetitions. The manuscript only states that amplitude amplification is 'required' at the end of Section 3.4 and provides no reflection operator, no oracle for the marked subspace, and no end-to-end success-probability estimate. Please supply a complete amplitude-amplification construction and a rigorous total runtime analysis, or explicitly reframe the result as a postselected circuit and remove the claim that it constitutes an efficient quantum simulation.","section":"Section 3.4, Eq. (67)"},{"comment":"The numerical demonstrations in Section 4 are classical evaluations of the predictor-corrector scheme in Eqs. (10)-(11), not executions of the quantum circuits in Figures 7 and 8. They therefore cannot validate the postselection step, the Eq. (67) estimate, or any amplitude-amplification strategy. The agreement with the Mathematica solver is useful evidence that the RK2 discretization is accurate, but it is not evidence about the behavior of the proposed quantum algorithm. Please either provide quantum-circuit-level simulations, even for small N_t, or clearly label Section 4 as validating only the classical finite-difference scheme.","section":"Section 4, Figures 11-17"},{"comment":"The total query count O(3^{N_t}) in Eq. (64), together with the postselection overhead in Eq. (67), means the expected runtime of the algorithm grows exponentially in the number of time steps. For the fixed three-dimensional Lorenz system, a classical RK2 solver runs in O(N_t) time, so the claimed 'exponential speed-up' is at most a statement about a hypothetical high-dimensional system and is not a speed-up in integration time for Lorenz itself. The paper should state this distinction explicitly and avoid implying that the Lorenz simulation is efficient in the number of time steps.","section":"Equations (64)-(66) and following paragraph"}],"minor_comments":[{"comment":"The text says 'we adopt the following convection in terms of notation'; 'convection' should be 'convention'.","section":"Section 3.1.1"},{"comment":"The word 'discetization' should be 'discretization' in both places where it appears.","section":"Section 3.4 and Conclusions"},{"comment":"The notation O(60d2pNt, T2/ϵ) is ambiguous; please write the full dependence on d, p, N_t, T, and ε with explicit exponents.","section":"Equation (65)"},{"comment":"The caption contains garbled text ('G #denotes' and 'LEFſCIRCLE /Cþrcle'); these rendering issues should be fixed before publication.","section":"Figure 2 caption"},{"comment":"The encoding in Eq. (20) is written for a 3-qubit state while the second-order scheme later uses 4 qubits; please add a sentence explaining the analogous 4-qubit amplitude encoding, since the notation is otherwise easy to misread.","section":"Equation (20)"}],"recommendation":"major_revision","confidential_remarks":"The paper contains a genuinely interesting postselected circuit construction and a clean copy-counting argument, but the abstract and conclusion overstate the result as an efficient quantum algorithm. The missing amplitude-amplification analysis and the absence of any circuit-level numerical validation are load-bearing issues. I would suggest asking the authors to either provide a complete amplification protocol and honest end-to-end complexity, or to reframe the contribution as a postselected quantum circuit with exponentially small success probability, which is a much more modest but defensible claim."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The paper has a real, checkable construction: an explicit second-order RK2 embedding of the Lorenz system into a linear update, a circuit for nonlinear state preparation via Hadamard products and LCU, and a recursive state-reuse scheme giving N_copies = 4N_t - 1. That copy count is genuinely an improvement over earlier time-marching algorithms, and the classical runs reproduce limit cycles and the chaotic attractor. So there is substance here.\n\nThe problem is the success probability. Equation (67) says p_success ∝ (1/σ_max^2)^(3^{N_t}). Since σ_max is only slightly above 1 (1.01 in Fig. 9), this is doubly exponential decay in N_t: for N_t=10, that's ~10^{-510}. The paper mentions amplitude amplification but gives no reflection oracle, no estimate of the success amplitude after amplification, and no protocol to make the output observable. Even with ideal quadratic speedup, you would need ~10^{255} runs for that N_t. The real probability is even lower because the nonlinear state preparation step U_nl also postselects with a state-dependent amplitude the paper never computes. So the central claim—that this is a usable quantum algorithm with a linear copy count—is not supported by the paper's own equations.\n\nThe numerical demonstrations don't fix this: they run the classical RK2 scheme, not the quantum circuit. No code is shipped, and no error analysis links the discretization error to the quantum output. The exponential gate count O(3^{N_t}) is acknowledged but framed as acceptable; with the postselection problem, it's not.\n\nI'd still send it to referees, because the construction is coherent and the failure mode is instructive. But the authors should be asked to either provide a concrete amplitude amplification strategy with a proven success probability, or reframe the paper as a postselected circuit that is exact in principle but impractical, without claiming a speedup. As it stands, the quantum speedup claim should not survive peer review.\n\nRecommendation: engage with it—a referee can learn from it—but do not accept the efficiency claims without substantial revision.","headline":"Recursive embedding is real, but doubly exponential postselection makes the claimed quantum speed-up collapse.","tokens_in":21825,"tokens_out":3527,"would_cite":false,"duration_ms":36311,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P68","37D45","65L06"],"pacs":["03.67.Ac","05.45.Ac"],"model":"deepseek-v4-flash","headline":"A quantum time-marching algorithm simulates the chaotic Lorenz dynamics using a recursive evolution operator that needs only a linear number of copies of the initial state.","keywords":["time-marching quantum algorithm","Lorenz system","Hadamard product","block encoding","linear combination of unitaries","recursive structure","postselection","chaotic attractor"],"falsifier":"Run the actual postselected circuit on a quantum simulator for, say, $N_t = 8$ time steps with $\\delta t = 10^{-3}$ and count how often every ancillary qubit reads 0; the expected count is essentially zero because $(1/\\sigma_{\\max}^2)^{3^8}$ is astronomically small, so the algorithm would be unusable unless the claimed amplitude amplification is explicitly implemented and its overhead counted.","tokens_in":20719,"feed_emoji":"🌀","tokens_out":7074,"duration_ms":79064,"temperature":0.7,"pith_summary":"The paper tries to establish that nonlinear, dissipative, chaotic dynamics, which normally sit outside the linear and unitary framework of quantum mechanics, can be simulated by a quantum time-marching algorithm. Its construction writes one step of a second-order Runge-Kutta discretization of the Lorenz equations as a nonlinear state preparation followed by a linear non-unitary update, then chains steps through the recursion $U_j = U_1 U_{j-1}^{\\otimes 3}$. The claimed payoff is a circuit whose width scales linearly with the number of time steps, needing only $4N_t - 1$ copies of the initial state, with a query count of $O(3^{N_t})$, improving on earlier nonlinear-solver proposals. The paper also claims that classically running this quantum scheme reproduces both the chaotic Lorenz attractor and the period-doubling limit cycles, matching high-order adaptive solvers. A sympathetic reader would care because, if true, the construction offers a general template for embedding polynomial nonlinear ODEs into postselected quantum circuits with linear growth in the number of state copies as the number of time steps grows.","feed_headline":"Lorenz chaos simulated by a recursive quantum circuit","feed_subtitle":"A postselected recursive scheme needs only 4N_t-1 state copies, but success probability shrinks exponentially with time steps.","key_machinery":"The load-bearing object is the recursive evolution operator $U_j = U_1 U_{j-1}^{\\otimes 3}$, together with the re-use of copy registers that makes the copy count linear. The nonlinear step $U_{nl}$ is implemented through the Hadamard product, the componentwise multiplication of amplitudes given by $|\\psi\\rangle \\odot |\\phi\\rangle = \\sum_i \\psi_i \\phi_i |i\\rangle$, realized by a shift-operator select unitary followed by postselection; the polynomial terms of the Lorenz nonlinear state are sums of such products combined through the linear-combination-of-unitaries (LCU) method. The non-unitary matrix $\\hat{A}_2$ is applied via an SVD-LCU block encoding, a unitary dilation whose top-left block is $\\hat{A}_2$ divided by its spectral norm, with success probability $\\|\\hat{A}_2|\\psi\\rangle\\|^2 / a^2$. The recursion exists because the no-cloning theorem forbids re-preparing the unknown evolved state, so the circuit runs $2j-1$ branches in parallel and replenishes initial-state copies with a controlled preparation operator $C\\hat{U}_{\\psi_n}^{\\otimes 2}$.","core_discovery":"The paper claims that the $j$-step evolution operator for a second-order Runge-Kutta discretization of the Lorenz system can be defined recursively as $U_j = U_1 U_{j-1}^{\\otimes 3}$, building each $j$-step advance from three parallel copies of the $(j-1)$-step advance. Because the single-step operator $U_1 = U_{A_2} U_{nl}$ is made from a Hadamard-product nonlinear state preparation followed by a block-encoded non-unitary matrix, the full $N_t$-step simulation is a postselected circuit requiring only $N_{\\text{copies}} = 4N_t - 1$ copies of the initial state, with $N_{\\text{queries}} = O(3^{N_t})$ single-step calls. The paper further claims that this copy count is an exponential improvement over the earlier time-marching scheme and a quadratic improvement over repeated-measurement and related approaches, while preserving a quantum speed-up in the dimension of the underlying ODE system. A classical implementation of the same recursive scheme is shown to reproduce the chaotic Lorenz attractor and the P1, P2, P4, and P6 limit cycles of the period-doubling route, in qualitative agreement with a high-order adaptive solver.","pith_inferences":["The numerical demonstrations run the classical RK2 scheme, not the postselected quantum circuit, so they establish the discretization's fidelity but do not probe the exponentially small success probability a real quantum execution would face.","The $O(3^{N_t})$ gate complexity means that, for the fixed three-dimensional Lorenz system, the quantum circuit depth grows exponentially with integration time; any practical advantage over classical integration would require a subexponential or amplified construction that this paper does not provide.","The Hadamard-product-plus-LCU nonlinear state preparation is a modular component that could be reused in other quantum integrators; if a later algorithm solves the postselection bottleneck, this part can be imported directly.","The claimed $O(\\operatorname{polylog}(d_s))$ dimension scaling, if realized, would matter most for high-dimensional PDE discretizations, but only after the success-probability and amplitude-amplification questions are settled."],"forward_implications":["For the Lorenz discretization, simulating $N_t$ steps requires $4N_t - 1$ copies of the initial state and $O(3^{N_t})$ single-step queries, an exponential improvement in copy count over the earlier time-marching scheme and a quadratic improvement over repeated-measurement approaches.","For a general $d_s$-dimensional polynomial ODE system of degree $p$ under a $K$-th order discretization, the claimed complexity is $O(d^2 \\log^2 d \\cdot p \\cdot N_t, (T^K/\\epsilon)^{1/(K-1)})$ with $N_{\\text{copies}} = O(N_t)$; when the original dimension is much smaller than the augmented dimension $d$, this is an exponential speed-up over classical ODE solvers.","A successful all-zero measurement at the output yields exactly the second-order RK2 update, so a successful run tracks the discretized Lorenz trajectory faithfully rather than an approximation of it.","The classical execution of the recursive scheme reproduces the chaotic attractor at $\\beta = 0.58$ and the P1, P2, P4, and P6 limit cycles of the period-doubling route, indicating that the discretization is faithful and that the recursion itself does not corrupt the dynamics.","The recursive structure is offered as a promising primitive for other quantum algorithms, and quantum compression gadgets are anticipated to further improve the resource scalings."],"supporting_citations":[{"why":"Supplies the earlier time-marching framework that required exponentially many copies and is the baseline the paper improves on.","marker":"[14]"},{"why":"Supplies the state re-usage strategy that yields the recursive U_j construction and the linear copy count.","marker":"[18]"},{"why":"Supplies the original Hadamard-product implementation between single-qubit states.","marker":"[27]"},{"why":"Supplies the representation of polynomial nonlinear transformations as sums of Hadamard-product gates.","marker":"[33]"},{"why":"Supplies the LCU method used to combine the Hadamard-product terms and the block-encoding terms.","marker":"[34]"},{"why":"Supplies the no-cloning theorem, the obstruction that forces parallel evolution of many copies.","marker":"[35]"},{"why":"Supplies the SVD-LCU block encoding used to implement the non-unitary matrix A_2.","marker":"[37]"},{"why":"Supplies the amplitude amplification that the paper invokes to try to rescue the postselection success probability.","marker":"[43]"}],"fun_headline_variants":["Recursive quantum circuit simulates Lorenz chaos with 4N-1 copies","Quantum simulation of Lorenz system needs only 4N_t-1 state copies","Recursive scheme cuts state copies to linear while preserving quantum speed-up","Lorenz attractors reproduced classically by recursive quantum-inspired algorithm"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The whole scheme depends on measuring every auxiliary qubit in the zero state at the end, and the chance of that happening falls like $(1/\\sigma_{\\max}^2)^{3^{N_t}}$; the paper assumes amplitude amplification can turn this negligible probability into a usable one without showing how.","fun_headline_variants_meta":{"raw":{"variants":["Recursive quantum circuit simulates Lorenz chaos with 4N-1 copies","Quantum simulation of Lorenz system needs only 4N_t-1 state copies","Recursive scheme cuts state copies to linear while preserving quantum speed-up","Lorenz attractors reproduced classically by recursive quantum-inspired algorithm"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000715,"raw_usage":{"total_tokens":3236,"prompt_tokens":985,"completion_tokens":2251,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":601,"completion_tokens_details":{"reasoning_tokens":2172}},"tokens_in":601,"tokens_out":2251,"duration_ms":19965,"temperature":1.0,"reasoning_tokens":2172,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T22:27:12.691354+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the actual postselected circuit on a quantum simulator for, say, $N_t = 8$ time steps with $\\delta t = 10^{-3}$ and count how often every ancillary qubit reads 0; the expected count is essentially zero because $(1/\\sigma_{\\max}^2)^{3^8}$ is astronomically small, so the algorithm would be unusable unless the claimed amplitude amplification is explicitly implemented and its overhead counted.","supporting_citations":[{"cited_title":"Quantum algorithm for nonlinear Burgers’ equation for high-speed compressible flows","cited_arxiv_id":null,"evidence_quote":"Supplies the state re-usage strategy that yields the recursive U_j construction and the linear copy count."},{"cited_title":"Non-linear quantum state transformation of spin-12","cited_arxiv_id":null,"evidence_quote":"Supplies the original Hadamard-product implementation between single-qubit states."},{"cited_title":"Quantum Computation and Quantum Information: 10th Anniversary Edition ; Cambridge University Press, 2010","cited_arxiv_id":null,"evidence_quote":"Supplies the no-cloning theorem, the obstruction that forces parallel evolution of many copies."},{"cited_title":"Quantum amplitude amplification and estimation","cited_arxiv_id":null,"evidence_quote":"Supplies the amplitude amplification that the paper invokes to try to rescue the postselection success probability."}],"review_version":1}