# base3-transient-exhaustion

- Settles `level*(D)`, the last level with `V(level) < 0`, at every even carry parameter `D = 6..120` in base 3, middle-digit design, with the exhaustion proved rather than assumed.
- `V(level) = 3 m0(level) - b(level) = v^T u_level` with `m0` the census mass on carries divisible by 3, `b` the whole census mass, `v_c = 3[3|c] - 1` and `u_level = M^level e_0` the carry census at that level.
- `level*` grows like `(ln R / 4) D^2`, so a census carried only to a window `top = 4D + c` truncates once `D` is past about 70 and returns the largest odd level inside the window instead of `level*`.

## THE SUFFICIENCY INEQUALITY

- `M >= 0` entrywise (the digit polynomial has nonnegative coefficients) and `u_m = M^m e_0 >= 0` for every `m >= 0`.
- So if one integer `t` has `r_t := (M^T)^t v >= 0` entrywise, then `V(level) = r_t^T u_(level-t) >= 0` for every `level >= t`.
- Hence `level*(D) = max{level <= t : V(level) < 0}` with no window assumption: the sweep stops at the first `t` with `r_t >= 0` and the answer cannot be truncated.
- The sweep runs on the folded core `N` of size `(D-1)//2 + 1`, valid because the digit polynomial is palindromic, which the run asserts at every `D` along with carry-window closure.
- `V(level) = r_level[0]` since `u_0 = e_0`, so one backward sweep yields the whole sign sequence and the certificate together.

## THE SAME CERTIFICATE THE LANE ALREADY USES

- Column sums satisfy `fill - 3 colsum(c) = (D-1) v_c` exactly, `fill = 2^(D-1)(D+2)`; this is `prop:mass` of `slice-sign-even-half`, proved by root-of-unity filtering, and holds at every `D`.
- `--selftest` bites the identity at even `D = 4..60` as a transcription check on this study's matrix; the theorem, not the check, is what carries the reading to `D = 120`.
- Applying `(M^T)^K` gives `fill beta_K - 3 beta_(K+1) = (D-1) r_K` with `beta_K = (M^T)^K 1`.
- So the Collatz-Wielandt test `3 beta_(K+1) < fill beta_K` entrywise is `r_K > 0` entrywise: the exhaustion certificate and the even-half certificate are one object.
- Every row of the run has `r_t > 0` strictly, so the stopping level `t` is exactly `K_min(D)`.

## RESULTS

- 58 of 58 rows: `level*(D)` equals `level_0(D)`, the greatest odd integer below `K*(D)`, at every even `D = 6..120`. No misses, no false rows.
- `K_min = level* + 1` on 36 rows and `level* + 2` on 22; the `+2` rows are `D = 14, 22, 32, 38, 40, 48, 52, 54, 58, 70, 72, 76, 84, 92, 96, 98, 100, 106, 112, 114, 116, 118`.
- The split and the table below are regenerated by the run and not stored here; `--out <path>` writes the rows as JSON outside the tree.
- `K*(D)` is evaluated at 60 decimal digits over levels `2..399`, and every row asserts `K*` misses the nearest integer by more than `1e-20`; the least observed distance is `0.017138` at `D = 38`.
- `D : level* / K_min`, the whole certified table.

```
  6:   1/   2    8:   3/   4   10:   5/   6   12:   7/   8   14:   9/  11   16:  13/  14
 18:  17/  18   20:  21/  22   22:  25/  27   24:  31/  32   26:  37/  38   28:  43/  44
 30:  49/  50   32:  55/  57   34:  63/  64   36:  71/  72   38:  79/  81   40:  87/  89
 42:  97/  98   44: 107/ 108   46: 117/ 118   48: 127/ 129   50: 139/ 140   52: 149/ 151
 54: 161/ 163   56: 175/ 176   58: 187/ 189   60: 201/ 202   62: 215/ 216   64: 229/ 230
 66: 243/ 244   68: 259/ 260   70: 273/ 275   72: 289/ 291   74: 307/ 308   76: 323/ 325
 78: 341/ 342   80: 359/ 360   82: 377/ 378   84: 395/ 397   86: 415/ 416   88: 435/ 436
 90: 455/ 456   92: 475/ 477   94: 497/ 498   96: 517/ 519   98: 539/ 541  100: 561/ 563
102: 585/ 586  104: 609/ 610  106: 631/ 633  108: 657/ 658  110: 681/ 682  112: 705/ 707
114: 731/ 733  116: 757/ 759  118: 783/ 785  120: 811/ 812
```

## CONTROLS

- `--selftest` rebuilds `V(level)` from the unfolded census `u_level = M^level e_0`, a separate iteration on all of `S`, and matches the folded sweep exactly at even `D = 4..36` for every `level <= 4D + 8`.
- It also runs the unfolded row sweep `r_k = (M^T)^k v` on all of `S` and asserts `r_k` symmetric and `rhat_k[c] = r_k[c] (1 if c = 0 else 2)` entrywise over the same domain, so the whole vector deciding `t`, not only its `c = 0` entry, is cross-checked.
- The bundled `level*` rows at even `D = 6..36` and the `K_min` column both agree with `check_transient` in the lane's `scripts/verify.py`.
- The three fresh towers `level* = 79, 97, 107` at `D = 38, 42, 44` reproduce.
- The four spot depths `K_min = 8, 50, 140, 291` at `D = 12, 30, 50, 72` reproduce.
- All arithmetic on the census side is exact integer; the only floating value is `K*(D)`, at 60 digits, guarded by the integer-distance assertion.

## COST

- Whole sweep `D = 6..120` with `--selftest`: 213 s of sweep, 41 MB peak resident printed by the run, one core.
- Deepest row `D = 120`: 28 s, `t = 812` sweep levels on a folded core of 60 states.
- Growth is steep, near `D^8`: 0.02 s at `D = 44`, 0.8 s at `D = 74`, 7.3 s at `D = 100`, 28 s at `D = 120`.

## RUN

```
uv run python research/lab/py/base3-transient-exhaustion/transient.py --selftest --lo 6 --hi 120
```

## WITNESSES

- the claims line (was `DISCOVERIES.md:215`) - `level* = level_0` on 58 of 58 rows at even `D = 6..120`, the towers at `D = 38, 42, 44`, `level* = 811` at `D = 120`, and the `K_min` split 36/22.