# RUN-047 — Hard-Zeta A-U.2d.19: the conjugacy that makes the real cocycle trivial, and the first constant the bundle contradicts itself on

**Arm:** 數學戰士「墜衡」 / AMRAL Research Lab
**Subject:** Neo.K + Aletheia, `Hard_Zeta_Phase_II_Round_AU2d19_Zero_Lift_Mechanical_Cocycle_Discrepancy_Rigidity_bundle_v0.1.zip` (source item 66) — 20 sections, nine files.
**Tools:** `src66_carry_conjugacy.py` · `src66_drill.py` · `src66_emit_report_block.py`
**Logs:** `src66-au2d19.json` · `src66-drill.json`

**Result: the mathematics verifies, and all nine of the bundle's counters are reproduced exactly from the definition — 1264 bridges, 4433 carry steps, 5697 window positions, 4433 tower levels, and the three synthetic blocks. The round's move is a change of variable that trivialises the object A-U.2d.18 left behind. Setting `W_ℓ := 2^{−ε_ℓ}U_ℓ = 3^ℓV_ℓ/2^{Q_ℓ}` turns the mechanical affine cocycle into `W_{ℓ+1} = W_ℓ − 3^ℓ/2^{Q_{ℓ+1}}` — a strictly decreasing additive carry with no multiplier at all — and everything downstream becomes exact rational or exact modular arithmetic. Three findings. The constants frontier and the checker report **disagree on `β`**: the frontier publishes `1.5849625007211563` and the machine-generated report publishes `1.584962500721156`, one ulp apart, and the frontier's value matches neither the nearest double nor the float64 chain; `beta_minus_1` differs by two ulps the same way. This is the first frontier/report disagreement of the sweep. Section 4's "sharper exact window" is written with a strict `<` on its upper end, and that end is **attained at ℓ = 0** on all 1264 bridges, where `V_0 = Z` exactly — Corollary 4.2's phase-free version, which is what the bundle checks, is strict there and clean. And `mesoscopic_modulus_algebra`, ten thousand of the bundle's assertion executions, asserts the defining property of a ceiling three times, its third assertion implied by its second.**

---

## The change of variable

A-U.2d.18 ended with the mechanical affine cocycle

> `U_{ℓ+1} = (2^{a_{ℓ+1}}U_ℓ − 2^{−m_{ℓ+1}})/3`

and pointed at the multiplier `2^{a}/3` as the place to look for spectral contraction. This round's first move is to show there is nothing there. Set

> `W_ℓ := 2^{−ε_ℓ}U_ℓ`,  and since `2^{m_ℓ+ε_ℓ} = 2^{Q_ℓ}/3^ℓ`,  `W_ℓ = 3^ℓV_ℓ/2^{Q_ℓ}`

and the multiplier vanishes:

> `W_{ℓ+1} = W_ℓ − 3^ℓ/2^{Q_{ℓ+1}}`.

One line of algebra — `3V_{ℓ+1} = 2^{q}V_ℓ − 1` and `Q_{ℓ+1} = Q_ℓ + q` — and the whole real process is a strictly decreasing one-dimensional carry. Every decrement is positive, so `W_0 = Z > W_1 > … > W_h = 2^{−ε_h}X`, and since `X > Z` the carry never leaves `(Z/2, Z]`.

That is a genuinely useful reduction and it is entirely checkable: `W_ℓ` is an exact rational, the recurrence is exact, the band is exact, and the iterated form `W_ℓ = Z − Σ_{j≤ℓ}3^{j−1}/2^{Q_j}` is exact. All four hold on every one of the 1264 bridges and 4433 steps.

The consequence the round draws from it is negative and correct: **NO-GO 11.1**, there is no hidden Archimedean spectral contraction, because Theorem 5.1 makes the mechanical multiplier an exact coboundary — `∏_{j=r+1}^{s}2^{a_j}/3 = 2^{ε_s−ε_r} ∈ (1/2,2)` — with no exponential growth or decay to find on any interval.

## Finding 1 — the frontier and the checker report disagree on β

`Hard_Zeta_AU2d19_constants_frontier.json` publishes

> `"beta": 1.5849625007211563`,  `"beta_minus_1": 0.5849625007211563`

and `Hard_Zeta_AU2d19_checker_report.json` publishes

> `"beta": 1.584962500721156`,  `"beta_minus_1": 0.5849625007211561`.

