# OMEGA NAUGHT: A Geometric–Arithmetic Compatibility and Reconstruction Theorem

24 October 2026. Mathematical proof note; companion exact Python checker.

## Definitions and scope

Let `K` denote the *labeled* planar OMEGA template with its unit circle centered at the origin, retained major arc, and bilateral golden extensions. For `a >= 0` define the marked scaled reference `K_a = {a p : p in K}`, preserving all label correspondences. The `a=0` reference is degenerate. The chosen positively homogeneous readouts are

\[G(a)=a\varphi,\quad C(a)=a\pi,\quad
\varphi=\frac{1+\sqrt5}{2},\quad
\lambda=\frac{G(a)}{G(a)+C(a)}=\frac{\varphi}{\varphi+\pi}.\]

The choice that *the geometric evolution uses this invariant fraction* is a declared modeling rule. Similarity by itself does not select that rule. Write `Q=339949771344778`, `S=10^15`, `q=Q/S`, with `0<q<1`. Define on `d in N_0`

\[T(d)=\lfloor qd\rfloor,\qquad \rho(d)=Qd-S T(d)\in\{0,1,\ldots,S-1\}.\]

## Theorem A: the same exact witness corrects the entire geometry

For every nonnegative integer `d`, every labeled template point `p`, and `t=T(d)`,

\[\boxed{q(dp)=tp+\frac{\rho(d)}{S}p.}\tag{A1}\]

Every degree-one homogeneous scalar readout `L` of the scale therefore satisfies

\[\boxed{L(qd)-L(t)=\frac{\rho(d)}{S}L(1).}\tag{A2}\]

In particular, simultaneously,

\[G(qd)-G(t)=\varphi\rho(d)/S,\qquad
C(qd)-C(t)=\pi\rho(d)/S.\]

For any unit-circle mark `p` (so `||p||=1`),

\[\boxed{\lVert qdp-tp\rVert=\rho(d)/S.}\tag{A3}\]

Thus the Euclidean remainder is the *measurable radial scale discrepancy* between corresponding marks of the rationally scaled and quantized references, assuming exact calibrated measurements and known labels. Neither the arbitrary-message-to-scale code nor a semantic interpretation is needed.

**Proof.** Euclidean division states `Qd=S t+rho` uniquely with `0<=rho<S`. Divide by `S` to obtain `qd=t+rho/S`, multiply by `p`, and apply any readout satisfying `L(a)=a L(1)`. For a unit vector the norm of `(rho/S)p` is `rho/S`. QED.

## Theorem B: exact recovery of the scale and every finite trajectory

The lifted one-step map `d -> (T(d),rho(d))` is injective, with inverse on the valid image

\[\boxed{d=(S T(d)+\rho(d))/Q.}\tag{B1}\]

Given a terminal state `d_N` and the *ordered* remainders `rho_0,...,rho_{N-1}` for any finite `N`, reverse (B1) reconstructs every `d_k`. Summation yields the exact telescoping invariant

\[\boxed{Q^N d_0=S^N d_N+
\sum_{k=0}^{N-1}\rho_k S^k Q^{N-1-k}.}\tag{B2}\]

**Proof.** Uniqueness of quotient and remainder proves (B1). Backward induction recovers the orbit. Multiply the relation `Qd_k-Sd_{k+1}=rho_k` by `S^k Q^{N-1-k}` and sum; intermediate terms cancel, leaving (B2). Each recovered `d_k` recovers the correspondingly labeled geometry `K_{d_k}`. This result holds for all nonnegative integer seeds and every finite horizon, not only canonical seeds or horizon 23. QED.

## Theorem C: exact separation of the irrational geometric factor from its rational implementation

Set `Delta=lambda-q`. For every template point `p`,

\[\boxed{\lambda dp=t p+
\left(\frac{\rho(d)}{S}+\Delta d\right)p.}\tag{C1}\]

The real residual `lambda*d-t` is not generally the rational residual `rho/S`. For positive `d`, it is irrational because `lambda` is irrational while `t` is an integer. (If `lambda` were rational and nonzero, `pi=phi(1-lambda)/lambda` would be algebraic, contradicting transcendence of pi.)

Given a complete valid arithmetic ledger, one can recover `d_0`, then generate both the exact quantized orbit and the ideal real-scale orbit `lambda^k d_0` as mathematical expressions. These are generally *different trajectories*. No claim of equality between their intermediate real scales is made.

**Proof.** Add and subtract `qdp` and apply (A1). Recoverability follows from Theorem B. QED.

### Certified canonical limb agreement

The checker obtains exact rational bounds `L<lambda<U` from integer-square-root bounds on `sqrt(5)` and alternating Machin arctangent-series bounds on `pi`, using `pi=16 atan(1/5)-4 atan(1/239)`. It proves `q<L<U<q+10^-14` and checks *using exact rational arithmetic* that for every integer `d in [0,32767]`,

