REVIEW 4 major objections 5 minor 3 references
Quantum-Kit: Simulating Shor's Factorization of 24-Bit Number on Desktop
T0 review · 4 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash
Pith's one-line read Quantum-Kit's hybrid circuit claims the first desktop 24-bit Shor factorization, in 26 minutes.
desk verdict Plausible but unverified 24-bit Shor simulation record; the missing QuModExpUaj spec and absent logs make reproducibility the whole ballgame. read the letter →
The pith
A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.
The reading
What carries the argument
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.
What would settle it
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.
Extended reading notes
Core claim
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.
Load-bearing premise
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.
Editorial extensions
If this is right
- 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.
Reading between the lines
- 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.
Editorial analysis
A structured set of objections, weighed in public.
Referee Report
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].
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 (4)
- [Appendix A (nx2n script)] 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.
- [Appendix A and Fig. 6] 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).
- [Fig. 4 and Section 'Simulations with 3nx1 approach'] 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 'Simulations of numbers larger than N'] 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.
minor comments (5)
- [Appendix A, nx2n script] 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.
- [Fig. 2 caption] The phrase 'these circuits is only for illustration' should be 'these circuits are only for illustration.'
- [Circuit section] The text refers to 'Fig. 5b' when describing the nx2n circuit for N=15; this should presumably be 'Fig. 6b'.
- [Appendix A] The typo 'Keitev' should be 'Kitaev'.
- [General] 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.
Circularity Check
No circularity: the simulation claims are measured outputs and external comparisons, not derived from fitted inputs or self-citations.
full rationale
The paper's central claims are runtimes, memory usage, and extracted factors from a quantum circuit simulator. No parameter is fitted to the data that is later 'predicted'; the measured bit strings are post-processed with continued fractions, which is standard Shor post-processing and is not built into the simulator's inputs. The only self-citations (Refs [10,13,14]) concern unrelated prior work on donor-electron states in silicon and are not load-bearing for the Shor simulation, the nx2n circuit construction, or the performance comparisons. The 24-bit result is a direct execution outcome compared against external published results from Refs [1,2], so the claim is externally anchored. The absence of a specification or verification of the custom QuModExpUaj oracle is a reproducibility and correctness gap, but it is not circularity: an undefined or unchecked oracle does not make the reported factorization equivalent to its inputs by construction. Accordingly, the paper receives a score of 0 for circularity.
Assumptions & free parameters
assumptions (5)
- standard math Shor's factoring algorithm and continued-fraction post-processing recover prime factors from a sufficiently good phase estimate.
- standard math Kitaev's one-control-qubit recycling circuit (nx2n) is equivalent to standard phase estimation after 2n stages.
- domain assumption The Q-Kit 'QuModExpUaj' oracle gate correctly computes quantum modular exponentiation for all supplied values of a, j, and N.
- domain assumption The measurement-to-classical-bit copy and the subsequent SigmaX reset faithfully implement Kitaev's qubit recycling without corrupting the state.
- domain assumption The published runtimes in Refs [1,2] are valid baselines for the claimed speedups.
Cite this review
Pith. "Pith review of Quantum-Kit: Simulating Shor's Factorization of 24-Bit Number on Desktop." pith.science (2026). https://pith.science/paper/LDJCM6PV
@misc{pith2026190807187,
author = {Pith},
title = {Pith review of: Quantum-Kit: Simulating Shor's Factorization of 24-Bit Number on Desktop},
year = {2026},
howpublished = {\url{https://pith.science/paper/LDJCM6PV}},
note = {Machine review of arXiv:1908.07187}
}
read the original abstract
Quantum-Kit is a graphical desktop application for quantum circuit simulations. Its powerful, memory-efficient computational engine enables large-scale simulations on a desktop. The ability to design hybrid circuits, with both quantum and classical bits and controls, is employed to demonstrate Kitaev's approach to Shor's factorization algorithm. For the first time, Shor's factorization of a 24-bit integer is simulated with Quantum-Kit in a mere 26 minutes on a modest desktop with Intel Core i5 7400T, 2.4GHz and12GB RAM. While the largest number factorized so far has been a 20-bit integer, requiring 60 qubits and a supercomputer, the hybrid circuit functionality allows the same number to be factorized using Kitaev's trick with only 21 qubits, in 2.3 minutes, on a desktop. Furthermore, conventional Shor's algorithm for a 13-bitinteger with 39 qubits is shown to be 35x faster with Quantum-Kit.
Figures
Reference graph
Works this paper leans on
-
[5]
Bouwmeester, D., Pan, J.W., Mattle, K., Eibl, M., Weinfurter, H. and Zeilinger, A., 1997. Experimental quantum teleportation. Nature, 390 (6660), p.575. [6] Duan, L.M., Lukin, M.D., Cirac, J.I. and Zoller, P., 2001. Long-distance quantum communication with atomic ensembles and linear optics. Nature, 414(6862), p.413. [7] Gisin, N. and Thew, R., 2007. Quan...
arXiv 1997
-
[18]
Monz, T., Nigg, D., Martinez, E.A., Brandl, M.F., Schindler, P., Rines, R., Wang, S.X., Chuang, I.L. and Blatt, R., 2016. Realization of a scalable Shor algorithm. Science, 351(6277), pp.1068-1070. [19] Politi, A., Matthews, J.C. and O'brien, J.L., 2009. Shor’s quantum factoring algorithm on a photonic chip. Science, 325(5945), pp.1221-1221. [20] Martín-L...
work page 2016
-
[23]
Vandersypen, L.M., Steffen, M., Breyta, G., Yannoni, C.S., Sherwood, M.H. and Chuang, I.L., 2001. Experimental realization of Shor's quantum factoring algorithm using nuclear magnetic resonance. Nature, 414(6866), p.883. [24] De Raedt, K., Michielsen, K., De Raedt, H., Trieu, B., Arnold, G., Richter, M., Lippert, T., Watanabe, H. and Ito, N., 2007. Massiv...
arXiv 2001
Reviewed August 14, 2026 · model on record in the stance chip above.
Discussion (0). Continue with ORCID to comment.