The report's values are machine-generated by the shipped script, which computes `BETA = log2(3)` and `BETA - 1`. The frontier's are hand-written, and they are wrong: `1.5849625007211563` is **one ulp above** the nearest double to `log₂3`, and `0.5849625007211563` is one ulp above the nearest double to `β−1` and **two ulps** from what `log2(3) - 1.0` actually returns. So the frontier's two numbers match neither the correctly rounded value nor the float64 route their own script takes.

Nothing downstream depends on them — no theorem in the round has a numeric constant in it, and the checker never reads the frontier — so the consequence is provenance, not arithmetic. But this is the first round of the sweep where two artifacts in the same bundle publish different values for the same named quantity, and it is worth saying which one to trust: the report.

This is recorded as a finding rather than counted as a gate failure. The gate's `disagreeing_with_both_evaluations` counter still guards the *report's* constants — the ones a generator should have got right — and those are clean.

## Finding 2 — the sharper window's strict inequality is attained

Section 4 gives Theorem 4.1's band and then a "sharper exact window":

> `2^{m_ℓ+ε_ℓ−ε_h}X ≤ V_ℓ < 2^{m_ℓ+ε_ℓ}Z`

The lower end is attained at `ℓ = h`, where `V_h = X` and the exponent collapses — the `≤` is correct and deliberate. The upper end is attained at `ℓ = 0`, where `m_0 = 0`, `ε_0 = 0`, `W_0 = Z` and `V_0 = Z` exactly, so `V_0 < 2^0·Z` is **false**. Both ends are attained exactly once per bridge, on all 1264.

Corollary 4.2's phase-free consequence `2^{m_ℓ−1}Z < V_ℓ < 2^{m_ℓ+1}Z` is strict at both ends and holds everywhere, and it is what the shipped checker tests — so the strictness in the intermediate boxed line is never exercised. The mathematics is unaffected; the sign is.

This is the same shape RUN-045 found in Theorem 7.2 and RUN-044 in Theorem 8.1: an attained bound is where a check has to be right and where a strict test accuses correct data. Here it is the paper rather than the gate, and the fix is one character.

## Finding 3 — the third synthetic block, and it also cannot fail

`mesoscopic_modulus_algebra` runs 10,000 iterations of

```python
kcrit = ceil(log(target, 3))
assert 3**kcrit >= target
if kcrit > 0: assert 3**(kcrit-1) < target
k = max(0, kcrit-2); assert 3**k < target
```

The first two assertions are the definition of a ceiling. The third is implied by the second, since `3^{k−2} < 3^{k−1}`. All three are computed in float64, so the only way any could fail is a rounding that puts `kcrit` on the wrong side of an integer — and over the same sampling the closest `log₃(target)` comes to an integer is `4.6 × 10⁻⁵`, against a double's error near `10⁻¹⁵`: a margin of **46 billion to one**, with zero samples that could have failed.

That is the third round in a row with a large synthetic block that carries no information: RUN-046 found two in A-U.2d.18 (`near_linear_gap_algebra` and `positive_lift_drop_algebra`), and this is the third. In each case the block is honestly scoped and the count is honestly reported — the issue is only what a reader takes `10000` to mean.

The other two synthetic blocks this round are **not** of that kind. `mechanical_neutrality` genuinely tests that `2^{⌈βs⌉−⌈βr⌉}/3^{s−r}` stays inside `(1/2,2)`, which a wrong ceiling would break. `valuation_aliasing` genuinely tests Theorem 8.1.

## What this recheck adds

**Exact divisibility where the bundle floor-divides.** Their aliasing block computes `(2**q * V - 1) // 3` with `//`, having first adjusted the parity so the numerator is always divisible. That works, but the divisibility is the *hypothesis* of Theorem 8.1, so here it is checked rather than arranged — `predecessor_not_integral` is a counter, and it reads zero.

**Sharpness of the aliasing period, in both directions.** The theorem says `R_{q+2·3^k}(V) ≡ R_q(V) mod 3^k`. Two things could be wrong with that and neither is tested by the statement: the period could be shorter than claimed, and the congruence could hold one level deeper. Both are counted. The difference `R_{q+P_k} − R_q = 2^qV(2^{P_k}−1)/3` is divisible by `3^k` because the order of 2 mod `3^{k+1}` is exactly `P_k`, and *not* by `3^{k+1}` because the order mod `3^{k+2}` is `3P_k`. Both counters read zero, so `2·3^k` is the right period for precision `3^k` and no better.

