Fifteen years ago, talking about factoring RSA-2048 on a quantum computer required billions of physical qubits and years of work. Today, the preprint arXiv:2610.37839v1 reports the figure of 22,593 qubits and 3.14 days . The difference is five orders of magnitude in terms of the “qubit x day” volume. But behind each such figure lies a chain of assumptions, one of which is a bit-flip time of approximately 100 years . This article examines what has been proven, what has been estimated, and what remains open, and why the question of “when?” gives way to the question of “under what conditions?”
Content
- Intrigue: Three Numbers That Change the Conversation
- The central question and methodology of analysis
- Why Cat Qubits Are a Game Changer
- Algorithmic chain: from Shor to Gidney
- How Resources Are Calculated: Three Levels of Abstraction
- Results: three problems, three numbers
- Space-time compromises
- What’s behind the number “3.14 days”?
- The Bit Flip Problem: How Much is 100 Years?
- Bitcoin and ECDLP: A Separate Story
- Fair comparison with other architectures
- What’s next: benchmarks and open questions
- How can a reader verify the conclusions?
- Sources and principles of selection
1. Intrigue: Three numbers that change the conversation
In 1994, Peter Shor demonstrated that integer factorization and the discrete logarithm can be solved on a quantum computer in polynomial time. Since then, the question “when will a quantum computer break RSA-2048?” has become one of the most important in cryptography. The answer has varied radically: from “never in the foreseeable future” to “in ten to twenty years.”
The preprint arXiv:2610.37839v1 (hereafter referred to as the “work”) adds three specific numbers to this discussion. All three were obtained in the same scenario: superconducting cat qubits, LDPC-cat code, phase-flip probability p Z = 5×10−4 per operation, error – correction cycle time of 1 μs, decoder response time of 10 μs, and—key— negligible bit-flips .
| Task | Logical qubits | Toffoli for one launch | Physical qubits | Time for one launch | Launches | Final time |
|---|---|---|---|---|---|---|
| RSA-2048 | 1,433 | 2 29.5 | 22,593 | 7.84 hours | 9.60 | 3.14 days |
| ECDLP-256 (secp256k1, Bitcoin) | 1,462 | 2 25.8 | 29,588 | 60 min | 1,036 | 61.8 min |
| FFDLP-512 (intermediate benchmark) | 208 | 2 22.2 | 6,656 | 2.51 min | 8.44 | 21.2 min |
Table 1. Logical and physical resources for three target problems (balanced configuration, LDPC-cat, p Z = 5×10 −4 , bit flips are negligible). Source: arXiv:2610.37839v1, Table I.
These numbers naturally raise the question: what exactly do they mean? If 22,593 qubits is “almost ready,” why does the same paper separately discuss the additional Elevator code, which nearly doubles the number of qubits? If 3.14 days is “fast,” why does it require a bit-flip time of about a hundred years, while experiments in 2024–2026 demonstrate times of tens of seconds?
It’s this gap—between the attractive final figure and the chain of physical assumptions—that constitutes the plot of this article. It’s more interesting than just another date prediction.
2. The central question and methodology of analysis
What’s behind the “22,593 qubits and 3.14 days” estimate for RSA-2048, which of its components have been confirmed, which have been evaluated, and which remain open—and how does this change the reality of the quantum threat to RSA and Bitcoin?
To answer it, I broke the work down into four layers and posed testable questions for each (the numbering corresponds to the “Questions for Research in Quantum Technologies”):
- Physical mechanism (questions 7–12): Why cat qubits and not transmons, and what physics produces biased noise?
- Algorithm and Mathematical Model (Questions 25–30): What chain of optimizations transforms Shor’s original algorithm into 1,433 logical qubits?
- Errors and Correction (Questions 31–36): How is the error budget structured and what does the “100 years without a bit-flip” requirement mean?
- Cryptographic context and fair comparison (questions 37-56): How do these numbers compare to other architectures and what do they mean for Bitcoin?
The analysis method is an assumption audit : for each key figure, I record whether it is proven, estimated, or assumed, and under what conditions it ceases to hold. This corresponds to the principle from the questionnaire: “separate observations, evidence, estimates, and predictions.”
3. Why cat qubits are a game changer
A conventional superconducting qubit (transmon) stores information in two energy levels of a nonlinear oscillator. Its errors—bit flips and phase flips—are roughly symmetrical. This means error correction must protect against both types, which is expensive: it requires shallow codes with large spacing.
The cat qubit is designed differently. Its state is encoded in superpositions of two coherent states of the electromagnetic mode with opposite phases—the so-called “Schrödinger-cat states” |α⟩ and |−α⟩. The key property is that the bit-flip rate decreases exponentially with the number of photons n̄ = |α|², while the phase-flip rate increases only linearly .
Biased noise of a cat qubit (simplified)
Bit-flip rate: Γ X ∝ e −2n̄ · κ 1 · n̄
Phase-flip rate: Γ Z ∝ κ 1 · n̄
where κ 1 is the rate of loss of one photon, κ 2 is the rate of two-photon dissipation that stabilizes the cat. Meaning: by increasing n̄, one can make bit-flips arbitrarily rare, paying only a linear increase in phase-flips.
Practical implication: if bit flips are suppressed to the point of being negligible, then error correction should only correct phase flips . And for this, much simpler and cheaper codes—repetition codes and LDPC codes—are sufficient. This is precisely what provides the gain in the number of physical qubits.
But herein lies the work’s main weakness. The assertion that “bit-flips are negligible” is not a physical law, but an assumption about the quality of a particular technology . The work honestly makes this law explicit and separately evaluates what would happen if it ceased to hold (Section 9).
4. Algorithmic chain: from Shor to Gidney
The second reason the final figures appear modest is thirty years of algorithm optimizations. The paper reconstructs a chain of four independent improvements and shows how they add up.
4.1. Original Shor: 2n qubits and O(n³) gates
Shor’s classical algorithm for an n-bit module requires an exponent register of 2n qubits (so that 2 2n ≥ N² for continued fractions) and an accumulator register of n qubits. This results in approximately 3n logical qubits and O(n³) Toffoli gates.
4.2. Ekerå–Håstad: Input register reduction
Factorization reduces to the short discrete logarithm problem : if x = g (N−1)/2 mod N, then x = g d , where d = (p+q−2)/2 is only about n/2 bits long. Instead of one register for 2n qubits, two registers of total length (1/2 + 1/s) n are used, where s ≥ 2 is the lattice parameter. For s = 8, this is 1,280 qubits instead of 4,096.
4.3. May–Schlieper: Output Register Compression
An n-qubit output register can be replaced with a t-bit hash (up to t = 1), because for periodicity search, only the fact that the function is periodic matters, not its exact value. The cost is a factor of 1/(1 − 2 − t ) in the number of runs.
4.4 Chevignard–Fouque–Schrottenloher and Gidney: RNS arithmetic and masking
The key trick is to calculate the modular exponent not in a full n-bit register, but in a residual class system (RNS), where each intermediate value occupies O(log log N) qubits. Accumulation is performed modulo the product of primes L ≥ N n e , and at the end, only the most significant κ bits of the result are taken. This allows us to use an accumulator of κ+1 = 34 qubits instead of n = 2,048.
Result of the chain: 1,433 logical qubits for RSA-2048
• 1,280 — exponent register (Ekerå–Håstad, s = 8)
• 34 — accumulator (RNS arithmetic + masking)
• ~119 — working registers, buffers, auxiliary qubits
• Total: 1,433 logical qubits, 229.5 Toffoli per run. Comparison: the original Shor would require about 6,000 logical qubits for RSA-2048. Reduction is about 4 times in qubits and orders of magnitude in gates.
5. How resources are counted: three levels of abstraction
The work clearly distinguishes between three levels, and this is methodologically important—it is the mixing of levels that most often leads to inflated or deflated ratings in popular reviews.
| Level | What is being described | What can be assessed | What you can’t do |
|---|---|---|---|
| Algorithm | Flowcharts, pseudocode, mathematical transformations | Asymptotics, structure of subroutines | Real qubits and time |
| Logical | Logical qubits and gates (CNOT, Toffoli, adders, lookups) | Number of logical qubits and Toffoli gates | Physical qubits, parallelism, code distances |
| Physical | The layout of each physical qubit, the schedule by clock, the factories of magical states | The exact number of physical qubits, time, and error budget | Nothing beyond the stated noise and equipment assumptions |
It is the third level that is the main contribution of the work. Instead of multiplying the number of logical qubits by an average logical-to-physical ratio, the authors compile dominant subroutines (adder, lookup, phase-up) directly into physical operations on a specific chip layout. This allows them to take into account parallelism, code distances, and fab runtime.
Why this is important for the reader. Many popular resource estimates stop at the logical level and multiply by a “factor of 1000” or “factor of 10,000.” Such estimates can be off by several orders of magnitude. The work shows that for cat qubits, the physical-to-logical ratio is not constant: it depends on what the qubit is doing at the moment (storage, adder, lookup, factory).
6. Results: three problems, three numbers
6.1. RSA-2048: 22,593 qubits, 3.14 days
This is the main result of the work. Balanced configuration: LDPC-cat architecture, code distances d rep = 13, d LDPC = 16, p Z = 5× 10−4 . One run takes 7.84 hours; taking into account the success probability, an average of 9.60 runs is required, which gives 3.14 days.
Of the 22,593 physical qubits:
- 8 656 — LDPC layer (data storage);
- 5 603 – global routing in the repetition layer;
- 5 760 is the access zone Γ QFT , which is idle until the final Fourier transform;
- 1 872 – factories of magical states;
- the rest is buffers, proxy string, factory routing.
A curious detail: a quarter of the physical qubits (Γ QFT ) are needed only to measure the Z L of each exponential qubit individually at the end, since the semiclassical Fourier transform requires sequential measurements. The authors frankly admit that this is an open problem for future optimization.
6.2. ECDLP on secp256k1: 29,588 qubits, ~1 hour
The secp256k1 curve is the same one used in Bitcoin. This work applies RSA-optimized operations (adder and lookup) to an elliptic curve point addition scheme. This isn’t optimal: the authors explicitly state that the resulting numbers are upper bounds , not the optimum. Nevertheless, the result is significant: about 30,000 qubits and an hour of work.
In cryptography, this means that Bitcoin public keys already exposed in the blockchain (for example, in P2PK outputs or reused addresses) are at risk if such a machine is built. For keys that haven’t yet been exposed (P2PKH with a one-time address), the attack is more difficult: the attacker must succeed before the transaction is included in a block.
6.3. FFDLP-512: 6,656 qubits, ~21 minutes
This is an intermediate benchmark, which the authors propose as a common milestone for all fault-tolerant architectures. The problem is the discrete logarithm in a finite field of 512 bits with an 80-bit exponent. It is classically decidable but uses the same building blocks as RSA-2048. The advantage: such a demonstration can be performed on significantly fewer qubits sooner than full RSA-2048.
7. Space-time compromises
The figure “22,593 qubits and 3.14 days” isn’t a singular point. The work clearly shows a tradeoff curve: qubits can be traded for time, and vice versa.
| Configuration | Qubits | Time | What’s changing? |
|---|---|---|---|
| Space efficient | 21 188 | 8.08 days | Slower Factory |C X C X X⟩ (second layout instead of third) |
| Balanced | 22,593 | 3.14 days | Basic option |
| Time-effective | 610 530 | 1.25 hours | 10 chips with 7 engines each, parallel launches |
| With p Z = 10 −3 | 25,673 | 3.63 days | Worse quality of phase flips, code distances (17, 22) |
| With the Elevator code (bit-flips ~1 hour) | ~45,000 | ≥ 3.14 days | Additional external code [15, 9, 3] |
| Only repetition-cat | 49,649 | 2.67 days | Without LDPC layer, d = 15 |
Table 2. Space-time tradeoffs for RSA-2048. Sources: Table II, Table XXIX, Appendix C9d.
Two conclusions from this table are important for a fair comparison:
- The figure of “610,530 qubits in 1.25 hours” is achieved through parallel runs on 10 chips and 7 engines on each. This is not a single chip, but a small cluster. For comparison with other architectures, it is necessary to specify whether this is a single device or a cluster.
- The Elevator code nearly doubles the number of qubits (from 22,593 to ~44,850–45,000), but relaxes the bit-flip time requirement from ~100 years to ~1 hour. This is a crucial compromise: it transforms the “unrealistic” requirement into “challenging but achievable.”
8. What’s behind the number “3.14 days”?
Let’s factorize the final number to see where exactly the uncertainty lies.
RSA-2048 score decomposition (balanced configuration):
22,593 physical qubits = 8,656 (LDPC layer) + 5,603 (routing) + 5,760 (Γ QFT ) + 1,872 (factories) + 702 (other).
3.14 days = 7.84 h/launch x 9.60 launches x (1 / 0.958 failure correction).
7.84 h/run = 2.82×10 10 correction cycles × 1 µs/cycle.
9.60 runs = 9.2 (base average for s = 8) / (1 − 0.042) (correction for the probability of failure per run). Each factor is based on its own assumption: the number of qubits is based on the layout and code distances; time is based on the correction cycle and the number of operations; the number of runs is based on the (j, k) pair measurement statistics and the error budget.
The most vulnerable points of this decomposition are:
- The correction cycle time is 1 µs. This is an optimistic, but not fantastic, value for superconductors. Increasing it to 2 µs would double the time.
- The decoder response time is 10 µs. For LDPC codes with large blocks, real-time decoding is a separate engineering challenge.
- The probability of a phase flip is 5×10−4 . This number is taken from the circuit-level noise model and corresponds to modern laboratory demonstrations, but does not necessarily scale to a 22,000-qubit chip.
- Negligible bit flips. This assumption makes “22,593” a realistic number; without it, ~45,000 qubits are needed (Section 9).
- A semi-classical Fourier transform. It requires sequential measurements, resulting in a quarter of the chip (Γ QFT ) being idle. The authors leave optimization for future work.
- The model for the distribution of the number of launches uses a negative binomial distribution with independent failures; the authors acknowledge that failures are not completely independent.
9. The Bit-Flip Problem: How Much is 100 Years?
This is perhaps the most interesting and most underappreciated aspect of the paper. Cat qubits suppress bit flips exponentially, but do not eliminate them completely. The paper explicitly estimates the bit flip time T Z required to ensure that the probability of at least one bit flip per run does not exceed 10%.
| Architecture | Physical qubits | Launch duration | Required T Z | Required n̄ |
|---|---|---|---|---|
| LDPC-cat, p Z = 5×10 −4 | 22,593 | 7.84 hours | ~100 years | ~18 photons |
| LDPC-cat, p Z = 10 −3 | 25,673 | 9.24 h | ~200 years | ~18 photons |
| Repetition-cat, p Z = 5×10 −4 | 49,649 | 6.92 hours | ~100 years | ~18 photons |
| With code Elevator (bit-flip time ~1 hour) | ~45,000 | ≥ 3.14 days | ~1 hour | ~11 photons |
Table 3. Bit-flip time requirements. Sources: Appendix C9c, C9d, Table XXXI, Table XXXII.
Experimental state of the art for 2024–2026: the bit-flip time of a cat qubit has been measured to be 15–22 seconds for n̄ ≈ 4–11 (work by Réglade et al., Rousseau et al.). This is 8–9 orders of magnitude shorter than the required 100 years. Furthermore, experiments have observed saturation of the bit-flip time with increasing n̄, and the mechanisms limiting this have not yet been identified.
The key gap. The statement “22,593 qubits and 3.14 days” is true under the condition that the bit-flip time is about a hundred years. Modern experiments yield tens of seconds. The Elevator code reduces the gap to ~1 hour—still 2–3 orders of magnitude better than what was achieved, but no longer “eight orders of magnitude.” This is precisely why the Elevator code is not “another option,” but a necessary element of a realistic scenario .
The work frankly formulates three unresolved questions that need to be demonstrated experimentally:
- The bit-flip time should continue to grow exponentially with n̄ in the presence of quantum control , up to ~18 photons.
- All operations, especially CNOT, must preserve this bit-flip time (gates add new bit-flip mechanisms, e.g. p X CX ≈ 0.5 e −2n̄ ).
- This must be done on a chip with thousands of cat qubits, not a single qubit.
10. Bitcoin and ECDLP: A Separate Story
The result for secp256k1 (29,588 qubits, ~1 hour) deserves a separate analysis, because here the cryptographic implications are most concrete.
10.1 Which keys are at risk?
In Bitcoin, the public key is usually kept secret until the transaction is spent. However, there are exceptions:
- P2PK (pay-to-public-key) outputs—the public key is visible to everyone from the moment the output is created.
- Reused addresses – if an address has been used even once, the public key is compromised.
- Blocks mined the old way (coinbase transactions of early blocks) – many of them use P2PK.
For such keys, an ECDLP attack with 30,000 qubits and an hour of work is a direct threat. For keys that haven’t yet been revealed, an attacker would need to execute the attack between the transaction’s publication and its inclusion in a block; this is a matter of network race, not just quantum resources.
10.2 What does “1 hour” mean?
One hour is the estimate for a single run with a balanced configuration and the same assumptions as for RSA-2048 (including negligible bit flips). With the Elevator code, the number of qubits will increase, and the time may change slightly. The key point is that 30,000 qubits is an order of magnitude smaller than estimates for RSA-2048 in other works , making ECDLP a more achievable first target for quantum cryptanalysis.
10.3 Comparison with RSA
Interestingly, ECDLP requires more physical qubits (29,588 versus 22,593), but significantly less time (an hour versus 3.14 days). This is due to the different problem structure: ECDLP requires one successful run (plus a small allowance for failure), while RSA requires around 9–10 runs. This once again demonstrates that the “threat” is not a single number, but a set of modes.
11. Honest comparison with other architectures
The paper compares its results with previous publications. The key figure: a reduction in the volume of spacetime by 5 orders of magnitude over 15 years —from 10 4 Mqubit day (early estimates using surface codes) to 7 × 10 −2 Mqubit day.
Compared to Gidney’s 2025 estimate for surface codes (transmons), the work yields a roughly 40-fold reduction in the number of physical qubits in comparable or less time. This is achieved through:
- shifted noise of cat qubits (only phase flips require active correction);
- LDPC codes with a higher ratio of logical to physical qubits;
- recompiling adder and lookup for a specific architecture.
However, the comparison is not absolute: Gidney makes different assumptions about noise and hardware. The paper explicitly states that comparing architectures requires agreement on metrics: the number of physical qubits, total time, number of runs, success rate, design complexity, and power consumption.
What you shouldn’t read into the comparison table: “40-fold reduction” doesn’t mean that cat qubits are “40 times better” overall. It means that, under the given noise assumptions and given compilation , RSA-2048 requires 40 times fewer physical qubits. Under other assumptions (such as a bit-flip time of one hour without the Elevator code), the advantage partially disappears.
12. What’s next: benchmarks and open questions
The work proposes two practical steps for the community.
12.1 General Benchmarks: FFDLP-512 and RSA-2048
The authors recommend adopting FFDLP-512 as an intermediate milestone, and RSA-2048 as the final one . FFDLP-512 uses all the same building blocks as RSA-2048, but requires only ~6,656 qubits and ~21 minutes. This allows end-to-end verification of the architecture well before the full RSA-2048.
12.2. Open questions
- Achievability of bit-flip time. Can it be extended from tens of seconds to hours or years with quantum control and at chip scale?
- Optimizing Γ QFT . A quarter of the chip is idle; is it possible to reuse these qubits or propose a Fourier transform compatible with simultaneous measurement?
- Real-time decoding. LDPC codes with large blocks require fast decoders; their latency and power consumption have not been estimated.
- Scaling Factories. Magic state factories are a time bottleneck; can they be sped up without increasing the number of qubits?
- Cross-chip interconnects. The paper mentions chiplets and cryogenic microwave links; their noise and cost are not included in the assessment.
- Post-quantum cryptography. The work calls for immediate migration to hybrid schemes; however, the security of post-quantum schemes themselves requires separate cryptanalysis.
13. How can the reader check the conclusions?
If you want to evaluate for yourself how realistic the “3.14 days” figure is, ask six questions about any publication (these are also the basis of the “Article Worksheet” in the questionnaire):
- What are the noise assumptions? Is the model circuit-level or phenomenological? What are the values of p Z and p X ?
- What counts as a physical qubit? Do fabrics, routing, buffers, and access zones count?
- How many launches? One successful launch or an average number, taking into account the probability of failure?
- Are decoding and response times taken into account? Is the decoder’s response time included in the clock cycle?
- What is the model for bit-flips? Are they negligible, and if so, on what basis?
- A single chip or a farm? If “an hour” is claimed, isn’t that the result of ten chips working in parallel?
The paper arXiv:2610.37839v1 answers all six questions explicitly—and that’s its strength. Its weakness lies not in the methodology, but in the physics: the bit-flip time requirement remains at the limit of what’s achievable.
14. Sources and principles of selection
The main source is the preprint arXiv:2610.37839v1 (Alice & Bob, Université Paris-Saclay / CEA / CNRS, Inria, University of Edinburgh). All numerical values and assumptions are taken from it; references to tables are given in the captions.
Additional context (not included in the resource estimate, but important for interpretation):
- P.W. Shor, “Algorithms for quantum computation: discrete logarithms and factoring”, FOCS 1994 – original algorithm.
- M. Ekerå, J. Håstad, “Quantum algorithms for computing short discrete logarithms and factoring RSA integers”, PQCrypto 2017 – Input register reduction.
- A. May, L. Schlieper, “Quantum period finding is compression robust,” IACR ToSC 2022 – Output register compression.
- C. Chevignard, P.-A. Fouque, A. Schrottenloher, CRYPTO 2025 – RNS Arithmetic.
- C. Gidney, “How to factor 2048-bit RSA integers with less than a million noisy qubits,” arXiv:2505.15917 — a modern estimate on shallow codes.
- D. Ruiz, J. Guillaud, A. Leverrier, M. Mirrahimi, C. Vuillot, “LDPC-cat codes”, Nature Communications 2025.
- U. Réglade et al., Nature 2024; R. Rousseau et al., Nature Communications 2026 — experimental bit-flip times.
- P. Shanahan, D. Ruiz, “Elevator codes”, arXiv:2601.10786 — a code for additional protection against bit-flips.
The main conclusion. The paper arXiv:2610.37839v1 is not a claim that RSA-2048 will be broken tomorrow. It is a careful engineering estimate: under these assumptions , 22,593 physical qubits and 3.14 days are needed. The main uncertainty is not in the algorithm or the number of qubits, but in the physics of bit-flips. That’s why the honest answer to the question “when?” is: when the cat qubit bit-flip time increases from tens of seconds to hours (with Elevator code) or years (without it) —and when this is demonstrated not on a single qubit, but on a chip of thousands.
The document is self-contained: All numerical values are provided with links to tables in the original work. Russian terminology: “cat qubit,” “phase flip,” “bit flip,” “residual class system” (RNS), “magic state.”
