RDTvlokip PRO

Checked your arithmetic first, then the premise under it. The arithmetic holds. The premise doesn't, and the reason is a bug in my tour-54 script. Then I ran the event-aligned test you asked for, and it answers your question with a measurement instead of a bound. A second pass before sending found that I had measured only half of the unstable mode. The other half reverses a claim I was about to make.

Your arithmetic holds; the second row of your table is a different quantity

0.998963 x 0.001037            = 1.0359e-3     your 1.04e-3      ok
1.847767e-5 / 1.0359e-3        = 1.784e-2      your 1.78e-2      ok
-9.33e-3 - 8.30e-3             = -1.763e-2     your -1.76e-2     ok
1.426e-10 / 1.0e-7             = 1.43e-3       your ~1.4e-3      ok

But 0.998963 and 0.99999990 aren't the same variable. The first is e.loi()[3,10], the softmax over 27 messages, the real s3. The second comes from verifier_precommis_dipankar_delta0_controle.py, which computes s3 = torch.sigmoid(p_e[3, 10]), the sigmoid of the raw logit. In a softmax parametrization that quantity means nothing: it isn't invariant to shifting the row. Same bug on R4 = sigmoid(p_e[4,10]) * sigmoid(p_r[10,4]). Reproduced both tour-54 numbers bit for bit from a fresh trace (1.426e-10, R4 = 0.99856537), so there's no doubt about where they came from.

What delta=0 actually looks like, never measured before today:

               true s3          1-s3        s3(1-s3)   r[10,3]   r[10,4]   true R4   d3-dbar (X)
delta=0        0.9999999996     3.500e-10   3.50e-10   0.5000    0.5000    0.5000    25.0546
delta real     0.9989630570     1.037e-3    1.036e-3   0.2052    0.7948    0.7948    10.1285

So your saturation point is stronger than you stated. s3(1-s3) is 3.5e-10 at delta=0, not 1e-7, which is ~3,000,000x smaller than at real delta, not 10,000x. And the receiver at delta=0 sits at an exact 50/50 tie. True R4 is 0.5. The 0.9986 I reported in tour 54 was the same sigmoid bug.

Your conversion of 1.426e-10 is still a valid bound on something: the quantity measured has derivative 1e-7, so it bounds the raw-logit move d3 to ~1.4e-3. But that's d3 alone, not d3 - dbar, and it's measured against the mean of the window's first 100 steps, not a local baseline.

Why the two X values differ, since this sets everything below: both are the entropy-regularized equilibrium of row 3, X* = (1-delta) r[10,3] / beta. At real delta, 0.98697 x 0.20524 / 0.02 = 10.12832 against 10.12854 measured. At delta=0, 0.5 / 0.02 = 25.0 against 25.0546, still relaxing (linear drift -7.8e-7/step). The receiver closes the loop: log(r4/r3) = ((1+delta)s4 - (1-delta)s3)/beta = 1.354, so r4 = 0.7948. Iterating those two closed forms reproduces the real-delta state to every printed digit (1-s3 = 1.0369e-3, r3 = 0.20524, X = 10.12854). The 50/50 receiver tie at delta=0 pins X* = 25 and parks s3 at 1 - 3.5e-10. That's not a trajectory accident.

The event-aligned test: yes, it moves with every kick, 19,700x weaker

Ran it the way you set it up. Full step-by-step trace of rows 3/4 (emitter) and 10 (receiver), logits plus gradients plus Adam state, over [54000, 62000) at both deltas. Same event detection as tour 57, which reproduces the 16 and 15 events step for step and sign for sign. At each event, took the residual of X = d3 - dbar from a linear fit over quiet windows before and after ([p-240, p-60] and [p+150, p+240], which removes the slow drift). Then regressed that residual on the gap residual across the burst. 15 usable events per delta: the 16th at delta=0 (61978) runs off the end of the trace.

                                delta real                   delta=0
|X| at peak (median)            2.37e-2                      9.1e-7
slope X/gap across the burst    0.937  [0.9347, 0.9396]      4.75e-5  [4.35e-5, 4.79e-5]
|d_logit_r4| at peak (median)   1.136e-2                     1.148e-2
|d true R4| at peak (median)    3.71e-3                      5.74e-3

d3 - dbar moves with the kicks at delta=0: in phase, at every one of the 15 events. 14 of the 15 slopes fall within 1% of the median. The outlier (4.35e-5) is the weak edge detection at 55,002, where the gap only reaches 1.95e-3. It's a bound and not a zero, as you said. But it's ~19,700x weaker, not 12x. Same numbers with the exact gap G = logit_10 - logsumexp(others) instead of d3 - dbar, which matters because at delta=0 the 26 other messages aren't uniform (CV 2.4e-2 against 4e-11 at real delta). Slope 4.76e-5 there.

So tour 54's "the co-timing does not survive" was wrong as stated. It survives at 5e-5 relative amplitude. What was flat was a readout that couldn't have shown it.

Your 7.35x: worse than a bad sample point

The kick is the same size at both deltas. d_logit_r4 at the peak is 1.148e-2 vs 1.136e-2, a 1.01 ratio. You were right that the 7.35x came from sampling at 59,989. But it isn't a small kick read between big ones. There's no signal at 59,989 at all. The +1.504e-3 comes entirely from the interpolation's right endpoint: 61,000 sits 25 steps after the delta=0 burst at 60,975, where the r4 logit is still displaced by -3.0411e-3. Carried to 59,989 by the linear interpolation, that's 989/2000 x 3.0411e-3 = 1.5038e-3, against 1.5041e-3 published. Retracted. The true R4 kick is actually 1.55x larger at delta=0 (r3 r4 = 0.25 vs 0.163, a 1.53 ratio). That fits "optimizer-intrinsic" as you said.

What the kick is: Adam's edge of stability

The kick is a period-2 oscillation: the gap changes sign on every step, grows to ~4.4e-2 per step, and dies out in ~10 steps. Cohen et al. 2022 (arXiv:2207.14484, checked at the source): "For Adam with step size η and β₁ = 0.9, this stability threshold is 38/η", on the top eigenvalue of the preconditioned Hessian P^-1 H, P = diag(sqrt(v) + eps). The linearized Adam recursion for one mode, with S = lr lambda / (sqrt(v) + eps):

mu^2 + ((1 - b1) S - (1 + b1)) mu + b1 = 0
mu = -1 at S = 2(1+b1)/(1-b1) = 38;   below S = 37.974 the roots are complex with |mu| = sqrt(b1) exactly

S_gap is the preconditioned Rayleigh quotient along the gap direction. lambda_max is from eigh of the full 1458x1458 matrix lr P^-1/2 H P^-1/2:

delta=0     step 58680 (after a burst)   S_gap 32.4    sqrt(v r10[4]) 5.71e-7
            step 59000                   S_gap 37.3    dgap ~1e-9
            step ~59040                  S_gap crosses 38
            step 59123 (peak)            dgap 4.3e-2, sqrt(v) back up to 5.0e-7, then 5.4e-7
            step 59127                   S_gap 34.4, burst over
delta real  step 59480                   S_gap 36.7052   lambda_max 38.4605   eigenvector 95.15% gap + 4.85% row 3
            step 59520                   S_gap 37.4483   lambda_max 39.2368

Between bursts, the v-floor decay pushes the preconditioned sharpness up. Past 38 the period-2 mode grows, and the oscillation refills v and shuts itself off. That's Cohen et al.'s self-stabilization, in bursts rather than continuous. At delta=0 the unstable mode is 100.0% on the gap. At real delta it's a coupled mode, gap plus emitter row 3, and the gap alone never gets there first: at its rate of rise it would reach 38 around 59549, after the peak at 59540. The coupled mode is already at 38.46 by 59480. (A power iteration I ran first missed this. Warm-started, it got stuck on a cluster of row-5 modes near 38, and logged 37.99 at 59480 where the exact value is 38.46.)

Two halves of one mode

The coupling has an eigenvector half and an eigenvalue half. I first measured only the eigenvector, which is the slope. They come out differently, and your saturation factor plays a different role in each.

Eigenvector (the slope). At real delta, sqrt(v) on e3[10] is 1.9e-8, 190x above eps. Adam's step lr m / sqrt(v) is scale-invariant, so the s3(1-s3) riding on row 3's gradient cancels between m and sqrt(v). Row 3 takes the receiver's normalized step (m/sqrt(v): 0.42 vs 0.43). At delta=0, sqrt(v) is 9e-15, 11,000x below eps. The step becomes lr m / eps, linear in the gradient, and the saturation passes straight through. With u = sqrt(v) on e3[10], and each of the 26 other messages taking -1/26 of the gradient:

slope = 1/2 [ u/(u+eps) + (u/26)/(u/26+eps) ]
delta real (u = 1.88e-8):   0.937     measured 0.937
delta=0    (u = 9.2e-15):   4.78e-5   measured 4.75e-5

That also accounts for last round's unexplained dbar/d3 = 0.89. Predicted 0.8784/0.9947 = 0.883, measured 0.8848 over 15 bursts. Causal test, predictions pushed before reading (commit d54c143): Adam's eps changed on emitter row 3 only, as an exact per-row correction after opt.step():

delta=0      eps_row3   1e-10     1e-11     1e-12     1e-13     1e-14     0
             predicted  4.8e-5    4.8e-4    4.7e-3    4.4e-2    0.26      O(1)
             measured   4.78e-5   4.78e-4   4.75e-3   4.48e-2   0.265     0.68
delta real   eps_row3   1e-10     1e-9      1e-8      1e-7      1e-6      1e-5
             predicted  0.937     0.685     0.360     0.083     9.6e-3    9.8e-4
             measured   0.938     0.677     0.349     0.0785    8.96e-3   9.11e-4

Five decades, both directions. With eps removed on row 3 at delta=0, the slope goes from 4.8e-5 to 0.68 while s3 stays at 1 - 3.6e-10. But u in that formula is a proxy. Below the floor the law has no u in it:

slope_i = +/- G poids_i s_i(1-s_i) r3 r4,    G = 1.4652e7 (pinned on row 3 at delta=0)
row 4 at delta=0:      predicted -5.92e-7,  measured -5.53e-7 (14 of 15 events negative)
                       the u-formula gives +7.3e-5: v on e4[10] is background relaxation, not burst
sweep delta=0.002/0.004:  measured/predicted 1.008 / 0.999   (the u-formula: 1.036 / 1.025)

The ratio of two sub-floor rows at the same eps is eps-free. Row 4 over row 3 is −0.0116 measured, against s4(1-s4)/s3(1-s3) = 0.0125.

Eigenvalue (the timing). The coupled mode sits above the gap mode by

Delta S = slope * S_gap * kappa,     kappa = H(e3[10], r10[4]) / H(r10[4], r10[4]) = (1-delta) s3(1-s3) / beta

r3 r4 cancels, because H(r4,r4) = (beta/N) r3 r4 at the receiver's equilibrium (1.20829e-4 exact). At 59480 that gives 1.7581 against 1.7553 exact. At 59520 it gives 1.7937 against 1.7885. kappa = 0.051119. In the eigenvalue, the saturation is linear and eps plays no part. So my sentence "without eps, Adam would erase s3(1-s3) entirely" is true of the eigenvector only. And since S_gap rises at d ln S/dt = (1-beta2)/2 (the v-floor decay), row 3 brings the crossing forward by Delta t = 2 slope kappa / (1-beta2) = 96 steps. Tested by scaling row 3's Adam step by k from 59600:

                                      next burst peak     shift
real delta   k=1 (base)               59989
             k=0 (row 3 frozen)       60095               +106
             k=2                      59878               -111
delta=0      k=0, k=2                 59579               0
receiver beta2 = 0.998 from 59600     base 59802, frozen 59861     +59   (predicted 47.9; at 0.999: +106 vs 95.8)

At real delta, row 3 advances the receiver's burst by about a quarter of the cycle. Without it the burst comes ~100 steps later. Halving the v-decay time halves the delay, roughly: 106 goes to 59, not to 48. What's left over is additive, about 10.5 steps at both beta2. That fits row 3 also seeding the mode (a fixed number of growth steps saved), but it's a reading from two points. It bears on something I left unexplained last round, that the real-delta cycle runs shorter than the delta=0 one. The row-3 channel exists only at real delta, and with row 3 frozen the real-delta period stretches (518, 497, 481 against 445; that run wasn't mine). Whether it also explains the contraction of intervals within the window, I haven't checked.

My ablation log had the timing all along. Burst onsets ran 59981 → 60079 as eps3 went up, a 98-step shift, while the amplitude moved −7%/+8%. I read the amplitude, which is the one observable self-stabilization pins. I'd written "the coupling runs both ways, weakly". That's wrong: the amplitude feedback is weak, and the timing feedback is 24% of the cycle.

So on your saturation argument: it's right about what attenuates. In the eigenvector it acts through Adam's eps floor, not the readout. In the eigenvalue it acts directly and linearly.

What this does to the tour-54 claim

You said the sign does no work. It doesn't. Neither does the thing I credited in its place. Tour 54 said the reward asymmetry was the "transmission channel" that turns the receiver's move into a differential push on s3. That can't be the mechanism: dJ/ds[3,m] = poids[3] r[m,3] + (entropy), and poids[4] never appears. I ran a fixed-state weight swap to "test" it and got 1.0000000000. That's an identity of J. It couldn't have failed, so it isn't evidence, and I've withdrawn it as such. delta acts only through the state. It sets r[10,3], hence row 3's saturation X* = (1-delta) r[10,3]/beta, hence both halves of the mode.

How far: where the coupling switches on

The equilibrium closed form plus the scaling of u put the slope transition near delta 0.009. Predictions were pushed before the runs (commit 74b43cc). 12–13 bursts per delta:

delta    slope predicted   measured   final X / closed-form X*
0.002    6.6e-4            6.17e-4    22.46331 / 22.4633
0.004    7.5e-3            7.05e-3    19.98532 / 19.9853
0.006    6.8e-2            6.47e-2    17.61055 / 17.6106
0.008    0.31              0.301      15.37439 / 15.3744
0.010    0.59              0.586      13.29145 / 13.2915
0.012    0.85              0.850      11.29519 / 11.2952

The equilibrium holds to 5 digits at every delta. The 2–4% residual I had open here was in u, not the mechanism (see the sub-floor law above). The timing channel switches on later than the slope, since it follows s3(1-s3) itself, which grows 7.4x from 0.010 to 0.012. The rerun that located it (delays of about 0 at 0.010, +28 at 0.012, +106 at real delta) wasn't done with my own code, so read those as indicative.

Something the same instrument turned up: the "extra walls" aren't walls

Between bursts, the modes sitting near S = 38 are emitter row 5. That's referent 5, the "total non-convergence, H ≈ ln 27" row I reported two rounds ago as a possible high-dimensional saddle. Its most trivial reading turned out to be right. No message decodes to referent 5 (max_m r[m,5] = 6.3e-11, raw reward 8.6e-12). Its emitter row optimizes entropy only, so uniform is the optimum of that row. It isn't the optimum of the code, though. Moving referent 5 onto message 19 (a synonym of 8) and relaxing gains Delta J = 1/N - (beta/N)(ln 27 + ln 2) = 0.034082, predicted and measured to 6 digits. The orphan code is a strict local maximum: a trap, not a non-convergence.

What was left was the residual ln 27 - H = 8.07e-7. It's the same edge of stability, per coordinate. sqrt(v) self-stabilizes near lr h/38 - eps, with h = beta/(N K), the Hessian's eigenvalue on the zero-sum subspace. I first used the diagonal element and found the right one while chasing a residual. My eps test below, with predictions pushed before the run, separates the two out of sample: h predicts 2.47e-8, the diagonal predicts 1.63e-8, measured 2.505e-8. Since v = h^2 <(z - zbar)^2> there:

ln K - <H> = 1/2 c_K^2 (lr/38 - eps N K / beta)^2,    c_27 = 1.011,  c_2 = 1.08

c_K depends only on the block size. I checked it on my own pure quadratic toy (f = 1/2 h z^T (I - 11^T/K) z, exact Adam, no free parameter, 200k steps). K=2 gives z_rms/(lr/38 - eps/h) = 1.0801, K=27 gives 1.0116. The ingredient is the softmax's translation invariance, the -11^T/K term. Removed, a 27-block reportedly behaves like K=2, but I haven't rerun that ablation with my own code. My measured residuals were these constants all along: sqrt(v) measured/predicted is 1.011 on the orphan and 1.08 on the synonym pairs. It isn't "v refilled by bursts". The orphan doesn't fire in bursts at all. Its top mode stays above 38 almost all the time and is handed from one coordinate to the next.

                                          predicted (c=1)    measured
lr on row 5 x 1 / 0.5 / 0.25   <deficit>  8.61e-7 / 2.14e-7 / 5.29e-8     8.73e-7 / 2.20e-7 / 5.40e-8   (f^2 holds)
standard replay, eps=1e-8, rows 4 and 5   exactly uniform at 10k steps, edge regime from ~20k: sqrt(v) 2.639e-8 on both rows
eps on row 5 only: 3e-8  (lr h/eps = 45.7 > 38)   2.47e-8        2.505e-8
                   5e-8  (27.4 < 38)              0              5.9e-17  (float64 floor)
                   1e-7  (13.7 < 38)              0              4.6e-17

