wai-quantum 0.3.29: the architecture around the code, priced, and the 2025 factoring machine re-run #148

Merged

dcharlot merged 1 commit from wai-quantum-arch into main 2026-10-05 05:07:02 -04:00

Conversation 0 Commits 1 Files changed 15 +2495 -22

dcharlot commented 2026-10-04 17:34:08 -04:00

Owner

Copy link

Stacked on #147 (→ #145 → #144 → #143). Merge those first; this diff then reduces to the one commit.

What

quantum_arch, a new feature of wai-quantum (0.3.29), prices the architecture-level ideas behind the recent fall in projected fault-tolerant cost:

• Yoked storage (arXiv:2312.04522)
  • Plain, row-yoked and grid-yoked patches, in cold and hot storage.
  • Uses the published path-counting fits: SI1000, uniform, and the refit used by arXiv:2505.15917.
• Whole-block storage plans, capped at the block sizes the fits were drawn from.
• Magic-state cultivation (arXiv:2409.17595)
  • Read off the published end-to-end simulation curves (Apache-2.0 data) and interpolated log-linearly.
  • Noise strengths that were not simulated are refused.
• 8T-to-CCZ factories and the clock. A step takes the slowest of lattice surgery, CCZ supply and reaction time, and the estimate says which one binds.
• The factoring workload of arXiv:2505.15917: operation tallies, logical qubits, Toffoli counts and a whole-machine estimate.

CLI: wai-quantum arch factoring|storage|cultivate [--json]. Example: arch_factoring.

Checked

• Storage layouts. The layout search matches the source's own footprint tool on all 915 layouts it produces: three fit sets × 61 targets × five storage kinds. Distance, block shape, check period and qubits per logical qubit are identical, and errors agree to 1e-12. The oracle table is in tests/data/yoked_footprint_oracle.csv.
• Toffoli counts. Under the source's counting rule, the counts match its reference implementation for every tabulated key size from 1024 to 8192 bits, to its rounding of half operations (relative difference below 1e-7). Its logical-qubit column also matches exactly.
• Re-run of the 2048-bit estimate.
  • Its 897,864 physical qubits are reproduced from its layout.
  • Its 429.03 qubits per cold logical qubit are reproduced from its fit (grid blocks 16 wide at d = 11).
  • Its factory arithmetic is reproduced: 114.79 rounds per CCZ, and a 25 µs step at d = 25 with six factories.
• Reproducibility. The new pin holds natively and under wasm32-wasip2, and all 14 pins pass. CLI output is byte-identical natively and under WASI.
• Lint and prose. Clippy is clean on the new code, and the comparative-prose and vanity-metric checks pass.

Where the source disagrees with itself

Each item is asserted in a test:

1. Runtime per shot. Its tallies at its stated durations (2 ms per addition and per lookup, 1 ms per phaseup) give 10.62 h per shot, not 12.07 h.
2. Hot storage. It keeps 131 logical qubits hot. Its own peak formula m + 3f + 2ℓ + len m gives 1432, which means 152 hot. Its table gives 1399 and its text gives 1409.
3. Phaseup Toffolis. Its reference counting code prices a 6-bit phaseup at 0.25 Toffolis, an exponent sign slip; the text says 8. Correcting it adds 1.7%.
4. Loop 4. Its table lists 1.5 additions and 2.5 lookups per iteration; its code performs 2.5 and 1.5.
5. Cultivation. It reads 30,000 qubit·rounds per 10⁻⁷ T state off a figure; the data behind the figure give 22,600.
6. Block granularity. 1280 cold logical qubits need seven whole blocks, 582,624 qubits, not 550,400.

With every correction the machine needs 958,480 physical qubits and 4.3 days per factoring. The conclusion holds.

🤖 Generated with Claude Code

