Draft v0.1 · Section 6 · [GAP G3] · Selene Emulator

Per-Window Cost
√p Improvement Check

Sweeps modal prime p ∈ {2, 3, 5} on Z₃₂ with SRP-class slopes. Each coset readout is treated as one sieve query; we measure the Birthday-style expected number of queries to a "useful collision" y₁ + y₂ ≡ 0 (mod 2p).

Per-rung surrogate · Not an end-to-end sieve. A single-rung Birthday count cannot validate the full Kuperberg sub-exponential exponent; it can only tell us whether the per-window cost moves in the direction the conjecture predicts.

What G3 claims

Under the SRP promise the y-distribution lives on an effective sub-lattice of size N/p, so per-rung Birthday queries should drop by a factor √p relative to the p = 2 anchor. The competing prediction is the naive Birthday curve √(p/2), where the query count grows with p instead. The plot below overlays both predicted curves on the observed ratios.

Observed vs predicted query-count ratio (anchor p = 2)

Results table

p	mean queries	observed ratio	SRP-curve prediction	naive-birthday prediction
2	2.68	1.000	1.000	1.000
3	3.14	1.172	0.816	1.225
5	3.10	1.158	0.632	1.581

Refutation verdict

Tension with the √p improvement heuristic

Worst deviation from SRP curve = 0.525 vs from naive-Birthday curve = 0.423. Observed query-count ratios track the naive Birthday curve more closely than the draft's 1/√(p/2) improvement. The per-rung √p win is not visible in this surrogate. As with G1 and G2 this is a wind-tunnel toy — it can reject a heuristic, not a theorem.

Kernel snippet

open in Playpond ↗


from quantum.nadarasa_g3_lib import guppy, qubit, h, measure, result, cphase_on

@guppy
def program() -> None:
    lbl = qubit()
    d0 = qubit()
    d1 = qubit()
    d2 = qubit()
    d3 = qubit()
    d4 = qubit()
    h(lbl)
    h(d0)
    h(d1)
    h(d2)
    h(d3)
    h(d4)
    cphase_on(lbl, d0, 0.39269908169872414)
    cphase_on(lbl, d1, 0.7853981633974483)
    cphase_on(lbl, d2, 1.5707963267948966)
    cphase_on(lbl, d3, -3.141592653589793)
    cphase_on(lbl, d4, 0.0)
    h(lbl)
    result("lbl", measure(lbl))
    h(d0)
    result("y0", measure(d0))
    h(d1)
    result("y1", measure(d1))
    h(d2)
    result("y2", measure(d2))
    h(d3)
    result("y3", measure(d3))
    h(d4)
    result("y4", measure(d4))

Kernel diff · G1 vs G3

Frontier card kernel-diff: the G1 and G3 Guppy kernels are nearly identical — the experiment lives almost entirely in the host post-processor. The diff below is rendered client-side from the kernel snippets in each demo JSON.

diff · G1 kernel_snippet → G3 kernel_snippet

22 equal · +13 -23 · 38% identical

   
- from quantum.nadarasa_g1_lib import (
-     guppy, qubit, h, cx, measure, result,
-     cphase_true_on,
- )
+ from quantum.nadarasa_g3_lib import guppy, qubit, h, measure, result, cphase_on
   
  @guppy
  def program() -> None:
      lbl = qubit()
      d0 = qubit()
      d1 = qubit()
      d2 = qubit()
      d3 = qubit()
+     d4 = qubit()
      h(lbl)
      h(d0)
      h(d1)
      h(d2)
      h(d3)
-     cphase_true_on(lbl, d0, 0.25)
-     cphase_true_on(lbl, d1, 0.5)
-     cphase_true_on(lbl, d2, -1.0)
-     cphase_true_on(lbl, d3, 0.0)
+     h(d4)
+     cphase_on(lbl, d0, 0.39269908169872414)
+     cphase_on(lbl, d1, 0.7853981633974483)
+     cphase_on(lbl, d2, 1.5707963267948966)
+     cphase_on(lbl, d3, -3.141592653589793)
+     cphase_on(lbl, d4, 0.0)
      h(lbl)
      result("lbl", measure(lbl))
-     h(d3)
-     cphase_true_on(d2, d3, 0.5)
-     cphase_true_on(d1, d3, 0.25)
-     cphase_true_on(d0, d3, 0.125)
-     h(d2)
-     cphase_true_on(d1, d2, 0.5)
-     cphase_true_on(d0, d2, 0.25)
-     h(d1)
-     cphase_true_on(d0, d1, 0.5)
      h(d0)
-     cx(d0, d3)
-     cx(d3, d0)
-     cx(d0, d3)
-     cx(d1, d2)
-     cx(d2, d1)
-     cx(d1, d2)
      result("y0", measure(d0))
+     h(d1)
      result("y1", measure(d1))
+     h(d2)
      result("y2", measure(d2))
+     h(d3)
      result("y3", measure(d3))
+     h(d4)
+     result("y4", measure(d4))

← Back to Draft v0.1 [G1] modal projection →[G2] two-window experiment →