Above eps_c = lr beta / (38 N K) = 3.61e-8 the edge is unreachable and the orphan converges exactly. The synonym pairs (referents 8 and 12, two messages each, both decoding to them) follow the K=2 version: (p - 1/2)_rms = c_2 lr/76, measured 7.04e-4 and 6.94e-4. Their instantaneous |p - 1/2| swings over ten decades per cycle, so the "0.50000000024, balanced to machine precision" I reported for referent 12 was a snapshot between bursts.

One more correction, bigger than it looks. I wrote that a code with synonyms must have orphans. It must have referents with no decoded message, but those can be collisions instead, and a census over emitter rows can't see them. Seed 12345, k=3: three extra messages and three referents with nothing decoded (6, 16, 25). All three are collisions, on messages 3, 7 and 8, with the receiver at 0.500000/0.500000 and both senders at s = 1.000000. Seed 77777, k=1: one collision, message 14, referents 5/20, at 0.5/0.5. Each of those is your delta=0 mur 23, arising spontaneously. "Mur 23 is the only referential collision" holds for the 77777 k=3 code only.

What I haven't tested

The additive ~10.5-step offset in the timing shift. It shows up at both beta2 values, but I have no closed form. It's the right size for row 3 seeding the mode.

Where the timing channel settles. With row 3 frozen, the period stretches to 518, 497, 481 against 445, still relaxing after three cycles. That wasn't with my own code.

A closed form for c_K. I have the toy values and the ingredient, not the derivation.

The earlier non-monotonic beta2 result (periods 462/110/163). It may be a detector-threshold artifact: at beta2 = 0.99, the 0.0015 threshold keeps 66 of 477 pumping events. I haven't rerun it.

Your question, and one back

At the 16 delta=0 events, d3 - dbar moves with the kicks: in phase, step for step, at 4.75e-5 of the gap's move (15 usable events, 14 within 1% of that value). It isn't the level between kicks. Tour 54's "doesn't survive" is retracted. Your bound was right in kind. The measurement is 1,600x tighter than the bound. And the half that neither of us asked about, the timing, is where row 3 matters most.

delta_c = 0.013437 has been treated as a property of mur 23. The spontaneous collisions give two readings to choose between. If it belongs to the collision object (receiver at 0.5/0.5, both colliders at X* = 25), then weighting collider 14 against 6 on message 8 of seed 12345 k=3 breaks at 0.01344 ± 1%. If it belongs to the code around it, it moves, because the 25 rows that absorbed the mass in H13 are different rows there. Which way do you expect it to fall?

Scripts: tracer_mur23_lignes3_10_complet.py (full step trace), verifier_reponse_dipankar_tour58_evenements_alignes.py (event-aligned test, reproductions of the tour-54/56 numbers), verifier_reponse_dipankar_tour58_ablation_eps_ligne3.py (row-3 eps ablation), verifier_reponse_dipankar_tour58_balayage_delta_couplage.py (delta sweep), verifier_tour58_bord_stabilite_salve.py (edge of stability), verifier_tour58_audit_valeur_propre_et_timing.py (exact eigh, k test), verifier_tour58_beta2_recepteur_timing.py (beta2 test), verifier_tour58_referent5_orphelin.py, verifier_tour58_synonymes_8_12_bord_stabilite.py, verifier_tour58_audit_agent2.py (trap, collisions, toy), sauver_checkpoints_mur23_tour58.py (checkpoints, bit-identical resume).

Notebook: section "VRAIE CRITIQUE DE DIPANKARSARKAR, 23/09/2026 (tour 58, PAS simulée)".

Checked your math line by line before writing anything back. Both closed forms verified exact, not approximately close. Then chased your closing question and found a real bug in my own delta=0 numbers — not a subtle one.

Both rows, exact sigmoid, zero residual — conceded without reservation

Ran sigmoid on the raw logit gap for row 10, no linearization:

Row 10 (r4 vs r3, direct logit gap):
  pas=59,989:  dR exact sigmoid = -3.632578e-03   dR measured = -3.632578e-03   0.0000%
  pas=60,432:  dR exact sigmoid = -3.587504e-03   dR measured = -3.587504e-03   0.0000%

Zero to every printed digit. My 0.65% was linearization, full stop — you were right that the row needed no correction term at all, just the exact nonlinear form instead of the first-order Taylor approximation.

Row 3 took a second attempt. First pass at your ds3 = s3(1-s3)(d3 - dbar) gave 96% error — I'd dropped the multiplicity factor. Reducing a 27-way softmax to two outcomes when 26 entries sit at a shared value dbar isn't sigmoid(logit_10 - dbar); the 26 combine, so it's sigmoid(logit_10 - dbar - ln(26)). Fixed:

Row 3 (s3 vs dbar), with the ln(26) term:
  pas=59,989:  ds3 exact sigmoid = -1.847767e-05   ds3 measured = -1.847767e-05   0.0000%
  pas=60,432:  ds3 exact sigmoid = -1.881122e-05   ds3 measured = -1.881122e-05   0.0000%

Zero to every printed digit, both points. That 26 is the same K from H7 — third time it's shown up this month, always in the same role (the count of alternatives a saturated entry normalizes against).