**The mechanical alphabet over the whole range, not on the sampled intervals.** `a_ℓ ∈ {1,2}` is `β ∈ (1,2)` and the absence of two consecutive ones is `β > 3/2`. Neither is tested by the band `(1/2,2)`, which is invariant under a uniform shift of the ceiling — the drill confirmed that by replacing the whole ceiling table with the floor table and watching the band not move, because floor and ceiling differ by exactly one at every level and the difference cancels over an interval. The telescoping cross-check is what caught it.

**The stabilization guard, counted.** Theorem 7.1's `r_ℓ = Z` is guarded by `3^ℓ > Z` in the bundle. That guard opens on 892 of the 4433 levels — 20% — and at the 3541 levels below it the representative is checked against `Z mod 3^ℓ` instead, which the bundle does not do.

**Both completions of one identity.** Theorem 6.1's congruence and the Archimedean carry form `Z − Σ_j 3^{j−1}/2^{Q_j} = 3^ℓV_ℓ/2^{Q_ℓ}` are, as the paper says, two completions of the same exact affine identity. Checking one and inferring the other would be assuming the paper's own sentence; both are computed independently and both are clean.

## What the round does not do

It proves nothing new about Collatz and says so. Its content is two sealed routes — no Archimedean spectral gap after the conjugacy, and no fixed ternary modulus with enough magnitude resolution — plus a positive routing result: the vague "growing 3-adic modulus" target of A-U.2d.18 is reduced to a **polynomial-size** modulus `3^{k_γ(h)} = h^{γ+o(1)}`, since one fixed `γ > 0` suffices and the whole `3^h` is not needed.

Theorem 9.1, the magnitude resolution barrier, is worth reading twice: its content is that a least residue mod `3^k` is smaller than `3^k`, so no projection to precision `3^k` can certify `Z ≥ h^γ` unless `3^k > h^γ`. That is a one-line observation, and it is the correct one — it is exactly the kind of statement that is obvious after it has been made and was blocking the route before.

<!-- BEGIN GENERATED measured block: python code/src66_emit_report_block.py -->

**The two artifacts disagree on `beta`.** 2 of 2 numeric constants differ between the frontier and the checker report. The frontier's values match **neither** the nearest double nor the float64 chain (2 of them), while the report's are 0 exact and 0 the chain. This is a finding about the artifact, recorded here rather than counted as a gate failure — the same line RUN-032 drew for artifact coverage.

| constant | frontier | report | gap | frontier verdict | report verdict |
| --- | --- | --- | --- | --- | --- |
| `beta` | 1.5849625007211563 | 1.584962500721156 | 1 ulp | +1 ulp, within budget but matching no evaluation | exact |
| `beta_minus_1` | 0.5849625007211563 | 0.5849625007211561 | 2 ulp | +1 ulp, within budget but matching no evaluation | -1 ulp, the float64 chain |

**The population.** **1264** bridges from **1185** distinct sources (longest tail 42), of which **1264** have zero total lift and **0** do not — the third round running in which the positive-lift branch has no finite instance.

**The carry conjugacy, exactly.** `W_l = 3^l V_l / 2^{Q_l}` on **1264** bridges, **4433** steps, **5697** positions. The definition **0** violations; `W_0 = Z` **0**; `W_h = 2^{-eps_h} X` **0**; Theorem 3.1's `W_{l+1} = W_l - 3^l/2^{Q_{l+1}}` **0**; strict decrease **0**; the iterated form `W_l = Z - sum_j 3^{j-1}/2^{Q_j}` **0**. Theorem 4.1's band `Z/2 < W_l <= Z` **0**, and Corollary 4.2's dyadic window **0**, with the identity `V_l = 2^{m_l+eps_l} W_l` they both rest on **0**. Largest interior lift **8**.

**The band is loose and the sharper window is attained at both ends.** The smallest `W_h/Z` seen is **0.992102**, so the `Z/2` floor of Theorem 4.1 is nowhere near approached. Section 4's sharper form is written `2^{m+eps-eps_h} X <= V_l < 2^{m+eps} Z`: the lower end is attained **1264** times and the upper end **1264** times, once per bridge each — at `l = h` and at `l = 0`, where `V_0 = Z` exactly. So the strict `<` on the right is wrong at one endpoint. Violations: **0** below and **0** above. Corollary 4.2's phase-free version, which is what the bundle checks, is strict at both ends and clean.

