{"id":"87d7b454-f07e-4d22-a56b-f5f8fddb567b","arxiv_id":"2411.16138","paper_version":1,"verdict":"REJECT","confidence":"MODERATE","novelty_score":3.0,"correctness_risk":"high","formal_verification":"none","parameter_count":3,"one_line_summary":"An iterative bit-slicing QUBO refinement method claims 16-decimal precision for linear systems but demonstrates only 1e-13 error and lacks a proven convergence guarantee.","lead":"This paper proposes an iterative QUBO refinement algorithm that uses only two qubits per variable per step and shrinks the search range to improve precision, claiming up to 16 decimal places. The method is a plausible extension of prior QUBO numerical work, but the submitted data stop at about 12 decimal places and the convergence guarantee is contradicted by the paper's own ill-conditioned example.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The 16-decimal claim depends on an unproven basin-containment property: each QUBO refinement step must keep the center inside the true solution's basin, yet Fig. 4 shows a 2x2 case where the center jumps far away; no convergence proof or bound is given.","rationale":"The reader's weakest assumption identifies the same load-bearing issue: the iterative refinement assumes that each QUBO's coarse-grid minimum lies in the basin of the true solution, so the center follows the solution as the grid shrinks. The paper's own Fig. 4 directly challenges that assumption by exhibiting a 2x2 system, condition number 129.44, where the center jumps to (-16384, 16384), far from the solution, at a step when the grid spacing is 2^16. Without a proof that subsequent iterations recover, or a bound on how many iterations are needed, the claim that the algorithm 'can always determine a solution if there exists one' is not justified. This is not merely a disagreement with external consensus; it is an internal inconsistency between the claimed guarantee and the presented failure example. The reported success in Table 1 is only one well-conditioned example, and even there the smallest shown error is 3.27e-13, not 1e-16; the 16-decimal figure appears in the abstract and Sec. III but is never reached in the displayed table. The proposed concrete test, using a tilted ill-conditioned system with known solution, would settle whether the basin-containment failure is an occasional artifact or a systematic property of the algorithm; either way, the current manuscript lacks the evidence and analysis needed to support the headline precision claim. Therefore the reader's REJECT verdict stands unchanged.","tokens_in":10208,"tokens_out":7965,"duration_ms":76242,"concrete_test":"Run the published GitHub implementation (Numerical_Quantum_Computing/HP) on the 2x2 tilted system A = R^T diag(1, 129.44) R with R the 30-degree rotation matrix and b = A (1,1)^T, so x* = (1,1)^T. Start at c=(0,0), m=20, and step m down to -80, recording c_m and the error ||A c_m - b||_2 at each m. If for any m <= 0 the center satisfies max(|c_m,1 - 1|, |c_m,2 - 1|) > 2^m, or if the final error exceeds 1e-14, then the greedy refinement step has left the solution basin and the claimed 16-decimal precision is not a general property of the algorithm. Repeating with a few rotation angles (15, 30, 60 degrees) would also show whether the Fig. 4 failure is generic for ill-conditioned systems.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim of up to 16 decimal places requires that the sequence of centers c_l converges to the true solution. In Sec. II-B, the algorithm solves, at each level l, a QUBO over y in {-2^l, 0, 2^l}^n centered at c, then sets c <- c + y_min and unconditionally decreases l. This is a greedy local step: it sees the objective only on a coarse grid of spacing 2^l. For the center to remain useful, the global minimizer of that QUBO must lie in the same basin as the continuous solution; otherwise the center can move to a grid point farther from the solution than the current grid spacing, and the monotonically decreasing step size may never recover. Sec. IV and Fig. 4 provide exactly such a case: for a matrix with condition number 129.44, the center jumps from the origin to (-16384, 16384) at l=16, far from the solution. The paper provides no proof of convergence, no bound on the number of iterations, and no condition-number threshold. The statement in Sec. IV that 'The proposed algorithm can always determine a solution if there exists one' is therefore unsupported. Moreover, Table 1's last reported error is 3.27e-13, not 1e-16, so the headline precision claim is not demonstrated even on the favorable system.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes an iterative QUBO refinement algorithm for solving linear systems. Each variable is represented at each step by two qubits corresponding to x_i = 2^l(q_i^+ - q_i^-), the QUBO is solved on a coarse grid, the center is moved to the minimizer, and the exponent l is decreased. The authors test the method on a 2x2 linear system with irrational coefficients using a hybrid QPU solver and claim accuracy up to 16 decimal places while using only a constant number of qubits per variable. The paper also discusses a failure mode for an ill-conditioned matrix in Section IV.","tokens_in":10514,"tokens_out":5392,"duration_ms":47537,"significance":"If the claims were fully substantiated, the algorithm would be a practical way to obtain high precision from QUBO solvers with limited qubit counts, which is an important problem for quantum optimization. The per-step QUBO equations (15)-(17) are algebraically correct for a single exponent, and the provided GitHub repository strengthens reproducibility. However, the headline precision claim is not supported by the reported data, and the greedy refinement procedure has no convergence guarantee; Figure 4 shows a concrete instability where the center jumps far from the solution. As presented, the contribution is a heuristic with a promising numerical example rather than a validated high-precision method.","major_comments":[{"comment":"The paper's headline claim of 'up to 16 decimal places' is not demonstrated by the experimental results. The smallest error reported in Table 1 is 3.27e-13 at m = -40, which is approximately 13 decimal digits, not 16. The abstract and Section III explicitly state that solutions of up to 16 decimal places were determined, but no table entry or described run shows an error at or below 1e-16. The 101-iteration run mentioned in Section III is not fully tabulated; the last shown exponent is -40, so the reader cannot verify the 16-digit claim. The authors should either provide the full iteration history or a plot of error versus iteration and should temper the abstract and introduction claims to match the reported data.","section":"Section III, Table 1"},{"comment":"The algorithm's convergence is not proven, and Fig. 4 provides a concrete counterexample to the implicit basin-containment assumption. In the 2x2 example with condition number 129.44, the center jumps from (0,0) to (-16384,16384) when the exponent decreases from 2^17 to 2^16, far from the true solution. Because Section II-B decreases the step size l unconditionally after each QUBO solve, a jump of this kind can place the center outside the basin of attraction at a scale that the subsequent finer grids cannot correct. The text acknowledges that 'many iterations' are needed but gives no bound, no condition-number threshold, and no convergence analysis. The statement in Section IV that 'the proposed algorithm can always determine a solution if there exists one' is therefore unsupported and is not consistent with the behavior shown in Fig. 4.","section":"Section IV, Fig. 4"},{"comment":"The core iterative step assumes that the global minimizer of the QUBO on the coarse grid at level l lies in the same monotone basin as the continuous solution, so that recentering at that minimum and shrinking l converges. No such property is established. The algorithm's free parameters - the starting exponent m, the exponent decrement (here 1 or 3), and the number of qubits per variable - are chosen ad hoc for the test problem (m=20, decrement 1), and the paper does not explain how these should be set for a general linear system or how they affect the attainable precision. Without a proof or a systematic parameter study, the robustness of the method for general problems is not established.","section":"Section II-B, Eqs. (18)-(19)"}],"minor_comments":[{"comment":"The notation O is used for the previous center point but is not defined; it should be a vector such as c_l to avoid confusion with the origin.","section":"Section II-B, Eq. (19)"},{"comment":"The paper states both '3n qubits' (Section II-B) and 'two qubits for each xi' (Section IV), while Section III uses 'four qubits are used when calculating a 2 x 2 matrix.' The relationship between these statements should be clarified.","section":"Sections II-B and III"},{"comment":"The header 'THE NUMBER OF QUBIT COMBINATIONS OBTAINED WHEN THE STEP OF x IS EXPRESSED IN INTERVALS OF 5' is unclear, and the column '#Occurrences' is not defined in the text.","section":"Table 1"},{"comment":"The sentence introducing y_i and c_i should explicitly define C = (c_1, ..., c_n) and replace the ad hoc notation to make the substitution x = y + C consistent with the subsequent formulas.","section":"Section II-B, after Eq. (17)"},{"comment":"The phrase 'The algorithm can obtain zero when the eccentricity e of the curve is 0 < e < 1' is vague; it should explain what becomes zero and how this relates to the algorithm's behavior.","section":"Figure 1 caption"}],"recommendation":"reject","confidential_remarks":"The per-step QUBO construction is sound, and the GitHub repository is a positive feature, but the central claims are not supported by the evidence. The 16-decimal precision claim is contradicted by Table 1, and the convergence issue exposed in Fig. 4 is fundamental because the algorithm's unconditional step-size reduction cannot recover from a basin jump. In my view, this requires either a substantial theoretical convergence analysis or a significant reframing as a heuristic with far more extensive empirical validation, which goes beyond a routine revision."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The paper's core idea is a simple, sensible one: instead of encoding a variable with many qubits at once, encode it with two qubits per digit and iterate from coarse to fine, shifting the center each step. Equations (15)–(17) are arithmetically correct for a single binary exponent, and the approach does keep the QUBO tiny per iteration. The authors also deserve credit for honestly reporting a negative example: Fig. 4 shows a 2x2 system with condition number 129.44 where the center jumps to (-16384, 16384), far from the true solution, and the text admits that many iterations may be needed. That kind of self-criticism is rare.\n\nThe soft spots are real and load-bearing. The headline claim of \"up to 16 decimal places\" is not demonstrated anywhere. Table 1's last reported error is 3.27e-13, which is about 12 decimal places, not 16. The 101-iteration run is mentioned but not shown, so we cannot verify that it reaches 1e-16. More importantly, there is no convergence proof. The greedy step assumes the global minimum of each coarse QUBO lies in the correct basin, and Fig. 4 shows that assumption failing in a simple case. The sentence in Section IV that \"the proposed algorithm can always determine a solution if there exists one\" is therefore unsupported and contradicted by the paper's own experiment. The novelty is also modest: this is an incremental extension of the authors' earlier range-dependent QUBO formulation (refs 36–37), and the paper does not clearly differentiate the new contribution from that prior work.\n\nThe equations are checkable and the failure case is instructive, but the gap between the stated precision claim and the evidence is substantial. This is not a fatal flaw in the underlying refinement idea—it is a problem of overclaiming and missing analysis. A revision that reports the full iteration table, states the actual precision reached, proves a convergence bound or explicitly characterizes when the algorithm can fail, and dials back the unconditional claims would make this a useful contribution.\n\nThis paper is for researchers who follow QUBO-based numerical computing on quantum annealers. It deserves a serious referee because the formulation is concrete and the negative example is interesting, but I would expect a major-revision decision rather than acceptance as is.","headline":"The per-step QUBO arithmetic is correct and the two-qubit refinement trick is neat, but the 16-decimal claim is not in the data and the paper's own Fig. 4 undercuts the convergence argument.","tokens_in":11056,"tokens_out":1518,"would_cite":false,"duration_ms":15062,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"An iterative QUBO refinement algorithm using two qubits per variable at each step is claimed to solve a linear system to up to 16 decimal places, far beyond the two-decimal precision of existing QUBO solvers.","keywords":["QUBO","iterative refinement","quantum annealing","linear systems","precision","qubit encoding","numerical quantum computing","hybrid solver"],"falsifier":"Run the algorithm on the paper's $2\\times2$ irrational system and record the error at each $\\ell$; if the error does not go below $10^{-16}$ as $\\ell$ decreases past $-40$, the 16-decimal-place claim is not supported. Alternatively, apply the algorithm to a matrix with condition number 129.44 and check whether the center jumps to $(-16384,16384)$ as in the paper's Fig. 4 and whether the promised many iterations eventually terminate.","tokens_in":9974,"feed_emoji":"⚛️","tokens_out":12296,"duration_ms":95776,"temperature":0.7,"pith_summary":"This paper proposes an iterative scheme for solving linear systems on quantum annealers. Instead of encoding the full precision of each variable in one large binary expansion, the algorithm uses two qubits per variable at each step, finds the minimum of a QUBO, moves the search center to that minimum, shrinks the step size, and repeats. The paper claims this reaches up to 16 decimal places of accuracy on a linear system with irrational coefficients, whereas existing QUBO simulators and hybrid solvers were limited to about two decimal places. The value of the claim is that precision becomes a function of iteration count rather than qubit count, which would make high-precision quantum optimization practical on today's limited hardware. The paper also shows a failure case for an ill-conditioned matrix, where the center jumps far from the solution and the algorithm needs many iterations.","feed_headline":"Two qubits per variable reach 16 decimal places","feed_subtitle":"Iterative QUBO refinement recenters and shrinks the search, beating the two-decimal limit of standard solvers.","key_machinery":"The machinery is an iterative refinement loop on the QUBO formulation of least squares. For each variable the paper writes $x_i = c_i + 2^\\ell(q_{i,\\ell}^+ - q_{i,\\ell}^-)$, where $q^+,q^-$ are the two qubits at scale $\\ell$ and $c_i$ is the current center. The least-squares objective $\\|Ax-b\\|^2 = x^T A^T A x - 2b^T A x + b^T b$ is expanded into a QUBO in the qubits, solved, and the resulting minimizer becomes the new center; $\\ell$ is then decreased and the process repeats. The loop is what carries the argument: precision is accumulated by recentering rather than by lengthening the binary expansion, so the coefficients in the QUBO matrix stay within the physical accuracy of the annealer at every step.","core_discovery":"The paper's central claim is that an iterative QUBO refinement algorithm can solve a linear system $Ax=b$ to up to 16 decimal places while using only two qubits per variable at each step. The authors demonstrate this on a $2\\times2$ system with irrational matrix entries $(\\sqrt2, -\\sqrt3, \\sqrt5, \\sqrt7)$ and a specially chosen $b$, running 101 iterations from $\\ell=20$ down to $\\ell=-40$; the error between the QUBO minimum and the true solution falls from $3.22\\times10^3$ at $\\ell=15$ to $3.27\\times10^{-13}$ at $\\ell=-40$. A second experiment with six qubits per variable reaches the same solution in 39 iterations. The paper presents this as overcoming the physical limitations of bias and coupler accuracy, because each step's QUBO has a smaller dynamic range than a single monolithic encoding would.","pith_inferences":["A testable extension is to replace the greedy recentering with a backtracking or wider-search step when the condition number is high; the paper identifies the jump failure but does not specify a recovery strategy.","The two-qubit representation is essentially a one-bit signed-digit encoding, and the paper itself notes the representation is redundant; comparing this encoding with balanced or redundant number systems could reduce the many-iterations cases without adding qubits.","The accuracy ceiling of 16 digits is tied to the hardware's QUBO coefficient precision, so a natural stress test is to solve a system whose exact solution requires coefficients beyond that range and check whether iterative refinement still converges.","The paper does not benchmark against classical iterative refinement of a floating-point solve; a direct comparison would isolate whether the quantum step contributes accuracy or just a recentering that a classical presolve could do."],"forward_implications":["Any QUBO-based numerical solver can trade qubit count per variable for iteration count, making high-precision quantum optimization feasible with small logical registers at each step.","The reported error table shows roughly two orders of magnitude of accuracy gained per five steps of $\\ell$, from $10^{-2}$ at $\\ell=0$ down to $10^{-13}$ at $\\ell=-40$.","With a hybrid solver handling up to about two million variables, the paper estimates the algorithm can target linear systems up to roughly $333{,}333\\times333{,}333$ using the paper's reported $3n$-qubit accounting.","Using six qubits per variable instead of two cuts the required iterations from 101 to 39, so the method exposes a direct qubits-versus-iterations trade-off.","The method inherits a condition-number sensitivity: for a matrix with condition number 129.44 the greedy center update can jump away from the solution, and the paper reports that many iterations are then needed."],"supporting_citations":[{"why":"supplies the base QUBO model for a system of linear equations that the iterative refinement modifies.","marker":"[36]"},{"why":"introduces the range-dependent center shift $x_i = y_i + c_i$ used to move the search center toward the current minimizer.","marker":"[37]"},{"why":"provides the radix-2 representation of real variables as qubits that the two-qubit step refines.","marker":"[39]"},{"why":"establishes the 16-digit coefficient accuracy of the QPU solver that the experiment relies on.","marker":"[30]"},{"why":"demonstrates hybrid-solver capability and motivates the scaling estimate for large linear systems.","marker":"[31]"},{"why":"gives the gate-model quantum linear-system baseline against which the QUBO approach is positioned.","marker":"[22]"}],"fun_headline_variants":["Two-qubit QUBO iterative refinement reaches 16-digit precision","Iterative QUBO with two qubits per variable hits 16 decimals","QUBO refinement: two qubits per variable, 16 decimals","Two-qubit QUBO steps up precision from 2 to 16 decimals","Two-qubit QUBO iteration: 16-digit precision"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that the global minimum of the QUBO at each coarse step lies in the basin of the true solution, so recentering onto that minimum and shrinking the step size converges; the paper's own condition-number-129.44 example, where the center jumps to $(-16384,16384)$, shows this premise can fail without a stated bound on the many iterations needed.","fun_headline_variants_meta":{"raw":{"variants":["Two-qubit QUBO iterative refinement reaches 16-digit precision","Iterative QUBO with two qubits per variable hits 16 decimals","QUBO refinement: two qubits per variable, 16 decimals","Two-qubit QUBO steps up precision from 2 to 16 decimals","Two-qubit QUBO iteration: 16-digit precision"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.00098,"raw_usage":{"total_tokens":4196,"prompt_tokens":1018,"completion_tokens":3178,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":634,"completion_tokens_details":{"reasoning_tokens":3082}},"tokens_in":634,"tokens_out":3178,"duration_ms":21421,"temperature":1.0,"reasoning_tokens":3082,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T13:30:56.998739+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the algorithm on the paper's $2\\times2$ irrational system and record the error at each $\\ell$; if the error does not go below $10^{-16}$ as $\\ell$ decreases past $-40$, the 16-decimal-place claim is not supported. Alternatively, apply the algorithm to a matrix with condition number 129.44 and check whether the center jumps to $(-16384,16384)$ as in the paper's Fig. 4 and whether the promised many iterations eventually terminate.","supporting_citations":[{"cited_title":"Larger sparse quadratic assignment problem optimization using quantum annealing and a bit - flip heuristic algorithm","cited_arxiv_id":null,"evidence_quote":"supplies the base QUBO model for a system of linear equations that the iterative refinement modifies."},{"cited_title":"QUBO Formulations for a System of Linear Equations","cited_arxiv_id":null,"evidence_quote":"introduces the range-dependent center shift $x_i = y_i + c_i$ used to move the search center toward the current minimizer."},{"cited_title":"The unconstrained binary quadratic programming problem: a survey","cited_arxiv_id":null,"evidence_quote":"provides the radix-2 representation of real variables as qubits that the two-qubit step refines."},{"cited_title":"HUBO formulations for solving the eigenvalue problem","cited_arxiv_id":null,"evidence_quote":"establishes the 16-digit coefficient accuracy of the QPU solver that the experiment relies on."},{"cited_title":"HUBO and QUBO models for prime factorization","cited_arxiv_id":null,"evidence_quote":"demonstrates hybrid-solver capability and motivates the scaling estimate for large linear systems."},{"cited_title":"Distance-based clustering using QUBO formulations","cited_arxiv_id":null,"evidence_quote":"gives the gate-model quantum linear-system baseline against which the QUBO approach is positioned."}],"review_version":1}