My "row 3 needs the full 27-term sum" framing had the right number (0.88-0.90%, matching your 0.65%'s twin almost exactly) for the wrong reason. It never needed 27 terms. It needed dbar and the multiplicity factor — two numbers, not a sum over 26 separate contributions. Retracted, replaced with your version.

One thing I hadn't explained and should have: why row 10 never needed the ln(K) term row 3 did, when both have 25-27 "other" entries. Checked directly rather than leaving it as a coincidence:

row 10, pas=59,989: max logit among the 25 others = -20.046   logit_r3=5.880   logit_r4=7.212
combined probability mass of those 25 others = 2.618e-11   (r3+r4 = 0.999999999974)

row 3, pas=59,989: dbar (the 26 others' shared logit) = +8.3007e-3, comparable scale to logit_s3

Row 10's other 25 entries move a lot in raw logit (Σ|d_logit|=0.2221, already reported) but sit ~20 logit-units below the dominant pair — exp(-20) swallows any 0.01-scale movement regardless of precision, so they contribute nothing to the softmax's weighted sum no matter how much their logits shift. Row 3's 26 others sit at a scale comparable to the dominant entry, so their shared position (dbar) isn't negligible and the multiplicity factor is required. Not a structural property of "row 10 vs row 3" — an accident of where this specific point in training happens to have parked the other 25/26 entries. Could flip for a different wall if the buried entries were closer to the surface.

Your closing question found a bug, not just an open question

You asked whether the delta=0 kick I'd reported (+0.0030 on the gap) was the same event as the real-delta dip (-0.0221), pointed the other way, or a different event sharing the step.

Ran real event detection on the delta=0 trajectory instead of trusting the two pre-picked points — same method as the original kick characterization, grid-1, threshold, merge:

delta=0, detected events, [55000,62000):
  55002(-) 55424(+) 55890(+) 56350(-) 56806(-) 57260(+) 57730(-) 58194(+)
  58663(+) 59123(-) 59579(+) 60044(-) 60508(-) 60975(+) 61483(+) 61978(+)
  magnitude ~0.023 on the gap, period ~460-500 -- matches the established v-floor cycle exactly

gap value at exactly pas=59,989 and 60,432 (the points I published):
  pas=59,989:  -6.52e-07   (essentially zero)
  pas=60,432:  -6.57e-07   (essentially zero)

59,989 and 60,432 sit between two real delta=0 kicks (59,579 and 60,044), not on one. My +0.0030 was linear interpolation across a trough on a trajectory oscillating with ~8x larger amplitude than that number suggested — not a kick, noise from a bad sample point. Wrong number, published without checking it against real event detection first.

Checked the real-delta side the same way, since I'd never verified those points were genuine detections either — they are:

real delta, detected events, [55000,62000):
  55366(+) 55836(-) 56298(+) 56757(-) 57227(+) 57689(+) 58162(-) 58625(-)
  59087(+) 59540(+) 59989(-) 60432(-) 60871(+) 61312(+) 61768(+)

59,989 and 60,432 land exactly on real detected events here (-2.213426e-02, -2.186503e-02 — matches the published numbers, so that side was fine).

The actual answer to your question

Neither of the two readings you offered. The sign alternates through the whole sequence at both delta values, not just between them — real-delta shows +,-,+,-,+,+,-,-,+,+,-,-,+,+,+, delta=0 shows -,+,+,-,-,+,-,+,+,-,+,-,-,+,+,+. Landing on a - at 59,989/60,432 in the real-delta trace has nothing to do with the reward asymmetry — it's just where in an alternating sequence that step happened to fall. Same mechanism, same period, same rough magnitude, at both delta values.

Checked "essentially random" formally instead of eyeballing it — Wald-Wolfowitz runs test on both sign sequences: real-delta (15 events, 9+/6-) gives 9 runs against 8.2 expected under randomness, z=0.448; delta=0 (16 events, 9+/7-) gives 10 runs against 8.875 expected, z=0.592. Neither significant. Also checked the obvious alternative before ruling it out — a forced ringing pattern (kick up, mechanical rebound down, repeat) would push the consecutive-sign-flip rate toward 100%; measured 57% (real-delta) and 60% (delta=0), both statistically indistinguishable from the 50% a coin flip would give (binomial p=0.30-0.40). The sign of one kick doesn't predict the sign of the next beyond chance. n=15-16 per series is not large — this doesn't prove randomness, it fails to reject it, and a moderate real effect could hide at this sample size. What sets the sign of any individual kick isn't delta, and isn't simple alternation either — open question, not one I'm claiming to have closed.

Addendum, your open question answered

What sets the sign, since it's not delta and not forced alternation: chaotic sensitivity to initial conditions, not randomness. This system has no stochastic sampling anywhere in the objective (full expectation, no REINFORCE/Monte-Carlo) — "alternates essentially at random" can't be real randomness, it's a deterministic trajectory that looks random to a simple statistical test.

Control first — reran the baseline twice, bit-for-bit identical to 15 significant digits (-0.022134276174497147 both times at pas=59,989). Deterministic, not simulation noise. Then perturbed by amounts from 1e-15 (relative, on adam_eps) up to 1e-9 (absolute, on the row-10 logit at step 0):

baseline (no perturbation):        event at pas=59,989, sign NEGATIVE
adam_eps perturbed by 1e-15:       event at pas=59,891, sign POSITIVE
+1e-12 on r[10,4] at step 0:       event at pas=59,936, sign POSITIVE
-1e-12 on r[10,4] at step 0:       events at pas=59,838 and 60,273, both POSITIVE
+1e-9 on r[10,4] at step 0:        event at pas=60,169, sign POSITIVE

Every perturbation tested, down to 1e-15, flips both sign and timing. Magnitude stays consistent (~0.022-0.024, the same v-floor cycle amplitude already established) — only sign and exact timing are chaotically sensitive, not the mechanism itself.

Checked the obvious alternative before believing it — that this is just a phase shift, i.e. the perturbation moves timing enough that we're measuring a different, adjacent kick in the already-alternating sequence, not the same kick actually reversing. Aligned events by index across the whole [55000,61000) window instead of by proximity to pas=59,989, baseline vs three perturbations, 39 index-matched comparisons total: 19 same-sign, 20 flipped — 49%, indistinguishable from a coin flip. A real phase shift would predict something close to 0% or 100% (the whole sequence just translated, signs preserved or uniformly inverted). It doesn't. This is genuine divergence, not relabeling. Timing gap between same-index events also grows with elapsed cycles (69 steps near the start of the window, peaking ~164 mid-window) rather than staying constant — consistent with a positive Lyapunov exponent, not a detector artifact.

Also pushed the perturbation down to exactly 1 ULP — ulp(adam_eps)≈1.29e-26, ulp(r[10,4])≈8.88e-16, both still flip the kick. A sub-ULP perturbation (1e-16 on a value with ULP 8.88e-16) does nothing, as expected — floating point rounds it away, not a counterexample. No saturation floor found at any testable scale; the floor is float64 arithmetic itself, not a property of the mechanism.

One comparison worth being precise about: this isn't quite the same kind of chaos as the K=12.80 separatrix from the K-toy. K=12.80 is sensitivity along a parameter axis (independent runs at slightly different delta), and the project's own diagnostic on it flags that the classification there stays partly entangled with a detection-threshold artifact near a deliberately-constructed boundary. This is temporal divergence of neighboring trajectories under a single-step initial perturbation — standard butterfly-effect sense — and the kicks here sit ~30x above the detection threshold, no boundary-artifact ambiguity. If anything this is the cleaner demonstration of the two.

What I haven't tested

What actually determines the sign of an individual kick, if not delta and not forced alternation. Whether the ln(K) correction generalizes to the other three walls found this week (referents 5, 8, 12) or is specific to this row's near-degenerate structure.

One thing checked more precisely than "a few dozen steps later" — the phase drift between delta=0 and real-delta isn't a constant offset. Real-delta's inter-kick intervals contract over the window (~470 steps down to ~439-456, roughly 6-7%); delta=0's stay flat around 454-470 before jumping up near the end (495, 508). Two different behaviors, not one clock running slightly slow — that's what's producing the growing gap between the two event lists (+58 steps early in the window, +210 by the end), not a fixed period mismatch. Not explained, just measured more precisely than last round.

Given the sign is genuinely unresolved and alternates at both delta values — does dropping the "asymmetric reward as sign-setting channel" idea entirely change how you'd read the earlier co-timing result (kick survives at delta=0, s3 echo doesn't)? That finding was about whether a kick couples into s3 at all, not which direction it goes — does it still stand on its own once the sign question is separated out, or did the sign assumption do more work in that argument than I credited it for?

Scripts: verifier_reponse_dipankar_tour57_sigmoide_exacte.py (exact-sigmoid verification, both rows, the ln(K) bug and fix), verifier_reponse_dipankar_tour57_delta0_meme_evenement.py (real event detection on delta=0), verifier_reponse_dipankar_tour57_pattern_reel.py (same on real delta, for comparison).

Notebook: new section "VRAIE CRITIQUE DE DIPANKARSARKAR, 22/09/2026 (tour 57, PAS simulée)".

Ran your precommitted test. Your back-solved d3 prediction is wrong, sign and magnitude both — but what's actually there is cleaner than what either of us was chasing. Everything below is fresh, rerun this round, cross-checked by an independent agent in its own worktree before I wrote this.

H2, closed on your terms

Accepted without further test — your dR channel comparison (4.29e-17 via s[4,10] vs 1.80e-03 via r[10,4], 14 orders apart) is consistent with everything we'd already established (dR≈dr[10,4] to 12 significant digits on a real dip). Your per-step rate check on logit_s4 — I reran it independently from the same printed trace:

58,000->59,000   6.542e-06/step
59,000->59,989   6.494e-06
59,989->60,432   6.459e-06
60,432->61,000   6.436e-06
61,000->61,999   6.399e-06

Matches your five numbers to the digit. Strictly monotone, no reversal. s4 bystander, confirmed a second way.

Your precommitted test, run

logit_r[10,3] and the full row-10 vector, same run, same window as the 10-decimal trace:

pas=58000  logit_s3=4.3094661807  logit_s4=32.9623739824  logit_r4=7.2225388720  logit_r3=5.8687056176  s3=0.9989630570  R4=0.7947556118
pas=59000  logit_s3=4.3094897407  logit_s4=32.9689159854  logit_r4=7.2225707917  logit_r3=5.8687375356  s3=0.9989630570  R4=0.7947556121
pas=59989  logit_s3=4.3001332727  logit_s4=32.9753383652  logit_r4=7.2115356960  logit_r3=5.8798355339  s3=0.9989445735  R4=0.7911217224
pas=60432  logit_s3=4.2999653705  logit_s4=32.9781996290  logit_r4=7.2116842146  logit_r3=5.8797148171  s3=0.9989442374  R4=0.7911662096
pas=61000  logit_s3=4.3095375845  logit_s4=32.9818553984  logit_r4=7.2226254917  logit_r3=5.8688084907  s3=0.9989630452  R4=0.7947529606
pas=61999  logit_s3=4.3095662029  logit_s4=32.9882475232  logit_r4=7.2226644158  logit_r3=5.8688312931  s3=0.9989630569  R4=0.7947555903

Deviations against the linear baseline interpolated [59000,61000), same convention you used:

pas=59989:  d_logit_s3 = -9.380127e-03   d_logit_r3 = +1.106291e-02
pas=60432:  d_logit_s3 = -9.558626e-03   d_logit_r3 = +1.092648e-02

Your predicted d3 = -2.2642e-03 (59989) and -1.9603e-03 (60432). Measured d_logit_r[10,3] is +1.106291e-02 and +1.092648e-02 — wrong sign, ~5x wrong magnitude. Kill it as stated.

What's actually there instead of your sigma≈0.24

pas=59989:  d_logit_r4=-1.106214e-02   d_logit_r3=+1.106291e-02   ratio d_r3/d_r4 = -1.00007
pas=60432:  d_logit_r4=-1.092574e-02   d_logit_r3=+1.092648e-02   ratio d_r3/d_r4 = -1.00007

Not a small correction term. A near-exact mirror, both points, -1.00007 both times. sigma≈-rho, not sigma≈0.24.

Your formula, tested with the real numbers — overshoots worse than doing nothing

Fixed a unit bug in my own script before this was usable: first pass divided dR (probability) by d_logit_s3 (logit space) — caught it, redid it with ds3 in probability, consistent with how your own formula converts rho/sigma through R(1-R)/s3(1-s3).

pas=59989, |dR|/|ds3| (dR, ds3 both probability):
  measured directly on this excursion        = 196.59
  157.4623 * rho              (sigma=0)       = 185.70   (-5.6%)
  157.4623 * (rho - sigma)    (your formula)  = 371.41   (+88.9%)

Your formula, fed the real rho and sigma you asked me to measure, overshoots by 89%. Plain rho alone — the thing you were trying to correct — was already closer (-5.6%). Including sigma the way you combined it makes this worse, not better.

The closed form that actually closes it

dR ≈ R(1-R) * (dlogit_r4 - dlogit_r3)          NOT   R(1-R)/s3(1-s3) * (rho-sigma) * dlogit_s3

R(1-R)*(d_logit_r4 - d_logit_r3) = 0.1631199 * (-0.02212505) = -3.6090e-03
dR measured directly                                          = -3.632578e-03
gap                                                            = 0.65%

(d4-d3) is the right quantity — exactly what your closing question asked — but it belongs in the numerator against R(1-R) directly, not combined through ds3 via (rho-sigma). Checked the denominator side separately and it's where the rest of your gap was hiding:

s3(1-s3)*d_logit_s3 = -9.7166e-06
ds3(prob) measured directly = -1.847767e-05
factor = 1.90

s3 doesn't behave like a clean two-outcome sigmoid either — off by a factor of ~1.9, same shape of problem as r4 was. logit_s3 is one entry in a 27-way softmax over messages for referent 3, not referents. If it has the same kind of mirrored partner r4 had in r3, it's some other message j≠10 in the emitter's row 3, not yet measured. Precommitting this for next round: full row-3 emitter vector, same window.

Your delta=0 control — your prediction fails on the numbers, survives on the mechanism

delta=0, pas=59989:  d_logit_s3 = -6.07e-06   (already flat, tour 54: "max |ds3| over window: 1.426e-10")
                      d_logit_r4 = +1.504e-03   d_logit_r3 = -1.504e-03
                      rho = -247.65   sigma = +247.61

rho/sigma explode because ds3 collapses to noise at delta=0 — division by a vanishing denominator, not a regime change. Your literal prediction ("sigma collapses, rho stays") fails on these numbers because the ratio itself is ill-conditioned there, something we'd already told you (s3 stays flat through the kick at delta=0).

Used the well-conditioned version instead — d_logit_r3/d_logit_r4, no ds3 in the denominator:

                    delta real      delta=0
ratio d_r3/d_r4       -1.00007       -0.99982
|d_logit_r4|            0.01106       0.001504      (x7.35 smaller at delta=0)

The r3↔r4 mirror is delta-independent — survives at delta=0 at the same precision as delta≠0 — consistent with "the kick is optimizer-intrinsic" (tour 54, test 3). Its raw size drops 7.35x with no reward asymmetry, but the near-exact anti-correlation itself doesn't care about delta at all.

The one thing flagged as open — resolved before sending, not left for you to ask about

Row 10 has 25 other entries besides {3,4}. Their aggregate movement at delta≠0, pas=59989: Σ|d_logit_r[10,j]| = 0.2221, about 20x |d_r3| or |d_r4| individually (~0.011 each). Complicates the "row 10 ≈ {3,4}" assumption we've both been running with. Checked it rather than flag it and move on:

top-6 movers, delta real (referents):   {9,5,18,22,8,10}, each ≈ -0.0089 to -0.0093
top-6 movers, delta=0    (referents):   {9,5,18,22,8,10}, each ≈ -0.0097 to -0.0102

(Convention note: this section and the rho/sigma/closed-form sections above use different baselines — the row-10 breakdown here is a raw difference against pas=59000 alone, the earlier sections use the linear-interpolated [59000,61000) baseline. Each is internally consistent on its own comparison, doesn't affect any conclusion above, flagging it rather than leaving it implicit.)

Same referents, same order, delta=0 values slightly larger than delta≠0. That rules out a kick-caused mechanism — if these 25 entries were responding to the kick, they should move differently with vs. without it, and they don't; they move by comparable amounts whether the kick's asymmetric-reward channel exists or not. Reads as background Adam drift shared across the whole row (same step count, same bias-correction schedule, same eps, a small residual gradient sitting on otherwise-idle entries), not signal. Also notable, not asked: the per-entry average among those 25 (~0.0089) is the same order of magnitude as |d_r3|/|d_r4| individually — this isn't 25 negligible contributions summing to something visible, each one individually moves almost as much as the pair you're tracking. Makes "row 10 ≈ {3,4}" a rougher approximation than either of us assumed, even though it didn't break the (d4-d3) result above.

Addendum, run before you got the chance to ask for it

The row-3 emitter partner for s3, precommitted above — run. Not what I expected, and not the same shape as r3↔r4 at all.

pas=59989  d_logit_s[3,10] = -9.380127e-03
  ALL 26 other messages, min/max: 8.300733420022688e-03 / 8.300733420649742e-03
  (identical to 10 significant digits, CV = 2.628e-11)
  ratio mean(26) / d_logit_s[3,10] = -0.884928

No single mirror partner — corrected this from an earlier draft where I only printed a "top-6" by magnitude and mistook it for structure; an agent I had check this before sending pointed out (and I reproduced) that all 26 move together, not 6, and the top-6 ranking was floating-point noise ordering, nothing more. Not a two-entry reduction like row 10 — a near-uniform redistribution across the alternatives, consistent with s[3,10]≈0.9990 dominating so completely the other 26 sit at near-degenerate, near-equal tiny probabilities. Checked whether this degeneracy is frozen from initialization or a genuine training-time convergence — it's the latter, CV of the 26 decays monotonically from perturbation onward:

steps since +30 perturbation:   0        10       100      1000     5000     40000    59989
CV of the 26 probabilities:     2.126    2.001    1.601    1.231    0.741    0.393    ~0.000

Four orders of magnitude of step count, smooth monotonic decay to near-exact degeneracy — not a coincidence of initialization. This is the same K=26 signature as H7's toy (delta_c(K=26) matching the real system to 0.006%, established 20/09) — today's CV trajectory is the most direct dynamical confirmation of that "26 symmetric alternatives" assumption yet, not just a static snapshot match.

Ran the full 27-entry softmax Jacobian (ds3 = s3*(dlogit3 - Σ_j s_j*dlogit_j), sum over the whole row, not just message 10 against message 10's own complement) instead of the two-outcome reduction:

pas=59989:   ds3 measured        = -1.847767e-05
             full 27-entry sum   = -1.831514e-05   (0.88% off)
             two-outcome naive   = -9.716625e-06   (47.41% off)
pas=60432:   ds3 measured        = -1.881122e-05
             full 27-entry sum   = -1.864280e-05   (0.90% off)
             two-outcome naive   = -9.901553e-06   (47.36% off)

The ~1.9x factor wasn't a missing correction term the way r3 was for r4 — it was the two-outcome reduction itself being the wrong model for this row. s3's row doesn't reduce to a pair; it needed the full sum. Closes to under 1% once you stop pretending message 10 has one complement instead of 26.

What I haven't tested

Whether the 25-entry background drift in row 10 has its own closed form (a shared Adam schedule effect, not yet derived, just measured as "comparable with/without kick"). Whether the 0.65% residual on dR≈R(1-R)*(d4-d3) shrinks further if row 10's other 25 movers are included properly instead of dropped — same treatment as row 3 just got, not yet applied there.

Next experiment: the same 25-entry background-drift check on a window with no kick at all (not just delta=0, an actual quiet stretch), to get a clean per-step drift rate to subtract before re-testing whether row 10 reduces to {3,4} once that background is removed.

Given row 3 needed the full 27-entry sum and row 10 apparently didn't (the (d4-d3) two-entry reduction already closed to 0.65%) — is that difference itself expected from the shape of the two distributions (s3 at 0.999 vs R4 at 0.79, one much more saturated than the other), or is row 10's 0.65% residual hiding the same kind of full-sum correction row 3 needed, just smaller because R4 isn't as saturated?

Scripts: verifier_precommis_dipankar_sigma_row10.py (this round's full test — logit trace, rho/sigma at both baselines, the (d4-d3) closed form, the delta=0 control, the row-10 background-drift breakdown).

Notebook: new section "VRAIE CRITIQUE DE DIPANKARSARKAR, 21/09/2026 (tour 56, PAS simulée)".

Checked everything before writing back. Your bracket derivation is exact. Two of your three calls (H1, H3) converge with something we'd already found independently before this letter arrived. The third (H2's falsifiable prediction) is refuted hard, but the qualitative conclusion you were reaching for survives anyway, through a mechanism simpler than the one you proposed.

Your bracket, verified independently — exact

J(s3) = s3(1-s3) = 1.035925e-03
bracket (1-s)+(1-r), fixed s·r=R:  [0.205244, 0.217018]
predicted |dR|/|ds3|:              [157.46, 166.50]
your trace ratios:  step 60,000 = 147.69   step 160,000 = 145.56

All recomputed from scratch, matches your numbers exactly. The residual — measured ratios sitting 6–7% under your predicted floor — is real, not an arithmetic slip on your end.

H1: your correction was already sitting in our own notebook, independently, before this letter

You're right that my original argument was second-order (curvature) when it should have been first-order (the softmax Jacobian, p(1-p)). We'd already found this ourselves this round, the same way you did — an internal review caught the same error, precommitted a test (Δlogit_R4/Δlogit_s3 measured directly across a real excursion, not inferred from a snapshot), and got 0.985, near 1:1 in logit space. Adam equalizes the logit-space walk; the visible probability-space asymmetry is the Jacobian alone, comp¹, not comp². Same correction, same direction, found in parallel rather than in response to you. Credit where it's due: your version of the argument is cleaner — you derived the exact bracket range under the s·r=R constraint rather than just checking the ratio empirically, which is why you could also show the residual is real and quantify it, not just confirm the sign.

H3: dead, and dying for the same reason your H2 formula breaks

Agreed, dropped. Your read (147.7 vs 145.6, 1.4% apart — one mechanism with a sign flip, not two accidents) turns out to understate the case. We'd independently found, this same round, that the "two excursions" at step 60,000 and 160,000 aren't even the only two — full-Adam's R shows a recurring kick of near-constant amplitude (~0.0037, CV 5.6%) every ~460–500 steps, mechanism confirmed end-to-end: exp_avg_sq on the receiver's relevant coordinate decays toward a numerical floor during quiet steps, a small residual gradient triggers an oversized normalized step once the floor is close enough, the resulting gradient reinflates the second moment, the oscillation damps, and the cycle restarts. Verified: the decay phase, the pre-reinflation trigger timing, the reinflation itself, suppression by raising adam_eps to ~1e-6 (kills it entirely — 0/20,000 steps vs 29 at the default), and absence under the hybrid optimizer (0 events — no receiver-side v to collapse in the first place, since the receiver runs SGD there). Steps 60,000 and 160,000 are two arbitrary samples of this same recurring process, not two events at all. Your two-ratio argument and our six-part mechanism check point at the same thing from different directions.

H2: your falsifiable prediction — tested, refuted by seven orders of magnitude, and then the actual mechanism turned out simpler than either formula

You asked for s[4,10] and r[10,4] printed separately at the hybrid's settled point, predicting 1-s[4,10]≈6.12e-05, r[10,4]≈0.794805. Ran the full 400,000-step hybrid trace logging them apart:

pas=300,000 (your exact cited dip: R 0.7947556089 -> 0.7947549760):  s[4,10]=1.0000000000
FINAL:  s[4,10]=1.0000000000   r[10,4]=0.7947556073   1-s[4,10]=5.624390e-13

1-s[4,10] sits at 1e-12–3e-12 across the entire trajectory, including at the exact dip you cited — seven orders of magnitude past your prediction, and further from it than your own stated fallback (~0.89). Neither of your two scenarios is what happens.

Pushed further before writing this: the saturation predates the hybrid optimizer taking a single step. construire_mur23() adds +30 to the row-4 logit, then runs 40,000 steps of full Adam before the hybrid montage ever sees the state — 1-s[4,10] ≈ 26·exp(-30) ≈ 3e-11 from that perturbation alone. The system never passes through the regime your formula needs. Checked the consequence by the product rule rather than assuming it: dR = r·ds4 + s4·dr, and with s4 pinned, dR≈dr[10,4] to 12 significant digits on an actual dip event (dr=-2.141e-7, dR=-2.141e-7, identical). Your dr[10,4]=0 assumption is inverted — it's d(s[4,10])≈0 that holds, not dr=0. R is r[10,4] here, structurally, not asymptotically.

Your qualitative call — "R's whole shortfall is receiver-side" — survives. It's just not carried by an emitter-saturation channel the way your formula frames it.

One more piece, checked rather than assumed: s[3,10] and s[4,10] never appear in the same term of the objective — reward is additively separable per referent (Σ poids[i]·s[i,:]·r[:,i]). There is no mechanical channel by which a move in s[4,10] produces a move in s3. The only real structural coupling runs through the receiver's row 10, where r[10,3] and r[10,4] share one softmax normalization.

Your three precommitted tests — all run, not left for next round

1. Grid-1 through the true peak of the step-60,000 kick. [59,000, 61,000), every step, no subsampling:

s[4,10] range: [0.9999999999999951, 0.9999999999999953]
1-s[4,10]:     [4.663e-15, 4.885e-15]

Three orders of magnitude under your own 5e-12 reopening threshold. Your wrong-sampling-instant defense is closed, not weakened — this was the strongest version of it and it still doesn't survive contact with grid-1.

2. Bias-correction factor alongside s3/r4 in that window. Didn't need a rerun — (1-β1^t) and (1-β2^t) are deterministic in t alone:

t=60,000:  1-β1^t = 1.000000000000000   1-β2^t = 1.000000000000000

Both saturated to machine precision by step 60,000. The raw bias-correction envelope is flat there — it cannot be the shared beat. That rules out the first half of the disjunction your own agent-check raised, cleanly, not just weakens it. The ~460–500-step periodicity is downstream of the v-floor relaxation cycle itself (a self-sustained dynamical process), not an artifact of Adam's warm-up schedule, which was done saturating tens of thousands of steps earlier.

3. delta=0 control, same window. Full symmetry, no asymmetric reward at all:

baseline: s3=0.99999990  R4=0.99856537
max |ds3| over window:  1.426e-10   (flat — no co-dip, no kick, nothing)
max |dR4| over window:  1.738e-05   (one real event, pas=59,600: dR4=+3.720e-06,
                                       ~2 orders above the ~1e-8 background)

Splits your disjunction into a third answer, more precise than either branch: the v-floor kick on the receiver survives at delta=0 — same mechanism, optimizer-intrinsic, exactly as your test predicted it would if it's a real artifact independent of the reward asymmetry. But the co-timing with s3 does not survive — s3 stays completely flat through the same window where R4 kicks. The kick itself doesn't need delta; the transmission of that kick into a visible s3 echo does. Mechanism: at delta≠0, a kick in r[10,4] forces r[10,3] the opposite way through the shared softmax, and the asymmetric reward weight is what turns that receiver-side move into a differential push on s3's gradient. At delta=0 the same receiver-side kick still happens, but nothing downstream cares which way r[10,3] vs r[10,4] moved, so s3 never sees it. Not "shared beat" and not "coincidence" — the asymmetric reward is the transmission channel, and it's necessary for the correlation even though it's not the source of the kick.

Your quantization caveat — the exact logit trace, not just the promise of one

You flagged ds3 at six printed decimals carrying ~8% quantization noise. Logged logit_s3, logit_s[4,10], logit_r[10,4] at 10 decimals through the same step-60,000 window, full-Adam (not the hybrid):

pas=58,000  logit_s3=4.3094661807  logit_s4=32.9623739824  logit_r4=7.2225388720
pas=59,000  logit_s3=4.3094897407  logit_s4=32.9689159854  logit_r4=7.2225707917
pas=59,989  logit_s3=4.3001332727  logit_s4=32.9753383652  logit_r4=7.2115356960
pas=60,432  logit_s3=4.2999653705  logit_s4=32.9781996290  logit_r4=7.2116842146
pas=61,000  logit_s3=4.3095375845  logit_s4=32.9818553984  logit_r4=7.2226254917
pas=61,999  logit_s3=4.3095662029  logit_s4=32.9882475232  logit_r4=7.2226644158

logit_s4 rises smoothly and monotonically through the entire window — no kink at 59,989 or 60,432, nothing distinguishable from ordinary drift. logit_s3 and logit_r4 both dip at the same two steps and both recover by 61,000. In logit space, where quantization isn't an issue at this precision, the coupling is visibly s3↔r4, and s4 is a bystander. This is the same structural read the additive-separability argument above gives algebraically, now shown directly in the trace rather than inferred.

Your closing question, answered directly

Yes, I still had the trace — didn't need the 400k steps again. The Δlogit_R4/Δlogit_s3=0.985 result already in hand used r.p[0][10,4]'s own logit against s3's, which is r[10,4] not the s[4,10]/r[10,4] split your R=s·r formula needs; the new 10-decimal trace above fills that gap directly rather than reusing the old measurement as a stand-in.

What I haven't tested

Whether s3's sign-flip events (rises instead of falls, at least three in the trajectory we checked) share the same mechanism as the falling dips — the logit trace above is only one window, not checked across others yet. Haven't derived why the v-floor's steady-state amplitude lands at ~0.0037 specifically rather than some other constant — mechanism confirmed, magnitude not yet closed-form. Haven't derived the asymmetric-reward transmission mechanism (test 3, above) into a closed form either — described qualitatively, not yet written as an equation relating delta to the size of the s3 echo.

Given the kick is optimizer-intrinsic (survives delta=0) and the co-timing is reward-mediated (dies at delta=0): does that change what you'd want to defend from H2, or does "the emitter's Adam state acts through the step size, not through s[4,10] itself" turn into "the receiver's Adam state acts through r[10,4], and delta is what lets it leak into s3" — same shape of claim, different cell owning it?

Scripts: verifier_delta_logit_excursion.py (original Δlogit cross-check), verifier_split_s4_r4_hybride.py (hybrid s[4,10]/r[10,4] split), verifier_precommis_dipankar_grille1_s410.py (test 1), verifier_precommis_dipankar_delta0_controle.py (test 3), verifier_logits_s3_s4_r4_60000.py (the 10-decimal logit trace above), verifier_kicks_adam_grille_fine.py / verifier_mecanisme_plancher_v.py / verifier_eps_supprime_kicks.py / verifier_kicks_absents_hybride.py (the six-part v-floor mechanism check).

Notebook: new section "VRAIE CRITIQUE DE DIPANKARSARKAR, 20/09/2026 (tour 54)".

Checked all three before writing anything back. Two of your corrections hold and sharpen the reading; the third produced the test you asked for, and it refutes your own follow-on prediction — a cleaner localization than either of us had, for a reason neither of us expected.

H_momentum: your rescale reading is correct, and it's the better argument

Reproduced your arithmetic exactly:

R_init   k(b1=0.9)   k(b1=0)   ratio      global c=1.4389 residual
0.50       1.418      2.080    1.4669     +1.95%
0.60       1.586      2.316    1.4603     +1.49%
0.75       2.449      3.406    1.3908     -3.34%

                      beta1=0.9   beta1=0    change
k(0.75)/k(0.50)         1.7271     1.6375    -5.2%
spread / k(0.50)        0.7271     0.6375   -12.3%

Every number matches. My original framing ("the absolute spread grew, so momentum isn't the cause") was answering the wrong question — an absolute spread isn't invariant under a rescale, and beta1=0 behaves almost exactly like one: all three levels move by 39–47%, and the two scale-free statistics both shrink slightly instead of growing. H_momentum was correctly dead either way, but your version is the real argument: the shape of k(R) survives a 1.44× reclocking to within a few percent, which is a positive case for "intrinsic to the state" that "the gap grew" never was. Retracting the original framing, keeping the verdict, crediting the better reason to you.

beta2: you're right that one cell can't speak to state dependence — ran the cross

The original beta2 sweep was three values, all at R_init=0.60. That measures the level of k, not whether beta2 touches its R-dependence — no beta2 × R_init cross existed anywhere in that round, and I'd written "réfutée, dans le même sens que H_momentum" as if it had. Ran the two points you named:

R_init=0.75  beta2=0.99  flip=0.989714  k_fit=2.4357
R_init=0.50  beta2=0.99  flip=0.972195  k_fit=1.3971

k(0.75)/k(0.50) = 1.7434 against the beta1=0.9, beta2=0.999 baseline of 1.7271 — about a 1% shift. Your predicted outcome (another clock rescale, ratio within a couple of percent) is what happened, qualitatively. One caveat before you take the digit seriously: I reran this cross at a smaller bisection budget (15k steps / 2e-4 tolerance instead of the original 40k / 1e-5) to check reproducibility, and the flip points matched to 4-5 significant figures, but the shift itself moved from 0.94% to 1.14% — a ~20% relative change from budget alone. So the qualitative read (rescale, not a shape effect) holds, but don't treat "0.94%" as a precision measurement; it's "of order 1%, and that order is itself close to the bisection noise floor at this resolution." Both Adam hyperparameters now have a genuine same-shape, different-level signature under a real cross-test, not an assumed one — just not to the second decimal.

The hybrid comparison: you're right about the mismatch, and your own follow-on prediction is what breaks

Checked your reconstruction against the four printed rows first:

R dip:   0.7947556073 -> 0.7947549760 = 6.313e-07
s3 dip:  0.9989630573 -> 0.9989496174 = 1.344e-05

Matches. ~1e-5 against ~0.002 in my original text was comparing the hybrid's s3 dip to full Adam's R dip — different variables. Same-variable, it's R against R: full Adam's dip at the excursion I'd flagged earlier (0.794756 → 0.792799) is 1.957e-3; against the hybrid's 6.313e-7, that's ~3,100×, not 200×. The amplitude argument was never as clean as it looked, in either direction.

Your free test — if the hybrid's local slope (s3_dip/R_dip = 21.3) holds under full Adam, a 1.957e-3 R-dip should carry an s3 dip near 0.0417, s3 falling from ~0.9990 toward ~0.957 — didn't need new training, just the existing full-Adam trace re-read at its excursion steps. Reran it clean anyway (same construction, delta=0.013026615, both players on Adam, 400,000 steps, s3 and R logged together this time, every 20,000 steps):

step  20,000  R=0.794729  s3=0.998963
step  40,000  R=0.794756  s3=0.998963
step  60,000  R=0.792836  s3=0.998950   <- R excursion, dip 1.92e-3
step  80,000  R=0.794756  s3=0.998963
step 120,000  R=0.794805  s3=0.998963
step 160,000  R=0.797376  s3=0.998981   <- R excursion, +2.62e-3
step 260,000  R=0.794457  s3=0.998962
step 320,000  R=0.794738  s3=0.998963

s3 moves by 1e-5 to 2e-5 at every one of these — not the 0.04 your prediction called for, not remotely toward 0.957. Your own test is the one that answers the question: full Adam's excursions live almost entirely in R, not along the hybrid's (s3,R) direction at all. That's the cleaner localization you asked whether this would give, and it did — just not the way either of us expected going in. The hybrid isolates a real but apparently different, much smaller channel (Adam's second-moment state on the sender alone, carrying a small coupled excursion into both variables at a fixed ratio); full Adam's much larger excursions are a receiver-side phenomenon that the hybrid's SGD receiver can't show at all. Necessary-not-sufficient was your reading of the amplitude gap; this is sharper than that — the hybrid and full-Adam excursions aren't the same mechanism at two amplitudes, they look like two different mechanisms that happen to share the emitter's Adam state as a common ingredient.

Three hypotheses on why full Adam's excursion stays almost entirely in R, none tested yet

Standard: the receiver's own exp_avg_sq occasionally under-tracks a real, small, R-directed gradient fluctuation, and near the branch value the receiver's local sensitivity in R is simply much higher than the sender's local sensitivity in s3 — s3 is sitting near a saturated optimum (0.998963, matching H7's closed form) where its own second derivative is large and stiff, while R's own landscape near 0.794756 may be comparatively flat, so the same-sized Adam step-size fluctuation produces a much bigger visible move in R than in s3 by simple curvature mismatch, no separate "receiver-side mechanism" required.

Standard: the hybrid's SGD receiver, lacking Adam's own second-moment amplification, structurally cannot reproduce whatever the full-Adam receiver's adaptive state does — so the 21.3 slope measured under SGD is a property of that (non-adaptive) receiver's response curve, not a slope that should transfer to full Adam at all, making the precommitted prediction invalid by construction rather than by coincidence.

Non-standard: the full-Adam excursions are two distinct events, not one mechanism at two amplitudes — the step-60,000 dip and the step-160,000 rise have opposite signs and don't obviously share a cause; checking whether they correlate with anything in the receiver's own exp_avg_sq trace (the same diagnostic that found the wall latch and, separately, the original excursion hypothesis) would distinguish "one receiver-side mode, sign flips" from "two unrelated adaptive-state accidents."

Which of the three would your own read of the receiver's local curvature near 0.794756 rule out first?

Scripts: verifier_derive_k.py (beta2 cross), verifier_localisation_excursion_full_adam.py (full-Adam trace, s3 and R logged together). Independently re-verified before sending: full-Adam trace confirmed at a 10x finer grid by an agent (7 excursions found instead of 2, none approaching s3≈0.957); the beta2 cross's 0.94% figure was rerun at reduced bisection budget and moved to 1.14%, so treat it as "of order 1%, close to the bisection noise floor" rather than a precise digit — the qualitative rescale reading still holds.

Notebook §7.65/§7.66.

Verified your two-timescale system independently before trusting a single number from it, then ran the pin-and-falsify protocol and the SGD question in the order you gave them.

Your ODE, your k-table, and k* — all reproduced from scratch, not read off your printout

Integrated dx/dt = x_br(R)-x, dR/dt = k(R_br(x)-R) myself, Euler backward from the saddle along its stable direction:

k       my s3_flip@0.60      yours
0.50    0.912057             0.912058
0.75    0.953092             0.953092
1.00    0.967243             0.967244
1.50    0.978537             0.978537
2.00    0.983293             0.983293

k*: my R_min crosses zero between k=0.42 and k=0.43, landing at k=0.428762 (your value) to the digit.

Both exact, from the equations, not your printed table. Saved as verifier_ode_separatrice.py.

Your SGD question, answered directly

=== SGD pur, delta=0.013026615, 400,000 steps, lr=50 ===
step 0:       0.5060392864
step 20,000:  0.7862825715
step 40,000:  0.7862825715
...
step 380,000: 0.7862825715
final:        0.7862825715

Zero excursions. Flat to the tenth decimal from step 20,000 onward. This is the opposite of the Adam trajectory at the same delta, which sat mostly at 0.794756 with intermittent drops to ~0.7928 throughout the same 400,000 steps. Your reading is the one that survives: the excursions are specific to Adam, not a mode of the underlying flow that any optimizer would reveal — which argues for the second-moment-overshoot mechanism over a real low-frequency eigenmode of the linearized system. I'm not calling my own hypothesis dead outright (a real mode could in principle be suppressed by SGD's much larger effective step noise floor rather than absent), but the burden's moved to that reading now, not yours.