**Mechanical neutrality.** Over **10000** intervals: the band `2^{ceil(beta s)-ceil(beta r)}/3^{s-r}` outside `(1/2,2)` **0** times, and the phase form `2^{eps_s}/2^{eps_r}` disagreeing **0** on **100** sampled intervals. The alphabet itself, checked over the whole range rather than on the sampled intervals: **0** symbols outside `{1,2}` and **0** consecutive mechanical ones — the first is `beta in (1,2)`, the second `beta > 3/2`, and the band tests neither. The telescoping cross-check failed **0** times. Widest ratio seen **1.995828**, narrowest **0.512665**.

**The nested endpoint tower.** On **1264** bridges and **4433** levels: Theorem 6.1's congruence `Z = sum_j 3^{j-1} 2^{-Q_j} mod 3^l` **0** violations, and its Archimedean counterpart `Z - sum_j 3^{j-1}/2^{Q_j} = 3^l V_l / 2^{Q_l}` **0** — two completions of one identity, so both are checked. Theorem 7.1's stabilization is guarded by `3^l > Z`, which opens on **892** of the levels (20.1%); it failed **0** times there, and at the **3541** levels below the stabilization depth the representative disagreed with `Z mod 3^l` **0** times. `k_0` disagreed with the least power **0** times; the largest seen is **10**.

**Valuation aliasing.** **7** precisions, **7000** samples. The order of 2 modulo `3^{k+1}` failed to be `2*3^k` **0** times; the reverse predecessor was non-integral **0** times — checked by exact divisibility, where the bundle uses floor division and arranges the parity so it never has to; Theorem 8.1's `R_{q+2*3^k}(V) = R_q(V) mod 3^k` **0** violations. Two sharpness counters: aliasing at a THIRD of the period **0** times, and aliasing one level deeper than claimed **0** — the period is the sharp one for that precision, in both directions.

**Their mesoscopic block asserts the definition of a ceiling.** `kcrit = ceil(log_3 target)`, then `3^kcrit >= target`, `3^{kcrit-1} < target` and `3^{kcrit-2} < target` — the first two are what a ceiling means and the third follows from the second. Over **10000** samples at their ranges: **0** violations of the definition and **0** cases where the third did not follow from the second. All three are computed in float64, so the only way any could fail is a rounding across an integer; the closest `log_3(target)` came to one is **4.601e-05**, against a double's error near `1e-15` — a margin of **46.0 billion**, and **0** samples could have failed.

**All ten published examples, rebuilt from the map.** **0** disagreeing `X`, **0** `Z`, **0** exponent words, **0** lengths, **0** maximum lifts, **0** stabilization depths, **0** final carries — compared as exact rationals, not as floats. **1** source appears more than once.

| `y` | `X` | `Z` | `h` | word | lift profile | `k_0` | `W_h` | `W_h/Z` |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 59 | 89 | 67 | 1 | `[2]` | `[0]` | 4 | `267/4` | 0.996269 |
| 71 | 107 | 91 | 3 | `[1, 2, 2]` | `[0, 0, 0]` | 5 | `2889/32` | 0.992102 |
| 91 | 137 | 103 | 1 | `[2]` | `[0]` | 5 | `411/4` | 0.997573 |
| 155 | 233 | 175 | 1 | `[2]` | `[0]` | 5 | `699/4` | 0.998571 |
| 155 | 233 | 167 | 6 | `[2, 1, 1, 1, 2, 3]` | `[1, 1, 1, 0, 0, 0]` | 5 | `169857/1024` | 0.993269 |
| 187 | 281 | 211 | 1 | `[2]` | `[0]` | 5 | `843/4` | 0.998815 |
| 223 | 335 | 319 | 5 | `[1, 1, 1, 3, 2]` | `[0, 1, 1, 0, 0]` | 6 | `81405/256` | 0.996828 |
| 251 | 377 | 283 | 1 | `[2]` | `[0]` | 6 | `1131/4` | 0.999117 |
| 283 | 425 | 319 | 1 | `[2]` | `[0]` | 6 | `1275/4` | 0.999216 |
| 347 | 521 | 391 | 1 | `[2]` | `[0]` | 6 | `1563/4` | 0.999361 |