Stacked on #147 (→ #145 → #144 → #143). Merge those first; this diff then reduces to the one commit. ## What `quantum_arch`, a new feature of wai-quantum (0.3.29), prices the architecture-level ideas behind the recent fall in projected fault-tolerant cost: - **Yoked storage** (arXiv:2312.04522) - Plain, row-yoked and grid-yoked patches, in cold and hot storage. - Uses the published path-counting fits: SI1000, uniform, and the refit used by arXiv:2505.15917. - **Whole-block storage plans**, capped at the block sizes the fits were drawn from. - **Magic-state cultivation** (arXiv:2409.17595) - Read off the published end-to-end simulation curves (Apache-2.0 data) and interpolated log-linearly. - Noise strengths that were not simulated are refused. - **8T-to-CCZ factories and the clock.** A step takes the slowest of lattice surgery, CCZ supply and reaction time, and the estimate says which one binds. - **The factoring workload of arXiv:2505.15917**: operation tallies, logical qubits, Toffoli counts and a whole-machine estimate. CLI: `wai-quantum arch factoring|storage|cultivate [--json]`. Example: `arch_factoring`. ## Checked - **Storage layouts.** The layout search matches the source's own footprint tool on all **915** layouts it produces: three fit sets × 61 targets × five storage kinds. Distance, block shape, check period and qubits per logical qubit are identical, and errors agree to 1e-12. The oracle table is in `tests/data/yoked_footprint_oracle.csv`. - **Toffoli counts.** Under the source's counting rule, the counts match its reference implementation for every tabulated key size from 1024 to 8192 bits, to its rounding of half operations (relative difference below 1e-7). Its logical-qubit column also matches exactly. - **Re-run of the 2048-bit estimate.** - Its 897,864 physical qubits are reproduced from its layout. - Its 429.03 qubits per cold logical qubit are reproduced from its fit (grid blocks 16 wide at d = 11). - Its factory arithmetic is reproduced: 114.79 rounds per CCZ, and a 25 µs step at d = 25 with six factories. - **Reproducibility.** The new pin holds natively and under wasm32-wasip2, and all 14 pins pass. CLI output is byte-identical natively and under WASI. - **Lint and prose.** Clippy is clean on the new code, and the comparative-prose and vanity-metric checks pass. ## Where the source disagrees with itself Each item is asserted in a test: 1. **Runtime per shot.** Its tallies at its stated durations (2 ms per addition and per lookup, 1 ms per phaseup) give 10.62 h per shot, not 12.07 h. 2. **Hot storage.** It keeps 131 logical qubits hot. Its own peak formula `m + 3f + 2ℓ + len m` gives 1432, which means 152 hot. Its table gives 1399 and its text gives 1409. 3. **Phaseup Toffolis.** Its reference counting code prices a 6-bit phaseup at 0.25 Toffolis, an exponent sign slip; the text says 8. Correcting it adds 1.7%. 4. **Loop 4.** Its table lists 1.5 additions and 2.5 lookups per iteration; its code performs 2.5 and 1.5. 5. **Cultivation.** It reads 30,000 qubit·rounds per 10⁻⁷ T state off a figure; the data behind the figure give 22,600. 6. **Block granularity.** 1280 cold logical qubits need seven whole blocks, 582,624 qubits, not 550,400. With every correction the machine needs 958,480 physical qubits and 4.3 days per factoring. The conclusion holds. 🤖 Generated with [Claude Code](https://claude.com/claude-code)

dcharlot added 5 commits 2026-10-04 17:34:08 -04:00

wai-quantum 0.3.25: error correction at circuit level, sampled, modelled and decoded exactly ... ed592d76f9

quantum_frame takes an error-correction experiment as what it is: a noisy
Clifford circuit with detectors and observables.

- parse reads the ecosystem's circuit text (resets and measurements in Z and
  X, H/S/sqrt(X)/Paulis/CX/CZ/SWAP, flip and depolarizing noise, detectors,
  observables, REPEAT), and refuses anything else rather than skipping it.
- sample is bit-packed Pauli-frame simulation, 64 shots per word, with
  geometric skipping between noise hits; reproducible from
  (circuit, shots, seed).