One thing this SGD run surfaced that neither of us asked about yet: it converges to 0.786283, not 0.794756. Your closed form's branch value at this delta is 0.794756 (verified against the Adam run, which matches it to seven digits) — SGD sits 0.0085 below that, stably, for 380,000 steps. Not noise, not slow drift: a different resting point. Flagging rather than explaining — likely a discretization bias from a finite step size on a stiff direction near the branch (SGD's fixed-step Euler doesn't have to land exactly on a continuous-time fixed point the way an infinitesimal-step method would), but I haven't derived it, and it's now on the list.

The pin-and-falsify protocol, run exactly as specified

Step 1 — bisect the flip point at R_init=0.60, delta=0.013:

s3=0.979619  (measured, bisection to 1e-5)

Step 2 — read k off your table / my independent fit: interpolating between your k=1.50 (0.978537) and k=2.00 (0.983293) rows, or fitting directly against my own ODE integration: k≈1.586.

Step 3 — falsify at R_init=0.75 and R_init=0.50, predicted from that one k:

predicted flip@0.75 = 0.987148     measured = 0.989740     diff = +0.0026
predicted flip@0.50 = 0.975765     measured = 0.972652     diff = -0.0031

Both predictions miss, in opposite directions — small, but real and outside anything I'd call noise given the 1e-5 bisection precision. Rather than call the protocol wrong, checked what k each point implies on its own:

R_init=0.75  ->  k = 2.449
R_init=0.60  ->  k = 1.586
R_init=0.50  ->  k = 1.418

k isn't one number — it drops by about 42% as R_init falls from 0.75 to 0.50. Your pin-one-falsify-two protocol did exactly its job: it didn't just measure k, it found that the model's central assumption (a single relaxation-rate ratio) doesn't hold across this range, and it did that with three cheap runs instead of a grid. Combined with the SGD result above, this is consistent with the same mechanism: if the excursions come from Adam's second moment adapting differently for the sender's and receiver's parameters depending on their recent gradient history, then the effective k an Adam-trained trajectory experiences isn't a constant of the system, it's a state-dependent quantity that a fixed-k ODE can only approximate locally — closer to exact near the point it was calibrated on (R=0.60, where it was fit) and drifting away from it elsewhere, exactly the shape of the three residuals above.

Where this leaves things — applying the full checklist rather than stopping at the numbers

OÙ (where does the state-dependence live): in the receiver's and the sender's separate exp_avg_sq accumulators, by your own excursion hypothesis — not yet directly measured, only inferred from the SGD contrast and the k drift.

COMBIEN (how much): k ranges roughly 1.4 to 2.5 over R_init ∈ [0.50, 0.75], a factor of ~1.7, large enough to explain a ±0.003 miss in s3 at the flip point but not enough to invalidate the separatrix picture itself — every prediction stayed within a few thousandths, not order-of-magnitude wrong.

JUSQU'OÙ (where the constant-k approximation stops being usable): untested outside R_init ∈ [0.50, 0.75]; round 1's own result (recovery from s3=0.90 at the natural, unforced tie state) and this round's forced R_init=0.50 run land close but not identically (worth resolving — the natural post-construction R reads ≈0.500009, not exactly 0.500000, and this system's sensitivity right at the symmetric point may be enough to matter; not yet checked directly).

DEPUIS QUAND (does the drift predate this test): the three-point Adam slowdown table from last round used a single delta throughout — never checked whether k's value at delta=0.010 (far from the fold) differs from k near delta=0.013422 (at the fold). If k itself depends on delta, not just on R_init, the whole separatrix picture needs a k(delta) surface, not a single number, before the slowdown coefficient (0.2212·√(δc−δ)) can be trusted at more than the three deltas it was fit to.

SUR COMBIEN (reproducibility): everything above is one seed, one pair (referents 3/4, delta≈0.013). Zero evidence yet that k's drift pattern, or its rough magnitude, generalizes to a different collision.

Three hypotheses on the k-drift, tested rather than left standing:

H_chemin (path/budget dependence) — refuted. If k's value were an artifact of exp_avg_sq not having stabilized within 40,000 steps, a much longer run should move it. Reran the R_init=0.50 flip point at 200,000 steps instead of 40,000:

budget=40,000   flip=0.972652  k_fit=1.4180
budget=200,000  flip=0.972652  k_fit=1.4180

Identical to four decimals. Not a convergence artifact — k at this point is a stable property of the state, not of how long training ran.

H_momentum (beta1 drives the drift) — refuted, and in the wrong direction. If momentum were carrying the spread, removing it (beta1=0, plain RMSprop-style Adam) should shrink the gap between k at R_init=0.75 and R_init=0.50. Reran all three flip points with beta1=0:

R_init=0.75  beta1=0  flip=0.991042  k_fit=3.406
R_init=0.60  beta1=0  flip=0.985081  k_fit=2.316
R_init=0.50  beta1=0  flip=0.981371  k_fit=2.080

spread k(0.75)-k(0.50), with momentum (beta1=0.9):    2.449 - 1.418 = 1.031
spread k(0.75)-k(0.50), without momentum (beta1=0):   3.406 - 2.080 = 1.326

The spread got bigger without momentum, not smaller. Every individual k shifted up (as expected — removing momentum changes the whole dynamics, not just the drift), but the R-dependence itself is not carried by beta1. That hypothesis is dead, cleanly, by the same test that would have vindicated it.

beta2 tested too, and it dies the same way. At R_init=0.60 fixed, three values of beta2:

beta2=0.99    k_fit=1.5676
beta2=0.999   k_fit=1.5859   (default, matches earlier baseline)
beta2=0.9999  k_fit=1.5883

A total spread of 0.02 across two orders of magnitude of 1-beta2 — tiny next to the ~1.03 spread k shows across R_init. Neither Adam hyperparameter, taken alone, explains the state-dependence.

What's left standing: k(R) is a genuine, budget-invariant, momentum-independent, second-moment-independent function of state. Three mechanisms refuted now, not one, and the remaining reading is the "standard" one from two rounds ago — a real state-dependent damping that isn't a tunable Adam knob at all, most likely living in the reduced 2-variable model itself being an incomplete projection of the full 27-referent system (the other 25 rows, shown load-bearing for delta_c and the collapse target back in round 49, may be load-bearing here too, untested directly).

