ECDSA.Fail: Open Autoresearch for Optimizing Elliptic-Curve Point Addition in Shor's Algorithm

Abstract: We propose Open Autoresearch, a paradigm in which humans and AI agents publish evaluator-verified improvements to a public leaderboard. We instantiate it in ECDSA.Fail, optimizing reversible secp256k1 point-addition circuits, a bottleneck in Shor's algorithm for elliptic-curve cryptography. The benchmark minimizes the spacetime-inspired score $S=Q\times T$, where $Q$ is peak logical qubit width and $T$ is average executed Toffoli count. Participants reduced $S$ by 86.1%. At the data cutoff (26 July 2026), the best-scoring circuit uses 1,151 qubits and 1,299,453 average executed Toffoli gates, giving $Q\times T\approx1.496$ billion. This is more than 50% below Google's published point-addition score thresholds (arXiv:2603.28846), under different accounting conventions. Because the benchmark supplies one addend classically, we construct a coherent windowed-addition-compatible variant implementing the single-call interface required by windowed Shor. It uses 1,162 qubits and 1,684,161 average executed Toffoli gates. On 100,000 random inputs, its empirical success probability is $\hat{p}=0.99809$, giving $Q\times T/\hat{p}\approx1.961$ billion under an independently rerunnable per-call sensitivity model, not a full-Shor success estimate. Its qubit and Toffoli counts lie below Google's published thresholds and Schrottenloher's reported operating points (arXiv:2606.02235), although differing interfaces, accounting conventions, and validation scope preclude formal dominance. After the cutoff, the score was further reduced to 1.259 billion, while a separate low-width circuit reached 813 qubits. The public record shows AI agents complementing human judgment, providing evidence for open autoresearch on efficiently evaluable, machine-checkable objectives.

• The paper develops Open Autoresearch, allowing an open, machine-independent verification process of elliptic curve point additions and other quantum operations, resulting in a 57.6% reduction in $Q$ (width) and a 67.2% reduction in $T$ (average Toffoli count), yielding the new metric “Q × T”.
• The approach demonstrates that a subset of reversibility of these quantum gates in elliptic curve computation can be achieved by adopting modular transcript encoding, distributed record, replay, and special operations, such as jump-2 Euclidean.
• The study finds that further crucial reductions in peak logical-qubit width (Q) and average gate functionality counts can likely be reached with better optimization of quantum routers, lower support filtering, and improved overall logic architecture design during checkpoints.

Problem setting and research objective

The paper studies the optimization of reversible elliptic-curve point addition for Shor’s algorithm applied to the elliptic-curve discrete logarithm problem (ECDLP) over secp256k1. This primitive is relevant to quantum attacks on ECDSA deployments in Bitcoin, Ethereum, and related systems. In a fault-tolerant implementation, affine point addition is dominated by modular inversion: the slope requires evaluating

$\lambda=(y_R-y_A)(x_R-x_A)^{-1}\pmod p,$

after which the output coordinates are obtained through modular squaring, multiplication, and affine-coordinate updates. Reversibility introduces additional costs because intermediate values, Euclidean transcripts, and ancilla registers must be uncomputed without leaving relative phase.

The paper’s central methodological contribution is Open Autoresearch, defined as a verifier-gated optimization process in which independent human–agent teams modify a shared implementation, submit candidates to a machine-checkable evaluator, and publish verified improvements to a public leaderboard. The authors instantiate this process in the ECDSA.Fail challenge, whose objective is to minimize

$S=Q\times T,$

where $Q$ is peak logical-qubit width and $T$ is average executed Toffoli count. The metric is explicitly a proxy: it captures a width–non-Clifford-work trade-off but omits Toffoli depth, parallelism, routing, QROM access, magic-state distillation, decoding, and architecture-specific error-correction overhead.

The benchmark evaluates three distinct properties: classical value correctness, ancilla cleanliness, and phase cleanliness. The latter two are essential because a circuit can implement the correct classical map while still leaving garbage entangled with the output or introducing relative phases that invalidate its use inside Shor’s algorithm. The evaluator uses a circuit-dependent, SHAKE256-derived test set of 9,024 inputs, thereby avoiding a single fixed public corpus, although this design creates support-selection issues discussed below.

The relevant point-addition interface supplies the addend classically. This is directly compatible with mixed addition in double-and-add scalar multiplication, but not with the coherent table-indexed addends used by windowed Shor. A substantial part of the paper therefore concerns adapting the best mixed-addition circuit to a coherent QROM lookup/use/unlookup interface.

Open autoresearch as an optimization model

