# Octonion order U: the 52 two-step cells, and U's local factor for every odd prime

Research note, 11 November 2026, ~8:50–9:05 PM PST (Grant pt216u). Follows `octonion-n4-p5-proof-20261111.md` (Theorems 5–9 there; §"U remainder" stated the gap closed here).
Labels: [known] established mathematics; [project] proved or checked in this project (computer-assisted where stated); [speculative] unproved.
Nothing here is about the zeros of the Riemann zeta function; these are local factors at one prime.

## In plain words
U's lattices fall into 802 cells. 750 were counted for every p last time. In the other 52, the "glue" between the hull and the core is two steps deep, so it lives in a group built from Z/p², where adding digits can carry. Carries are not polynomial in p, so the field method stopped there.

The fix has two steps.
1. Count the same cells in a look-alike ring, F_p[t]/(t²): there p·p = 0 just as in Z/p², but digits never carry. In that ring the glue is again an F_p-subspace, and the existing exact counter applies. Every cell gives a polynomial in p.
2. Show the carries never matter for these cells, so the Z/p² count is the same polynomial.

All 52 polynomials match the exhaustive counts at p = 3, 5 and 7 (156 checks). Adding them to the 750 gives U's local factor for every odd p. It is exactly the formula fitted earlier from p = 3, 5, 7, so "no zero on ½" now holds for U unconditionally.

## Results
- **Theorem 10 (two-step glue, U) [project, proved; computer-assisted].** For each of the 52 two-step cells and every odd prime p, the number of admissible glue subgroups (by length) equals the number of admissible F_p[t]/(t²)-submodules. The counts are:

  | count | cells |
  |---|---|
  | p(p−1) | 20 |
  | 2p(p−1)² | 16 |
  | p(p−1)² | 8 |
  | p(p−1)³ | 4 |
  | p(p−1)²(p²+4p−4) | 4 |

  The distribution by length is in `n4proof/tmodel-U.json`.
- **Corollary 11 (U) [project, proved].** Z_{U,p}(s) = N_U(x)/(1 − x⁴), x = p^{−s}, for every odd p, with
  N_U = 1 + 2x + (p³+p²+2p+1)x² + (p⁴+p³+2p²+3p+2)x³ + (p⁴+3p³+3p²+3p+1)x⁴ + (p⁵+2p⁴+4p³+4p²+2p+1)x⁵ + (p⁴+4p³+5p²+2p+1)x⁶ + (3p⁴+4p³+3p²+p+1)x⁷ + (p⁴+3p³+3p²+p)x⁸ + (p⁵+2p⁴+2p³+p²)x⁹ + (p⁴+p³)(x¹⁰+x¹¹).
  This equals the fitted formula (`verify.py U`: ALL OK). P_O and P_Λ match the exhaustive runs at p = 3, 5, 7, and every one of the 802 cells matches cell by cell at p = 3, 5, 7 (`percell-U.json`).
- **Corollary 12 [project, proved].** No zero of Z_{U,p} lies on Re s = ½ for any odd prime.
  - Proof: the resultant of N_U(x) and x^11 N_U(1/(px)) factors as p⁵⁸ (p − 1)⁴ · (degree 12, constant 1) · (degree 38, constant −1)².
  - None of these factors has an odd prime root.
  - The script is `resultant.py`, with output in `resultant.json`.
- **Consequence [project, proved].** All five odd-conductor patterns (P6, Q, N4, P5, U) are now proved for every odd prime, and none has a zero on ½. U's zeros nearest ½ tend to ½ from the right like 1/(2p log p). This is the limit listed in the general-p note, now unconditional.

## The transfer lemma (why carries do not matter)
Setting: R is Z/p² or F_p[t]/(t²), with π = p or t, and residue field k = F_p. Let N = ⊕_{δ_i=2} R e_i ⊕ ⊕_{δ_i=1} k e_i, and let I2 and I1 be the two index sets. The operators T are the induced maps of Theorem 5: signed partial matchings with coefficients π^k, where k < δ_target and k ≥ δ_target − δ_source.

1. **Data of G [project, proved].** A submodule G ⊆ N is the same as three pieces of data:
   - its top A = image in N/N[π] ≅ k^{I2}, a k-space with reduced row-echelon basis y_1..y_r;
   - its bottom K = G ∩ N[π], a k-subspace of N[π] ≅ k^{I2} ⊕ k^{I1} with πA ⊆ K;
   - offsets n_j ∈ N[π]/K, so that G is generated by K and the g_j = λ(y_j) + n_j.

   Here λ is a fixed lift of residues to R. Any lift gives a bijection G ↔ (A, K, n), because G/K ≅ A as k-spaces (pG ⊆ K).
2. **Invariance [project, proved].** T(G) ⊆ G holds exactly when three things hold:
   - T̄(A) ⊆ A on the top;
   - T₀(K) ⊆ K, where T restricted to N[π] is a fixed k-matrix, the same in both rings;
   - for each j, T(λ(y_j)) − Σ_l λ(c_jl) λ(y_l) + T₀(n_j) − Σ_l c_jl n_l ∈ K, where T̄ y_j = Σ c_jl y_l. Any lift of the c_jl gives the same condition, since π g_l = π y_l ∈ K.

   The "meets each factor trivially" and "projects onto each factor" conditions are conditions on A, K and n that are the same in both rings.
3. **The only ring-dependent term is the I2-part of the carry D_j = T₀(λ(y_j)) − Σ_l λ(c_jl) λ(y_l)** [project, proved]. The π-terms of T, and the I2 → I1 parts, depend only on residues.
   - In F_p[t]/(t²), λ is the ring inclusion, so D_j = 0.
   - In Z/p², take λ = Teichmüller lift. It is multiplicative, and λ(−x) = −λ(x) because p is odd. Coordinate m of D_j is ±λ(y_{j,σ⁻¹m}) − Σ_l λ(c_jl y_lm), and the residues agree. So D_j vanishes whenever each coordinate sum Σ_l c_jl y_lm has at most one nonzero term.
4. **Check [project, computer-assisted, every odd p].** `carry2.py` runs over all 52 cells, every echelon pattern of A, and every zero/nonzero pattern of its free entries.
   - For each pattern it decides exactly whether T̄(A) ⊆ A has a solution, using count.solve. That solver uses only unit monomials and an exact zero/nonzero split, and its BAD list stays empty.
   - On every pattern that has a solution, every carry sum has at most one nonzero term (max_terms = 1).
   - Hence D_j = 0 in both rings, the k-systems for (A, K, n) are identical, and the counts agree for every odd p. ∎

The naive guess "count = p × (count with δ lowered to 1)" was false (`delta2-U.json`). The look-alike count is the right replacement.

## Rigour remarks
- This is computer-assisted in the same sense as Theorems 5–9. It rests on symbolic case splits in sympy, exact over Z[p] with no floating point, and on the p-independent word searches of Lemmas 6–7.
- The carry check covers every A-pattern, including ones that end up contributing zero.
- Independent checks: the exhaustive lattice lists at p = 3, 5, 7 (U at 7: 148490 lattices) agree cell by cell.

## Overnight jobs
At ~9:05 PM PST neither had finished: Q at p = 7 by method B, and P6 at p = 11 by brute force. Nothing was folded in.

## Reproduce (in `n4proof/`, sympy venv)
`python tmodel.py` (look-alike counts, ~1 min) → `python carry2.py` → `python run_U_full.py` → `python verify.py U` → `python percell.py U 3,5,7` → `python resultant.py` → `python figure_u.py`. Tests: `python test_n4proof.py`.