Generalization to a second, independent collision — found the lost recipe, then tested

Everything so far rests on one pair (referents 3/4, an artificially-pushed tie). Found the exact recipe for a second, naturally-occurring tie documented back in round 30-31 but never saved to a script — default_rng(50000), referents 23/25, message 13 — by grepping this session's own transcript (same method as replay_idx5.py), verified against the published masses to the digit, and saved as replay_23_25.py.

Ran the identical prior-reweighting sweep on it:

baseline:      H(27-way) = 0.693148 ≈ ln 2  (natural tie confirmed, same signature as 3/4)
delta=0.010:   R = 0.731486                  <- identical to six digits vs referents 3/4
delta=0.013:   R = 0.794022, s23=0.999000161 <- identical vs referents 3/4
delta=0.020:   R = 1.000000, s23=0.037019523 ≈ 1/27  <- same collapse

Matches the referents-3/4 numbers to the digit, on a completely different pair, seed, and message, one artificially pushed and one entirely natural. Not a coincidence once you look at what H7's closed form actually contains: d3 = 26·exp(-N·poids[3]·r3/beta) never references which referents are involved, only N=27 and beta=0.02, which are fixed constants of this whole bench. The delta_c/collapse mechanism isn't a property of one collision — it's a property of the objective itself, shared by every tied pair regardless of how the tie was reached. Worth having confirmed rather than assumed.

Closing the SGD-branch-value question from earlier this round, on my own initiative

Left 0.786283 (SGD's resting value) against 0.794756 (the closed form's branch value) as an open flag. Chased it rather than leave it: checked whether it's a genuine, still-slowly-moving approach (fine-grained, every step, for 200 steps after the 390,000-step mark) or a true fixed point.

step 0 through 190 (every step logged): R[10,4] = 0.786282571470, unchanged to 12 digits
gradient norm at this point: 3.97e-12
s3 = 0.999999999665   s4 = 0.999999999997

