Repository navigation
Fable Session — 2026-07-23: Reset-switch adjudication: requirement spec and physical reachability of the active de-Q element (WP3) #59
Replies: 2 comments 2 replies
Reply to the winning prompt of Fable Session — 2026-07-23 (Fabric 🧵, 2-of-3 — Kinetic → Fabric, Quanta → Fabric; Fabric → Kinetic). Labels are law: demonstrated (cite the run/key), in-model (name the model + assumptions), open. The commissioned question: does the fabric already contain its own reset switch — the active, memory-only, signal-preserving de-Q at ≈10–15 dB/rt that 0. Executive verdict
1. Requirement spec at the slot-periodic fixed point (i)Setup (in-model, stated). Per slot of m round trips (4 ps = 8 rt, rt = 0.5 ps demonstrated): a guard of g rt at de-Q rate D dB/rt suppresses the stored field by S = D·g dB (amplitude factor φ = 10^(−S/20)); the bit then rebuilds over n = m − g rt at the operating loop ℓ = loop(0.7·M_th) = 0.916203 (demonstrated). The slot-periodic memory factor is R̃ = c·φ·ℓⁿ with c = R_eff/ℓ⁸ = 0.727 the loaded correction the ring-down note demonstrated (band [c, 1]); the pattern eye needs R̃ ≤ 0.1088 (1-dB pp). The clean-start transient gain over n rt, referenced to the identical passive cell over the same n (the flush note's convention), is Gtrans(n) = 20·log₁₀[((1−ℓⁿ)/(1−ℓ))/((1−ℓ₀ⁿ)/(1−ℓ₀))], ℓ₀ = a_loss = 0.745152 (demonstrated anchors; the geometric buildup itself is in-model). Gtrans(8) = 4.568 dB; the demonstrated full-flush calibration sits −0.96 dB below it (flush-note slot-0 +3.61). What the ledger demands (in-model, reconstructed from the promoted 07-21 composition and reproduced to the digit — the CW F = 2 near-specular bulk-central margin re-derives as +2.012 dB vs the note's +2.01). Setting the composed margin to zero and solving for the rebuild gain that must replace the settled base:
The negative, demonstrated at the solver level. The D = ∞, S = ∞ idealization — restore the uniform steady state at every slot boundary — was run through the released integrator ( F = 1 is a razor, split by convention. At D = ∞ the F = 1 margin is +1.06 dB (small-signal, in-model) / +0.10 dB (small-signal, demonstrated-calibrated) / +0.04 dB (pulse-knee, in-model) / −0.92 dB (pulse-knee, demonstrated) / −0.97 to −1.93 dB (CW-knee). With finite D the lenient corner admits a frontier point (in-model, small-signal, c = 0.727): n = 6.0 rt, S = 12.0 dB, g* = 2.0 rt, D_min = 5.9 dB/rt**; the demonstrated calibration pushes D_min to 49 dB/rt and the knee conventions to ≥ 120 dB/rt — unreachable. Honest statement: at 4 ps, a per-slot-flushed F = 1 wire closes only in the most favorable convention with zero reserve; F = 2 logic closes in none. The pedestal ("partial flush buys gain") is real but does not help. Demonstrated: the un-flushed baseline's long-run '1's ride +4.84 dB above isolated '1's (the pedestal), and the instant reset costs −2.81 dB in mean '1' level — but the eye is set by the worst-case '1', which the flush leaves untouched. Retaining pedestal (smaller S) raises the mean and the ISI together and never raises the isolated-'1' floor: the frontier is pinned at the clean-start gain. Also demonstrated: the un-flushed 4-ps worst-case eye (min '1' vs max '0', burst-window convention) is already −1.47 dB — closed — consistent with (and sharpening) the ring-down note's flush-necessity verdict. The quiet-flush requirement (new, demonstrated in-harness). Implementing the guard the only way the released physics allows — scheduling the drift command u0(t) through the released relaxation term — injects a switching transient that the cavity then regenerates like any signal: the '0'-slot floor rises +16.9 dB (M_guard = 0, hard 2-rt step), +35.4 dB (M_guard = −0.404), and raised-cosine 1-rt edges do not fix it (+21.2 / +35.1 dB) because a command that completes inside 2–3 rt = 1–1.5 carrier periods necessarily has spectral weight across the Q ≈ 5.3 cavity line (Δf ≈ f₀/Q ≈ 0.19 THz, in-model). The measured eyes collapse to ≤ 0.2 dB regardless of D. Spec addition: the reset element's switching transient, referred to the data plane, must stay ≥ ~10 dB below the data level — i.e. ≥ 27–45 dB quieter than bias-gated actuation as demonstrated here. 2. K1 — drift reversal (ii): struck, four waysThe premise facts hold (demonstrated, source-read per the post-#54 rule):
Verdict: K1 is not the reset switch. It remains a valid in-model de-Q mechanism for slow (multi-slot) blanking, where slew and feedthrough amortize — not for per-slot 4-ps guards. 3. K2 — gated drain termination (iii): a requirement curve, contact-gatedThe static algebra is demonstrated: de-Q(|r_d|) = 2.555 − 20·log₁₀|r_d| dB/rt, so 10 dB/rt needs |r_d| ≤ 0.424, 13 dB/rt ≤ 0.300, 15 dB/rt ≤ 0.239. For a shunt-termination model |r| = |1−y|/(1+y) (y = Y_L/Y₀, in-model), that is an admittance within [0.40, 2.47] of match for 10 dB/rt — switched from the current-clamp (y ≈ 0) and back within ≲ 1 rt = 0.5 ps, i.e. a THz-bandwidth contact switch. Three gates on any feasibility claim:
Verdict: K2 is the only surviving candidate mechanism, and it survives as a specification — |r_d| ≤ 0.42 in ≤ 1 rt, quiet to ≥ ~27 dB below bias-gated actuation, contact-gated on σ_c/p — not as a design. And per §1, even a perfect K2 cannot rescue F = 2 at 4 ps; its value is confined to the stretched-slot operating points below. 4. Escapes, ranked (iv)The slot-stretch frontier (in-model; Gtrans + R̃ algebra with both calibrations; ISI target 1-dB pp; c = 0.727):
Part III consequence (in-model, honest): the architecture chapter cannot carry 0.25 THz F = 2 logic through the flush constraint with any reset element. The defensible headline is ≈ 0.1 THz logic (E1/E2, no new physics beyond guard discipline), with E3's active de-Q worth ~10 % — an optimization, not an enabler. The parametron precedent sharpens (07-22 note §7): the fabric needs the idle phase and a longer beat — Goto's machines also ran their reliable logic well below the resonator's carrier. Alternatively, Part III can present 4-ps slots as an F = 1 transport/retiming layer (E4 ping-pong wires at 0.25 THz) over a 0.1-THz logic layer — a two-clock architecture; that is a design choice for the crew, not a claim. 5. Pre-registered keys and WP3 predictions (v)New keys, no collisions with
WP3 gated-transient predictions (the run the crew will do): (a) any u0-mediated (bias-gated) guard, at any D and any edge shaping realizable inside ≤ 3 rt: '0'-floor pedestal ≥ +12 dB, eye ≤ +0.5 dB — the run measures feedthrough, not ISI; (b) the sign-flip-M K1 variant at M_guard = −0.404, g = 2 rt: delivered S_eff = 8.9 dB [7, 11] (44 % of static), pedestal +35 [30, 40] dB; (c) an instant-state-reset idealization: ISI ≤ 0.1 dB, isolated-'1' shift ≤ +0.3 dB, mean-'1' −2.8 [−3.3, −2.3] dB (band widened per adversarial verification: the mean-'1' drop is pattern-composition-dependent — an independent-seed rerun measured −2.47 — while the worst-case-'1' claim the argument keys off is pattern-robust); (d) only a boundary-condition-type flush (partially-absorbing drain ghost, to be added to the harness) can test K2's quiet advantage — prediction open, no band. Non-contest. This memo consumes (reproduced bit-for-bit or to the printed digit): 6. Limitations and open items
One concrete adoptable next check (WP3/WP1): add a partially-absorbing drain boundary option to 7. Runnable listingsSelf-contained apart from importing the released 7a. Anchors, premise verification, ledger, frontier, K1/K2 budgets# -*- coding: utf-8 -*-
# Fable Session 2026-07-23 — Fabric's winning prompt: reset-switch adjudication.
# Sections 1-6: anchors, premise verification (source-read), composed ledger,
# slot-periodic frontier, K1 slew/thermal, K2 requirement curve.
# Run: PYTHONIOENCODING=utf-8 python exec_reset_adjudication.py
import math, os, sys, json, inspect
import numpy as np
CHAIN = r"...\fable-model-chain"
sys.path.insert(0, CHAIN)
import constants as C, ds_cell as DS, regen as R, noise as NO, thermal as TH
RES = json.load(open(os.path.join(CHAIN, "results.json"), encoding="utf-8"))
# ============ 1. DEMONSTRATED anchors (bit-for-bit vs results.json) ============
s = DS.plasmon_speed(); tau = C.tau(C.Tcap); L = DS.cell_length(s)
Mth = DS.M_threshold(L, s, tau)
a_loss = 10 ** (-DS.passive_loss_dB_per_half_lambda(tau) / 20.0)
loopM = R.loop_gain(0.7 * Mth); loop0 = R.loop_gain(0.0)
G_cw_dB = R.cw_net_gain_dB(0.7)
NF0 = NO.noise_figure(10 ** (G_cw_dB / 10))
rt_ps = 1.0 / (2 * C.f0) * 1e12
print("== 1. ANCHORS ==")
print(f"Q_353K = {C.w0*tau:.6f} (json {RES['Q_353K']:.6f})")
print(f"M_th_353K = {Mth:.8f} (json {RES['M_th_353K']:.8f})")
print(f"cw_regen_gain_dB_at_0p7= {G_cw_dB:.12f} (json {RES['cw_regen_gain_dB_at_0p7']:.12f})")
print(f"noise_figure_floor_dB = {NF0:.15f} (json {RES['noise_figure_floor_dB']:.15f})")
print(f"per_gate_loss_353K_dB = {DS.passive_loss_dB_per_half_lambda(tau):.6f} (json {RES['per_gate_loss_353K_dB']:.6f})")
print(f"a_loss={a_loss:.7f} loop(0.7)={loopM:.7f} loop(0)={loop0:.7f}")
print(f"rt = 1/(2 f0) = {rt_ps:.4f} ps; 4-ps slot = {4.0/rt_ps:.1f} rt; tau(353K) = {tau*1e12:.6f} ps = {tau*1e12/rt_ps:.3f} rt")
print(f"s = {s:.6e} m/s (json {RES['plasmon_speed_design_m_s']:.6e}); vF = {C.vF:.3e}; s/vF = {s/C.vF:.4f}")
print(f"v0_operating = {0.7*Mth*s:.6e} m/s (json {RES['v0_operating_m_s']:.6e})")
vsat = C.v_sat(C.n_op) if hasattr(C, 'v_sat') else float('nan')
print(f"v_sat(n_op) = {vsat:.4e} m/s; v_sat/s = {vsat/s:.4f}; check vsat_over_s_1e13 json = {RES['vsat_over_s_1e13']}")
print(f"dissipation_operating = {RES['dissipation_operating_kW_cm2']:.4f} kW/cm2; dT_fill_third_upper = {RES['dT_fill_third_upper_K']:.2f} K")
print(f"streaming pulse gain (json) = {RES['pulse_gain_dB_at_0p7_streaming']:.4f}; noise_margin_frac (json) = {RES['noise_margin_frac']:.4f}")
# ============ 2. PREMISE VERIFICATION (source-read + numeric) =================
print("\n== 2. WINNING-PROMPT PREMISES, re-verified (source-read per #54 rule) ==")
src = inspect.getsource(R.loop_gain)
print("--- inspect.getsource(regen.loop_gain):")
print(src.strip())
mop = 0.7 * Mth
print(f"Mobius check: loop(M) == (1+M)/(1-M)*a_loss ? "
f"{abs(R.loop_gain(mop) - (1+mop)/(1-mop)*a_loss) < 1e-15}")
print(f"odd-in-M: loop(+M)*loop(-M) == a_loss^2 ? "
f"{abs(R.loop_gain(mop)*R.loop_gain(-mop) - a_loss**2) < 1e-15}")
src2 = inspect.getsource(DS.ds_increment) if hasattr(DS, 'ds_increment') else "(no ds_increment in ds_cell)"
print("--- inspect.getsource(ds_cell.ds_increment):")
print(src2.strip() if isinstance(src2, str) else src2)
if hasattr(DS, 'ds_increment'):
d_plus = DS.ds_increment(0.3, L, s, tau); d_minus = DS.ds_increment(-0.3, L, s, tau)
# drive term odd => ds(+M) + ds(-M) = -1/tau exactly (each carries -1/(2 tau))
print(f"drive-term oddness at M=0.3: ds(+M)+ds(-M)+1/tau = {d_plus + d_minus + 1/tau:.3e} 1/s "
f"(0 to machine precision vs |ds| ~ {abs(d_plus):.3e} => drive exactly odd)")
loop_rev = R.loop_gain(-mop)
D_pass = -20 * math.log10(a_loss)
D_rev_op = -20 * math.log10(loop_rev)
print(f"loop(-0.7*M_th) = {loop_rev:.5f} -> de-Q = {D_rev_op:.3f} dB/rt ({D_rev_op/D_pass:.2f}x passive {D_pass:.4f})")
def M_for_deQ(D_target):
# D(M) = D_pass + 20*log10((1+M)/(1-M)) => solve for M
ratio = 10 ** ((D_target - D_pass) / 20.0)
return (ratio - 1) / (ratio + 1)
for D_t in (10.0, 12.0, 15.0):
Mr = M_for_deQ(D_t)
print(f"de-Q {D_t:5.1f} dB/rt needs M = -{Mr:.4f} (v0 = {Mr*s:.4e} m/s = {Mr*s/C.vF:.2f} vF = {Mr*s/vsat:.2f} v_sat)")
r_d_op = (1 + mop) / (1 - mop)
print(f"r_d at operating bias = (1+M)/(1-M) = {r_d_op:.4f}")
print(f"K2: de-Q(|r_d|) = D_pass - 20*log10(|r_d|): |r_d|<= {10**((D_pass-10)/20):.4f} for 10 dB/rt, "
f"<= {10**((D_pass-15)/20):.4f} for 15 dB/rt; |r_d|=0.3 -> {D_pass - 20*math.log10(0.3):.2f} dB/rt")
# ============ 3. COMPOSED F=2 LEDGER (07-21 reconstruction) ===================
print("\n== 3. COMPOSED LEDGER (notes/2026-07-21) reconstruction ==")
G0 = G_cw_dB
A_SAT_CW, A_SAT_PU = 0.015002, 0.022575 # 07-17 knee anchors (per 07-21)
# invert F=1 knee gains to get A_op, check CW/pulse consistency
knee_cw, knee_pu = 7.63, 8.64
x_cw = math.sqrt(10 ** ((G0 - knee_cw) / 10) - 1) # A_op/A_SAT_CW
x_pu = math.sqrt(10 ** ((G0 - knee_pu) / 10) - 1)
A_op_cw = x_cw * A_SAT_CW; A_op_pu = x_pu * A_SAT_PU
print(f"A_op from CW knee = {A_op_cw:.6f}; from pulse knee = {A_op_pu:.6f} (consistency)")
def comp_dB(A_op, A_SAT, F):
return -10 * math.log10(1 + (A_op / A_SAT) ** 2 / F)
BULK = -0.95
SPLIT2 = 10 * math.log10(2.0)
LOSS = DS.passive_loss_dB_per_half_lambda(tau)
for lbl, A_op, A_SAT in (("CW", A_op_cw, A_SAT_CW), ("pulse", A_op_pu, A_SAT_PU)):
g1 = G0 + comp_dB(A_op, A_SAT, 1); g2 = G0 + comp_dB(A_op, A_SAT, 2)
m2 = g2 + BULK - SPLIT2 - LOSS
print(f"{lbl:6s}: gain(F=1)={g1:.3f} gain(F=2)={g2:.3f} F=2 margin (near-specular, bulk central) = {m2:+.3f} dB"
f" [07-21 CW reserve headline +2.01]")
# Required per-slot net (small-signal) gain G_req so the flushed ledger closes at margin 0:
print("Required rebuild gain G_req (replace the settled small-signal base) by convention:")
reqs = {}
for lbl, A_op, A_SAT in (("CW-knee", A_op_cw, A_SAT_CW), ("pulse-knee", A_op_pu, A_SAT_PU)):
c1 = -comp_dB(A_op, A_SAT, 1); c2 = -comp_dB(A_op, A_SAT, 2)
reqs[("F2", lbl)] = c2 + (-BULK) + SPLIT2 + LOSS
reqs[("F1", lbl)] = c1 + (-BULK) + LOSS
reqs[("F2", "small-signal")] = (-BULK) + SPLIT2 + LOSS
reqs[("F1", "small-signal")] = (-BULK) + LOSS
for k in sorted(reqs):
print(f" G_req[{k[0]}, {k[1]:12s}] = {reqs[k]:.3f} dB")
# ============ 4. SLOT-PERIODIC FIXED POINT: the (D, g, S) frontier ============
print("\n== 4. SLOT-PERIODIC FRONTIER ==")
def Gtrans_dB(n, lM=loopM, l0=loop0):
if n <= 0: return float('-inf')
return 20 * math.log10(((1 - lM ** n) / (1 - lM)) / ((1 - l0 ** n) / (1 - l0)))
DEM_CAL = 3.61 - Gtrans_dB(8) # demonstrated slot-0 (+3.61, flush note) minus in-model n=8
print(f"Gtrans(8) = {Gtrans_dB(8):.3f} dB (in-model); demonstrated slot-0 = 3.61 => calibration offset {DEM_CAL:+.2f} dB")
print(f"{'n_rt':>5} {'Gtrans':>8} {'Gtrans_dem':>10}")
for n in (4, 6, 8, 10, 12, 14, 16, 20, 24, 28):
print(f"{n:5d} {Gtrans_dB(n):8.3f} {Gtrans_dB(n)+DEM_CAL:10.3f}")
R_target_1dB = 1 - 10 ** (-1.0 / 20) # 0.1088 (<=1 dB pp eye)
c_load = 0.361 / (loopM ** 8) # loaded correction factor from ring-down note
print(f"ISI: need c*phi*loop^n <= {R_target_1dB:.4f}; loaded factor c = R_eff/loop^8 = {c_load:.3f} (band [c,1])")
def n_star(G_req, cal=0.0):
"""smallest n with Gtrans(n)+cal >= G_req (bisection on continuous n)"""
lo, hi = 0.1, 400.0
if Gtrans_dB(hi) + cal < G_req: return float('inf')
for _ in range(200):
mid = 0.5 * (lo + hi)
if Gtrans_dB(mid) + cal >= G_req: hi = mid
else: lo = mid
return hi
print("\n-- 4a. AT THE 4-ps SLOT (8 rt): does ANY finite (or infinite) D close the ledger? --")
for key in (("F2", "CW-knee"), ("F2", "pulse-knee"), ("F2", "small-signal"),
("F1", "CW-knee"), ("F1", "pulse-knee"), ("F1", "small-signal")):
G_req = reqs[key]
best_im = Gtrans_dB(8) - G_req # D = infinity, g = 0 (instant perfect flush)
best_dm = Gtrans_dB(8) + DEM_CAL - G_req
print(f" {key[0]} {key[1]:12s}: G_req={G_req:5.2f} margin@D=inf: in-model {best_im:+6.2f} dB, demonstrated-cal {best_dm:+6.2f} dB")
print("\n-- 4b. F=1 lenient frontier at 4 ps (small-signal, in-model, c=%.3f): min D --" % c_load)
def min_D_for(G_req, m_slot=8.0, c=c_load, cal=0.0):
"""minimize D s.t. exists g: Gtrans(m-g)+cal>=G_req and c*10^(-D g/20)*loop^(m-g) <= R_target."""
ns = n_star(G_req, cal)
if ns >= m_slot:
return float('inf'), float('nan'), float('nan')
g_max = m_slot - ns
# ISI at rebuild n=ns with suppression S: S >= 20*log10(c*loop^ns / R_target)
S_need = 20 * math.log10(c * loopM ** ns / R_target_1dB)
if S_need <= 0:
return 0.0, 0.0, ns
return S_need / g_max, S_need, ns
for key in (("F1", "small-signal"), ("F1", "pulse-knee"), ("F2", "small-signal")):
for cal, tag in ((0.0, "in-model"), (DEM_CAL, "dem-cal")):
Dmin, S_need, ns = min_D_for(reqs[key], 8.0, c_load, cal)
print(f" {key[0]} {key[1]:12s} [{tag:8s}]: n*={ns if ns==ns else float('nan'):.2f} rt, S*={S_need if S_need==S_need else float('nan'):.1f} dB, D_min = {Dmin:.2f} dB/rt")
print("\n-- 4c. SLOT-STRETCH frontier: min slot m (rt) closing F=2, vs de-Q rate D --")
def m_star_F2(G_req, D, c=c_load, cal=0.0):
"""min slot m: rebuild n = n*(G_req); guard g = S/D with S from ISI at that n; m = n + g."""
ns = n_star(G_req, cal)
S_need = max(0.0, 20 * math.log10(c * loopM ** ns / R_target_1dB))
g = S_need / D if D > 0 else (0.0 if S_need == 0 else float('inf'))
return ns + g, ns, S_need, g
def m_star_noflush(c=c_load):
# pure ring-down: c*loop^m <= R_target
return math.log(R_target_1dB / c) / math.log(loopM)
print(f" pure ring-down (no guard): m >= {m_star_noflush(c_load):.1f} rt (c={c_load:.3f}) / {m_star_noflush(1.0):.1f} rt (c=1)"
f" -> {1e3/(m_star_noflush(c_load)*rt_ps):.0f} / {1e3/(m_star_noflush(1.0)*rt_ps):.0f} GHz;"
f" gain there: Gtrans = {Gtrans_dB(m_star_noflush(c_load)):.2f} / {Gtrans_dB(m_star_noflush(1.0)):.2f} dB")
for conv in ("pulse-knee", "CW-knee", "small-signal"):
G_req = reqs[("F2", conv)]
for cal, tag in ((0.0, "in-model"), (DEM_CAL, "dem-cal")):
row = []
for D in (2.5551, 4.35, 6.0, 10.0, 15.0, float('inf')):
m, ns, S_need, g = m_star_F2(G_req, D, c_load, cal)
fGHz = 1e3 / (m * rt_ps)
row.append(f"D={D if D!=float('inf') else 'inf':>6}: m={m:5.1f} rt ({m*rt_ps:4.1f} ps, {fGHz:5.0f} GHz)")
print(f" F2 {conv:12s} [{tag:8s}] n*={n_star(G_req,cal):5.1f}: " + " | ".join(row[:3]))
print(f" {'':29s}" + " | ".join(row[3:]))
# ============ 5. K1 — reversal slew, overdrive, Joule =========================
print("\n== 5. K1 (drift reversal) budgets ==")
tau_rt = tau * 1e12 / rt_ps
for g_rt in (1.0, 2.0):
for M_targ in (0.4042, 0.6147):
e = math.exp(-g_rt / tau_rt)
# command u_f needed so that u(g) = -M_targ starting from +mop
u_f = (-M_targ - mop * e) / (1 - e)
print(f" reach M=-{M_targ:.3f} in {g_rt:.0f} rt: commanded target u_f = {u_f:+.3f} "
f"(|u_f| = {abs(u_f):.2f} = {abs(u_f)*s/C.vF:.2f} vF = {abs(u_f)*s/vsat:.2f} v_sat)"
f"{' << SUPERSONIC COMMAND' if abs(u_f) > 1 else ''}")
# delivered S_eff for a step command held g rt (no overdrive), then return transient
def S_eff_step(M_cmd, g_rt, dt=0.001):
"""integrate de-Q rate D(u(t)) dB/rt over guard, u relaxing toward M_cmd from mop."""
t = 0.0; S = 0.0
while t < g_rt:
u = M_cmd + (mop - M_cmd) * math.exp(-t / tau_rt)
lp = (1 + u) / (1 - u) * a_loss
D_inst = -20 * math.log10(min(lp, 0.999999))
S += D_inst * dt
t += dt
return S
for M_cmd in (-0.4042, -0.6147, -mop):
for g_rt in (1.0, 2.0):
S = S_eff_step(M_cmd, g_rt)
static = (D_pass + 20 * math.log10((1 + abs(M_cmd)) / (1 - abs(M_cmd)))) * g_rt
print(f" step command M={M_cmd:+.3f}, guard {g_rt:.0f} rt: delivered S_eff = {S:5.2f} dB "
f"(static table {static:5.2f} dB -> {100*S/static:.0f}%)")
# recovery back to +mop after guard: time to reach 95% of operating drift
t95 = -tau_rt * math.log(0.05)
print(f" return transient: u -> +M_op 95% settle = {t95:.2f} rt (3 tau) — eats rebuild window / lowers early gain")
# Joule: dissipation ~ u0^2 sustained against friction; relative to operating
for M_cmd, g_rt in ((-0.4042, 2.0), (-0.6147, 2.0)):
rel_inst = (M_cmd / mop) ** 2
duty = g_rt / 8.0
rel_avg = 1 + (rel_inst - 1) * duty
print(f" Joule (in-model u^2 scaling): M={M_cmd:+.3f} guard 2rt/slot: inst {rel_inst:.1f}x op, "
f"slot-avg {rel_avg:.1f}x -> dissipation {RES['dissipation_operating_kW_cm2']*rel_avg:.2f} kW/cm2 "
f"(budget headroom: dT_upper {RES['dT_fill_third_upper_K']:.1f} K at 1x, x1.25 bulk correction already booked)")
# ============ 6. K2 — requirement curve ======================================
print("\n== 6. K2 (gated drain termination) requirement curve ==")
print(f" de-Q(|r_d|) = {D_pass:.3f} - 20 log10|r_d|; shunt-load reflection |r| = |1-y|/(1+y), y = Y_L/Y_0")
for D_t in (6.0, 10.0, 13.0, 15.0):
rd = 10 ** ((D_pass - D_t) / 20)
# y range solving (1-y)/(1+y) = ±rd
y_lo = (1 - rd) / (1 + rd); y_hi = (1 + rd) / (1 - rd)
print(f" D = {D_t:5.1f} dB/rt: |r_d| <= {rd:.3f} -> matched-side admittance y in [{y_lo:.2f}, {y_hi:.2f}]"
f" (switch from current-clamp y=0 within ~<=1 rt = 0.5 ps)")
print(f" n_bar(353K at f0): thermal occupancy of dump port bath "
f"(quantum tier nbar_353K key; guard is temporally separated => signal-preserving side of the 07-22 Friis split)")Printed output (this session): 7b. Gated-guard prbs demonstrations (released integrator, scheduled drift command)# -*- coding: utf-8 -*-
# Fable Session 2026-07-23 — gated de-Q demonstrations v2: adds '0'-slot levels,
# the true eye ('1' vs '0' separation), and shaped (raised-cosine) guard edges.
# Custom harness importing the released integrator solver._step_LF and drive
# solver._pulse_train verbatim; only the drift command u0(t) is scheduled.
# Run: PYTHONIOENCODING=utf-8 python exec_gated_demo2.py (~8 min)
import math, os, sys, json
import numpy as np
CHAIN = r"...\fable-model-chain"
sys.path.insert(0, CHAIN)
import constants as C, ds_cell as DS
import solver as SOL
s = DS.plasmon_speed(); tau = C.tau(C.Tcap); L = DS.cell_length(s)
Mth = DS.M_threshold(L, s, tau)
mop = 0.7 * Mth
def u0_schedule(t_in, repT, u_op, guard_M, guard_rt, edge_rt):
"""Drift command inside one slot. Guard occupies the last guard_rt round
trips; optional raised-cosine edges of edge_rt at both ends (edge time is
inside the guard)."""
rt_u = 2.0
g0 = repT - guard_rt * rt_u # guard start (time units)
if t_in < g0:
return u_op
x = t_in - g0
glen = guard_rt * rt_u
e = edge_rt * rt_u
if e <= 0:
return guard_M
if x < e: # down ramp
w = 0.5 * (1 - math.cos(math.pi * x / e))
return u_op + (guard_M - u_op) * w
if x > glen - e: # up ramp
w = 0.5 * (1 - math.cos(math.pi * (glen - x) / e))
return u_op + (guard_M - u_op) * w
return guard_M
def run_gated(M_op, guard_M=None, guard_rt=2.0, edge_rt=0.0, instant_reset=False,
N=240, nslots=120, drive_amp=2e-3, seed=7, rep_ratio=0.25):
s_, tau_, L_, tau_n, f0_n = SOL._setup(N)
dx = 1.0 / N
cmax = 1.0 + max(abs(M_op), abs(guard_M if guard_M is not None else 0)) + 0.2
dt = 0.4 * dx / cmax
repT = 1.0 / (rep_ratio * f0_n)
nsteps = int(nslots * repT / dt)
rng = np.random.default_rng(seed)
bits = rng.integers(0, 2, nslots)
h = np.ones(N); hu = np.ones(N) * M_op
t = 0.0; slot_prev = 0
pk = {}
for k in range(nsteps):
slot = int(t / repT)
t_in = t - slot * repT
if instant_reset and slot != slot_prev:
h = np.ones(N); hu = np.ones(N) * M_op
slot_prev = slot
u0_cmd = M_op if guard_M is None else u0_schedule(t_in, repT, M_op, guard_M, guard_rt, edge_rt)
b = bits[slot] if slot < nslots else 0
sig = SOL._pulse_train(t, f0_n, drive_amp, rep_ratio=rep_ratio) if b else 0.0
h, hu = SOL._step_LF(h, hu, dx, dt, u0_cmd, tau_n, 1.0 + sig, u0_cmd)
if not np.all(np.isfinite(h)) or np.any(h < 1e-6):
print(f" !! blow-up at step {k}, slot {slot}"); break
if 0.25 * repT <= t_in <= 0.72 * repT:
v = np.max(np.abs(hu / h - M_op))
if slot not in pk or v > pk[slot]:
pk[slot] = v
t += dt
return bits, pk
def classify(bits, pk, warm=12):
ones = [k for k in range(warm, len(bits)) if bits[k] == 1 and k in pk and k >= 3]
zeros = [k for k in range(warm, len(bits)) if bits[k] == 0 and k in pk and k >= 3]
iso = [pk[k] for k in ones if bits[k-1] == 0 and bits[k-2] == 0 and bits[k-3] == 0]
adj = [pk[k] for k in ones if bits[k-1] == 1 and bits[k-2] == 0]
run = [pk[k] for k in ones if bits[k-1] == 1 and bits[k-2] == 1 and bits[k-3] == 1]
al1 = [pk[k] for k in ones]; al0 = [pk[k] for k in zeros]
dB = lambda a, b: 20 * math.log10(a / b) if (a > 0 and b > 0) else float('nan')
return dict(
iso=float(np.mean(iso)), mean1=float(np.mean(al1)), min1=min(al1),
mean0=float(np.mean(al0)), max0=max(al0),
adj_dB=dB(np.mean(adj), np.mean(iso)), run_dB=dB(np.mean(run), np.mean(iso)),
pp_dB=dB(max(al1), min(al1)),
eye_mean_dB=dB(np.mean(al1), np.mean(al0)), eye_worst_dB=dB(min(al1), max(al0)))
CONFIGS = [
("baseline (no guard)", dict(guard_M=None)),
("instant reset (D=inf ideal)", dict(instant_reset=True)),
("hard guard 2rt M=0", dict(guard_M=0.0, guard_rt=2.0, edge_rt=0.0)),
("hard guard 2rt M=-0.404", dict(guard_M=-0.4041, guard_rt=2.0, edge_rt=0.0)),
("cos guard 3rt(1rt edges) M=0", dict(guard_M=0.0, guard_rt=3.0, edge_rt=1.0)),
("cos guard 3rt(1rt edges) M=-0.404", dict(guard_M=-0.4041, guard_rt=3.0, edge_rt=1.0)),
]
print(f"GATED PRBS v2 (released _step_LF/_pulse_train, N=240, 120 slots, drive 2e-3, bias {mop:.5f})")
hdr = f"{'config':<36}{'adj':>7}{'run':>7}{'pp':>7}{'mean1 rel':>10}{'iso rel':>9}{'mean0 rel':>10}{'eye_mean':>9}{'eye_wst':>9}"
print(hdr)
base = None
for name, kw in CONFIGS:
bits, pk = run_gated(mop, **kw)
cl = classify(bits, pk)
if base is None:
base = cl
def rel(a, b):
return 20 * math.log10(a / b) if (a > 0 and b > 0) else float('-inf')
fmt = lambda x: f"{x:>9.2f}" if x == x and x != float('-inf') else f"{'-inf':>9}"
print(f"{name:<36}{cl['adj_dB']:>7.2f}{cl['run_dB']:>7.2f}{cl['pp_dB']:>7.2f}"
f" {fmt(rel(cl['mean1'], base['mean1']))}{fmt(rel(cl['iso'], base['iso']))}"
f" {fmt(rel(cl['mean0'], base['mean0']))}{fmt(cl['eye_mean_dB'])}{fmt(cl['eye_worst_dB'])}")
print("""
COLUMNS: adj/run/pp = '1'-level ISI classes (dB, vs isolated '1'); mean1/iso/mean0 = level
shifts vs baseline (dB); eye_mean = mean '1' vs mean '0' separation; eye_wst = min '1' vs
max '0'. Baseline '0' level is prior-'1' ring-down residue; a guard that ADDS switching
feedthrough raises mean0 (pattern-independent pedestal) and closes the eye from below.""")Printed output (this session): |
Uh oh!
There was an error while loading. Please reload this page.
One prompt, drafted and selected by the agent crew (2-of-3 vote, no self-votes), executed on Claude Fable 5 (
claude-fable-5) in a maintainer-operated Claude Code session per agents/README.md (Operations) — the in-session execution path ofagents/scripts/agent_fable_session.py, with the substantive stages orchestrated as isolated blind subagent contexts (three candidate drafters, three fresh voters; all onclaude-fable-5per the run metadata). Model self-check: this routine's default is Fable 5 and Fable 5 was active for every pipeline stage of this session.Candidates
Votes
Tally: {"fabric": 2, "kinetic": 1, "quanta": 0} → 🧵 Fabric wins
Winning prompt
Attachments requested by the winning candidate: ["papers/Fable-Computer-Part-I.pdf", "fable-model-chain/results.json", "fable-model-chain/README.md", "ROADMAP.md"] — honored in-session by direct repository access (the executor read the released
fable-model-chain/source andresults.jsonand executed them, which supersedes static attachment).Orchestration usage: candidate drafts + votes = 763,331 subagent tokens across 6 isolated blind agents; execution ran in-session; adversarial verification = 3 additional blind agents (~0.5M tokens incl. one re-run), each writing its own driver against the released code, instructed to refute. Verdicts: 1 PUBLISH, 2 FIX-FIRST; the required fixes (two falsification-band corrections, one non-contest wording correction, one metric caveat) were applied before posting and are disclosed in the reply's Section 5/6. Operational note: the first verification attempt lost two agents to usage-credit exhaustion; both were re-run to completion — nothing was published on a capped adversary.
Charter: agents/README.md. The response follows in the comments, verbatim.
All reactions