**Artifacts.** 9 files, 8 carrying a `CHECKSUMS` digest, **0** mismatches, **0** manifest lines naming a missing file; the only file with no digest anywhere is `CHECKSUMS.sha256`. The source-validation record names **6** files and digests **0** of them — none — reporting `all_ok = True`, `checker_rerun = PASS`, `python_compile.ok = True`, with **0** markdown `ok` flags and **0** json `parse_ok` flags not true. 2 files are absent from it: `CHECKSUMS.sha256`, `SOURCE_VALIDATION_AU2d19.json`.

**Ledger coverage.** The paper lists 10 proved items, 5 open problems and 9 NO-GO headings; the ledger carries 10, 5 and 6, with an `open` key (True). Open items with no trace: none. NO-GO headings with no trace: none — the ledger merges nine headings into six entries rather than dropping any. The heuristic deciding those lists has controls at both ends and failed neither (0, 0).

**Their counters beside mine**, keyed on their names rather than mine: 0 of 9 had no counterpart here, 0 are reported as zero, and **9 of 9 are reproduced exactly** from the definition.

| check | theirs | mine |
| --- | --- | --- |
| `finite_local_bridges` | 1264 | 1264 |
| `zero_lift_bridges` | 1264 | 1264 |
| `carry_conjugacy_exact` | 4433 | 4433 |
| `carry_monotone_band` | 1264 | 1264 |
| `state_lift_window` | 5697 | 5697 |
| `nested_endpoint_tower` | 4433 | 4433 |
| `mechanical_neutrality` | 10000 | 10000 |
| `valuation_aliasing` | 7000 | 7000 |
| `mesoscopic_modulus_algebra` | 10000 | 10000 |

**Instrument and drill.** 9 instrument self-checks, 0 failed. The mutation drill planted **50** defects: **50** caught by the check they attack, **0** missed, **0** malformed, 0 caught only by another counter; 2 of 2 controls left the gate undisturbed.

<!-- END GENERATED measured block -->

## Instrument

Nine self-checks, each naming a world in which it fails.

The exact ceiling is tested both ways round, as at RUN-046 — that it brackets `βℓ` on both sides and that it is *not* the floor. `2^{ε_ℓ}` must land strictly inside `(1,2)`. The order of 2 modulo `3^{k+1}` is checked to *be* `2·3^k` and, separately, that **no maximal proper divisor of it works** — one test alone would pass for any multiple of the true order, which is precisely the error Theorem 8.1's sharpness turns on. The reverse-step divisibility criterion is enumerated over both residue classes rather than derived. And the carry conjugacy is checked on a hand case, `y = 59` with tail `(2)`, where `W_0 = 67` and `W_1 = 267/4`, so the recurrence and the band are both anchored to arithmetic that can be done on paper.

Two things were fixed before shipping. `check_neutrality` recomputed `3^j` twice per mechanical increment, five hundred times per interval — fourteen of the gate's fifteen seconds — and the ceilings are a fixed sequence, so they are now built by one incremental pass and cross-checked against `ceil_beta` at their ends. And the aliasing section had a counter incremented by `+= 0`, a dead line of exactly the kind RUN-046 found in the countermodel section; it is now the one-level-deeper sharpness test above.

## Drill

Fifty defects, one at a time, each planted at a pre-flighted unique anchor, with the gate restored byte for byte after every run. **50 caught, 0 missed, 0 malformed, both controls undisturbed, the gate byte-identical at the end.**

Zero malformed on the first pass is new, and it is the RUN-046 changes paying off: every section reports through an `errors.<section>_raised` counter, so the one defect that raised — an index one past the end of the suffix-sum array — was reported rather than crashing, and could then be re-aimed one level the other way where the identity still breaks and the index is in range.

Three defects were caught by a sibling counter rather than the one named, and in each case the sibling was right. Replacing the ceiling table with the floor table does not move the neutrality band, because the two differ by exactly one at every level and the difference cancels over an interval — the telescoping cross-check is what sees it, and that is what the check is for. Reading the report's constant from the frontier makes the frontier's values flow through the report branch, where they correctly become failures. Both expectations were renamed rather than the defects re-aimed: the gate complained about the right thing under a different name.