The proposed research process combines several existing paradigms—program search, evolutionary code optimization, tool-using agents, and public leaderboards—but differs in treating the leaderboard, source repository, evaluator, and experiment history as a shared research substrate. Participants may begin from the current best circuit, another Pareto-optimal point, or an off-frontier construction. They generate a change, test it against progressively stronger checks, and promote it only when it improves the objective while satisfying all evaluator constraints.

The process is cumulative in two senses. First, promoted source changes become available as new baselines. Second, failed experiments are intended to remain usable as contextualized negative evidence. The paper describes recurring practices including isolated worktrees, parallel hypothesis testing, role-separated research and implementation agents, persistent experiment logs, staged validation, literature-guided hypothesis generation, and human intervention when local hill climbing stalls.

The empirical record contains more than 100 leaderboard contributors, over 400 promoted submissions at the stated cutoff, and 400 scored accepted source commits analyzed by optimization family. However, the paper does not claim a causal measurement of agent effectiveness. Participants selected their models, prompts, compute budgets, baselines, and objectives; private failed attempts were not exhaustively recorded; and there was no human-only control condition. The evidence therefore supports the descriptive claim that substantial progress occurred in an agent-mediated open workflow, not the stronger claim that agents caused a quantified fraction of the improvement.

The paper’s most important methodological claim is consequently conditional: open autoresearch is useful when the objective is difficult to optimize but inexpensive and reliable to evaluate, intermediate artifacts can be shared, and independent search branches can be recombined. The challenge provides a concrete test of those conditions rather than a general evaluation of autonomous scientific discovery.

Circuit interfaces and the windowing constraint

The benchmark circuit implements the in-place map

$\lvert R\rangle\mapsto\lvert R+A\rangle,$

where $R$ is a quantum accumulator and $A$ is a classically supplied elliptic-curve point. The reversible implementation follows the standard affine structure:

1. compute coordinate differences;
2. derive the slope through modular inversion;
3. form the intermediate $x$ expression;
4. subtract $\lambda^2$;
5. multiply by the output-side difference;
6. recover the output coordinates and clear temporary state.

This interface is narrower than the one required by a $w=16$ windowed Shor implementation. In the latter, a quantum address selects one of $S=Q\times T,$0 precomputed points through QROM. The selected addend is quantum data and must be coherently loaded, used, and uncomputed. A classically specialized optimization cannot automatically be transferred to this setting, particularly when it relies on compile-time constants or classical control bits.

The paper addresses this distinction by constructing a windowed-compatible variant of the best product-scoring circuit. The coherent variant uses 1,162 logical qubits and 1,684,161 average executed Toffoli-equivalent gates, compared with 1,151 qubits and 1,299,453 Toffolis for the mixed-addition incumbent. Thus, coherent addend selection costs 11 qubits and approximately 29.6% additional average executed Toffoli count per addition. On 100,000 independently selected inputs, the baseline had an empirical error rate of 0.192%, while the coherent variant had an error rate of 0.191%; a paired exact sign test found no detectable difference between the two failure patterns.

The implication is significant but limited: the classically supplied addend is not necessarily a fundamental barrier to obtaining a low-resource coherent kernel. It remains only a point-addition result. The complete 28-call windowed schedule, all shifted tables, Fourier layers, and classical postprocessing were not integrated and end-to-end validated.

Figure 1: Evolution of the best $S=Q\times T,$1 score from the baseline to the data-cutoff incumbent.

Quantitative results and Pareto structure

The baseline circuit uses 2,715 logical qubits and 3,960,753 average executed Toffoli gates, giving a score of approximately 10.75 billion. At the 26 July 2026 cutoff, the best promoted circuit uses

• $S=Q\times T,$2 logical qubits,
• $S=Q\times T,$3 average executed Toffoli gates,
• $S=Q\times T,$4.

Relative to the baseline, these values represent reductions of 57.6% in width, 67.2% in executed Toffoli count, and 86.1% in the product metric. The product improves by a factor of approximately 7.19.

The paper compares this point with the reported Google/Babbush operating point, whose circuit is not publicly disclosed but is attested through a zero-knowledge proof (Babbush et al., 30 Mar 2026). The ECDSA.Fail incumbent has a product more than 50% below the reported Google value, and its individual $S=Q\times T,$5 and $S=Q\times T,$6 coordinates are below the Google and Schrottenloher reference points (Schrottenloher, 1 Jun 2026). The claim is deliberately qualified: the interfaces, validation procedures, approximation conventions, and resource-accounting rules are not identical. The result is therefore a contextual numerical comparison, not a formal dominance theorem.

The challenge also produces a pronounced low-width branch. At the cutoff, the best admitted circuit uses 825 qubits and approximately 489 million executed Toffolis, with a product of about 403.6 billion. A subsequent public submission reportedly reaches 813 qubits. These results expose a sharp width–work trade-off rather than a single optimum. The product-efficient and low-width circuits use different inversion architectures, so the large gap between the 825-qubit and 1,151-qubit regimes cannot be interpreted as a proven lower bound or a fundamental discontinuity.

