{"id":"6778ab45-58fd-46d8-85b3-f5edfe122e74","arxiv_id":"1908.07187","paper_version":3,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"The authors report that their Quantum-Kit simulator factorized the 24-bit integer 13,564,597 in about 26 minutes on a single-core desktop using Kitaev's one-qubit-recycling version of Shor's algorithm.","lead":"A new desktop quantum-circuit simulator called Quantum-Kit is reported, and the authors claim it factorized a 24-bit integer using Kitaev's version of Shor's algorithm in about 26 minutes on a 12 GB desktop. The paper is a performance demonstration of a known algorithm, not a new factoring method, and it does not provide the simulator code.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"24-bit claim hinges on an undefined QuModExpUaj oracle and semiclassical feedback; neither is specified or validated, so the reported factorization cannot yet be independently confirmed.","rationale":"The paper is best read as an empirical software claim: a new record factorization using a plausible but undocumented engine. The reader's conditional verdict is appropriate. I considered whether the Kitaev circuit itself is wrong; the Appendix A script appears broadly consistent with the standard semiclassical QFT, but the syntax of RPhase and the oracle are opaque, so an internal error cannot be excluded. I also considered the statistical plausibility: with m=48 bits and order r~10^7, random bit strings have essentially zero chance of yielding a valid convergent, so the two successful runs are strong evidence that something meaningful was computed—provided the oracle is what it purports to be. The missing piece is therefore verification, not plausibility. The concrete test would settle it. No independent support (Lean/Coq, released code, raw data) exists in the preprint, so the burden stays on the authors to supply the oracle definition and logs. Verdict remains conditional.","tokens_in":7157,"tokens_out":13751,"duration_ms":143328,"concrete_test":"Independently implement the Appendix A circuit for N=13564597, a=2, using a verified quantum modular exponentiation and semiclassical QFT (e.g., Qiskit's `Shor` with a recycled control qubit, or ProjectQ). Run the same 48-stage sequence, record the 48 classical bits, apply continued fractions, and compare the recovered factors to Fig. 4. If the independent runs reproduce the observed bit strings and factors for the same number of shots, the oracle and feedback are validated; if the outputs diverge, the 24-bit claim is an artifact of Q-Kit's internal gate semantics. Asking the authors to release the .qp file and raw log for Fig. 4 is the minimal enabling step.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is that Q-Kit executed a faithful 24-bit Shor simulation: Appendix A's `nx2n` script must implement Kitaev's iterative phase estimation, with `QuModExpUaj` as a controlled unitary multiplying the work register by a^{2^j} mod N for each stage, and the `Measure/Copy/SigmaX/RPhase` sequence as the semiclassical inverse QFT. The paper never defines the matrix or function behind `QuModExpUaj`, never gives the angle semantics of `RPhase`, and gives no error bound or test of the oracle. Since the only evidence is that two of three observed bit strings in Fig. 4 lead to factors, and since a random 48-bit string would pass continued fractions with probability roughly r/2^48 ≈ 5×10^-8 (for r≈10^7), the observed success is statistically meaningful only if the simulator is actually implementing the intended unitary. Without a spec or logs, the result cannot be distinguished from a post-selected artifact, a classical shortcut in the oracle, or a bug masked by the reported outputs. The 8GB memory claim for 25 qubits (dense-vector expectation ~0.5–1GB) adds to the uncertainty about what state representation is being simulated. Reproducibility is the load-bearing gap.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents Quantum-Kit (Q-Kit), a graphical quantum circuit simulator, and claims record-size classical simulations of Shor's factorization on a desktop. Using Kitaev's one-qubit phase-estimation variant with qubit recycling (the 'nx2n' approach), the authors report factorization of the 24-bit integer N=13564597 in about 26 minutes on a 12 GB Intel Core i5 desktop, and also report a 35x speedup over a matrix-product-state simulation for a 13-bit number using the conventional '3nx1' circuit. The manuscript includes Python scripts in Appendix A that generate Q-Kit command files for both circuit styles, and it compares timings with published results from Refs. [1,2].","tokens_in":7367,"tokens_out":4444,"duration_ms":48263,"significance":"If the claims are substantiated, the work is a useful engineering benchmark: it demonstrates that qubit-recycling, semiclassical QFT approaches can bring Shor-factorization simulations to commodity hardware, and it highlights a hybrid classical/quantum control interface as a practical feature in a simulator. The paper makes concrete, falsifiable performance claims (24-bit factorization in 26 minutes) and directly compares with prior published simulations, which is valuable for the simulation community. However, the current manuscript lacks the reproducibility artifacts needed to verify that the reported factorization is a genuine simulation of Shor's algorithm: the modular exponentiation oracle is not specified, the hybrid feedback commands are not semantically defined, and no raw measurement logs or validation runs are provided.","major_comments":[{"comment":"The 'QuModExpUaj' gate is the core of the modular exponentiation, but the paper never specifies its unitary matrix, its algorithmic implementation, or any error bound. Please provide the exact definition (e.g., controlled multiplication by a^{2^j} mod N via repeated squaring) and validation on small cases such as N=15 with several bases a, including the measured bitstrings and the continued-fraction results. Without this specification, the 24-bit output cannot be distinguished from a simulator artifact or a classical shortcut inside the oracle.","section":"Appendix A (nx2n script)"},{"comment":"The hybrid feedback sequence in the nx2n script ('Measure 0', 'Copy 0,-...', 'SigmaX 0,-...', 'RPhase 0,...') is not semantically defined. In particular, the paper never states the angle semantics of RPhase or how the previously measured classical bits are used to condition the phase rotations. Please provide a precise command specification and demonstrate, on a small example such as N=15, that the sequence implements Kitaev's iterative phase estimation (e.g., by listing the quantum state or expected measurement distribution at each stage).","section":"Appendix A and Fig. 6"},{"comment":"The central benchmark claim rests on three simulation runs, but the paper reports only aggregate timing plots and prose. No raw measured bitstrings, continued-fraction computations, or resulting factors are given for the three runs of N=13564597. Please include a table with the three measured 48-bit strings, the order r obtained, the final factors, and the run-to-run timing, along with the Q-Kit version and random seed if applicable. Without these data, the statement that 'two of the three runs collapse to a state that can successfully estimate the order' cannot be independently checked.","section":"Fig. 4 and Section 'Simulations with 3nx1 approach'"},{"comment":"The claim that the 24-bit simulation 'already demands 8GB of memory' is surprising for a 25-qubit state, since a dense complex vector of that size requires roughly 0.5 GB. Please clarify the state representation used by Q-Kit, the memory accounting, and why the nx2n approach does not reduce the memory to approximately 2^24 amplitudes after the control qubit is measured at each stage. This is important because the paper's 'memory-efficient' positioning depends on it.","section":"Section 'Simulations of numbers larger than N'"}],"minor_comments":[{"comment":"The command 'GateOp QuModExpUaj 0:'+str(nQ) uses a slice syntax that is not explained; please specify whether the gate acts on qubits 0 through nQ-1 or 0 through nQ, and how the target work register is identified.","section":"Appendix A, nx2n script"},{"comment":"The phrase 'these circuits is only for illustration' should be 'these circuits are only for illustration.'","section":"Fig. 2 caption"},{"comment":"The text refers to 'Fig. 5b' when describing the nx2n circuit for N=15; this should presumably be 'Fig. 6b'.","section":"Circuit section"},{"comment":"The typo 'Keitev' should be 'Kitaev'.","section":"Appendix A"},{"comment":"No software version or release identifier for Q-Kit is provided; please include a version number and, if possible, a hash of the generated .qp files to support reproducibility.","section":"General"}],"recommendation":"major_revision","confidential_remarks":"The paper is essentially a software demonstration and benchmark report. The central algorithmic idea is standard, and the claimed numbers are plausible if the oracle and feedback are implemented correctly, but the manuscript as written does not allow independent verification. For a journal publication, the authors should be required to release the oracle specification, small-N validation results, and the actual measurement logs for the 24-bit runs. There is also a scope question: if the journal does not normally publish simulator benchmarks without algorithmic novelty, this should be weighed at the editorial level."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The thing to know: this paper claims the first simulation of Shor's factorization for a 24-bit number on a desktop, using Kitaev's one-qubit-recycling approach. That's a concrete benchmark claim, and if it's real, it's a useful data point for anyone tracking simulator capabilities. The paper does something else well: Appendix A gives a Python script that generates the circuit commands, so you can see the exact hybrid structure—the semiclassical feedback, the recycled control qubit, the 2n stages. That part is reproducible at the algorithm level.\n\nWhat's missing is the thing that turns a claim into a result: the definition of QuModExpUaj. The appendix calls it as a gate, but never specifies the matrix or function behind it, never gives an error bound, never validates it against a known factorization. The stress-test note is right: without that, the observed measurement strings and recovered factors could come from a bug, a classical shortcut, or post-selection, not from a working quantum simulation. Two of three runs succeeding is consistent with a real implementation, but it's not evidence on its own. The memory claim also sits oddly: 8GB for 25 qubits is far above the ~0.5GB you'd expect for a dense state vector, and the paper doesn't explain the state representation.\n\nOn the positive side, the algorithm is standard Kitaev/Shor, no derivation errors jump out, and the comparison against Refs [1,2] is fair at face value. The self-citations are unrelated, so no circularity. The paper honestly notes that one run failed, which matches Shor's probabilistic nature.\n\nBottom line: this is a benchmark paper, and benchmarks live or die by shipped artifacts. Without code, raw logs, and an oracle spec, I can't confirm the 24-bit record. But the claim is important enough to warrant referee time if the authors are asked to provide the missing material. Send it to review, conditionally.","headline":"Plausible but unverified 24-bit Shor simulation record; the missing QuModExpUaj spec and absent logs make reproducibility the whole ballgame.","tokens_in":7910,"tokens_out":2160,"would_cite":false,"duration_ms":22918,"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":"Quantum-Kit's hybrid circuit claims the first desktop 24-bit Shor factorization, in 26 minutes.","keywords":["quantum circuit simulator","Shor's algorithm","one-control-qubit phase estimation","qubit recycling","hybrid quantum-classical circuits","integer factorization simulation","desktop quantum simulation","modular exponentiation"],"falsifier":"Run the generated circuit for a small case such as N=15, a=2 and check after each stage that the work register is the expected modular-power state |$2^{{2^j}}$ mod 15>; any deviation, or any mismatch between the recorded classical bit string and a direct classical computation of the order of 2 modulo 15, would show the 24-bit factorization could come from a bug rather than a working Shor circuit.","tokens_in":6939,"feed_emoji":"🧮","tokens_out":10060,"duration_ms":97565,"temperature":0.7,"pith_summary":"Quantum-Kit is a graphical quantum circuit simulator whose hybrid circuits—quantum bits plus classical bits and controls—let it implement a one-control-qubit version of Shor's factorization. The paper's central claim is that this combination factors a 24-bit integer, N=13564597, in about 26 minutes on a 12 GB desktop with a single core, a size previous simulations reached only with supercomputer-scale resources. Two of three runs in the paper collapse to a measured state that yields the prime factors by continued fractions. If the claim holds, classical simulation of Shor's algorithm has moved from a 20-bit supercomputer benchmark to a 24-bit commodity-desktop benchmark while using only n+1 qubits instead of 3n.","feed_headline":"24-bit Shor factorization simulated on a 12GB desktop in 26 minutes","feed_subtitle":"One recycled control qubit replaces exponential memory, pushing simulation beyond 20 bits without a supercomputer.","key_machinery":"The load-bearing object is the one-control-qubit phase-estimation circuit, implemented as an nx2n hybrid circuit: n work qubits plus one recycled control qubit, with the control qubit reused 2n times. Each stage applies Hadamard, a modular-exponentiation operator (the paper's QuModExpUaj gate), an R-phase rotation, and Hadamard again; the qubit is then measured, the outcome copied to a classical bit, and the qubit reinitialized by a classical-controlled sigma_x before the next stage. The paper argues this keeps the quantum register sparse compared with the 3n-qubit approach, which is why the memory stays within desktop limits while the measured classical bit string still contains the phase information needed for continued fractions.","core_discovery":"On the paper's own terms, the discovery is that the one-control-qubit recycling trick is not just a theoretical memory saving but a practical simulation strategy. In the nx2n circuit, a single control qubit is reused for 2n stages; after each Hadamard–modular-exponentiation–rotation–Hadamard block, it is measured, the outcome is copied into a classical bit, and the qubit is reinitialized with a classical-controlled X gate before the next stage. This keeps the quantum state sparse enough that N=13564597 (24 bits) runs in roughly 26 minutes on 12 GB RAM, and the same N=961307 that previously cost tens of thousands of CPU hours on a supercomputer runs in 139 seconds on a single desktop core. The recovered prime factors in two of three runs are presented as evidence that the hybrid circuit genuinely implements Shor's algorithm rather than a classically guessed factorization.","pith_inferences":["Inference: the same sparse-state, measure-and-recycle pattern could be applied to other phase-estimation algorithms in simulators, not only to Shor's order finding.","Inference: the reported two-of-three success rate is consistent with the randomized nature of Shor's measurement; a fuller benchmark would report how many repetitions are needed on average for continued fractions to succeed with high probability.","Inference: because Appendix A gives a script that generates the full circuit, the 24-bit result is independently checkable by running the same commands on another simulator, without needing access to Quantum-Kit's source code."],"forward_implications":["If the claim holds, Shor's algorithm can be classically simulated to at least 24 bits on ordinary hardware, without GPU clusters or large shared-memory systems.","The n+1 qubit circuit reduces the state-vector cost from roughly 2^{3n} entries to 2^{n+1} entries, so each extra bit of N costs about twice the memory, not eight times.","Since the 24-bit run already uses about 8 GB, the same scripts should factor 25-bit numbers on machines with slightly more RAM, and larger ones on high-memory nodes.","The gate-level timing logs across the 2n stages make it possible to see which operations dominate the simulation cost and where optimization efforts should go."],"supporting_citations":[{"why":"Prior massively parallel simulator baseline; Quantum-Kit's timings for the same n-bit integers are compared against it.","marker":"[1]"},{"why":"Prior matrix-product-state Shor simulations; provides the earlier 20-bit supercomputer resource numbers and the 3nx1 data used in the timing comparison.","marker":"[2]"},{"why":"The original one-control-qubit phase-estimation scheme that the nx2n hybrid circuit implements by recycling a measured qubit.","marker":"[26]"}],"fun_headline_variants":["Desktop Shor factorization reaches 24 bits in 26 minutes","Qubit recycling makes 24-bit Shor factorization desktop-ready","24-bit Shor simulation on a desktop: 26 minutes flat","Recycled qubit trick: 24-bit Shor factorization on desktop","First 24-bit Shor factorization simulated on a desktop"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The argument stands on the assumption that the simulator's internal modular-exponentiation step does exactly $a^{{2^j}}$ mod N for every stage and that the measure-and-reset sequence faithfully reproduces the single-qubit phase-estimation trick; the paper does not define or verify this step.","fun_headline_variants_meta":{"raw":{"variants":["Desktop Shor factorization reaches 24 bits in 26 minutes","Qubit recycling makes 24-bit Shor factorization desktop-ready","24-bit Shor simulation on a desktop: 26 minutes flat","Recycled qubit trick: 24-bit Shor factorization on desktop","First 24-bit Shor factorization simulated on a desktop"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000661,"raw_usage":{"total_tokens":3006,"prompt_tokens":913,"completion_tokens":2093,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":529,"completion_tokens_details":{"reasoning_tokens":2003}},"tokens_in":529,"tokens_out":2093,"duration_ms":14512,"temperature":1.0,"reasoning_tokens":2003,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-14T12:23:17.513450+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the generated circuit for a small case such as N=15, a=2 and check after each stage that the work register is the expected modular-power state |$2^{{2^j}}$ mod 15>; any deviation, or any mismatch between the recorded classical bit string and a direct classical computation of the order of 2 modulo 15, would show the 24-bit factorization could come from a bug rather than a working Shor circuit.","supporting_citations":[],"review_version":1}