A genuine zero-gradient fixed point, not a slow approach — and s3 sits at 0.999999999665, essentially identical to the pre-perturbation baseline (0.999999999666, the value before any delta-weighted training even started). Under plain SGD, referent 3's sender never moved at all. Its raw gradient near saturation is tiny by construction (the same softmax-saturation effect behind every deficit formula this round), and without Adam's per-parameter rescaling, lr=50 isn't enough to move it in 390,000 steps — while the receiver's own logit, starting from a live R=0.5 rather than a saturated state, has a large enough raw gradient to move freely. 0.786283 isn't a different point on the true coupled branch — it's what the receiver alone settles at given a sender that SGD effectively never trained, the same "frozen, worthless" signature this project has been finding under adam_eps floors since round 33, now reproduced by a completely different mechanism (no adaptive floor at all — just an under-powered raw gradient against a fixed step size). Which also means the SGD excursion-check from earlier in this round measured something slightly different from what it looked like it measured: a system where one player is effectively frozen throughout, not a genuine two-player race under SGD dynamics. The "zero excursions" result stands (a frozen sender obviously can't excurse), but it's weaker evidence for the Adam-second-moment hypothesis than it looked — a fairer SGD test would need a learning rate calibrated separately per parameter to actually move both players, which defeats the point of testing "plain SGD."

The hybrid-optimizer test, run to close the H15 question properly

Two failed SGD-rescaling attempts first, reported rather than hidden. Tried matching a single SGD learning rate for the sender to the receiver's, calibrated two ways: (1) against the whole emitter tensor's gradient norm — lr_e=1.5e5, moved s3 by 1.15e-11, nothing; (2) against the specific e.p[0][3,10] gradient alone — |grad|=8.65e-14, which would need lr_e≈1.4e11 applied to the whole tensor, dangerous (every other logit gets the same absurd step). Neither is a fair test of anything; abandoned rather than forced.

The actual fix: a hybrid optimizer — Adam on the emitter alone (so its own vanishing-and-growing gradient near saturation is handled the way it's handled everywhere else in this project), plain SGD on the receiver alone. This isolates exactly one thing: does the receiver need to be adaptive for excursions to appear, or does the sender's own Adam state carry them regardless of what the receiver does?

step 0:        R[10,4]=0.5060392864  s3=0.9999999997
step 20,000:   R[10,4]=0.7947555061  s3=0.9989623515
step 60,000:   R[10,4]=0.7947553911  s3=0.9989578477   <- excursion
step 300,000:  R[10,4]=0.7947549760  s3=0.9989496174   <- excursion, larger
final:         R[10,4]=0.7947556073  s3=0.9989630573

The sender genuinely trains this time (s3 settles at 0.998963, matching H7's closed-form deficit prediction, not frozen at the pre-perturbation baseline), R converges to the true branch value 0.794756 to six digits, not the frozen-sender artifact 0.786283 — and the excursions are still there, smaller than under full Adam (~1e-5 here against ~0.002 under both-Adam) but real, at the same rough locations (step 60,000 shows up in both this run and the original full-Adam trace).

This localizes the mechanism rather than just confirming it exists: the excursions survive with the receiver on plain, non-adaptive SGD, so they are not a receiver-side phenomenon. They are carried by the sender's own Adam second-moment state. H15 (Adam-second-moment artifact) is confirmed, more precisely than before — not "Adam causes excursions" in general, but specifically "the sender's own adaptive normalization near its saturation boundary does." The "mode propre du système linéarisé" alternative I'd proposed is now harder to sustain: a genuine dynamical mode of the coupled flow should show up regardless of which player's optimizer is adaptive, and it doesn't — it needs the sender's Adam state specifically.

Redoing the critical-slowdown test with the working optimizer

With a sender that actually trains, the earlier three-point slowdown test (which used pure SGD, sender frozen) needs redoing. Same protocol — three distances below delta_c, first step to reach 99% of the final value — with the hybrid optimizer:

CHECK_TOUS=200 (coarse):  760 -> 800, 880 -> 1000, 940 -> 1000   (values round to nearest 200)
CHECK_TOUS=20 (fine):     3% below: 760 steps
                          0.3% below: 880 steps  (ratio 1.158)
                          0.03% below: 940 steps  (ratio 1.068)

A real, monotonic increase appears at finer resolution — not flat, contradicting the earlier "no slowdown at all" reading — but far weaker than a clean (delta_c-delta)^{-1/2} law would predict. That law implies a √10 ≈ 3.16 multiplier per decade of distance; measured here it's 1.16 then 1.07. So the honest reading is neither "H6, no slowdown" nor "H11, no local signature at all" — there is a genuine, small critical-slowing signature once the sender is actually training and the measurement is fine enough to see it, but it's damped relative to the textbook 1-D saddle-node rate, plausibly because the sender's own slow direction is coupled to the receiver's much faster SGD dynamics rather than isolated. Leaving this as the honest intermediate result rather than forcing it toward either camp.

Not a new phenomenon — checked against the notebook before calling it one. This is the same finding as round 47 (REPONSE_ORDRE48.md, §7.60quinquies): SGD at 100× Adam's learning rate on idx5's wall left r[0,0] at exactly 0.000000 and 1-s[0,0] barely moving, with the same conclusion drawn then — "Adam's adaptive per-parameter scaling isn't standing in for a bigger step size, it's doing something SGD... can't reproduce." Two independent collisions (referents 3/4 here, idx5's referent 0 there), two independent perturbation setups, the same mechanism both times: a near-saturated sender's raw gradient is too small for any fixed-step SGD to move within a realistic budget, no matter the nominal learning rate. This strengthens the reading rather than just repeating it — it means the SGD-freezes-a-saturated-parameter result is a property of this objective's geometry near saturation, not an artifact of one specific run's step size or seed.

Scripts: verifier_pin_k.py, verifier_ode_separatrice.py, verifier_excursions_sgd.py, verifier_derive_k.py.

Notebook §7.65.

Verified your coupled system first, then ran your precommitted test. It took two tries, and the reason the first one failed is itself the answer to something neither of us had asked yet.

Your two equations, verified independently

delta   eq1 (logit(R)*beta)        eq2 (d3/(26(1-d3)))
0.010   0.0200435 vs 0.0200435     1.6885e-06 vs 1.6889e-06
0.012   0.0243192 vs 0.0243192     1.2431e-05 vs 1.2432e-05
0.013   0.0269868 vs 0.0269868     3.8492e-05 vs 3.8494e-05

Both equations match your published rows to five-plus digits, from your closed forms, not a refit. Taking the coupled system and the fold location as given.

Round 1 of your probe: run exactly as you framed it, and it found nothing

You wrote "initialize sender 3 there and vary it." Did exactly that — set s[3,10] directly to eight values from 0.995 down to 0.98, left everything else (including the receiver) at the standard construction's starting point, trained 40,000 steps at delta=0.013:

init s3=0.99500  ->  graded branch (0.999000)
init s3=0.99430  ->  graded branch   <- your predicted twin, exactly
init s3=0.99400  ->  graded branch
init s3=0.98000  ->  graded branch

Every single point climbed back to the graded branch, including well below your predicted twin. Not a fuzzy result, not noise — a clean, wrong-looking answer at every value tested.

Why, before assuming your math was off

The receiver in this run starts wherever the standard construction leaves it — at the tie, R≈0.5 — not at the value your two-equation system says the unstable point actually sits at. Your fold has a receiver coordinate too: solving your eq1 at d3=5.70024e-03 (the unstable root) gives logit(R)·beta = 2(0.013)+(0.987)(0.0057) = 0.031625, so R_unstable ≈ 0.8294, not 0.5. I'd perturbed one coordinate of a two-variable fixed point and left the other one sitting far off the manifold your equations describe. With R starting at 0.5 — well below the 0.829 the unstable branch needs — referent 3 is getting more reward credit than the unstable point specifies (reward to referent 3 scales with r3, and r3=0.5 at R=0.5 is bigger than r3=1-0.829=0.171 at the true unstable point), which hands referent 3 extra restoring pull before the entropy term can tip it — enough to drag even an s3=0.98 start back onto the stable branch. The probe wasn't testing your prediction; it was testing a different, easier-to-recover-from point that happens to share one coordinate with it.

Round 2: both coordinates on the manifold, and the threshold lands where you said it would

Set s[3,10] and the receiver's R[10,4] jointly to (0.994300, 0.829390) — your predicted unstable point — then perturbed only s3 away from it along that line, R held at the same 0.829390 start each time:

init s3=0.99500  R init=0.829390  ->  graded branch (0.999000)
init s3=0.99450  R init=0.829390  ->  graded branch
init s3=0.99430  R init=0.829390  ->  graded branch   (0.998989, essentially your twin itself)
init s3=0.99420  R init=0.829390  ->  COLLAPSE (0.037088, 1/27)
init s3=0.99400  R init=0.829390  ->  COLLAPSE
init s3=0.99000  R init=0.829390  ->  COLLAPSE
init s3=0.95000  R init=0.829390  ->  COLLAPSE
init s3=0.90000  R init=0.829390  ->  COLLAPSE

A clean, sharp flip between s3=0.99430 and s3=0.99420 — inside 1e-4 of your predicted 0.994300, exactly the criterion you named. Below the threshold, every point collapses to 1/27 regardless of how far below (0.90 behaves identically to 0.9942); above it, the graded branch is recovered even from 0.995. This is not a fractal or unpredictable boundary. It is the separatrix of a saddle-node, at the place your closed form put it.

Where this leaves the two hypotheses

You asked me to say why H11 is useful or not, rather than just report the number. It isn't, anymore, and here's the actual reason rather than just the verdict: H11 earned its place only because three things looked inconsistent with a saddle-node — no bending, no critical slowing, and a continuation failure. Your closed form now accounts for all three without needing a second mechanism: the bending was there, in the two-variable system, invisible in my one-variable reduction; the missing slowdown was a measurement artifact (my bisection window was wider than the distances I was probing, and my own SGD numbers show growing lag once compared to the branch value instead of the run's own endpoint); and the continuation failure is exactly what an annihilated fixed point does to any initial condition, including one sitting on the branch a moment before. A hypothesis stays alive only as long as it explains something the leading candidate can't, and H11 has nothing left to explain that H6 — correctly derived — doesn't already account for more precisely, including now the one place I could think of where the two would have actually disagreed. I'm calling it dead, not shelved.

The why-under-the-why: what round 1's failure says about the basin, not just about my mistake

Round 1 isn't just a corrected methodology — it's a real measurement of something neither of us named yet: the graded branch's basin, projected onto the s3 axis alone with R unconstrained, is enormous — at least down to s3=0.98 with R starting at 0.5. The basin is only narrow along the specific direction your fold analysis describes (the line through the unstable point in the full (s3,R) plane); it's wide open in other directions through the same region of s3-space. That's worth having on record as a real 2-D map of the basin, not just a footnote explaining why round 1 came back clean: the separatrix isn't a wall the trajectory has to get past everywhere near 0.9943, it's a thin ridge, and round 1 shows how much of the surrounding volume isn't anywhere near it.

Two hypotheses on the ridge itself, before either is tested

Standard: the separatrix's location in the s3-only slice (if R is left free rather than fixed) is itself a curve, not a point — round 1's flat "always graded" result is degenerate because I never varied R's starting point there; a 2-D sweep over both initial s3 and initial R should trace out the actual separatrix curve in the plane, of which my two rounds sampled exactly two points (one off it entirely, one on it).

Non-standard: the ridge's width in the transverse direction (perpendicular to the s3 line, i.e. how far off the manifold R can start and still show the sharp flip) should itself shrink to zero as the starting point moves away from the true saddle along the stable/unstable manifold, the same way the fold's own gap shrinks toward delta_c — testable by repeating round 2's sweep at a few R starting values between 0.5 and 0.829 and checking whether the flip point drifts smoothly toward round 1's "never collapses" result, or vanishes abruptly.

Which of those matches what your own closed form would draw for the separatrix?

One more thing, found by checking whether you'd gotten anything wrong rather than only checking myself

You flagged that my "3% below" Adam row (R_final=0.792836) didn't match your branch-value reverse-solve — it corresponds to delta=0.012955853, not the 0.013026615 I claimed to have used. I went to find out which of us had the number wrong. Neither, and the actual answer is more interesting than a typo.

Re-ran the exact same cell (delta=0.013026615, identical code path) to 400,000 steps instead of 60,000, logging every 20,000:

step        R[10,4]
 20,000     0.794794
 40,000     0.794756
 60,000     0.795968   <- a different excursion from the one I originally reported
 80,000     0.794756
100,000     0.794756
120,000     0.794733
140,000     0.794756
160,000     0.792799   <- this is where my original 0.792836 came from
180,000     0.794756
...
380,000     0.794756

The trajectory isn't slowly converging — it's sitting on the branch value your closed form predicts (0.794756) almost everywhere, with intermittent, brief excursions down to the same ~0.7928 region my flagged row happened to land on. My original run sampled at exactly step=60,000 and caught one of these excursions; it wasn't a slow approach that hadn't finished, it was a single frame of something oscillating. This means the row you flagged wasn't measuring what either of us assumed: not the converged branch value (my claim), and not a monotonically-growing shortfall toward the fold (your reading of "the criterion is self-normalizing" as evidence of slowing). It's a noisy readout landing on an excursion.

This also means my whole three-point slowdown table needs to be rebuilt — every one of those numbers is a single snapshot at a fixed step count, and I now have direct evidence that a single snapshot can misread the branch value by nearly 0.002 depending on where an intermittent excursion happens to fall. Whatever the slowdown test shows once redone properly, it has to be built from a value averaged over a window or read only once the trajectory has visibly settled inside its own noise floor, not a bare snapshot at a round step count.

Two hypotheses on the excursions themselves, before testing either:

Standard: they're a real, low-frequency mode of the linearized system near the fold, not noise — the closer to delta_c, the slower and larger such excursions should become, which would make them a second, independent signature of the approaching saddle-node (on top of the relaxation-time slowdown), rather than a nuisance to average away.

Non-standard: they're an Adam-specific artifact of the second-moment estimate occasionally under- or over-shooting on this near-degenerate direction, given beta2=0.999's long memory can let a small run of correlated gradients briefly bias the adaptive step — testable by checking whether the excursions' timing correlates with anything in exp_avg_sq for the relevant parameters, the same diagnostic that found the wall latch three rounds ago.

Scripts: verifier_sonde_bassin.py.

Notebook §7.64.

Checked your residual arithmetic first, then ran both experiments in the order you gave them.

Your residual numbers, reproduced exactly

delta    R_pred        resid          resid/(1-s3)
0.010    0.731059       4.274e-04      9.736
0.012    0.768525       2.827e-03      8.750
0.013    0.785835       8.187e-03      8.189

Matches to the digit. The coefficient does drift down (~9.7 → ~8.2), not the flat constant a clean linear term would give, but it's the right order of magnitude and the right sign — worth deriving properly (below) rather than trusting the eyeball fit.

Test 1 (continuation): run, and it lands somewhere between your two readings

Converged to delta=0.013 first (R[10,4]=0.794022, matching test 2's number), then continued training the same parameters, no reset, switching only the weight vector to delta=0.014:

step 1 — converge at delta=0.013:        R[10,4]=0.794022  s[3,10]=0.999000161
step 2 — continue, same state, to 0.014:  R[10,4]=1.000000  s[3,10]=0.037048574
control — fresh init straight to 0.014:   R[10,4]=1.000000  s[3,10]=0.037016329

Continuation from a point already on the graded branch still collapses, landing on the same 1/27 as a cold start. That's your "truly annihilated" outcome — but it's not quite either of the two readings you offered. If the interior point had simply stopped existing at delta=0.014 in the ordinary saddle-node sense, I'd expect that from any starting point, which is what happened, so on its face this argues for real annihilation. But it doesn't fit a saddle-node either, given what test 2 shows below — no bending on approach, no slowing down. What it does fit is something in between the two mechanisms you named: the fixed point's basin didn't just fail to contain the original tie — it apparently failed to contain a point sitting on the delta=0.013 branch itself, one step later. Either the branch's own position moves enough between 0.013 and 0.014 that R=0.794 (last round's converged value) is no longer inside its basin, or the basin width goes to zero at some point inside (0.013, 0.014) rather than gradually shrinking past it. Test 2 was built to distinguish exactly this.

Test 2 (critical slowing down): no blow-up, your prediction lands

Bisected delta_c first rather than guess it:

delta=0.013500  saturated   R[10,4]=1.000000
delta=0.013250  graded      R[10,4]=0.801798
delta=0.013375  graded      R[10,4]=0.807474
delta=0.013437  saturated   R[10,4]=1.000000
delta=0.013406  graded      R[10,4]=0.809528
delta=0.013422  graded      R[10,4]=0.811417
delta_c ∈ (0.013422, 0.013437)

Tighter than my earlier (0.012, 0.014) bracket by an order of magnitude, and worth flagging on its own: right at the graded edge (delta=0.013422), R=0.811417 against the soft prediction sigmoid(2×0.013422/0.02)=0.793 — a residual of 0.018, bigger than the three points in your table but still small, still finite, no sign of a pole anywhere near this delta.

Then convergence speed at three distances below that bracket's midpoint (delta_c≈0.0134295):

3.000% below:   R_final=0.792836   first hits 99% of final value at step  200
0.300% below:   R_final=0.808275   first hits 99% of final value at step  800
0.030% below:   R_final=0.811395   first hits 99% of final value at step  800

Flat, not diverging. Going from 3% to 0.03% away from the edge — two more orders of magnitude closer — should multiply convergence time by roughly 10× under (delta_c-delta)^{-1/2} scaling. It moved from 200 to 800 steps once, between the first two points, and then stopped moving entirely between the second and third. No critical slowing down anywhere near delta_c. H6 dies exactly the way you said it would, on the exact test you proposed.

So what actually happens between 0.013422 and 0.013437

Neither of us has a name for it yet that fits both results. It's discontinuous (no bending, no pole, lands on 1/27 to four digits every time — your nine-row statistic, confirmed again here) and it's not locally slow to approach (no critical slowing down) — but it also isn't simply "a fixed starting point missed a basin that's still there," because a point already sitting on the branch one delta-step earlier gets swept away too. The shape that fits all three of those at once, as far as I can tell without deriving it, is closer to what dynamical-systems language calls a boundary crisis — the attracting branch doesn't collide with an unstable twin (that's the saddle-node, and it's what carries the square-root slowdown); instead the boundary of its own basin sweeps across it, converting it from attracting to unreachable in a single step of delta, with no local warning at the branch itself because the branch's own stability never changes — only the region that can reach it does. That would explain a sharp, bend-free death (the branch's location and local dynamics are undisturbed right up to the crisis) with no slowing down (nothing about the branch's own attraction rate is changing) and an abrupt jump on the far side even for on-branch continuations (the crisis erases the basin out from under a point that was inside it the step before).

I don't have a derivation for why the basin boundary would move at this specific delta, only a name for the shape the data has. Putting it as a hypothesis rather than a conclusion.

Five hypotheses, formed before testing any of them

H11 (boundary crisis, standard in dynamical systems, non-standard for this project). As above — the interior point's own local stability never fails; a separate unstable structure's boundary reaches it first. Testable: a boundary crisis is generically accompanied by the basin's own geometry becoming fractal near the crisis delta, which should show up as non-monotonic sensitivity to the exact starting state right at the crisis point — perturb the delta=0.013 converged state by a tiny amount in a few different directions before continuing to 0.014, and check whether the outcome (collapse vs. survive) becomes unpredictable from the perturbation's sign/size, rather than a clean threshold.

H7, finished properly (standard, the one your table already argues for). Derive referent 3's own stationary condition — not assuming s3 fixed at 1, but solving jointly with the receiver's condition — and check whether the resulting two-equation system has its own critical delta, possibly closer to the observed 0.01342 than my one-variable reduction's implicit assumption of "senders always saturated" would suggest.

H12 (Adam-specific, non-standard: the second-moment estimate for referent 3's logit, not adam_eps, is the actual gate). I ruled out adam_eps twice now, at two different deltas, but never looked at exp_avg_sq itself mid-transition, the way the wall latch investigation eventually did (round 35) after ruling out the obvious floor first. Testable: trace sqrt(v) for referent 3's own logit step by step through a continuation run started just above and just below delta_c, the same diagnostic that found the wall latch after adam_eps alone didn't explain it.

H13 (the 27-row toy, your own aside, elevated to a real hypothesis). You note the collapse lands on 1/27, not 1/2, meaning the other 25 rows are where the mass actually goes — not passengers, participants. A 2-referent-only toy (softmax over {3,4} alone, no other 25 columns) should land on 1/2 if it collapses at all, and might not have a delta_c in the same place, or at all, if the 25 rows are load-bearing rather than incidental. Haven't built it yet — next.

H14 (non-standard: delta_c is itself a discrete artifact of N=27 — i.e., some resonance between 2·delta/beta and a quantity like log(N-2) that happens to land near 0.0134, not a continuous dynamical threshold at all). 2×0.01343/0.02 ≈ 1.343; I don't have a clean closed form producing that from N and beta alone, and I'd be surprised if one existed, but I hadn't checked, and a coincidence this specific is worth ruling out before trusting any dynamical story over a numerological one.

I'd bet on H11 over the other four, for the same reason you'd back H6 over mine last round — it's the only one of the five that predicts all three observations (no bend, no slowdown, on-branch continuation still fails) from one mechanism rather than needing a separate story for each. Which way do you read it?

Pushed further before calling any of this settled: why is the coefficient 8-10, and could Adam be hiding the slowdown?

Refuted-or-confirmed isn't where this stops. Two follow-ups, both run rather than argued.

H7, derived rather than left as an eyeballed slope. Treating referent 3's own row as a two-outcome softmax (message 10 against the other 26, lumped), its stationary condition against a fixed r3 is d3/(26(1-d3)) = exp(-N·w3·r3/beta) where d3=1-s3. Plugged in the measured r3=1-R_meas at each delta (not a free parameter):

delta   r3         d3 predicted   d3 measured    ratio
0.010   0.268514   4.3911e-05     4.3900e-05     1.0002
0.012   0.228648   3.2324e-04     3.2310e-04     1.0004
0.013   0.205978   1.0008e-03     9.9980e-04     1.0010

Within 0.1% at all three points, from a closed form, not a fit. This is why your 8-to-10 coefficient drifts rather than sitting flat: d3 depends on r3 exponentially, and r3 itself falls as delta rises, so the local slope of d3 against delta keeps steepening — a drifting linear coefficient is exactly what a fixed exponential relationship looks like over a window where its argument is moving. This also says why the residual on the soft law grows the way it does without yet exploding: the soft law's error is entirely this term, and this term has no singularity of its own anywhere near delta_c — it's smooth all the way, which is consistent with the sharp thing happening being in the coupled (s3, r3) system, not in this one-sided approximation to it.

H15, formed to explain the flat critical-slowing result, then run. Adam divides its step by sqrt(second moment), which tracks the gradient's own recent scale — near a true marginal (vanishing) eigenvalue, that normalization could in principle keep taking full-sized steps long after a plain gradient would have crawled, erasing the (delta_c-delta)^{-1/2} signature without the underlying vector field being innocent. Reran the exact three-point slowdown test under plain SGD instead of Adam, learning rate calibrated so the far point converges in a comparable number of steps:

3.000% below delta_c:  R_final=0.786283  first hits 99% of final value at step  400
0.300% below delta_c:  R_final=0.792312  first hits 99% of final value at step  400
0.030% below delta_c:  R_final=0.792909  first hits 99% of final value at step  400

Flat under SGD too — 400 steps at every distance, no divergence. H15 is refuted by the same test that would have vindicated it: the missing critical slowing down isn't an artifact of Adam's normalization, it's a real property of the dynamics regardless of which optimizer walks it. That's one more point for H11 over H6 — a boundary crisis doesn't require the branch's own local rate to change at all, which is consistent with SGD and Adam giving the identical flat answer here, while a marginal-eigenvalue saddle-node would need to show up under both.

H13, built and run rather than left as an aside

Your remark — the collapse lands on 1/27, not 1/2, so the 25 other rows are where the mass goes, not passengers — deserved an actual ablation, not a note. Built a standalone toy: two 2-outcome senders (message 10 vs one lumped elsewhere, not 26 of them) and a 2-outcome receiver (referent 3 vs referent 4, not 27 referents), same beta=0.02, same /N=27 normalization so the temperature scale is untouched — only the passenger dimensions are gone.

delta     R4         s3          prediction
0.010     0.731075   0.999998    0.731059
0.013     0.786041   0.999974    0.785835
0.014     0.802653   0.999940    0.802184   <- still graded here, real system already saturated
0.02      1.000000   0.500081    0.880797   <- collapses, lands on 1/2
0.05      1.000000   0.500000    0.993307
0.30      1.000000   0.500000    1.000000

Both predictions land. The collapse now lands on s3≈0.500000 — half, not 1/27 — confirming the other 25 rows really are the destination of the escaping mass, not incidental. And delta_c moved: bisected in the toy to (0.018688, 0.018711), against the real system's (0.013422, 0.013437) — a genuine shift, not invariance. The 25 rows are load-bearing on both counts your remark named.

Why, not just that. H7's closed form has the "26" sitting as a prefactor: d3 = 26·exp(-N·w3·r3/beta). With only 1 alternative instead of 26, referent 3 has far less entropy to gain by abandoning message 10 — one destination instead of twenty-six — so it resists collapse longer, and it takes a bigger delta (more reward pressure) to tip it. That's the mechanistic reason delta_c is higher in the toy, not just an observation that it is: fewer places to run to means a harder push needed before running looks worth it.

H9, closed as a special case of H13

Was going to build H9 (the same 2-referent toy) separately; H13's toy answers it directly, since a 27-way softmax collapsing to a 2-way one is exactly the ablation H9 asked for. Landing on 1/2 rather than 1/27 is the H9 result — the 25 rows aren't a numerical artifact of the full softmax's shape, they're where H7's entropy pressure actually comes from.

Scripts: verifier_continuation_delta.py, verifier_bissection_delta_c.py, verifier_ralentissement_critique.py.

Notebook §7.63.

You're right that all four arms sat on the same boundary and couldn't have separated anything. Ran both experiments you specified before writing an interpretation, not the other way around.

etat() now prints the sender row

Added s[3,msg]/s[4,msg] to its return, as asked. Used everywhere below.

Test 1: delta_c across three budgets, in the graded region this time

Swept delta from 0.010 to 0.020 (the bracket that actually moves) at three budgets spanning more than an order of magnitude — 15,000, 40,000, and 200,000 steps:

budget = 15,000 steps
  delta=0.010  R[10,4]=0.731486  s[3,10]=9.999561e-01  predicted=0.731059
  delta=0.012  R[10,4]=0.771352  s[3,10]=9.996769e-01  predicted=0.768525
  delta=0.014  R[10,4]=1.000000  s[3,10]=3.702269e-02  predicted=0.802184
  delta=0.016  R[10,4]=1.000000  s[3,10]=3.700369e-02  predicted=0.832018
  delta=0.018  R[10,4]=1.000000  s[3,10]=3.702923e-02  predicted=0.858149
  delta=0.020  R[10,4]=1.000000  s[3,10]=3.702835e-02  predicted=0.880797

budget = 40,000 steps
  delta=0.010  R[10,4]=0.731485  s[3,10]=9.999561e-01  predicted=0.731059
  delta=0.012  R[10,4]=0.771352  s[3,10]=9.996769e-01  predicted=0.768525
  delta=0.014  R[10,4]=1.000000  s[3,10]=3.701633e-02  predicted=0.802184
  delta=0.016  R[10,4]=1.000000  s[3,10]=3.710339e-02  predicted=0.832018
  delta=0.018  R[10,4]=1.000000  s[3,10]=3.703858e-02  predicted=0.858149
  delta=0.020  R[10,4]=1.000000  s[3,10]=3.706417e-02  predicted=0.880797

budget = 200,000 steps
  delta=0.010  R[10,4]=0.731485  s[3,10]=9.999561e-01  predicted=0.731059
  delta=0.012  R[10,4]=0.771352  s[3,10]=9.996769e-01  predicted=0.768525
  delta=0.014  R[10,4]=1.000000  s[3,10]=3.703866e-02  predicted=0.802184

delta_c sits between 0.012 and 0.014 at every budget tested, values matching to five or six digits across a 13× range in training length. delta=0.010 gives the identical 0.731485/0.731486 at 15k and 200k steps — this observable is fully converged by 15,000 steps even in the graded region, let alone at the edge. H1 is dead for real, the way you predicted it would need to be shown: not by running longer at a point that was already saturated, but by checking the one place a moving edge could actually appear. My original four-arm test never touched this region at all, and you were right that it couldn't have meant anything.

This also sharpens the bracket itself, independent of the budget question: delta_c is now between 0.012 and 0.014, not the looser 0.01–0.02 I originally reported.

Test 2: adam_eps ladder at a fixed point inside the graded region

Your question 1, answered with a location rather than the old bracket — ran the same 1e-8/1e-10/1e-12/1e-14 ladder replay_mur23_referent3.py already carries, at delta=0.015 (past the now-located edge, chosen before I had the tighter bracket from test 1 — still informative, see below):

delta=0.015, predicted (old soft law) = 0.817574
  adam_eps=1e-08  R[10,4]=0.000000  s[3,10]=1.000000e+00  (frozen, receiver never trained — same artifact as the original 1e-8 row)
  adam_eps=1e-10  R[10,4]=1.000000  s[3,10]=3.706e-02
  adam_eps=1e-12  R[10,4]=1.000000  s[3,10]=3.710e-02
  adam_eps=1e-14  R[10,4]=1.000000  s[3,10]=3.704e-02

Invariant across four orders of magnitude of adam_eps, once past the 1e-8 freeze artifact. Not the same latch as the walls — that one moved a real threshold by 2–5 logit units across this exact range. Here it moves nothing at all. Given test 1 now places delta_c between 0.012 and 0.014, delta=0.015 was already past the edge when I ran this, so the honest reading is "past the edge, adam_eps doesn't rescue it," not "at the edge, adam_eps doesn't move it" — the second, sharper version of this test (ladder run exactly inside 0.012–0.014) is still open, flagged below rather than left silently substituted.

Your regularizer fix, run rather than reasoned about

Added the one-line correction — entropie_s weighted by (N·poids[i]) instead of flat 1/N — and reswept delta from 0 out to the literal 2:1 endpoint (delta=1.0 in this fixed-combined-weight family):

delta=0.000  R[10,4]=0.500000  s[3,10]=1.000000000  s[4,10]=1.000000000
delta=0.001  R[10,4]=0.524979  s[3,10]=0.999999999  s[4,10]=1.000000000
delta=0.005  R[10,4]=0.622461  s[3,10]=0.999999835  s[4,10]=1.000000000
delta=0.010  R[10,4]=0.731188  s[3,10]=0.999961687  s[4,10]=1.000000000
delta=0.020  R[10,4]=1.000000  s[3,10]=0.036988530  s[4,10]=1.000000000
delta=0.030  R[10,4]=1.000000  s[3,10]=0.037034403  s[4,10]=1.000000000
delta=0.050  R[10,4]=1.000000  s[3,10]=0.037031123  s[4,10]=1.000000000
delta=0.100  R[10,4]=1.000000  s[3,10]=0.037064044  s[4,10]=1.000000000
delta=0.300  R[10,4]=1.000000  s[3,10]=0.036949334  s[4,10]=1.000000000
delta=0.500  R[10,4]=1.000000  s[3,10]=0.037036957  s[4,10]=1.000000000
delta=1.000  R[10,4]=1.000000  s[3,10]=1.000000000  s[4,10]=1.000000000  <- degenerate, see below

The fix doesn't move the edge. delta=0.01 gives 0.731188, essentially identical to the unweighted version's 0.731188/0.731486 — and the collapse to s[3,10]≈0.037 (uniform, 1/27) is already complete by delta=0.02, same as before, same value to three digits. Your mechanism — reward pressure falling while entropy pressure holds still — is real as an asymmetry in the unweighted objective, and it's a legitimate thing to have flagged, but removing it doesn't rescue the soft law here. The one row that looks like confirmation, delta=1.0 reading s[3,10]=1.000000000, isn't one. At delta=1.0, poids[3]=0 exactly, and under your correction the entropy term for row 3 is also scaled by N·poids[3]=0 — so both of referent 3's loss terms vanish simultaneously, its gradient is exactly zero everywhere, and it simply never moves from wherever it was before this stage (saturated near 1, from the original construction). That's a boundary artifact of this specific reweighting at the one point where reward and entropy both switch off together, not a data point about whether the posterior law holds — I'm flagging it rather than letting it read as support for the wrong reason.

Where this leaves it

Both of your candidate rescues are dead: the budget concern doesn't survive being tested where it could show up, and the regularizer-scaling fix doesn't move delta_c at all. What's left is what I found last round by inspection — referent 3's own sender confidence collapses to uniform once the weight cut crosses a real threshold, now bracketed to delta_c ∈ (0.012, 0.014) rather than (0.01, 0.02), under either entropy convention. That's H4 standing on firmer ground than it did last round, not by elimination this time but because your two best candidates for dissolving it were run and didn't.

Five hypotheses on what actually sets delta_c, formed before testing any of them

Standard / expected:

H6 (a genuine saddle-node in the coupled 4-variable system). My original closed form was a 1-D reduction (receiver split only, senders frozen at 1). The real system is (s3, s4, r3, r4) jointly, and a saddle-node bifurcation — the interior fixed point colliding with and annihilating an unstable one as delta grows — would produce exactly this signature: a smooth branch that exists and is attracting up to a critical point, then disappears entirely, budget- and adam_eps-invariant, since it would be a property of the vector field itself, not of the integrator.

H7 (the sender's own second-order term, not the receiver's). The receiver's first-order condition assumed s≈1 constant; the sender's own first-order condition (which I haven't derived) might have a critical delta of its own, lower than any receiver-side threshold, and it's referent 3's row that visibly moves first. Testable: derive referent 3's own stationary condition treating r3 as the frozen quantity instead, and check whether it predicts a critical delta near 0.013.

Non-standard:

H8 (a resonance between the Adam second-moment estimate and the shrinking sender gradient). adam_eps didn't move it, but beta2 (momentum-of-variance) wasn't tested and has produced a real, though weaker, effect on other walls in this project (round 34/35). Testable: sweep beta2 at fixed delta=0.013, the same way the wall latch was checked against it.

H9 (the transition is set by where referent 3's gradient magnitude, not the loss landscape's curvature, first drops below the noise floor of float64 in this specific softmax parametrization — an artifact of representing a 27-way softmax rather than the 2-way marginal I've been reasoning about). Testable: rerun the same sweep in a hand-built 2-referent-only toy (softmax over just {3,4}, no other 25 rows), and check whether delta_c moves — if it's the same, the 25 irrelevant rows aren't involved; if it moves, they are.

H10 (hysteresis in delta, not in initial state — i.e., ramping delta up continuously in one run rather than restarting fresh at each grid point produces a different, possibly higher, delta_c). Every point above was measured from the same fixed starting tie, reweighted once, trained to convergence — never a continuous ramp. Testable: one run that slowly increases delta from 0 to 0.02 over the full training budget instead of jumping straight to each target value.

I haven't run any of these five — same position you were in last message, and I'd rather say where I expect it to land than pretend I don't. My guess: H6, on the grounds that a saddle-node is the standard shape for exactly this signature (smooth branch, hard death, no dependence on the integrator's own parameters) and nothing in H8/H9/H10 has an obvious reason to produce budget-and-eps invariance as cleanly as test 1 and test 2 both just did. Which way do you read it?

The sharper adam_eps test, closed rather than left open

Reran test 2 at delta=0.013 — inside the now-located (0.012, 0.014) bracket, not past it:

delta=0.013, predicted (soft law) = 0.785835
  adam_eps=1e-08  R[10,4]=0.000000  s[3,10]=1.000000e+00  (frozen, same 1e-8 artifact as always)
  adam_eps=1e-10  R[10,4]=0.794022  s[3,10]=9.990002e-01  H=0.508579
  adam_eps=1e-12  R[10,4]=0.794022  s[3,10]=9.990002e-01  H=0.508579
  adam_eps=1e-14  R[10,4]=0.794022  s[3,10]=9.990002e-01  H=0.508579

0.794022, in the graded regime this time (close to the predicted 0.786), bit-identical across three orders of magnitude of adam_eps. H2 is closed properly now, not just at a point past the edge: the basin edge isn't set by the same additive-floor mechanism as the wall latch, full stop.

Scripts: verifier_prior_asymetrique.py (now prints s[3,·]/s[4,·]), verifier_invariance_budget.py, verifier_adam_eps_ladder_delta.py (now at delta=0.013), verifier_entropie_reponderee.py.

Notebook §7.62.

Ran your prior-imbalance test before anything else, since it's the one that actually settles the question rather than describing it further. It settles it, and not quite the way either of us expected.

Your numbers, reproduced exactly

adam_eps        s[4,10]           s[3,10]
1e-10      0.999999999997    0.999999999666
1e-12      0.999999999639    0.999999999639
1e-14      0.999999999639    0.999999999639

All three rows match my own already-published 1-s columns to the last printed digit (2.994494e-12, 3.344895e-10 at 1e-10; 3.610847e-10/3.610856e-10 at 1e-12 and 1e-14). Your Bayes posterior, s4/(s4+s3) = 0.500000000083, reproduces to the same precision from those same numbers. And your residual table — observed offset 9.0e-6 against Bayes-predicted 8.3e-11 at 1e-10, ratio 1.1e5 — is exact too, though it's worth flagging what it's built on: at 1e-12 and 1e-14 the "Bayes offset" (2.2e-16, -3.3e-16) is below float64's own precision floor at that magnitude, so the ratio there isn't measuring anything — the two senders print as identical because they are identical to sixteen digits, not because the model has resolved a real asymmetry that small. Your 1e-10 row is the only one where the comparison is measuring a real number against a real number, and there the residual really is five orders larger than the sender asymmetry can explain.

The frozen row, checked properly rather than just cited

You use adam_eps=1e-8 (R[10,4]=0) as the control that shows 0.5 isn't imposed mechanically by the collision alone. Went one step further and printed the receiver's actual state there, since a bare zero doesn't say whether it's a frozen tie or a frozen non-tie:

adam_eps=1e-08:  r[10,3]=0.9999999997196851   r[10,4]=1.9210607954554012e-11
H(receiver, msg 10, full 27-way) = 7.294e-09

Not a frozen 50/50 — a frozen near-total collapse onto referent 3, entropy essentially zero. Compare the trained state:

adam_eps=1e-10:  H(receiver, msg 10, full 27-way) = 0.693147   =  ln 2, to six digits
                 mass on {referent 3, referent 4} = 1.000000000

Exactly your predicted ln 2, and all the mass is on the two colliding referents with nothing measurably elsewhere. This is a clean, independent confirmation of the collision reading, on a quantity neither of us had printed before: the receiver's row entropy at the contested message is machine-exact ln 2 when trained, and near-zero when frozen at the wrong starting point — the frozen state isn't a snapshot of the same tie, it's a snapshot of the optimizer never having gotten there.

The decisive test, run — and it lands on neither of your two predictions

Trained referent 4 with the objective's per-referent reward term weighted 2× referent 3's (all 25 other referents, and both entropy terms, left untouched), 40,000 more steps under adam_eps=1e-10:

symmetric control (re-run, no reweighting):  R[10,4]=0.500000  R[10,3]=0.500000  H=0.693147
asymmetric (referent 4 weighted 2x):          R[10,4]=1.000000  R[10,3]=0.000000  H=0.000000

Not 0.5. Also not 0.667. Your first prediction — that 0.5 would hold regardless, because it's a genuine dynamical fixed point immune to reweighting — is refuted outright: the moment any asymmetry enters, the tie breaks completely. But your second prediction, the specific value 2/3, doesn't land either — it goes all the way to a clean winner-take-all.

Why, worked out rather than left as a surprise

Restricting to the two-way split at message 10 (both senders already saturated, so s3, s4 ≈ 1), the objective's first-order condition on r4 (with r3 = 1 - r4) is, for general weights w3, w4:

log(r4 / r3) = N·(w4 - w3) / beta

For the literal test above (w4 = 2/N, w3 left at its default 1/N), that's N·(1/N)/0.02 = 1/0.02 = 50, and sigmoid(50) prints as exactly 1.0 in double precision. To characterize the transition itself I used a cleaner one-parameter family that keeps the combined weight on the pair fixed at 2/N (matching the original, unweighted setting) and only redistributes the split: w4=(1+delta)/N, w3=(1-delta)/N, for which the same first-order condition reduces to log(r4/r3) = 2·delta/beta — a different, smaller-scale parametrization than the literal "2×" test above, chosen so the sweep below could resolve the transition rather than jump straight from 0 to full saturation. Your "2:1 → 2/3" intuition is exactly what a naive frequency-weighted average would predict; it's just not what this objective's entropy term is strong enough to hold onto once the weight imbalance is that large, on either parametrization.

Swept delta (the fixed-combined-weight family) to check whether this is a real graded law or a post-hoc excuse:

delta     R[10,4]      predicted = sigmoid(2·delta/beta)
0.0000    0.500692     0.500000
0.0001    0.504368     0.502500
0.0005    0.511932     0.512497
0.0010    0.524979     0.524979   <- exact to six digits
0.0020    0.549834     0.549834   <- exact to six digits
0.0050    0.622347     0.622459
0.0100    0.731486     0.731059
0.0200    1.000000     0.880797   <- prediction breaks here
0.0500    1.000000     0.993307
0.1000    1.000000     0.999955

Up through delta=0.01, the closed form predicts the trained value to four decimal places or better — this genuinely is a graded, Bayes-like response in log-odds space, exactly the shape your reading calls for. Somewhere between delta=0.01 and delta=0.02 the soft prediction (0.88) and the trained outcome (1.00) come apart: past that point the system doesn't settle at the analytic soft optimum, it runs away to full specialization — the same shape as the latch mechanism from three rounds ago (a door that closes once a threshold is crossed, not a smooth approach to the unconstrained optimum). So the full answer is neither of the two you posed: 0.5 is not a dynamical fixed point that resists reweighting — it's the unique degenerate point of a genuinely continuous, correctly-predicted posterior-like law — but the law itself has a basin edge past which it stops being soft and the system snaps to a corner, and an actual "2:1" imbalance sits well past that edge, not inside the graded region.

What breaks the soft law between delta=0.01 and 0.02 — five hypotheses, tested rather than left as a shrug

Didn't stop at "there's a basin edge somewhere in there." Formed five candidate mechanisms, three of them standard engineering suspects and two less obvious, and ran all five at delta=0.02 before writing anything about which one is right.

H1  undertraining          — 40,000 steps isn't enough; still en route to 0.88, not arrived elsewhere.
H2  adam_eps floor          — same latch mechanism as the earlier walls: the restoring (entropy) gradient
                              gets swamped by Adam's additive floor once close to saturation.
H3  lr too large            — 0.05 overshoots the shifted interior optimum once the landscape steepens.
H4  a genuine bifurcation   — past some delta, the interior point stops being dynamically reachable at all,
                              even though it remains the static optimum of the reduced two-variable problem.
H5  path dependence         — starting from the already-converged 0.5 state (rather than imposing the
                              imbalance from the checkpoint before it ever tied) biases which point is found.

H1 (200,000 more steps instead of 40,000+15,000):        R[10,4]=1.000000  H=0.000000   <- refuted
H2 (adam_eps=1e-14 instead of 1e-10):                     R[10,4]=1.000000  H=0.000000   <- refuted
H3 (lr=0.005 instead of 0.05):                            R[10,4]=1.000000  H=0.000000   <- refuted
H5 (imbalance imposed from the 10k checkpoint, before the tie ever forms): R[10,4]=1.000000  H=0.000000   <- refuted

All four engineering explanations are dead — bit-identical outcome regardless of budget, floor, step size, or path. That leaves H4, and I didn't want to leave it as "process of elimination" without a mechanism, so I checked what my reduction to a two-variable receiver-only problem had assumed away: that s3 and s4 stay pinned near 1 throughout. They don't.

before reweighting:  s[3,10]=0.999999999666   s[4,10]=0.999999999997
after 40,000 steps:  s[3,10]=0.037064167       s[4,10]=0.999999999998

Referent 3's own sender confidence collapses to 1/27 — uniform, the same evacuation signature as the wall/latch mechanism from rounds 20 through 38. My closed form treated the senders as fixed and solved only for the receiver's split; that's the correct limit as delta → 0, but it's not a two-variable problem once the reward-weight imbalance is large enough that referent 3 starts losing real credit — at that point referent 3's own entropy term wins, its sender gives up on message 10 entirely, and the receiver's near-total commitment to referent 4 is downstream of that collapse, not a separate optimization on the receiver's row alone. Same shape as every wall in this project: a referent that stops earning reward on a message eventually stops claiming it, and once it does, there's nothing left to keep the tie alive.

What I take from this, and what's still open

Your reframing is the one that survives: 0.5 was never a fixed point in the sense the earlier rounds used the word — it's an artifact of exact symmetry in the effective per-referent weight, and it dissolves under the lightest possible asymmetry, following a law derived and confirmed to four decimals over two orders of magnitude of delta. What doesn't survive is the specific quantitative shape of "2:1 in, 2:1 out" — not because the entropy term is simply "too weak" (my first framing), but because past a threshold the whole mechanism switches from a graded receiver-side reweighting to the sender-eviction dynamics that produced every other wall in this project. The two-variable closed form is exact in the small-delta limit and stops applying, not gracefully, exactly where referent 3's own commitment starts to give.

Two questions

1. Is the basin edge (bracketed here between delta=0.01 and 0.02, not located) set by the same adam_eps-and-logit mechanism as the wall latch, or by something specific to having two already-saturated senders sharing one message? H2 (a smaller adam_eps) didn't move the outcome at all here, which argues against it being the same floor — but I only tested one value, not a sweep, and the walls' own latch needed a four-order-of-magnitude sweep in adam_eps before it moved.

2. Given that the mechanism turns out to be sender-side collapse, not a receiver-only reweighting — does that change how "prior" should be operationalized for a cleaner test of your original reading? What I built (reweighting the deterministic average) forces the senders' own incentives to move together with the receiver's; a REINFORCE-style literal 2:1 sampling frequency would too, in expectation, but might reach the same endpoint by a different route, or might not reach the corner as reliably if the sender's own stochastic gradient noise resists full collapse the way it resisted the traps in rounds 19–21.

Scripts: verifier_prior_asymetrique.py, verifier_prior_asymetrique_balayage.py, verifier_bassin_delta002.py.

Notebook §7.61.

Both corrections land. Answering the actual question this time.

r is R

Rebuilt r[0,0] from 1-r[0,0] on my own table:

pas      R[0,0]     r[0,0] = 1-(1-r)
 6000    0.000000   0.0000000000
 7500    0.000000   0.0000000000
 8000    0.682857   0.6828574000
 9000    0.999939   0.9999391562
10000    0.999963   0.9999628607

Every digit agrees, including the four rows where R[0,0] is exactly zero — as far from saturated as this trajectory ever gets. r is R on this whole run, not only past saturation. The "four orders above the residual" line never had anything under it, at eps=24 or anywhere else on this pair. Costs me nothing further since I'd already dropped what it was propping up, but it's worth saying plainly rather than leaving it half-corrected: the leak comparison was never a real second measurement here.

Your question, checked on the actual tie

Built the referents-3/4 configuration (master seed 77777, 3 pairs skipped, checkpoint 10k, referent 4 pushed +30 on message 10, retrained under a smaller adam_eps since the default one freezes the cell) and printed 1-s on both senders:

adam_eps=1e-08  R[10,4]=0.000000  1-s[4,10]=2.460254e-12  1-s[3,10]=2.458518e-10
adam_eps=1e-10  R[10,4]=0.500009  1-s[4,10]=2.994494e-12  1-s[3,10]=3.344895e-10
adam_eps=1e-12  R[10,4]=0.500001  1-s[4,10]=3.610847e-10  1-s[3,10]=3.610856e-10
adam_eps=1e-14  R[10,4]=0.500000  1-s[4,10]=3.610858e-10  1-s[3,10]=3.610845e-10

Both senders are already essentially fully saturated — 1-s sits at 1e-10 to 1e-12 on both, nowhere near 0.5. That's your first branch, not your second: the asymmetry test is dead here. Both rows read like a fully-committed sender long past any transient, exactly the reading that (by your own account) can't tell a way station from a fixed point on a single snapshot.

Which means what actually establishes referents 3 and 4 as a genuine fixed point rather than an unusually slow way station isn't anything in this snapshot — it's the longitudinal check from a few rounds back. I caught myself citing that without rerunning it on this exact reconstruction, so I reran it here rather than leave it as an inherited claim:

pas=40000...400000, adam_eps=1e-10:
R[10,4] = 0.500009, 0.500000, 0.499798, 0.500000, 0.499972,
          0.499999, 0.500000, 0.500000, 0.500000, 0.500080

Pinned at 0.5 across ten checkpoints spanning 360,000 more steps, no systematic drift either direction, verified on the actual pair I have rather than assumed from a run I can no longer reproduce. The single-snapshot column you pointed at doesn't do the job here; the time axis does, same as your own caveat said it would if 1-s came back small.

The thing I almost dismissed as nothing

I'd written off the non-monotonic climb in 1-s[0,0] on the way station (2.1, 2.3, 2.6, 2.9, peak 3.3 at pas=8000, then falling) as "two significant figures, not building a mechanism on it." That was the wrong reflex — I formed three actual hypotheses and tested them instead of leaving it as noted-not-explained.

Adam artifact? Reran the same window under plain SGD. Referent 0's logit doesn't move at all under SGD at this learning rate across this window (frozen exactly) — inconclusive, there's no dynamics to compare against, but it does mean every "exact ascent" claim across this whole exchange has actually been Adam, never literal gradient ascent (monter() always builds a torch.optim.Adam).

Entropy redistribution among the other 26 logits?

pas    somme_hors_gagnant   1-s[0,0]
7000   53.089291            2.586964e-09
7500   53.205838            2.918510e-09
8000   53.337311            3.343607e-09   <- both peak here
8500   53.186451            2.860844e-09
9000   53.052747            2.491666e-09

Yes — the sum of referent 0's 26 non-winning logits tracks the dip in lockstep, peaking at the same step.

Does it coincide with the receiver actually flipping?

pas    top1_logit   1-s[0,0]        r[0,0]
7000   25.072774    2.586964e-09    0.000000
7500   24.956668    2.918510e-09    0.000000
8000   24.825748    3.343607e-09    0.682857   <- the flip
8500   24.975879    2.860844e-09    0.999922
9000   25.108901    2.491666e-09    0.999939

Exactly. r[0,0] goes from 0 to 0.68 at the same step where referent 0's own dominant logit dips and its losing logits rise. This isn't noise — it's the visible signature of the coupled sender-receiver system at the exact moment the receiver's decoding flips, briefly redistributing the sender's own logit mass before the sender resumes climbing. What looked like two insignificant figures of jitter is the transition itself, seen from the sender's side.

Formed three more hypotheses on top of that before calling it settled.

Is Adam load-bearing for the transfer itself, not just for the dip? Reran idx5's eps=24 window under SGD with a learning rate 100x Adam's (5.0 instead of 0.05), all the way to 20000 steps: r[0,0] stays at exactly 0.000000 the entire time, 1-s[0,0] barely moves (9.8098e-10 throughout). Adam's adaptive per-parameter scaling isn't standing in for a bigger step size — it's doing something SGD at 100x the learning rate can't reproduce in this window at all.

Is the dip carried by one specific rival, or spread across all of them? Checked the top 5 non-winning logits at pas=7000/8000/9000:

pas=7000: (7,2.044036) (5,2.043422) (15,2.042842) (18,2.042563) (23,2.042304)
pas=8000: (7,2.053595) (5,2.052975) (15,2.052390) (18,2.052108) (23,2.051847)
pas=9000: (7,2.042626) (5,2.042013) (15,2.041435) (18,2.041156) (23,2.040898)

All five rise together by about the same +0.01 at the peak, then fall back together. It's a uniform lift across the whole losing set, not one rival gaining ground — consistent with the entropy-redistribution reading rather than a specific competitor.

Does pushing the tie harder ever force a real capture? Pushed referent 4 at eps=60, 100, 200, 400 (up from the 30 that produces the tie) on the referents-3/4 pair, trained 40000 steps each under adam_eps=1e-10:

eps= 60:  R[10,4]=0.500000 (10k) / 0.500000 (20k) / 0.499993 (40k)
eps=100:  identical to eps=60, to six figures, every checkpoint
eps=200:  identical
eps=400:  identical

No. Across more than a factor of six in perturbation size, the outcome is bit-identical — the sender saturates instantly at all four (1-s[4,10]=0 immediately), and once it does, further pushing has nothing left to affect. The receiver stays pinned at exactly 0.5 regardless. This tie isn't a slow capture that a big enough push would tip over — it resists sender-side perturbation across three orders of magnitude, which is a stronger and more specific claim than "it looked stable over 400,000 steps."

Notebook §7.60quinquies.

You'd already pointed at the right regime. I went and built it before answering anything else.

The transient, at eps=24, sampled step by step instead of only at convergence

pas      R[0,0]      residual       1-r[0,0]       1-s[0,0]
 6000    0.000000    4.999999e-01   1.000000e+00   2.1e-09
 6500    0.000000    4.999999e-01   1.000000e+00   2.3e-09
 7000    0.000000    4.999999e-01   1.000000e+00   2.6e-09
 7500    0.000000    4.999998e-01   1.000000e+00   2.9e-09
 8000    0.682857    1.443847e-03   3.171426e-01   3.3e-09
 8500    0.999922    5.157076e-10   7.799927e-05   2.9e-09
 9000    0.999939    3.164566e-10   6.084378e-05   2.5e-09
 9500    0.999952    2.115295e-10   4.751718e-05   2.2e-09
10000    0.999963    1.490894e-10   3.713933e-05   2.0e-09

The residual is not pinned during a real transfer. It moves nine orders of magnitude, from 0.5 down to 1.5e-10, while the pinned value you'd have found at full convergence (4.6e-12 at 20000 steps) is just the tail end of that collapse.

What's actually happening at pas=6000–7500

R[0,0]=0 but the residual sits at almost exactly 0.5 — referent 0's own sender row (s) is already fully saturated (1-s is 2e-9, negligible) but the receiver hasn't caught up (1-r[0,0]=1.0, meaning r[0,0]≈0). The mass the message sends is split almost exactly 50/50 between referent 0 and referent 18 for four straight checkpoints — the same signature as your tie on referents 3 and 4, appearing here as a way station on a trajectory that is not, in the end, a tie at all. By pas=8000 it's already broken: 68% to referent 0. By pas=8500 it's essentially over.

Which reframes the whole residual question

The pinned residual I reported at 20000 steps wasn't evidence about mechanism at all — it's just what's left of a collapse that already finished. The interesting object is the transient, and there it's not pinned, it's the whole story: mass visibly moving from referent 18 to referent 0, passing through a state indistinguishable from your tie along the way. That means a snapshot of a "tie" and a snapshot of a "wall capture" can be the same trajectory at two different times, not necessarily two different kinds of fixed point — some 50/50 splits are transient way stations, and some (your referents 3 and 4, still oscillating around exactly 0.5 many steps later with no sign of resolving) are actual fixed points. I don't yet have a way to tell which is which from a single snapshot; it took sampling across steps to see the difference here.

Notebook §7.60quater.

Your question, answered on the actual pair this time, plus how I got there.

First, an admission that belongs in the answer

I spent most of this round unable to answer you at all, because I'd lost the exact reconstruction of the wall I've been calling "referent 18 / message 0" for eight rounds. Those labels were never raw tensor indices — they were presentation labels from a run I never saved to a file. I tried two wrong master seeds (5, then 31415, the seed my one saved script uses) and got real captures on real walls neither of which matched anything I'd published — one pair's loser stayed frozen at zero all the way to eps=100, which isn't what I'd told you happens at eps=24. I nearly reported a number off the wrong pair. I caught it only because the baseline state didn't match the numbers already sitting in my own notebook (S[18,0]=0.499479 is specific enough to check against). I found the real recipe by grepping this session's own JSONL transcript for e.p[0][18 — the exact command was sitting there, verbatim, from eleven days ago: master seed 999, five pairs skipped. It's saved now, as replay_idx5.py, so this doesn't happen again.

Your question, on the real pair

Pushed referent 0 past its threshold (eps 24 through 100, default adam_eps, trained on past the perturbation rather than stopping at 2000 steps — my first attempt under-trained and only found the pre-capture transient, which is its own small lesson), then printed the residual at full precision:

eps= 24.0  R[0,0]=0.999999715203110  residu=4.648726e-12
eps= 26.0  R[0,0]=0.999999715817530  residu=4.636735e-12
eps= 30.0  R[0,0]=0.999999715881449  residu=4.640843e-12
eps= 40.0  R[0,0]=0.999999715883959  residu=4.635403e-12
eps= 60.0  R[0,0]=0.999999715883959  residu=4.635403e-12
eps=100.0  R[0,0]=0.999999715883959  residu=4.635403e-12

The residual holds essentially flat here too — 4.6353e-12 to 4.6487e-12, a spread of about 1.4e-14, roughly 0.3% relative, against a capture that itself is barely moving over the same range. It is not a tie. There is a clean winner and a clean loser. And the residual pins down anyway.

Which answers it directly

You proposed two branches, and this is your second one: the residual is pinned there too, so it's structural, not a tie-specific marker. My "qualitative branch" story from the last round doesn't survive this — I was reading the pinned residual as part of what distinguished a tie from a capture, and it demonstrably isn't, since it pins down identically (same order of stability, different absolute value, as expected for a different pair and message) when there's no tie in sight.

I also checked the sender-side leak you flagged as suspiciously matching the residual's order of magnitude:

eps=100:  1 - S[0].max() = 0.0   (referent 0 fully saturated, no measurable leak left)
          1 - r[0,0]     = 2.841160e-07

Here the comparison doesn't carry over as cleanly as it did on your tie — referent 0's own leak underflows to exactly zero at full precision once it's saturated, while the receiver's own leak on that cell sits at 2.84e-7, four orders above the residual itself. So whatever is pinning the residual at 4.6e-12 here, it isn't simply "the senders' combined leak dressed up as a receiver quantity" the way it looked on your pair — unless the mechanism is different for a single full winner than for two co-tied ones, which is plausible but not something I've verified.

Where that leaves it

You're right that it's structural rather than tie-specific, and that costs my last round's framing. What's still open is what it's structural to — it isn't simply mirroring the sender leak in the capture case the way it did in the tie case, so there are at least two different things converging on "small and pinned," and I don't yet know if they're the same mechanism viewed from two pairs, or two different mechanisms that happen to both produce a flat residual. I'd want to see it on a third pair, one with a partial rather than a full transfer, before guessing which.

Notebook §7.60bis.

Every question in your message has a clean answer, and the last one dissolves the comparison rather than fixing it.

Does referent 18 ever freeze? No. Anywhere.

Pushed it at checkpoint 40k, default adam_eps, all the way to eps=100:

eps = 24, 26, 30, 40, 60, 100:  all identical — S[0].max()=1.0000, R[0,0]=1.0000, clean capture

Never freezes, never plateaus, never anything but a clean winner-take-all once past its threshold. That's your discriminator, confirmed outright: freeze is not something referent 18 does at any perturbation I tried.

Does k_18 move under referent 3's lever? No.

checkpoint 40k, adam_eps=1e-10:  eps=18,20 retour, eps=23 capture — same bracket as default adam_eps=1e-8
checkpoint 10k, adam_eps=1e-10:  eps=10,13,14 retour, eps=15 capture — k=15/5.697=2.633, consistent with the 2.79 range

The lever only bites on frozen cells. Dropping adam_eps doesn't change referent 18's threshold at all — same bracket at 40k whether adam_eps is 1e-8 or 1e-10. So it isn't a global rescale; it specifically unfreezes cells that were frozen, and referent 18 was never one of those.

Which is exactly what the 0.5 plateau turns out to mean

You called 0.50000 a suspiciously round place for a plateau to sit. It's rounder than either of us guessed — it's a tie, not a capture, and I only saw it by finally printing full precision instead of trusting a >0.5 cutoff:

eps=24:  R[10,4]=0.500000583504767   R[10,3]=0.499999416424236
eps=26:  R[10,4]=0.499999999984430   R[10,3]=0.499999999944572
eps=28:  R[10,4]=0.499999055744959   R[10,3]=0.500000944184045
eps=29:  R[10,4]=0.500000003840574   R[10,3]=0.499999996088429

and both senders:  S[4].max()≈0.9999999996   S[3,10]≈0.9999999997

Both referents 3 and 4 are fully committed to message 10 simultaneously, and the receiver splits credit essentially exactly 50/50. This isn't the wasted-commitment freeze from three rounds ago (where the challenger commits and the incumbent keeps everything). It's the genuine tie this whole exchange characterized many rounds back — two fully confident senders, one message, a receiver that can't tell them apart — the same shape as the 23/25 pair from the earlier "égalité" investigation, arrived at from a completely different starting point. My R>0.5 cutoff called this "capture" because it happened to land a few millionths above 0.5 at two of the four eps values and a few millionths below at the other two — which is also why it looked non-monotone. It was never monotone in the sense I was checking; it was oscillating around an exact tie for a reason that has nothing to do with threshold-crossing.

What this does to k_3, and to the whole comparison

There is no k_3 to compare against k_18. Referent 3, pushed hard enough at this checkpoint, doesn't cleanly capture the way referent 18 does — it ties. Those are different events, and "how much perturbation until a tie forms" isn't the same measurement as "how much perturbation until a clean transfer happens," even though my classifier scored both the same way. The 4.907 I reported last round wasn't an upper bound on a censored capture. It was the onset of a different phenomenon entirely, and no amount of re-bracketing turns it into a k comparable to 2.79.

This also answers, cleanly, the question underneath the whole thread: what's the second axis? At least for this pair, it isn't a scalar sitting on the incumbent's side or the challenger's side. It's whether the two rows resolve into a winner and a loser, or into a tie — a qualitative branch, not a quantity on either defender's ledger. Referent 18's collisions apparently only ever resolve one way. Referent 3's, pushed this way, resolves into the other. I don't yet know what sets which branch a given pair takes, and I'd rather leave it there than propose a fourth scalar on the strength of one example.

I checked whether referent 4 carries this on its own, away from referent 3. It doesn't: referent 4's own natural slot (message 6) is already captured with zero contest at the same checkpoint, no perturbation needed at all. So the tie looks specific to this one collision — referent 3 and referent 4 both landing on message 10 — not a trait either referent carries on its own into any contest it enters.

Notebook §7.60.

Ran the uncensoring you asked for before answering anything else.

Your ratio table, confirmed

checkpoint  10k     20k     30k     40k
referent 18 2.4106  2.4474  2.4819  2.4916
referent 3  2.3913  2.4172  2.4474  2.4546

Matches yours closely (my figures use slightly rounded checkpoint grips, hence the fourth-decimal drift). You're right that this kills my "wrong too, more clearly" claim — the logit gap wasn't a second candidate, it's grip × 2.45 along a training trajectory, and rejecting one rejects the other by construction.

The uncensoring, and it needed the freeze lever too

Pushed referent 3 at its 10k checkpoint past 26, default adam_eps:

eps = 30 through 60, all identical: R[10,4] = 1.9211e-11, always retour

Frozen — the receiver's own step for that cell is stuck under the default eps, same signature as wall 1's freeze. Dropped adam_eps at eps_perturb=30:

adam_eps=1e-8:   retour
adam_eps=1e-10:  R[10,4]=0.50001  — right at the boundary
adam_eps=1e-12:  R[10,4]=0.50000  — same
adam_eps=1e-14:  retour again

eps_perturb=30 sits essentially exactly on referent 3's threshold at the 10k checkpoint, under the adam_eps window that actually lets the receiver move. k_3 = 30 / 6.1115 = 4.907.

The comparison you asked for

k_18 ≈ 2.79   (your feasible range, 2.7348–2.8537, all four brackets)
k_3  ≈ 4.91   (this round, one point, needs refining but not by a factor of 1.76)

Not close, and not explainable by the gap/grip spread. Even granting the full range you'd already found — 2.39 to 2.49, about 4%, and the two more defenders I checked below push it to 2.39–2.54, about 6% — that's an order of magnitude too small to move k from 2.79 to 4.91. Whatever sets the per-defender constant, it isn't riding on the same small variation that separates grip from the logit gap.

Your last question, checked on two more defenders

referent 14 (wall 3, 40k):  gap/grip = 2.5367
referent 1  (round 33's solo winner, 40k): gap/grip = 2.5119

Both sit outside your 2.39–2.49 window. So grip and the logit gap aren't one variable wearing two names after all — there's a real, small, defender-dependent spread in the constant relating them (2.39 to 2.54 across the four defenders now measured, roughly 6%). But that's exactly the point your question was aimed at: this spread is real and worth having on record, and it's still far too small to be where the k_18-versus-k_3 gap comes from. The third scalar isn't hiding in the difference between grip and the logit gap. It has to be somewhere else, and the challenger's side — which neither quantity measures at all — is still where I'd look first, exactly where you'd pointed before this round started.

Notebook §7.59.