Research log

Survey Kuperberg 2003 / 2011, Regev 2004, Bacon–Childs–van Dam, Moore–Russell–Schulman, Brakerski–Kirshanova–Stehlé–Wen 2017, Chia–Hallgren 2016, and 2020–2025 revisits.

• ·Confirmed: the 2^O(√log N) wall has not moved in over a decade.
• ·Confirmed: Bacon–Childs–van Dam density threshold ν = k / log₂N > 1 pins the obstruction; PGM is optimal but insufficient.
• ·Confirmed: Brakerski et al. 2017 (1710.08223) tightens Regev — poly-time DHSP ⇒ poly-time LWE.
• ·Flagged WITHDRAWN: Doliskani ePrint 2021/419 (poly-time DCP, fatal error in state discrimination).
• ·Flagged contested: Wang 2204.03295 (5 revisions, no top-venue acceptance).
• ·Tractability score 2/5: lone-contributor wins are narrow regimes / sharp constants, not the main exponent.

Survey Regev 2005, Chen 2024 withdrawal, Chailloux–Loyer 2021, Bonnetain–Chailloux–Schrottenloher–Shen 2023, Engelberts et al. 2025 (3-tuple), Cho et al. 2024 (QRAM impossibility).

• ·Chen ePrint 2024/555 WITHDRAWN. Flaw surgically located: Step 9 / §3.5.9, NOT the complex-Gaussian preparation (Steps 1–8 not refuted).
• ·Post-mortem credit: Hongxun Wu AND Thomas Vidick, identified independently 2024-04-18. ePrint 2024/583 (Shmueli) was concurrent and itself withdrawn after Chen's acknowledgment.
• ·Confirmed: best quantum SVP exponent is 0.2570 n (Chailloux–Loyer); Engelberts et al. 2025 (2510.08473) pushes slightly below via 3-tuple sieving.
• ·Confirmed: Cho et al. 2410.15565 prove quantum sieve advantage requires poly(n) QRAM — vanishes in circuit-only model.
• ·Direct precedent flagged: Eldar–Shor 2016 (arXiv:1611.06999) — same withdrawal pattern as Chen.
• ·Tractability score 2/5: deeply frustrating middle ground.

Survey CSIDH, SQIsign / SQIsignHD, the Castryck–Decru–Maino–Martindale–Robert SIDH-break trilogy, Peikert C-sieves, Bonnetain–Schrottenloher concrete cost.

• ·SIDH/SIKE permanently dead (classical poly-time break, ePrint 2022/975 + 2022/1026 + 2022/1038).
• ·CSIDH-512 quantum security ~62 bits, not 128 (Bonnetain–Schrottenloher ePrint 2018/537).
• ·SQIsign / SQIsignHD non-commutative; Kuperberg does not apply by construction.
• ·Patched SIDH (FESTA, M-SIDH) broken within months — the auxiliary-torsion design paradigm appears structurally unfixable.
• ·All key papers live on IACR ePrint, not arXiv — flagged for citation accuracy.
• ·Tractability score 3/5: CSIDH concrete-cost optimization is the most accessible lone-contributor target.

Survey Bernstein 2010, Kachigar–Tillich 2017, Kirshanova 2018, Engelberts–Etinski–Loyer 2024 closing result, Dinh–Moore–Russell 2011, Chailloux–Tillich 2023 quantum decoding.

• ·Best quantum ISD exponent: 2^(0.05869 n) — Kachigar–Tillich 2017; ~16% improvement, not 50%.
• ·Closing result: Engelberts–Etinski–Loyer 2408.16458 PROVES quantum sieving gives NO improvement over Grover-over-Prange.
• ·Shor-style code-equivalence route closed: Dinh–Moore–Russell 1111.4382.
• ·Chailloux–Tillich 2310.20651 defines a quantum-superposition decoding problem; poly-time at low noise.
• ·Tractability score 2/5: QRAM-free re-derivation and QC-structure exploitation are the open lanes.

Find 10 structural transplants from non-quantum fields with verifiable anecdotes and brutal breakage analysis.

• ·Game Boy: Yokoi's 枯れた技術の水平思考 ('Lateral Thinking with Withered Technology'), April 1989.
• ·Bell Labs transistor: Kelly's 'productive collision' co-location strategy, December 23 1947 (Bardeen + Brattain).
• ·Container shipping: SS Ideal X, April 26 1956; ISO 668 codified 1968.
• ·Phage lysis: Bull 2006 formula τ* = √(b/(δ·r)) — an actual solved optimization problem, not a metaphor.
• ·Modal jazz: Davis on March 2 + April 22 1959, sketches given to musicians on the day with no rehearsal.
• ·Wright wind tunnel: 6 ft, October–December 1901, ~200 airfoils, refuted Lilienthal's Smeaton coefficient.
• ·Linux merge window + RC freeze: formal 2-week / 6–10 week asymmetric gating, post-BitKeeper-crisis April 2005.
• ·TeX (1977–1982): semantic/presentational split with composable macros. Version number → π = frozen.
• ·Toyota Jidoka / Andon: defect detection at origin, mandatory propagation halt — Sakichi Toyoda 1924 loom.
• ·Cross-cutting observation: 'phase separation with asymmetric gating' and 'defect detection at origin' recur with suspicious frequency — both are underweighted in PQC standardization.