A separate Pareto branch reaches $S=Q\times T,$7 with $S=Q\times T,$8. This costs roughly 12.4% more Toffoli work than the 1,151-qubit incumbent while saving 18 qubits. Such points may be preferable under a hard logical-qubit capacity constraint, illustrating why reporting only $S=Q\times T,$9 would conceal relevant operating regimes.

Figure 2: The observed qubit–Toffoli Pareto frontier and its distinct low-width and product-efficient regimes.

After the cutoff, the paper reports a further product improvement using a comparison-free “ping-pong” dialog-GCD construction. That circuit uses 1,321 qubits and 952,707 average executed Toffolis, yielding a score of approximately 1.259 billion. Relative to its reproduced parent, it reduces Toffoli count by 25.85% and the product by 14.82%, while increasing width from 1,150 to 1,321 qubits. This result reinforces the central resource trade-off: a more compact transcript alphabet and simpler replay can reduce nonlinear work while increasing persistent transcript storage.

Architecture of the best product-efficient circuit

The cutoff incumbent builds on record-and-replay Euclidean inversion, originally developed in the dialog-GCD line of work (Khattar et al., 13 Oct 2025) and adapted to ECDLP point addition by Schrottenloher (Schrottenloher, 1 Jun 2026). Rather than retaining a conventional extended-GCD history, the forward computation evolves shrinking Euclidean operands and records a coherent transcript of parity, swap, subtraction, and halving decisions. Reverse replay applies the transcript to payload registers, implementing both modular division and multiplication while eventually clearing the transcript.

Several optimizations reduce the width and executed Toffoli count.

Jump-2 Euclidean steps combine consecutive divsteps so that one or two divisions by two are handled within a macro-step. This reduces the number of comparisons, swaps, subtraction blocks, and transcript boundaries without changing the induced Euclidean transformation. Increasing the fixed macro-step budget from 258 to 261 reduced the observed nonconvergence frequency over ten million inputs from $Q$0 to $Q$1.

Base-5 transcript encoding exploits the fact that only five of the eight possible three-bit control triples are reachable. Three symbols can therefore be encoded in seven qubits rather than nine. For a 261-step schedule, the transcript requires 609 qubits instead of 783, a saving of 174 qubits. The encoder is reversible on the complete Hilbert space and returns the two unused degrees of freedom to $Q$2; it does not discard unreachable states.

Specialized Karatsuba squaring decomposes $Q$3 into three half-size squares and uses the pseudo-Mersenne relation

$Q$4

The circuit accumulates the result directly into the destination register and never stores a full 512-bit product. Symmetry and Karatsuba decomposition reduce the number of off-diagonal partial products from 32,640 for a direct 256-bit square to 24,512, approximately a 24.9% reduction.

Constant propagation and dead-code elimination remove arithmetic controlled by classical zero bits, cancel self-inverse operations, narrow carry and comparison ranges, and exploit known live-bit bounds. These transformations are exact when their preconditions are analytically established. Other width truncations are calibrated against the finite benchmark support and therefore do not provide all-input correctness guarantees.

The source-level architecture is important because the numerical improvement is not attributable to one isolated gate cancellation. It combines Euclidean algorithm redesign, transcript compression, liveness scheduling, arithmetic specialization, QROM boundary management, and reversible cleanup. The paper’s audit of 400 accepted source commits finds that 244, or 61.0%, are primarily classified as dead-code or redundancy elimination; register and scratch allocation accounts for 12.5%, measurement-based uncomputation for 5.5%, and constant propagation for 4.8%. These frequencies measure commit counts rather than resource impact. Rare structural changes, particularly inversion-architecture changes, generated much larger frontier movements than the frequent local refinements.

Low-width architecture

The 825-qubit circuit is structurally different from the product-efficient incumbent. It uses a register-shared shrunken-PZ extended Euclidean architecture rather than dialog-GCD transcript replay. Two 259-qubit banks store shrinking remainders, growing cross-cofactors, quotient information, and metadata through moving ownership boundaries. Inactive lanes are temporarily borrowed by local arithmetic and restored before their logical owners become active.

The peak decomposition is approximately

$Q$5

persistent and local qubits. The circuit computes the slope using one register-shared inversion, reconstructs an output-side witness, and performs a second inversion to erase the slope. This avoids retaining a dialog transcript but increases reversible Euclidean work substantially.