\[\boxed{\lfloor Ld\rfloor=\lfloor Ud\rfloor=\lfloor qd\rfloor.}\tag{C2}\]

By squeezing this proves `floor(lambda*d)=T(d)` for all 32,768 canonical limb states. This is a finite certified-domain result, not unrestricted equality of the rational and irrational floor maps.

## Theorem D: a two-bit witness is necessary and sufficient in the worst case

For `y>=0`, define the lower boundary of the floor fiber

\[b(y)=\left\lceil\frac{S y}{Q}\right\rceil.\]

The predecessor set of `y` under `T` is exactly

\[\boxed{T^{-1}(y)=\{b(y), b(y)+1,\ldots,b(y+1)-1\}.}\tag{D1}\]

For the canonical `q`, `1/3<q<1/2` and hence `2<S/Q<3`. Every nonnegative integer `y` therefore has either two or three possible integer predecessors. Define the *minimal-alphabet rank witness*

\[\boxed{w(d)=d-b(T(d))\in\{0,1,2\}.}\tag{D2}\]

The pair `(y,w)` reconstructs `d=b(y)+w`, after validation that `T(d)=y`. Thus a fixed two-bit witness is sufficient. Since `T(0)=T(1)=T(2)=0`, at least three witness values, hence **at least two bits in any fixed-length binary witness**, are necessary to distinguish all predecessors of zero. Consequently **two bits per step are optimal in the worst-case fixed-width sense** (not necessarily optimal total sequence compression).

**Proof.** `T(d)=y` iff `y<=Qd/S<y+1`, which for integer `d` is `b(y)<=d<b(y+1)`. For `2<S/Q<3`, the difference of consecutive ceilings is 2 or 3; the rank is 0,1,or 2. The three examples at `y=0` prove the lower bound. QED.

The large remainder `rho` is a convenient canonical Euclidean witness; it is **not a minimal-bit encoding**. The smaller witness `w` carries exactly the distinction lost inside each discrete floor fiber.

## Theorem E: geometric localization and the necessary boundary

For `a>0`, choose three existing, noncollinear unit-circle anchors, oriented as
`A0=(-1,0)`, `A1=(1,0)`, `A2=(0,1)` before scaling. For an unknown planar position `x=(x_1,x_2)` measured against scaled anchors `a A_i`, let `delta_i=||x-a A_i||^2`. Then

\[\boxed{x_1=\frac{\delta_0-\delta_1}{4a},\qquad
x_2=\frac{\delta_0+\delta_1-2\delta_2}{4a}.}\tag{E1}\]

**Proof.** Expand and subtract the three squared-distance equations. The formulas recover any point in the reference plane. QED.

To reconstruct a more general configuration consisting of a scale `d>0` and an arbitrary normalized planar point `u` (so the point is `x=d u`), retain its initial calibrated distance profile along with the scale ledger. The initial profile determines `u` via (E1), and the ledger reconstructs all the scales. Thus every earlier point `d_k u`, as well as each template `K_{d_k}`, can be regenerated. If only the terminal geometry at `d_N=0` is kept and `u` was not recorded, no such recovery of `u` is possible: all anchors coincide at zero scale. In ambient dimensions above two, planar distance anchors also leave the perpendicular direction ambiguous. These are genuine limitations and must not be erased from the theorem.

## One exact commuting diagram

The main content of the compatibility can be expressed as

```text
 nonnegative integer d --Euclidean division--> (t,rho)
         |                                   |
         | include integer scale             | reconstruct t+rho/S
         v                                   v
 real scale d --------------------------> real scale q*d
                  multiply by q
```

Both paths yield the exact same real scale. Applying the fixed labeled geometry `a -> K_a` to the bottom row preserves the equality at every individual marked point, while the normalized readout proportion `G/(G+C)` determines the chosen ideal geometric factor `lambda`.

**Combined mathematical conclusion.** With the stated Ω template, selected homogeneous measurements, evolution rule, integer lattice, quotient convention, and retained witnesses: (i) geometric scale evolution and the affine scale coordinate are conjugate, (ii) integer quantization is an exact discretization of that scaling with a *universal geometric remainder correction*, (iii) each integer history is exactly reversible, and (iv) the canonical limb domain implements the same integer next-state as the exact irrational factor. This is a unified structure-preserving *model*; it is not a theorem that geometry alone compels `lambda`, or that Ω automatically represents arbitrary semantics, quantum processes, or neural computation.

## Executable evidence

Companion program: `omega_unification_checker.py` (Python 3.10+, standard library only). It uses exact integers and `fractions.Fraction`, derives an interval for `lambda` using certified series bounds, tests 32,768 canonical seeds and 753,664 prefix identities, checks 50,001 consecutive floor fibers and their predecessors, checks 32,768 geometry identities/localizations, and performs 32,768 full 23-step ledger reversals. The program is a finite corroboration; the all-domain claims above have mathematical proofs.