Survey QSP/QSVT, qubitization, MNRS quantum walks, QAOA, tensor networks, dequantization, anyonic braiding, hidden nonlinear structures for transplant candidates.

• ·QSVT (1806.01838) — block-encoded sieve operator + spectral sharpening; plausibility 4/5.
• ·MNRS quantum walk (quant-ph/0608026) — per-window quadratic speedup; partially cashed in by Laarhoven 1504.03280.
• ·Tang dequantization (1807.04271) — MANDATORY negative control, plausibility 5/5: the single most useful import.
• ·Qubitization (1610.06546) — embed coset-combination as walk operator + QSP eigenphase estimation.
• ·Quantum rejection sampling (1103.2774) — candidate primitive for the open QRAM-free dual-attack speedup.
• ·Childs–Schulman–Vazirani 0705.2784 — hidden nonlinear structures; long-shot for LWR / NTRU framing.
• ·Shared failure pattern: every transplant hits QRAM cost, exponential spectral gap, or counting-vs-search wall.

Pair frontiers with donor analogies. Select target sub-problem and assemble Draft v0.1.

• ·Selected target: Dihedral HSP under a structured-reflection promise (SRP).
• ·Donors paired: modal-jazz (the SRP itself), polyphasic (windowed combination), Wright (Selene toy), TeX (GAP-marker draft format), Andon (refutation experiments).
• ·Negative control: Chen 2024 Step 9 — every algorithmic step in the draft must explicitly declare its post-state structure.
• ·Output: Draft v0.1 — 'A windowed, modally-restricted dihedral coset sieve'. Four explicit GAP markers, four refutation experiments.

Calibrate the wind-tunnel with primitive Selene toys G4–G11; factor parameter-sweep boilerplate; ship the selene_run schema and a live in-Worker sampler.

• ·G4 (feed-forward): `if measure(...): rz(...)` fires inside one compiled shot — branch split tracks sin²(θ/2) within 0.02. Verdict: feed_forward_verified.
• ·G5 (qubit recycling) + G6/G6b (encoded ancilla, transversal-fixed): peak live qubits stays at n+1; encoded-subspace share = 1.000 across all six slopes. Ready for a noise model.
• ·G7 (host-fused vs per-slope compile): >1.5× wall-clock speedup at byte-identical shot statistics.
• ·G8 (canonical QPE on coin operator) and G9 (LCU PREP·SELECT·UNPREP with post-selection): both pass their refutation gates — wind-tunnel can host QPE + amplitude amplification.
• ·G10 (QSP phase finder): Chebyshev sign(x) target → scipy.optimize Powell recovers φ → Selene executes qsp_sequence → `max |measured − target| < 0.05` over 16-point x grid. Verdict: qsp_phase_finder_verified.
• ·G11 real (Shor modexp for a=2, N=15): real controlled `pow_const_mod` as CSWAP-chain cyclic shift on the orbit of |1⟩; QPE bins concentrate at {0, 4, 8, 12}; continued-fractions recovers r=4.
• ·quantum/sweep.py: SweepSpec + SweepRunner factor ~80 lines of per-driver boilerplate. nadarasa_g1_via_sweep.py reproduces the G1 tension within Monte-Carlo error — TENSION is real, not a driver artifact.
• ·src/lib/selene-run-schema.ts + src/components/selene/SeleneRun.tsx: Zod-validated `selene_run` v1 schema; 9/9 demos covered with no `extras` escape hatch. Conformance dashboard at /nadarasa/schema-coverage.
• ·src/lib/selene/mini-sim.ts + /api/public/nadarasa-stream: in-Worker statevector sampler streams shots over SSE; G4 kernel ported to TS; live verification gate `|P̂ − P| < 0.05` over ≥500 shots passes consistently.
• ·Net effect: every primitive the conjecture would need (QPE, LCU, QSP, feed-forward, modexp) is calibrated on the rig. The G1/G2/G3 tensions therefore localise to the SRP structural claim, not the wind-tunnel.

Fold G4–G11 evidence into the draft; rename the original G4 (MRS) to G4-MRS to free the name for the Selene feed-forward demo; add G12 as the next-experiment slot.

• ·Abstract rewritten to lead with the calibration narrative: primitives PASS, G1/G2/G3 are UNDER PRESSURE, so the tension is structural.
• ·New Section 4 migration note: SweepRunner re-run of G1 matches reference within Monte-Carlo error.
• ·New Sections 7 (QSP phase finder) and 8 (real Shor modexp) — calibration, not load-bearing.
• ·GAP table updated: G1/G2/G3 marked EMPIRICALLY UNDER PRESSURE; G4 renamed G4-MRS; new G12 (modal-projection scaling) scheduled.
• ·Next-steps list: G12 first, Zenodo DOI second, expert review third.

Port G1 (small-N) and G10 (single-x QSP) to the in-Worker mini-sim; generalize /api/public/nadarasa-stream with ?kernel=; add kernel-picker UI; re-run the live verification flow at the original (N, p) scales.