The resulting design demonstrates that width can be reduced from 1,151 to 825 qubits, but at the cost of increasing the average executed Toffoli count from approximately 1.3 million to 489 million. The paper appropriately avoids interpreting this as an optimal time–space trade-off. The two branches use different architectures, and no systematic hybrid search establishes whether a lower-width, lower-work intermediate family exists.

Correctness, approximation, and evaluator dependence

The challenge permits approximate arithmetic, provided that submissions pass the evaluator’s finite support. This is motivated by the fact that prior point-addition constructions also use bounded failure probabilities, but it complicates interpretation of resource improvements. An apparent reduction in $Q$6 can reflect lower arithmetic precision, a validation-support artifact, or a favorable submission-dependent input distribution.

The authors address this by re-evaluating 42 accepted submissions on a common corpus of 50,000 pseudorandom inputs and reporting the retry-adjusted proxy

$Q$7

where $Q$8 is the empirical success probability. Under the assumption that failures are independently rerunnable classical events, this estimates expected work per successful point addition. Under that model, the adjusted trajectory generally follows the raw trajectory because the observed per-call error rates remain small.

The assumption is not innocuous. A coherent quantum failure inside Shor’s algorithm need not behave like an independently rerunnable classical output error. The paper therefore treats $Q$9 as a sensitivity proxy rather than a fault-tolerant success estimate. The analogous whole-Shor extrapolation, which compounds errors over 28 point additions, is explicitly described as illustrative and not as evidence of coherent end-to-end success.

The evaluator’s nonce mechanism introduces a second issue. A 48-bit identity tail changes the circuit hash without changing its semantics, allowing submitters to search for a validation support on which an approximate circuit passes. The authors estimate that hiding a 1% error rate would require roughly $T$0 candidates under a random-oracle model, making such concealment infeasible within the nonce space. This bounds—but does not eliminate—the concern. The score remains a finite-support empirical quantity rather than an all-input resource bound.

Limitations and open questions

The principal limitation is the mismatch between benchmark correctness and full algorithmic correctness. The evaluator checks a finite set of computational-basis inputs, whereas the target use is coherent execution on superpositions. The authors separately check ancilla and phase cleanliness, which is necessary, but coherent correctness of the windowed adaptation is argued primarily through linearity and targeted basis-address tests rather than direct simulation of the complete coherent construction.

The generic affine circuit also excludes degenerate cases such as $T$1, $T$2, and $T$3. The evaluator filters some degeneracies but does not separately filter $T$4; its probability under random-scalar sampling is negligible, but correctness is not claimed there. This is acceptable for the stated benchmark but prevents treating the circuit as a complete generic group operation without additional exceptional-case handling.

The $T$5 metric is not a physical spacetime-volume estimate. It ignores depth, parallelism, routing, QROM static costs, classical feed-forward, measurements, logical error correction, and architecture-dependent distillation. The windowed-compatible circuit’s static operation stream increases by a factor of 23.36 even though the reported executed-Toffoli metric rises by only about 29.6%. Consequently, the relative ranking of circuits could change under an architecture-aware cost model.

The comparisons with Google and Schrottenloher are also conditional. Google’s circuit is not public, Schrottenloher’s accounting differs, and the ECDSA.Fail benchmark begins with a classically specified addend. The coherent variant narrows this interface gap but does not establish complete Shor integration.

Finally, the open-autoresearch conclusions are observational. The archive does not contain all failed local experiments, private agent sessions, or unsubmitted hypotheses, and it cannot estimate success rates per attempt or attribute specific frontier movements to particular models. The paper leaves open whether the same optimization progress would have been achieved by expert human teams without agents, and which components of the workflow—tool use, parallelism, persistent memory, public sharing, or human steering—contributed most to the observed gains.

Conclusion

“ECDSA.Fail: Open Autoresearch for Optimizing Elliptic-Curve Point Addition in Shor’s Algorithm” (2609.09582) presents both a source-auditable family of reversible secp256k1 point-addition circuits and a public optimization methodology centered on verifier-gated human–agent collaboration. The headline cutoff result reduces the benchmark score from approximately 10.75 billion to 1.496 billion, an 86.1% reduction, while a separate branch reaches 825 logical qubits and a later post-cutoff construction reaches approximately 1.259 billion.

The technical progress comes from architectural changes to reversible modular inversion, compressed Euclidean transcripts, register sharing, specialized squaring, aggressive liveness management, and exact or support-calibrated compiler transformations. The coherent windowed-compatible construction shows that the mixed-addition result can be adapted with modest reported overhead, but complete Shor integration and architecture-specific resource estimation remain unresolved. The paper’s strongest conclusion is therefore specific: an open, machine-checkable optimization environment can produce substantial and reproducible progress on a difficult reversible-circuit objective, while the numerical results must remain bounded by the evaluator’s finite support, interface assumptions, and proxy cost model.