- error_model derives the detector error model by backward sensitivity
  propagation. It converts depolarizing channels to equivalent independent
  mechanisms exactly, XOR-merges identical ones, and refuses non-deterministic
  detectors. A graphlike mechanism stays one matching edge; otherwise it splits
  into X and Z halves, then into per-qubit parts.
- surface_code_memory generates the rotated surface-code memory experiment.

quantum_match decodes by exact minimum-weight perfect matching: Dijkstra on
integer weights, with boundary paths computed once and dominated pairs cut,
then Edmonds' blossom. memory_experiment and fit_code_model measure
P(d) = a(p/p*)^((d+1)/2): a = 0.023, p* = 0.0100 under uniform circuit
noise, and CodeFit::surface_code feeds that into a resource estimate.

Checked against an independent implementation:
- generated circuits identical byte for byte (135 configurations, d 2-15,
  1-8 rounds);
- error models identical mechanism for mechanism, to 1e-12 in probability
  (41 circuits: rotated and unrotated surface codes in both bases,
  repetition codes);
- decoded logical error rates within 1.4 standard errors on all 12 grid
  points.

tests/frame_reference.rs keeps a circuit and a model from that implementation
as fixtures. Blossom equals brute force on 3000 random graphs. A mirrored
random Clifford circuit over every gate type ties the sampler's forward rules
to the model's backward ones. Mutating the depolarizing conversion, any gate
rule on either side, the determinism check or the decomposition fails a named
test. bit_identity pins sampling, decoding and the fit natively and under
wasm32-wasip2; repro gains an in-crate exp, within an ulp.

CLI: wai-quantum qec [-d --rounds --p --shots --seed --json] | --file |
--circuit | --dem | --fit, and estimate --prefactor/--threshold for a
measured code. Byte-identical natively and under wasm32-wasip2.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum 0.3.26: tensor-network contraction, hyper-optimised, sliced, bit-identical ... ae0d1c4cd4

quantum_tn turns a circuit (any unitary on any qubits, as a matrix) into the
tensor network of one amplitude or an open-output batch, and contracts it.

- Network::amplitude builds the network; simplify absorbs vectors and
  one-qubit gates into neighbours.
- find_path is a seeded hyper-optimiser over two tree families:
  - randomised greedy, scoring size(out)/c - c(size(a)+size(b)) with Gumbel
    noise;
  - recursive bipartition, multilevel (heavy-edge coarsening, several
    initial cuts, refinement at every level), with greedy leaves.
  Families alternate until one leads; later trials sample near the best
  parameters. The best few trees are reconfigured: subtrees of up to eight
  tensors are re-contracted optimally by subset dynamic programming, until
  nothing improves.
- slice fixes the index that leaves the least total work until the largest
  intermediate fits the cap, pricing each candidate incrementally. A second
  search round then finds a tree for the network with the first round's
  slices fixed (all, or the more valuable half).
- contract_plan contracts every slice in a fixed accumulation order and sums
  them in order. Threads are bounded by an 8 GiB budget; WASI runs
  sequentially. The bits are the same everywhere.

Measured on single amplitudes of random circuits on the 54-qubit
advantage-experiment grid (fSim(pi/2, pi/6), staggered couplers), 256 trials,
under ten seconds each, in log10 operations:
  m = 10: 10.48   m = 12: 13.91   m = 14: 14.63   m = 16: 17.60   m = 20: 18.77
An independently developed hyper-optimiser, given the identical networks,
lands within 0.4 of these at every depth, in either direction. The 54-qubit,
10-cycle amplitude, contracted here in 16 slices, agrees with an independent
contraction to 12 significant figures.

Tests:
- Amplitudes match a dense state vector for every tree family, with
  reconfiguration and with slicing.
- Reconfiguration reaches the exact optimum on 40 random small networks.
- Incremental slice pricing matches a full recount.
- The same seed gives the same plan.
- Mutating the permutation, the complex product, the contraction's summed
  indices, slice pricing, the slice offset or the reconfiguration DP fails a
  named test.