• ·src/lib/selene/kernels/nadarasa-g1.ts + nadarasa-g10.ts now run inside the Worker; mini-sim gains a cphase helper matching the Guppy rz/cx/rz/cx identity.
• ·/api/public/nadarasa-stream dispatches on ?kernel=g4|g1|g10 and emits a per-kernel `predicted` meta; /nadarasa/stream has a kernel picker + per-kernel verdict chip.
• ·Live verification exposed a documentation bug: the G1 Python driver's claim that H^n + Z-basis readout matches the Fourier-basis distribution (1 + cos(2π y s / N))/N is FALSE — H^n is Walsh–Hadamard, not QFT. The samples were always right; the closed-form was wrong.
• ·Replaced the predictor with the exact circuit-level distribution P(y|s) = (δ_{y,0} N² + |T_y|²)/(2N²), T_y = Σ_x e^{i 2π s x/N} (-1)^{popcount(x AND y)}. Live |Δ| drops to < 0.02 across N ∈ {16, 32} × p ∈ {2, 3, 5}.
• ·Tension signal STRENGTHENS at the same scales: violating-branch excess_over_uniform ≥ srp-branch excess at every (N, p) — N=16,p=2: srp 0.21 vs violating 0.25; N=32,p=2: srp 0.22 vs violating 0.25. The 'modal projector' isolates nothing; it just exposes structured-vs-random spread.
• ·G4 (θ=π) and G10 (QSP grid) remain live-verified with |Δ| ≤ 0.018 at 2000 shots — the wind-tunnel is fine; the structural claim is what fails.

Phase 1 of the v0.3 push: replace the broken H^n + Z-basis G1 readout with a real little-endian QFT (controlled-phase ladder + bit-reversal SWAPs), in both Guppy and the mini-sim. Rerun on Selene at N ∈ {16, 32} × p ∈ {2, 3, 5}.

• ·quantum/nadarasa_g1_lib.py gains `cphase_true_on` (controlled-phase via the Rz–Rz–CX–Rz–CX identity, halfturn-correct) and `emit_qft_lines` (per-N inlined QFT, SWAP via triple-CX because the pinned guppylang does not expose swap).
• ·quantum/nadarasa_g1.py rewritten: kernel emits the QFT after measuring the label; main() reports closed-form prediction and a tri-valued verdict (`modal_projector_works_when_p_divides_N` / `consistent_when_p_divides_N` / `does_not_isolate_srp` / `kernel_mismatch`).
• ·Real Selene shots at 600/slope: SRP concentration 1.000 vs predicted 1.000 (p=2, p|N); 0.500 vs 0.500 (p=3,5, p∤N); violating 0.500 vs 0.500 (p=2) and 0.620–0.750 vs 0.625–0.750 (p=3,5). Worst |observed − predicted| = 0.0133.
• ·Closed-form derivation: ρ_data = (1/2N) Σ_{x,x'} (1 + ω^{s(x−x')}) |x⟩⟨x'| ⇒ P(y|s) = (1/2)[δ_{y,0} + δ_{y,(N−s) mod N}]. Two delta peaks, mass 1/2 each.
• ·Verdict on Conjecture C1: the modal projector is exact when p | N (perfect classical witness for SRP membership) and inverts when p ∤ N (violating exceeds SRP on residue 0). v0.2 'tension_with_g1' is RETRACTED as a wrong-basis artifact.
• ·nadarasa_g1_via_sweep.py picks up the new render_kernel automatically; sweep-mode parity check passes (verdict matches reference).
• ·Live-sampler mini-sim mirrors the Guppy circuit (cphaseTrue + qft + swap helpers); JS observed matches the same closed form within 0.025 at 1500 shots.
• ·Methodology lesson now lives in the Quantinuum skill's live-sampler.md: predictors must be derived from the gates actually executed, not from the kernel's docstring.

Apply the v0.3 G1 lesson to G2: derive the predictor from the gates, not the docstring.

• ·G2 kernel = single-qubit Rz on |+⟩^n + parity probes — neither couples data qubits. Closed form: P(x | s, k, branch) = 1/N exactly, for every configuration.
• ·Real Selene run at N ∈ {16, 32, 64} × k ∈ {1, 2, 4}: worst |observed − predicted| = 0.0029 (Monte-Carlo error). Max SRP-vs-violating gap = 0.0006.
• ·Verdict: `kernel_cannot_test_g2`. The v0.1 'tension_with_srp_prediction' was a comparison against a heuristic decay the kernel never had a chance to produce.
• ·GAP G2 reclassified in draft v0.3: NOT YET TESTABLE — a coherent two-coset-combination kernel is the next G2 work item.

Rebuilt the G2 kernel as a real two-coset combiner — two label qubits, two cphase ladders, CX(lbl0, lbl1) + H(lbl1) + measure glue, real-QFT readout — and re-derived the predictor from the gates.

• ·New driver `quantum/nadarasa_g2_real.py` + lib `quantum/nadarasa_g2_real_lib.py`; in-worker TS port at `src/lib/selene/kernels/nadarasa-g2-real.ts` wired into the live sampler at `/nadarasa/stream`.
• ·Closed form (derived from the executed gates): P(y | s0, s1) = (1/4)[δ(y,0) + δ(y, N−s0) + δ(y, N−s1) + δ(y, N−s0−s1)]; same formula imported by Python, TS, and the predictor chip.
• ·Selene shots at N ∈ {16, 32} × p ∈ {2, 3, 5}, 200 shots/pair × 6 pairs/branch: worst |observed − predicted| = 0.016. Min SRP-vs-violating gap when p | N = +0.485 (predicted +0.500).
• ·Verdict: `coherent_combiner_produces_srp_signal_when_p_divides_N`. GAP G2 status updated from `kernel_cannot_test_g2` (v0.3) to `empirically_consistent_two_coset` (v0.3.1) — the conjecture is now testable at toy scale and survived the test.

