{"id":"dc230dbc-8883-4bf4-bdd9-9e330632b793","arxiv_id":"1908.01292","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":5,"one_line_summary":"Fast and oblivious convolution quadrature can evaluate Schrödinger Green's-function convolutions with memory O(n0 + log N) and near-FFT speed, enabling long-time simulations of point-interaction Schrödinger models.","lead":"A new numerical method simulates quantum systems where the potential is concentrated at a few points, such as impurities or delta traps, with far less memory than previous convolution methods. It compresses the solution history so that long-time runs, including nonlinear and blow-up cases, become practical in 1D.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The global complexity claim O(N log N) is contradicted by Section 5's own estimates: with n0=O(h^{-1/2}) and fixed d>0, total cost is O(h^{-3/2} log h^{-1}) = O(N^{3/2} log N), not O(N log N).","rationale":"The paper is a genuine contribution: the real inversion formula, the truncation estimate, and the geometric-interval Gauss quadrature for the one-dimensional Schrodinger kernel are derived in detail, and the DOI-linked MATLAB code supports the experiments. The reader's central per-step claim is accurate. The most load-bearing concern is the mismatch between the advertised global complexity in the abstract and conclusions (O(N log N) time, O(n0 + log N) storage) and Section 5's own complexity calculation, which gives O(N^{3/2} log N) time in the memory-saving regime when the point separation d is fixed and positive. This is an internal arithmetical inconsistency rather than a matter of differing from established consensus. Secondary concerns, such as the explicit restriction of the proofs to D = 1 and the finite-precision cancellation risk from integrand growth exp(d^2/(n0 h)), are real but are either stated as expected extensions or acknowledged with a mitigation. Because the core one-dimensional algorithm remains usable and the overclaim is correctable, the CONDITIONAL verdict already given by the reader remains appropriate; no change in verdict is needed, though the authors should correct the complexity statements.","tokens_in":20786,"tokens_out":20958,"duration_ms":183428,"concrete_test":"Re-derive the total operation count directly from Section 5: substitute n0 = c h^{-1/2} into NQ = O((log epsilon^{-1} + d^2/(n0 h)) log(T/h)) and into the total cost O(n0 log^2 n0 + N NQ). For fixed d > 0, let h -> 0 (equivalently N -> infinity) and check whether the d^2/(n0 h) term dominates; if it does, the total cost is Theta(h^{-3/2} log h^{-1}) = Theta(N^{3/2} log N), contradicting the O(N log N) stated in the conclusions. Also verify that the reported NQ values in Section 6.3 (for example NQ = 112 for h = 1/128, d = 2) are consistent with the d^2/(n0 h) contribution, confirming that the d-dependent term is not negligible in the tested regime.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Section 5 derives NQ = O((log epsilon^{-1} + d^2/(n0 h)) log(T/h)) and states that the total computational cost is O(n0 log^2 n0 + N NQ). With the advertised memory-saving choice n0 = O(h^{-1/2}), the term d^2/(n0 h) equals d^2 c^{-1} h^{-1/2}, which is unbounded as h -> 0 for any fixed d > 0. Hence N NQ = O(h^{-1} (log epsilon^{-1} + h^{-1/2}) log h^{-1}) = O(h^{-3/2} log h^{-1}), i.e. O(N^{3/2} log N) for fixed final time T. The abstract and conclusions instead promise O(N log N) and a computational cost 'significantly below existing approaches.' FFT-based convolution quadrature achieves O(N log N) time, so the proposed method is asymptotically slower when d > 0, which is the generic case for several point potentials. The reader's strongest claim about per-step cost O(NQ) is correct, but the global complexity advertised in the paper is not supported by the paper's own formulas. This is an internal inconsistency in the complexity analysis, not a disagreement with external consensus.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper develops fast and oblivious convolution quadrature (CQ) algorithms for time convolution with the free Schrödinger Green's function, targeting Schrödinger equations with point-concentrated potentials in dimensions D=1,2,3. Starting from the CQ weight representation (2.9), the authors derive a real contour integral representation for the weights (Theorem 8), truncate the vertical contour and bound the truncation error (Proposition 9, Corollary 10). For D=1 they split the remaining interval into an initial interval treated by Gauss-Jacobi quadrature (Theorem 12) and geometrically growing intervals treated by Gauss-Legendre quadrature (Theorem 14, Corollary 16). Section 5 combines the local direct convolution for the first n0 weights with a recursive history term evaluated by the quadrature, giving per-step cost O(NQ) and storage O(n0 + NQ), with NQ = O((log epsilon^{-1} + d^2/(n0 h)) log(T/h)). Numerical experiments in Section 6 validate the weight approximation and solve 1D linear and nonlinear models, including the quantum beating problem and a near-blow-up case. The paper claims O(N log N) complexity and O(n0 + log N) storage in the abstract and conclusions.","tokens_in":20954,"tokens_out":5955,"duration_ms":57230,"significance":"If the central derivation is correct, the 1D contribution is valuable: it provides a tolerance-driven parameter-selection strategy for the quadrature nodes, a recursive memory-efficient evaluation of the history term, and reproducible numerical experiments showing long-time and blow-up simulations. The quadrature and truncation analysis is detailed and does not appear to be fitted to benchmarks; the parameter choices are derived from the error bounds. However, the advertised complexity statement is internally inconsistent with Section 5's own estimates for the demonstrated regime n0 = O(h^{-1/2}): the global cost is O(N^{3/2} log N), not O(N log N), and the storage is not O(log N). Since the main selling point of the paper is efficiency relative to FFT-based CQ, this inconsistency affects the central claim. The restriction of all quadrature theorems to D=1 also means the advertised D=1,2,3 family is only supported in one dimension.","major_comments":[{"comment":"The complexity claims in the abstract and §7 are not supported by the estimates in §5. With n0 = O(h^{-1/2}) and fixed d > 0, the formula just after (5.1) gives NQ = O((log epsilon^{-1} + d^2/(n0 h)) log(T/h)) = O(h^{-1/2} log h^{-1}), so the total cost O(n0 log^2 n0 + N NQ) becomes O(h^{-3/2} log h^{-1}) = O(N^{3/2} log N). This is asymptotically worse than FFT-based CQ's O(N log N) and contradicts the 'O(N log N)' claim in §7. Likewise the storage is O(n0 + NQ) = O(h^{-1/2} log h^{-1}), not O(n0 + log N). The efficiency claims should be corrected to match what §5 actually proves; the memory-saving contribution can still be stated, but not as an O(N log N) method for d > 0.","section":"§5 (after Eq. (5.1)), §7"},{"comment":"All quadrature and truncation theorems (Corollary 10, Theorems 12 and 14, Corollary 16) are proved only for D = 1, and the text explicitly says 'we restrict ourselves to D = 1' and 'we expect similar estimates' for D = 2, 3. Since the abstract and introduction advertise algorithms for D = 1, 2, 3 and the singularity treatment is different in higher dimensions, the paper's scope claim is not established. The authors should either restrict the claims to one dimension or provide the analogous analysis, or at least numerical convergence evidence, for D = 2, 3.","section":"§4, page 8"},{"comment":"The finite-precision stability of the memory-saving regime is not demonstrated. Remark 17 notes that the integrand can grow like exp(c d^2/(n0 h)), so with n0 = O(h^{-1/2}) the quadrature terms may suffer catastrophic cancellation; §5 acknowledges this and suggests n0 = O(h^{-1}) to remove the difficulty, but the complexity conclusions are drawn for n0 = O(h^{-1/2}). The paper should either provide a finite-precision analysis or an experimental study of cancellation, and state the complexity in the regime in which the algorithm is actually stable.","section":"Remark 17, §5 (n0 paragraph)"}],"minor_comments":[{"comment":"In the text before Figure 6, 'Fugures 6–8' should be 'Figures 6–8'.","section":"§6.5"},{"comment":"In the statement of Theorem 14, the function denoted h_{n,j}(epsilon) is defined with eta_theta but the argument epsilon is never introduced; this notation should be cleaned up, presumably to h_{n,j}(eta_theta).","section":"Theorem 14"},{"comment":"The term 'mosaic-free' is used without definition; since the mosaics of the earlier algorithms are the main point of comparison, a brief explanation would help readers.","section":"Introduction"},{"comment":"Figure 5 would be more reproducible with a statement of the hardware and software environment and whether the timings include the parameter optimization.","section":"§6.5, Figure 5"}],"recommendation":"major_revision","confidential_remarks":"The paper is likely of interest to the numerical analysis community; the 1D algorithm and experiments appear sound and reproducible. The main risk is that the advertised complexity and scope claims, if not corrected, could mislead readers. I would welcome a revision that corrects the asymptotic statements, clearly separates the 1D results from the higher-dimensional expectations, and addresses the finite-precision concern at n0 = O(h^{-1/2})."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The paper is worth reading and worth refereeing, but the headline complexity claim is internally contradicted by the paper's own formulas. What is genuinely new: this is the first application of fast-and-oblivious convolution quadrature to the Schrödinger Green's kernel. The authors derive a real integral representation of the CQ weights, a truncation bound, and a geometric-interval Gauss quadrature compression that avoids the mosaic bookkeeping of earlier oblivious methods. The 1D quadrature analysis is detailed and honest, the experiments match the intended benchmarks, and the published MATLAB code makes the implementation reproducible. Reusing their own prior framework is not an issue here; the Schrödinger application and the new integral representation are distinct enough, and the parameters are chosen from error bounds rather than fitted to solutions.\n\nThe soft spots are real, but not hidden. First, the complexity summary is wrong. The abstract and conclusions promise O(N log N) time and O(n0 + log N) memory. Section 5, however, derives total cost O(n0 log^2 n0 + N NQ) with NQ = O((log epsilon^{-1} + d^2/(n0 h)) log(T/h)). With the advertised memory-saving choice n0 = O(h^{-1/2}) and fixed d > 0, the d^2/(n0 h) term is unbounded, giving NQ = O(h^{-1/2} log h^{-1}) and total cost O(h^{-3/2} log h^{-1}) = O(N^{3/2} log N). So the paper's own asymptotic analysis contradicts its abstract. This is not a subtle disagreement with external consensus; it is an internal inconsistency. It can be fixed by revising the claimed complexity to match the actual parameter regime, or by explicitly choosing n0 = O(h^{-1}) and stating the memory trade-off. Second, all the rigorous quadrature theorems are proven only for D = 1. The introduction advertises a family of algorithms for D = 1, 2, 3, but Section 4 explicitly restricts the analysis and says similar estimates are \"expected\" in higher dimensions. That is a legitimate limitation, but it should be labeled more prominently. Third, Remark 17 notes the integrand can grow like exp(d^2/(n0 h)), so the memory-saving choice may suffer destructive cancellation in finite precision. The authors acknowledge this and push n0 larger when needed, but it remains a practical fragility.\n\nWho is this for: numerical analysts working on convolution quadrature, Schrödinger point-interaction models, and fast convolution methods. It deserves a serious referee, and the code repository strengthens the case. My recommendation: send it to peer review, but require the authors to either correct the complexity claim or justify a parameter regime under which O(N log N) actually holds. As written, the central algorithm is solid in 1D, but the advertised scope and complexity need revision.","headline":"First fast-and-oblivious convolution quadrature for the Schrödinger Green's function, with a solid 1D analysis and a real complexity claim that needs correcting: the memory-saving regime costs O(N^{3/2} log N), not O(N log N).","tokens_in":21591,"tokens_out":2185,"would_cite":true,"duration_ms":24764,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["65R20","65L06","65M15","65M38"],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper claims that the convolution quadrature weights for the Schrödinger Green's function can be replaced by a fixed Gauss quadrature expansion, reducing memory from O(N) to O(n0 + log N) while keeping O(N log N) complexity.","keywords":["convolution quadrature","Schrödinger equation","concentrated potential","fast and oblivious algorithm","Gauss quadrature","Laplace transform","point interactions","memory reduction"],"falsifier":"For a fixed tolerance and decreasing h in D = 2, use the paper's parameter choices (e.g., B = 3, L0 = A1/T, ξ = A0/h) to compute the convolution weights for the 2D kernel and compare with standard FFT-based convolution quadrature weights. If the maximum error exceeds the tolerance or grows as h shrinks, the unproved D = 2 extension fails; alternatively, check whether the bound in (3.4) suffices to control the new singularity term.","tokens_in":20462,"feed_emoji":"⚛️","tokens_out":5523,"duration_ms":52225,"temperature":0.7,"pith_summary":"The paper introduces a fast and oblivious convolution quadrature method for the Schrödinger equation with point-concentrated potentials, targeting the integral-equation reformulation of the problem. It claims that, once n ≥ n0, the convolution weights of the Schrödinger kernel can be replaced by a fixed Gauss quadrature expansion whose coefficients are updated by a simple recursion. This reduces the per-step cost to O(NQ) and the storage from O(N) to O(n0 + NQ), with NQ = O((log $ε^{{-1}}$ + $d^{2}$/(n0 h)) log(T/h)). If correct, long-time simulations of highly oscillatory or blow-up-prone solutions become feasible at far less memory cost than existing FFT-based or naive implementations.","feed_headline":"Fast method cuts memory for Schrödinger point-potential simulations","feed_subtitle":"Convolution quadrature weights become a fixed Gauss rule, cutting storage from O(N) to O(log N) with O(N log N) cost.","key_machinery":"The machinery is the real inversion formula for the convolution quadrature weights (Theorem 8), which deforms the contour to the negative real axis and expresses ω_n(x) as an integral of G(λ,x) e_n(−hλ) over [0, ξ] plus vertical-line remainders. The analysis bounds the remainders (Proposition 9), truncates the integral, and approximates it on a geometrically graded partition using Gauss–Jacobi quadrature for the first interval and Gauss–Legendre quadrature for later intervals, with error estimates in Theorems 12 and 14. The fast summation step replaces each weight by a sum over NQ quadrature nodes and stores only the short direct part (n0 weights) plus the NQ running sums Q_{ℓ,k}.","core_discovery":"The central discovery is the algorithm of Section 5. For n ≥ n0, the history term in the discrete convolution is rewritten as a fixed quadrature sum: the CQ weights ω_n(x) are first expressed through a real integral representation (Theorem 8), then approximated by Gauss–Jacobi quadrature on an initial interval and Gauss–Legendre quadrature on geometrically graded intervals. In the fast summation, each historical weight is replaced by contributions from NQ quadrature nodes, and the running sums Q_{ℓ,k} are updated by the recursion Q_{ℓ,k} = r(−h x_k) Q_{ℓ−1,k} + q(−h x_k) f_{ℓ−n0−1}. This yields the claimed complexity and memory bounds while preserving the accuracy of standard convolution quadrature.","pith_inferences":["The same real-inversion-plus-geometric-grading strategy may apply to other non-sectorial transfer operators with exponential growth, such as damped wave kernels, potentially simplifying the bookkeeping of earlier oblivious algorithms.","A rigorous extension to D = 2 and D = 3 would likely need a separate treatment of the kernel singularity at λ = 0; the paper's expressions for G(λ,x) show the 2D case involves a Bessel function J0, which is smoother than the 1D cosh, so the first-interval analysis may be improvable.","For problems with many point potentials, the O(n0 + NQ) storage becomes the dominant advantage over FFT-based methods, making the method most impactful in multi-point or higher-dimensional settings.","The finite-precision cancellation noted in Remark 17 could be tested by comparing the n0 = O(h^{-1/2}) and n0 = O(h^{-1}) parameter choices on ill-conditioned data; the paper leaves this trade-off as a user parameter."],"forward_implications":["Long-time simulations of the nonlinear Schrödinger equation with point potentials become feasible at O(N log N) cost and O(n0 + log N) storage, allowing the study of quantum beating and finite-time blow-up.","The method's memory advantage grows with the number M of point potentials and with spatial dimension, since each convolution evaluation uses the same compressed history.","The recursion-based history term permits a variable-step implementation, which FFT-based convolution quadrature does not naturally allow.","Numerical experiments indicate the method matches standard convolution quadrature results for both linear beating and nonlinear suppression of beating over long time horizons."],"supporting_citations":[{"why":"Supplies the real inversion formula approach and the Gauss–Jacobi error analysis used in Section 4.","marker":"[6]"},{"why":"Extends fast and oblivious convolution quadrature to hyperbolic problems; the present work builds on and simplifies that framework.","marker":"[7]"},{"why":"Provides the nonlinear Schrödinger model and the quantum-beating experiment reproduced in Section 6.5.","marker":"[13]"},{"why":"Gives the linear Volterra integral formulation and the convolution quadrature baseline for the Schrödinger kernel.","marker":"[21]"},{"why":"Supplies the Runge–Kutta convolution quadrature framework and the representation e_n(z) = r(z)^n q(z) used throughout.","marker":"[22]"},{"why":"Introduces oblivious convolution quadrature and the memory-compression concept that this paper adapts.","marker":"[24]"},{"why":"Describes the FFT-based convolution quadrature implementation used as a comparison baseline.","marker":"[10]"},{"why":"Provides the asymptotic and small-argument properties of the modified Bessel function K0 used in the kernel bounds and in the 2D case.","marker":"[14]"}],"fun_headline_variants":["O(log N) memory for Schrödinger point potentials","Fixed Gauss rules slash Schrödinger simulation memory","New quadrature rules shrink Schrödinger storage to O(log N)"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The quadrature and truncation error bounds are proved only for D = 1; the advertised D = 2 and D = 3 algorithms rely on an expectation, not a proof, that the same estimates hold after treating the kernel singularity at the origin.","fun_headline_variants_meta":{"raw":{"variants":["O(log N) memory for Schrödinger point potentials","Fixed Gauss rules slash Schrödinger simulation memory","New quadrature rules shrink Schrödinger storage to O(log N)"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000739,"raw_usage":{"total_tokens":3260,"prompt_tokens":868,"completion_tokens":2392,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":484,"completion_tokens_details":{"reasoning_tokens":2342}},"tokens_in":484,"tokens_out":2392,"duration_ms":17193,"temperature":1.0,"reasoning_tokens":2342,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-14T15:17:41.819482+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"For a fixed tolerance and decreasing h in D = 2, use the paper's parameter choices (e.g., B = 3, L0 = A1/T, ξ = A0/h) to compute the convolution weights for the 2D kernel and compare with standard FFT-based convolution quadrature weights. If the maximum error exceeds the tolerance or grows as h shrinks, the unproved D = 2 extension fails; alternatively, check whether the bound in (3.4) suffices to control the new singularity term.","supporting_citations":[{"cited_title":"Carlone, R","cited_arxiv_id":null,"evidence_quote":"Provides the nonlinear Schrödinger model and the quantum-beating experiment reproduced in Section 6.5."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Gives the linear Volterra integral formulation and the convolution quadrature baseline for the Schrödinger kernel."},{"cited_title":"Sch¨ adle, M","cited_arxiv_id":null,"evidence_quote":"Introduces oblivious convolution quadrature and the memory-compression concept that this paper adapts."},{"cited_title":"Banjai and M","cited_arxiv_id":null,"evidence_quote":"Describes the FFT-based convolution quadrature implementation used as a comparison baseline."},{"cited_title":"http://dlmf.nist.gov/, Release 1.0.22 of 2019- 03-15","cited_arxiv_id":null,"evidence_quote":"Provides the asymptotic and small-argument properties of the modified Bessel function K0 used in the kernel bounds and in the 2D case."}],"review_version":1}