- bit_identity pins a plan and its sliced, threaded amplitude natively and
  under wasm32-wasip2.

CLI: wai-quantum tn --file CIRCUIT.jsonl [--bits --open --trials --seed
--cap-log2 --plan-only --json], byte-identical natively and under
wasm32-wasip2.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum 0.3.27: Gaussian boson sampling, exactly ... 6ab907e107

A photonic sampler's outcome probabilities are hafnians (photon-number
detection) or torontonians (threshold detection) of its Gaussian state.
quantum_gbs computes both exactly and reproducibly.

- hafnian: power traces, a sum over 2^{n/2} pair subsets, each the
  lambda^{n/2} coefficient of exp(sum tr(B^k) lambda^k / 2k). The traces come
  from a Householder Hessenberg reduction, La Budde's characteristic
  polynomial and Newton's identities: O(n^3 2^{n/2}).
- torontonian: inclusion-exclusion over the 2^m clicked-mode subsets.
- Both sums run in 64 fixed chunks, threaded natively and sequential on WASI,
  added in chunk order, so the bits do not depend on threading.
- GaussianState: squeezed vacua through an interferometer with uniform loss,
  as the complex covariance in the (a, a-dagger) basis.
- click_probability, photon_probability: exact pattern probabilities.
- sample_clicks: exact samples, drawn mode by mode from marginal
  torontonians.
- click_marginals, check_samples: the one- and two-mode click statistics
  every sampler of the state must reproduce, polynomial in the modes, and a
  z-score check of observed patterns against them.

Against an independent implementation:
- click probabilities of three lossy states, every pattern: 1.1e-10;
- photon probabilities up to four photons: 2.3e-13;
- hafnians: 1.5e-12 up to 20x20 and 4.5e-8 at 36x36, where the alternating
  sum loses precision on either side. A 36x36 hafnian takes under 2 s.

Tests:
- hafnians match exhaustion over matchings, and (2k-1)!!;
- squeezed vacuum reproduces its textbook click and photon statistics;
- click probabilities sum to one with loss;
- exact samples reproduce marginals and full-pattern frequencies, and pass
  the check, while a different interferometer fails it.
Mutating the hafnian sign, La Budde's recurrence, Newton's identities, the
torontonian sign or the loss channel fails a named test. bit_identity pins a
24x24 hafnian and a 14-click torontonian (threaded natively, sequential under
WASI), probabilities, samples and marginals, on both targets.

CLI: wai-quantum gbs --squeezing ... [--eta --seed | --unitary] [--sample K |
--check FILE] [--json], byte-identical natively and under wasm32-wasip2.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum 0.3.28: the dense state vector at any angle, the same bits threaded or not ... 38a205ee33

The byte-exact simulator is fixed-point and dyadic by design. quantum_sv is
the general state vector for everything else (arbitrary rotations, sqrt W,
fSim, random unitaries), and the ground truth approximate methods are
measured against, up to about 30 qubits.

- Split real and imaginary arrays; qubit 0 most significant, as in the
  tensor networks.
- Kernels: unrolled one- and two-qubit, general k-qubit, and a diagonal
  fast path.
- Fusion around multi-qubit gates: pending one-qubit gates join the next
  multi-qubit gate on their qubit, trailing ones the last, and above width 2
  adjacent multi-qubit gates merge. Each move only crosses gates on other
  qubits.
- Threads, with no unsafe code: block-aligned slices, and for gates on the
  top qubits a split at the top target bit, or into four quarters for
  adjacent pairs.