Re-ran the G1 modal-projection kernel at N ∈ {64, 128} × p ∈ {2, 3, 5, 7} with the predictor derived from the real-QFT gates, not the docstring.

• ·Closed form (from G1 gates): P(y | s, N) = ½[δ(y, 0) + δ(y, (N − s) mod N)]; per-branch predicted concentration averages 0.5 + 0.5·1[(N − s) mod p == 0] over the chosen slope set.
• ·Selene shots (120/slope, 4 slopes/branch): worst |measured − predicted| = 0.040 at N=128, 0.027 at N=64 — both well within Monte-Carlo error √(0.25/480) ≈ 0.023.
• ·Min SRP-vs-violating gap when p | N stays at +0.527 across N ∈ {64, 128} (predicted +0.500). Conjecture C1 is not refuted at the largest reachable N on this kernel.
• ·Verdict: `consistent_but_residual_drift` — the closed form holds, and the apparent N=64 → N=128 drift is shot noise, not signal. The v0.2 `tension_persists_at_scale` reading was an artifact of comparing the violating branch to a uniform 1/p baseline instead of the gate-derived predictor.

Re-ran the G3 windowed sampler at N ∈ {16, 32, 64, 128} × p ∈ {2, 3, 5, 7} with two gate-derived predictors: √(N/p) (SRP improvement) and √N (naive birthday).

• ·Driver `quantum/nadarasa_g3_cost.py`: per cell, run the legacy cphase_on G3 kernel, post-select y mod p == 0, bootstrap first-collision query count on full y from the post-selected stream.
• ·Measured mean queries stays roughly flat (~2.2–3.1) across N ∈ {16..128} for every p, while √(N/p) grows from 1.5 to 8.0 and √N grows from 4.0 to 11.3. Worst flatness vs √(N/p) = 1.98; worst vs √N = 1.98.
• ·Verdict: `neither_curve_is_flat_quantitative_claim_only`. The SRP √(N/p) improvement is not visible in this surrogate, and the naive √N curve is wrong in the same direction.
• ·Root cause (from observed_support diagnostic): the modal projector collapses the post-QFT stream to 2–3 distinct y-values per slope, so first-collision floors at ~2 picks regardless of N. The per-rung Birthday-on-y metric is the wrong knob.
• ·GAP G3 ledger entry held at `empirically_under_pressure_naive_birthday` pending author review. Next G3 work item: re-run cost analysis on a kernel whose modal window has support that actually grows with N (e.g. two-coset combiner post-selected on residue 0).

Whole-book digest of Coecke & Kissinger, Picturing Quantum Processes (quantum/PQP_DIGEST.md). Five frontend/data artifacts land the alignment without touching kernel code.

• ·D · methodology citations: src/data/nadarasa/methodology-citations.ts anchors the v0.3 'predictor from gates' rule in Eq. 6.4 (doubling-Born), Cor. 8.35 + Thm 8.41 (spider fusion + dodo), Thm 9.128 + JPV/Ng–Wang (ZX completeness), Def 6.52 + Eq. 10.31 (causality), Ch. 13 (resource gaps), §12.2.3 vs §12.2.4 (Grover vs HSP).
• ·F · vocabulary map at /notes/pqp-vocabulary: 'modal projector' = classical post-selection on a bastard-spider output (Ch. 8 §8.3.3 + §8.4); 'predictor from gates' = spider fusion + doubling-Born; 'per-window √p' = wrong chapter (Grover not HSP).
• ·A · /nadarasa/g3-split retires single G3 entry into G3-grover (amplitude amplification, √-cost) and G3-hsp (Abelian HSP, log-cost). Ex. 12.22 forces the split.
• ·B · /nadarasa/g13 applies Thm 11.12 (Z₄-in-phase-group litmus) to G1 / G2-real / G12 phase sets. QFT cphase ladder forces Z₄ from n ≥ 3 → all kernels read quantum-like.
• ·C · /nadarasa/resources ships gate-derived spider count, T-count upper bound, CX and cphase counts per kernel (Ch. 13 local additive monotones). Certifies G2-real strictly above G1/G12/G3-cost on every monotone for n ≥ 3.
• ·E · PyZX / quizx adoption for §14.3-style conjecture synthesis remains scoped, not implemented — flagged as the gate to opening Ch. 14 properly.

Two new visualisation surfaces built on the v0.3.3 data: a phase-group atlas (generalises G13) and a Pareto frontier map (generalises the resource table). Both are coordinate systems, not new theorems.

• ·Track 1 · /nadarasa/atlas: each (kernel, n) plotted in (n, log₂|G|), coloured by cyclic order. All current kernels collapse onto a power-of-two ray — falsifier: program lacks non-Clifford / non-power-of-2 phase denominators.
• ·Track 3 · /nadarasa/frontier-map: kernels as points in (spider-count, T-count UB). G1/G12/G3-cost share the frontier point (diagrammatically identical); G2-real is strictly dominated on resources — its extra cost buys two-coset combination, not efficiency.
• ·Next swings (Tracks 2 + 4): bastard-spider rewriter for the modal-projector fragment, then conjecture-synthesis lite on top.