- Every path computes each amplitude through one row sum in one order, so
  threading never changes a bit. The native-vs-WASI pin caught a path whose
  sum ran in a different order; the fix is the shared row_dot, and a test
  now forces 1/2/3/8/32 threads and demands identical states (falsified by
  reversing one kernel's sum).
- Reductions (norm, Pauli expectations, sorted-uniform sampling) are summed
  in fixed chunks.

gates: Gate moves here from quantum_tn (re-exported there), with the
standard gates by name: H, X, Y, Z, S, T, sqrt X/Y/W, RX/RY/RZ, phase, CX,
CZ, SWAP, iSWAP, CPhase, RZZ, fSim.

Checked:
- final states of random circuits on 8, 12 and 16 qubits agree with an
  independent simulator to 2e-16 at fusion widths 0, 2 and 4;
- tensor-network amplitudes equal the state vector's to 1e-12 on 18 qubits
  (tests/tn_vs_sv.rs);
- a 26-qubit, depth-20, 770-gate circuit runs in about 9 s at width 2, in
  double precision.

CLI: wai-quantum sv --file CIRCUIT.jsonl [--fuse --top --sample --expect
--json]; tn shares its circuit reader. Byte-identical natively and under
wasm32-wasip2.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

wai-quantum 0.3.29: the architecture around the code, priced, and the 2025 factoring machine re-run ... 80335672ed

quantum_arch prices what has cut projected fault-tolerant cost since 2023
without a better qubit:

- Yoked storage (arXiv:2312.04522): plain, row-yoked and grid-yoked patches,
  cold and hot, under the published path-counting fits (SI1000, uniform,
  and the refit used by arXiv:2505.15917). The layout search matches the
  source's own footprint tool on all 915 layouts it produces (three fit sets,
  61 targets, five storage kinds): distance, block shape, check period and
  qubits per logical qubit.
- Whole-block storage plans: copies of one shape plus one remainder block,
  capped at the block sizes the fits were drawn from.
- Magic-state cultivation (arXiv:2409.17595), read off the published
  end-to-end curves (Apache-2.0 data), interpolated log-linearly; refuses
  unsimulated noise strengths.
- 8T-to-CCZ factories and a clock set by the slowest of lattice surgery, the
  CCZ supply and the control loop; it says which one binds.
- The factoring workload of arXiv:2505.15917: its operation tallies, logical
  qubits and Toffoli counts. Under the source's counting rule the counts match
  its reference implementation to its rounding of half operations, for every
  tabulated key size (1024 to 8192 bits).

Re-running the 2048-bit estimate reproduces its 897,864 qubits from its
layout and its 429.03 qubits per cold logical qubit from its fit. It also
finds six places where the source disagrees with itself:
- its tallies at its stated durations give 10.62 h per shot, not 12.07 h;
- its hot-storage count (131) sits below its own peak formula (152);
- its reference counting code prices a 6-bit phaseup at 0.25 Toffolis, not
  8 (+1.7%);
- loop 4's table swaps additions and lookups relative to its code;
- its 30,000 qubit-rounds per 10^-7 T state is 22,600 in the data behind the
  figure;
- 1280 cold qubits need seven whole blocks (582,624 qubits), not 550,400.
With every correction the machine is 958,480 qubits and 4.3 days: the
conclusion holds.

CLI: wai-quantum arch factoring|storage|cultivate [--json]. Example:
arch_factoring. Pinned bit for bit natively and under wasm32-wasip2; CLI
output byte-identical across the two.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

dcharlot referenced this pull request 2026-10-04 21:30:58 -04:00

wai-quantum 0.3.30: qLDPC memory at circuit level, re-derived from the circuit up #150

dcharlot merged commit a6716a4543 into main 2026-10-05 05:07:02 -04:00

dcharlot referenced this pull request from a commit 2026-10-05 05:07:04 -04:00

Merge pull request 'wai-quantum 0.3.29: the architecture around the code, priced, and the 2025 factoring machine re-run' (#148) from wai-quantum-arch into main

Sign in to join this conversation.

Reviewers

No reviewers

Labels

Clear labels

No items

No labels

Milestone

Clear milestone

No items

No milestone

Projects

Clear projects

No items

No project

Assignees

Clear assignees

No assignees

1 participant

Notifications

Subscribe

Due date

The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference

Transaction-Science/open-standards!148

No description provided.