Promoted Tracks 2 + 4 from in-browser matrix oracles to shot-based equivalence proofs on the Selene emulator. New harness at quantum/pqp_frontier/ compiles 1-qubit @guppy kernels and verdicts at 4σ on the binomial-difference shot-noise band.

• ·Rules (5/5 PASS): F · spider fusion, I · identity removal, HH · Hadamard cancel, CC · colour change, B · bastard absorption (Z-basis-only by design — it's a classical post-measurement identity). Worst TV across 78 cells: 0.0664. Total: 70.5s on Selene.
• ·Conjectures (11/11 PASS): every Track-4 conjecture at maxLen=5 confirmed on shots. Worst TV across 198 cells: 0.0833. The rewriter has 11 GENUINE completeness gaps in the {H,S,T} 1-qubit fragment — not a TS-oracle bug. Total: 182.8s.
• ·Harness: tomography.py runs the standard 6 prep states × 3 measurement bases = 18 cells per pair, compiling fresh kernels per cell. Pass criterion |Pₐ(1)−P_B(1)| < 4·√(0.5/shots).
• ·Sub-agents: 2 spawned in parallel during build. (a) Trace G1 predictor pipeline — concrete file:line references for emit_qft_lines + predicted_concentration so the future kernel_equivalence track plugs in cleanly. (b) Lock down selene_run JSON schema — exhaustive required/optional field map; informed the decision to ship custom proof-card components rather than retrofitting the generic histogram view (the 18-cell heatmap is denser).
• ·Routes: /nadarasa/proofs/rules and /nadarasa/proofs/conjectures show every cell's |Pₐ−P_B| as a colour-coded bar against the 4σ threshold, with PQP-anchor citations for each rule.
• ·Next swing: kernel_equivalence.py — swap G1's full QFT cphase ladder for a rewriter-emitted Approximate QFT and confirm byte-identical predicted_concentration on the same coset. That's the headline supremacy step: rewriter output executes on Selene with no metric regression.
• ·DELIVERED (v0.3.4): kernel_equivalence.py shipped at /nadarasa/proofs/kernels. AQFT_k3 (5/6 cphase kept) PASS worst |Δ| = 0.0104, AQFT_k2 (3/6 kept) PASS 0.0246, AQFT_k1 (0/6 kept!) ALSO PASS 0.0296. Unexpected finding: the G1 predictor (concentration on y mod p) is INVARIANT under the entire QFT cphase ladder at N = 16 — the bit-reversal SWAPs + H gates alone deliver the LSBs the predictor cares about. The bastard rewriter is justified in stripping all 6 controlled-phase gates for this kernel; the resulting circuit is strictly cheaper and observationally identical on Selene shots. Falsifier did not trigger because the predictor isn't sensitive to high-frequency phase content here.

Converted the kernel-equivalence proof into a NISQ-fidelity claim. Ran a Selene depolarizing-noise sweep (p_1q ∈ {0, 0.005, 0.010, 0.020}, p_2q = 10× p_1q, p_meas = 2× p_1q) on G1's coset predictor for both the full QFT ladder and the rewriter-stripped AQFT_k1.

• ·Verdict PASS: AQFT_k1 (zero cphase) matches or beats QFT_full in 11/12 = 92% of noisy cells. Largest single-cell advantage 0.21 (p1q=0.010, p=4, srp). The rewriter's I-rule output isn't merely equivalent under ideal shots — under realistic depolarizing noise it is quantitatively better because the absent 2-qubit gates avoid decoherence on a kernel whose predictor doesn't need their phase content.
• ·Sub-agents: 2 spawned in parallel before build. (a) Scout Selene noise API — confirmed DepolarizingErrorModel(p_1q, p_2q, p_meas, p_init) is the production entry point in selene_sim, with IdealErrorModel() as the ideal-shot baseline. (b) Trace G1 N-parameterization — confirmed render_kernel + emit_qft_lines are already n-parametric; only the Ns / ps lists in nadarasa_g1.py's main need touching to push to N ∈ {32, 64}. Lays the foundation for the next swing.
• ·Route: /nadarasa/proofs/noise renders the full 12-cell comparison heatmap with per-cell winner badges and the raw 32-row measurement table.
• ·Next swings: (1) push to N ∈ {32, 64} with the same noise sweep — the gap should widen because the QFT ladder gains O(n²) more cphase gates while AQFT_k1 stays linear; (2) attack the 11 conjecture gaps as candidate rewrite-rule families.

Closed the bastard-rewriter's completeness story on both fragments our kernels live in. Track A: rule (N) Euler-normalisation replaces any single-qubit interior with canonical Z(γ)·X(β)·Z(α) via direct 2×2 decomposition. Track B: new 2-qubit oracle enumerates 3 905 sequences over {H⊗I, I⊗H, CZ, S⊗I, I⊗S} at maxLen 5, grouping by 4×4 unitary mod global phase. Track B-next: rule (M) seals the 2q residue with the canonicalised 4×4 unitary itself.

• ·Rule (N): 11/11 1q conjectures PROMOTED at maxLen 5. The 1q rewriter (F, I, HH, CC, B + N) is empirically complete on Clifford+T to length 5.
• ·2q oracle: 441 equivalence classes from 3 905 sequences, 105 open conjectures whose structural residues disagree, smallest at length 2.
• ·Rule (M): 105/105 PROMOTED. The 2q rewriter (structural + M) is empirically complete on Clifford+S over our generator set to length 5.
• ·Routes: /nadarasa/proofs/conjectures-2q lists every 2q conjecture with sequence chips, structural residue, and rule-(M) matrix key. /notes/v0-3-8-changelog post-mortems both tracks.
• ·Queued for v0.4.0: Selene 2q tomography (324-cell grid, 36 product inputs × 9 bases) to physically prove the top-10 shortest 2q conjectures; 2q noise sweep on a genuinely entangling kernel pair.

Turned rule (M)'s matrix-canonical verdict into physical proof. For each of the 10 shortest PROMOTED 2q conjectures, ran the shortest representative against a contrasting longer rep (different structural residue) through Selene's IdealErrorModel on a 108-cell tomography grid (36 product preps × ZZ/XX/YY) at 256 shots/cell. Added a resumable per-conjecture cache so the Selene job survives sandbox resets.

• ·Verdict: 10/10 PASS. Worst single-cell Δp across all 10 conjectures = 0.13, threshold 4·√(0.5/256) ≈ 0.1768. Total wall-time 105s after cache priming.
• ·Closes the v0.3.8 loop end-to-end: structural rewriter → matrix oracle (rule M, sound by construction) → physical shot statistics. The 2q rewriter is empirically complete on Clifford+S up to length 5, and that completeness survives measurement.
• ·Harness: quantum/pqp_frontier/tomography.py gained prove_equal_2q (108-cell 'diag' mode, 324-cell 'full' available); quantum/pqp_frontier/conjectures_2q.py drives the 10-conjecture run with per-conjecture cache files under _cache_2q_selene/.
• ·Route: /nadarasa/proofs/conjectures-2q-selene renders per-conjecture pass cards with sequence chips and worst-cell drill-downs. /notes/v0-4-0-changelog post-mortems the step.
• ·Deferred to v0.4.1: Step C-2q noise sweep on an entangling kernel pair (highest-CNOT-delta PROMOTED rule, depolarizing + leakage); frontier-map headline refresh.

Read 'Rendering Coherent Scattering via Quantum Collision Models' (Ferreira, Topel, Fromholz, Wootton — Moth Quantum, acks K. Meichanetzidis). Four hooks into the Nadarasa scaffolding plus one candidate new rewriter rule.

• ·Symmetry-constrained collision unitaries U = ⊕ₙ Uₙ commute with total excitation number — a conserved quantity the 2q rewriter does not yet exploit. Candidate rule (P): sector-canonical residue on the number-preserving sub-alphabet {CZ, S⊗I, I⊗S}. Sound by construction, cheaper than rule (M), orthogonal to it.
• ·External validation of our architecture: their pipeline is slow-quantum-sampler → multidimensional LUT → real-time shader. That is exactly Selene → JSON dump → React route. The decoupling is not a workaround, it is the production pattern.
• ·App. B: the full collision circuit collapses to the classical thin-film Airy summation in the single-photon sector — same shape as our AQFT_k1 vs QFT_full story (full quantum machinery → stripped classical kernel inside a conserved sector).
• ·24-qubit / depth-modest circuits explicitly flagged as future work for real hardware execution. A 2-mode collision unitary slots into our existing tomography harness; possible Selene-side smoke test ahead of their hardware demo.
• ·Landed as: /nadarasa/g14 (positioning card); v0.4.2 queue: rule (P) prototype + restricted-alphabet enumerator + third column on /nadarasa/proofs/conjectures-2q.

Re-ran the 10 shortest PROMOTED 2q identities under depolarizing and leakage noise on Selene. Pivoted the original 'noise-advantage' framing to 'soundness-under-noise' once the data showed max CZ-delta across all 105 PROMOTED rules is only 1 (length budget capped at 5) — the advantage story has no room. Soundness story is the cleaner extension of v0.4.0.

• ·Harness: extended quantum/pqp_frontier/tomography.py · prove_equal_2q with an optional error_model argument applied identically to both sides. New driver quantum/pqp_frontier/noise_2q.py sweeps 10 conjectures × 5 noise levels (ideal, depol p_1q ∈ {0.005, 0.010, 0.020}, leakage 0.005) with per-(conjecture, noise) cache under _cache_2q_noise/.
• ·Acceptance: ≥75% conjectures PASS at the worst noise level (p_1q = 0.020). Both sides experience the same channel, so a PASS at noise level p means the channel preserves the identity within 4·√(0.5/shots) ≈ 0.177 per cell.
• ·Route: /nadarasa/proofs/noise-2q renders the pass-rate matrix per noise level + per-conjecture worst-Δp heatmap. Degrades to a 'pending' banner when the Selene run hasn't completed yet (resumable cache makes incremental rendering trivial).
• ·Why pivot: 105 PROMOTED rules at maxLen 5 means every contrasting rep-pair differs by at most 1 CZ. The QFT_full vs AQFT_k1 advantage story needed length 15 with O(n²) cphase gates. The soundness story doesn't need a delta — it asks whether the channel preserves rule (M)'s verdict, which is a strictly more general claim.
• ·Queued v0.4.2: 2-mode beam-splitter collision unitary from Ferreira et al. as the particle-number-preserving smoke test before rule (P) lands in v0.4.3.

Read 'Learning to Prepare Molecular Ground States with Transformer Models' (ADAPT-GQE). A generative-AI pipeline that trains transformers on ADAPT-VQE reference circuits and refines the result with RL.

• ·ADAPT-GQE reduces circuit-generation time by an order of magnitude vs. ADAPT-VQE while matching or improving state-preparation accuracy.
• ·Transfer across molecular geometries: the model learns reusable structure from previously solved configurations, addressing ADAPT-VQE's inability to share work across related geometries.
• ·Demonstrated on imipramine, a tricyclic antidepressant — drug-scale, not toy chemistry.
• ·AI-generated circuits were executed on Quantinuum Helios-1, a milestone for generative quantum chemistry on hardware.
• ·Complements the QPDE ethylene track: QPDE is a measurement primitive for energy gaps; ADAPT-GQE is a circuit-synthesis primitive for state preparation.
• ·Landed as: /nadarasa/g15 (positioning card) and a new entry on /nadarasa/quantinuum-2026; v0.4.3 queue: concrete composition of generated subcircuits with the rule-(N/M/P) canonicalisation pipeline.

Reproduced the SoftBank/Quantinuum white-paper QPDE protocol on the 2-qubit ethylene pi/pi* active space in Guppy + Selene/Quest, with a 4x5 evolution-time x phase-kick sweep validated cell-by-cell against the closed-form interference law.

• ·Exact subspace propagator: H restricted to {|01>, |10>} is diag_avg*I + off*X, so exp(-i off t X) compiles to a single XX+YY rotation (CX / CRx / CX) — no Trotterisation needed at this size.
• ·Evolution-time trick applied literally: phi = k*pi/16 written as angle(k/16) halfturns. Writing angle(math.pi/16) would silently emit the S gate.
• ·20/20 cells PASS at the 4-sigma binomial threshold 4*sqrt(0.5/shots) = 0.0442 at 4096 shots; worst delta 0.0217.
• ·Eigenvalue gap recovered from the beta = pi/2 column: 0.8099 Ha against a 0.8000 Ha reference (error 0.0099 Ha).
• ·k = 8 held out of the fit as an aliasing control: 2*phi reaches pi, the signal goes stationary and every beta column collapses to 0.5 — the QPDE mod-1 wrap, visible rather than hidden.
• ·Ran under the gated-authoring protocol after the turn-rollback incidents: per-cell resumable cache under quantum/qpde/_cache_qpde/, .pydeps/ gitignored, static JSON shipped to the frontend.
• ·Landed as: /nadarasa/g16 + src/data/demos/qpde_ethylene_selene.json (quantum/qpde/{kernel,model,sweep,validate}.py).

Re-ran the G16 ethylene QPDE gap fit on Selene under a depolarizing ladder anchored on Quantinuum's published H2 error rates (p_2q = 1.29e-3, p_1q = 3.0e-5, p_meas = 1.35e-3) at 1x, 5x and 20x, plus an ideal control.

• ·Recovered gap degrades monotonically: 0.8327 Ha ideal, 0.7576 at 1x H2, 0.7246 at 5x, 0.5884 at 20x, against a 0.8000 Ha reference.
• ·Degradation is a systematic one-sided bias, not shot noise: depolarizing channels pull every probability toward 0.5, which compresses the estimated phase and underestimates the gap. More shots cannot remove it.
• ·The k = 4 cell (ideal p = 0 exactly) is a clean error canary: 0.0056 at 1x, 0.0259 at 5x, 0.0989 at 20x.
• ·At 1x H2 the fit sits within ~5% of reference, the same order as the shot-noise-limited ideal control, so published H2 rates are not the binding constraint at this depth.
• ·Between 5x and 20x is where ZNE or an encoded implementation stops being optional for this protocol.
• ·Caveat: Selene ships no coherent / T1-T2 memory model, so the slow-dephasing channel that dominates long idle windows on real traps is absent from this ladder.
• ·Landed as: /nadarasa/g17, driver quantum/qpde/noise.py, static dump src/data/demos/qpde_ethylene_noise.json.

Estimated normalised Laplacian propagator traces tr(exp(-i*Delta*tau))/N on Selene for a 1-WL-indistinguishable graph pair (C6 vs 2C3), then fitted the truncated Taylor series to recover spectral moments T_1..T_4.

• ·Both graphs have 6 vertices, 6 edges and an all-degree-2 colouring, so 1-WL refinement stabilises immediately and cannot separate them; their Laplacian spectra and moments from k = 3 upward differ (T_3 = 120 vs 108).
• ·Circuit: Laplacian padded to 8 dimensions, rescaled by lambda_max = 4, Pauli-decomposed into ~20 terms, Trotterised at 3 steps, read out by a Hadamard test on one ancilla + 3 system qubits.
• ·Trace sampled deterministically over all 8 computational basis states instead of a random purification — cheaper than an ancilla register at this size and removes state-preparation variance.
• ·Model-free verdict first: subtracting the two measured curves gives chi-square/dof = 110 over 24 points, with a single point at 23.9 sigma. The emulator separates the pair decisively.
• ·Per-moment verdict is weaker and reported as such: at fit order 8 the T_3 gap of 12 sits inside its own 5.7 error bar; at fit order 6 the truncation moves the discrepancy into T_4, where it reads 5.1 sigma.
• ·Conditioning lesson: for a Taylor-series moment fit the tau grid and truncation order dominate the variance far more than the shot count. Going from order 6 to order 8 roughly quadrupled sigma(T_3) at fixed shots.
• ·Cost lesson: 384 circuits x 4096 shots is ~30 minutes of emulator time, well past a single sandbox command; the per-circuit resumable cache made it survivable.
• ·Landed as: /nadarasa/g18, drivers quantum/tda/{dataset,moments,sweep}.py, static dump src/data/demos/tda_laplacian_moments.json.

Reading note on Leviatan et al. 2026 (arXiv:2607.24937): 74-qubit Floquet mixed-field Ising magnet on a heavy-hex lattice, mitigated with QESEM on IBM Heron r3 and corroborated on Quantinuum H2 / Helios.

• ·Floquet cycle: three colour-layers of ZZ rotations plus single-qubit X/Z rotations, producing long-lived subharmonic prethermal oscillations with period ~4x the drive.
• ·QESEM unifies PEC and ZNE within the same quasiprobability noise model; QESEM-Unbiased and QESEM-Extrapolated agree over their shared window, giving an internal consistency check.
• ·Validation hierarchy: noise-model calibration → two-mitigation-estimator agreement → classical comparison (exact / small TN / PEPS-BP / sparse Pauli-path) → cross-platform corroboration.
• ·Cross-platform agreement on Quantinuum H2 and Helios is the strongest reliability layer because it rules out platform-specific noise-model artefacts.
• ·Mapping to Nadarasa: G16 gives the exact baseline, G17 is the noise ladder + ZNE, G18 is the independent model-free check. Leviatan et al. scale the same pattern to 74 qubits and add a second independent estimator.
• ·Open frontier: running a Floquet cycle natively on Guppy/Selene to test whether the heavy-hex schedule translates to Quantinuum's all-to-all topology without depth blow-up.
• ·Landed as: /nadarasa/g19 and a new entry in src/data/nadarasa/quantinuum-2026.ts; no new Selene data generated.

Re-ran the 10 shortest PROMOTED 2q conjectures on Selene under 9 depolarizing and leakage noise levels, using the same 108-cell diag tomography as v0.4.0.

• ·Noise levels: ideal, depol_p005/010/020, depol_h2/5x/20x (H2-2 rates), leak_p005, leak_h2. Acceptance target: ≥75% conjectures PASS at depol_h2.
• ·90/90 cells PASS across all 9 levels. Mean worst Δp stays around 0.12, well below the 4σ binomial threshold 4*sqrt(0.5/256) ≈ 0.1768.
• ·H2-2 parameters anchored on published Quantinuum rates: p_2q = 1.29e-3, p_1q = 1.29e-4, p_meas = 1.35e-3, p_init = 0.0.
• ·Per-(conjecture, noise) cache under quantum/pqp_frontier/_cache_2q_noise/ made the run resumable across sandbox sessions; ~90 cells × ~100s ≈ 2.5h wall-time.
• ·Verdict: rule (M) is sound on noisy Selene shots — both sides of each identity A ≡ B experience the same channel, so the residual difference stays within the binomial envelope.
• ·Landed as: /nadarasa/proofs/noise-2q, driver quantum/pqp_frontier/noise_2q.py, static dump src/data/demos/pqp_frontier_noise_2q.json, and v0.4.4 changelog.
• ·Next gate: Floquet native port on Selene, closing the cross-platform corroboration gap from G19.

Ported the Leviatan et al. 2026 mixed-field Ising Floquet cycle to Guppy/Selene at n = 6, closing the cross-platform corroboration gap flagged in G19.

• ·Two lattices (1D chain, heavy-hex 6-cell), four kick imperfections eps ∈ {0.00, 0.04, 0.08, 0.12}, eight Floquet cycles, 512 shots per cell: 384 cells across an ideal control plus an H2 ladder at 1x/2x/5x/10x/20x.
• ·Exact-diagonalization baseline in quantum/floquet/model.py; unrolled Guppy cycle generator in kernel.py using rz/rx/cx with halfturn angle hygiene and measure_array readout.
• ·Ideal Selene matches ED on every cell: worst deviation 0.0495 against the 4σ shot-noise threshold 4*sqrt(0.5/512) ≈ 0.125.
• ·Subharmonic peak collapses with kick imperfection exactly as in the paper: chain 1.000 → 0.650, heavy-hex 1.000 → 0.836 as eps goes 0 → 0.12.
• ·Noise resilience: at published H2-2 rates the peak retains ≥93.8% of ideal height in every cell; at 20x it falls to 46-61%.
• ·Richardson ZNE over the five noisy rungs: quadratic fit recovers the ideal peak to ≤2.0% worst-case (0.03% best), always beating the linear fit and far beating the unmitigated 20x value.
• ·Corroboration is qualitative, not numerical — n = 6 over 8 cycles is classically simulable, and the depolarizing model is not a device-characterized quasiprobability model, so ZNE performance here is an upper bound.
• ·Landed as: /nadarasa/g20, drivers quantum/floquet/{model,kernel,sweep,noise,zne}.py, static dump src/data/demos/floquet_native_zne.json.