# OMEGA NAUGHT ## Geometric–Arithmetic Unification: Full Proofs and Executable Python and Java Certificates **Prepared for Matthew Alan Newman** **Date:** 24 October 2026 **Version:** 2.0 — self-contained mathematical statement, two complete implementations, and fresh execution evidence. > **Central thesis.** A fixed labeled OMEGA geometry, its selected scale ratio, its affine scale coordinate, and its quantized integer representation fit into one exact compatibility system. The Euclidean remainder is the unique scalar discrepancy between rational scaling and integer quantization. That same scalar corrects every correspondingly labeled geometric point and every degree-one homogeneous scale readout. Retaining valid ordered witnesses makes every finite integer history exactly recoverable. This is a mathematical unification **within the explicitly defined model**. It does not assert that the unit circle alone forces a particular evolution rule, or that exact mathematical recoverability establishes physical transmission, cognition, or neural-network performance. The motivating OMEGA construction and research direction are Newman's. The exposition and implementations here are AI-assisted. No priority claim, independent peer review, or proof-assistant certification is asserted. The file contains the mathematical proofs, the complete Python program, the complete Java program, reproduction commands, and the observed execution record. No companion source file is needed to reconstruct either program. --- ## 1. Definitions and the exact claim ### 1.1 The labeled geometric reference Start with the unit circle, the **naught** stage. Put \[ \varphi=\frac{1+\sqrt5}{2},\qquad 0<\varepsilon<\pi,\qquad s=\sin(\varepsilon/2),\qquad c=\cos(\varepsilon/2). \] Orient the opening downward. A precise planar OMEGA template is \[ K=\{(x,y):x^2+y^2=1,\ y\ge -c\} \ \cup\ \{(x,-c):s\le |x|\le s+\varphi^2\}. \] Its six baseline marks, in their order, have horizontal coordinates \[ (-s-\varphi^2,\,-s-1,\,-s,\,s,\,s+1,\,s+\varphi^2). \] Their consecutive gaps are \[ (\varphi,1,2s,1,\varphi), \] because \(\varphi^2=\varphi+1\). All six marks lie on the same line. The circular arc, not the six baseline marks alone, supplies noncollinear anchors. The canonical opening is \(\varepsilon=\pi/648000\). None of the scale-discrepancy or ledger proofs below depends on that particular opening size. For every \(a\ge0\), define the scaled reference by its labeled placement map \[ \kappa_a:K\longrightarrow\mathbb R^2,\qquad \kappa_a(p)=ap. \] Write \(K_a\) for this labeled reference. Labels preserve the correspondence between the same template point at different scales. At \(a=0\), every geometric position collapses to the origin; the labels do not restore lost spatial separation. The fixed center, template, labels, orientation convention, and length calibration are part of the representation. An uncalibrated shape known only up to similarity does not supply an absolute scale. ### 1.2 Selected homogeneous readouts and evolution rule Select the outer straight segment of unit-scale length \(\varphi\), and the retained upper semicircle of unit-scale length \(\pi\). Their scaled readouts are \[ G(a)=a\varphi,\qquad C(a)=a\pi. \] Here \(C\) is a **selected semicircular readout**, not the length of the entire retained major arc. For \(a>0\), define \[ \boxed{\lambda=\frac{G(a)}{G(a)+C(a)} =\frac{\varphi}{\varphi+\pi}.} \] The ratio is not evaluated as \(0/0\) at zero scale; the constant is defined from positive scales. **Modeling rule:** geometric evolution uses this selected invariant fraction: \[ H_\lambda(K_a)=K_{\lambda a}. \] The geometry and selected readouts determine the ratio. Choosing that ratio as the time-update factor is an explicit rule, not a consequence of similarity alone. ### 1.3 Exact integer implementation Set \[ Q=339949771344778,\qquad S=10^{15},\qquad q=Q/S. \] For \(d\in\mathbb N_0=\{0,1,2,\ldots\}\), define \[ T(d)=\left\lfloor\frac{Qd}{S}\right\rfloor, \qquad \rho(d)=Qd-ST(d). \] Thus \[ 0\le\rho(d)0\), every ratio of nonzero correspondingly scaled lengths is unchanged. In particular, \(G(a)/(G(a)+C(a))=\lambda\). **Proof.** Subtract the vectors and use absolute homogeneity of the Euclidean norm: \[ \|ap-ar\|=\|a(p-r)\|=a\|p-r\|. \] For a length ratio, cancel the common positive factor \(a\). Applying this to the two selected readouts gives the displayed expression for \(\lambda\). ∎ ### Theorem 2 — Exact affine conjugacy Fix \(a_{\rm ref}>0\) and define \[ \chi(a)=1+\frac{a}{a_{\rm ref}},\qquad F(v)=1+\lambda(v-1)=\frac{\varphi v+\pi}{\varphi+\pi}. \] Then \[ \boxed{\chi(\lambda a)=F(\chi(a)).} \] For every integer \(n\ge0\), \[ H_\lambda^n(K_a)=K_{\lambda^n a},\qquad F^{\circ n}(v)=1+\lambda^n(v-1). \] On positive scales, \(\chi\) is a bijection onto \((1,\infty)\), so this compatibility is a conjugacy of the two update descriptions on those domains. **Proof.** Direct substitution gives \[ \chi(\lambda a)=1+\frac{\lambda a}{a_{\rm ref}} =1+\lambda\bigl(\chi(a)-1\bigr). \] The inverse coordinate is \(a=a_{\rm ref}(v-1)\). Induction gives the two iterate formulas. Since \(0<\lambda<1\), the unique fixed point of the real affine map is \(1\), and every real affine orbit converges to it. Positive scales approach zero, a degenerate limit reference. ∎ **Important distinction.** At any finite step, multiplication by the nonzero real number \(\lambda\) is injective and has inverse division by \(\lambda\) on its image. Exact real contraction alone is not information loss. Flooring, insufficient measurements, or retention of only a limiting value can lose distinctions. --- ## 3. The remainder is the exact discrepancy of the whole scaled geometry ### Theorem 3 — Universal pointwise correction for a fixed template Let \(d\ge0\) be an integer, \(t=T(d)\), and \(\rho=\rho(d)\). Then \[ \boxed{qd=t+\frac\rho S.}\tag{3.1} \] For **every** labeled template point \(p\), \[ \boxed{q(dp)=tp+\frac\rho S p.}\tag{3.2} \] For every scale readout satisfying \(L(a)=aL(1)\), \[ \boxed{L(qd)-L(t)=\frac\rho S L(1).}\tag{3.3} \] In particular, \[ G(qd)-G(t)=\varphi\rho/S,\qquad C(qd)-C(t)=\pi\rho/S. \] For any unit-circle mark, \(\|p\|=1\), \[ \boxed{\|qdp-tp\|=\rho/S.}\tag{3.4} \] **Proof.** Euclidean division gives the unique equation \[ Qd=St+\rho,\qquad 0\le\rhoq\). Therefore \(\varepsilon^\lambda(d)>0\) for every positive integer \(d\). On the floor-agreement domain it also proves \(\varepsilon^\lambda(d)<1\). These conclusions do not require a separate transcendence argument. ### The exact commuting identity Define \[ E(d)=(T(d),\rho(d)),\qquad J(t,\rho)=t+\rho/S. \] Then \[ \boxed{J\circ E=(d\mapsto qd).} \] ```text integer scale d ---- E ----> (integer output t, remainder rho) | | | include in the real scales | J(t,rho) = t + rho/S v v real scale d -------- multiply by q --> real scale q*d ``` Both paths give exactly the same scale. Applying \(a\mapsto\kappa_a(p)\) gives exactly the same point for every label \(p\). This is the direct structure-preserving link, not merely a comparison between two unrelated equations. The corresponding ideal-factor reconstruction on a valid record is \[ J_\lambda(t,\rho)=\frac{\lambda}{Q}(St+\rho), \qquad J_\lambda(E(d))=\lambda d. \] It uses \(\lambda\) explicitly and does not substitute \(q=\lambda\). --- ## 4. Every finite integer history has an explicit inverse ### Theorem 5 — One-step reconstruction The map \(d\mapsto(T(d),\rho(d))\) is injective. Its inverse on valid records is \[ \boxed{d=\frac{St+\rho}{Q}.}\tag{4.1} \] A candidate pair is valid exactly when \(t\) is a nonnegative integer, \(\rho\) is an integer in \([0,S)\), and \(St+\rho\) is divisible by \(Q\). **Proof.** Rearranging the Euclidean division identity gives (4.1), hence uniqueness. Conversely, under the stated validity conditions, the recovered \(d\) is a nonnegative integer and \[ Qd/S=t+\rho/S,\qquad 0\le\rho/S<1. \] Thus its floor is \(t\), and its Euclidean remainder is \(\rho\). ∎ ### Theorem 6 — Ordered history reconstruction and telescoping For \(d_{k+1}=T(d_k)\), write \(\rho_k=Qd_k-Sd_{k+1}\). Given \(Q,S,N,d_N\) and the ordered witnesses \(\rho_0,\ldots,\rho_{N-1}\), every state is uniquely recoverable by \[ d_k=\frac{Sd_{k+1}+\rho_k}{Q},\qquad k=N-1,\ldots,0. \] Moreover, \[ \boxed{Q^N d_0=S^N d_N+ \sum_{k=0}^{N-1}\rho_k S^kQ^{N-1-k}.}\tag{4.2} \] **Proof.** Apply Theorem 5 at the last step, then continue by backward induction. For (4.2), multiply \[ Qd_k-Sd_{k+1}=\rho_k \] by \(S^kQ^{N-1-k}\) and sum over \(k=0,\ldots,N-1\). Each interior state term cancels the term beside it. The uncanceled terms are \(Q^Nd_0\) and \(-S^Nd_N\). For \(N=0\), the empty sum gives \(d_0=d_0\). ∎ The theorem applies to **every finite horizon**, not just 23. The checkers separately test the canonical finite domain and every prefix through horizon 23. An efficient exact prefix check uses \[ W_0=0,\qquad W_{n+1}=QW_n+\rho_nS^n, \] so that \[ Q^nd_0=S^nd_n+W_n. \] This is the full accumulated identity, not merely a count of one-step equalities. ### Theorem 7 — Exact difference between ideal and quantized trajectories Let \(e_k=\rho_k/S\). Then \[ d_N=q^Nd_0-\sum_{k=0}^{N-1}q^{N-1-k}e_k, \] and hence \[ \boxed{\lambda^Nd_0-d_N =(\lambda^N-q^N)d_0+ \sum_{k=0}^{N-1}q^{N-1-k}e_k.}\tag{4.3} \] Equivalently, \[ \boxed{\lambda^Nd_0-d_N =\sum_{k=0}^{N-1}\lambda^{N-1-k}(e_k+\Delta d_k).}\tag{4.4} \] For \(N>0\), the quantization-only sum satisfies \[ 0\le\sum_{k=0}^{N-1}q^{N-1-k}e_k <\frac{1-q^N}{1-q}. \] **Proof.** Iterate \(d_{k+1}=qd_k-e_k\) by induction for (4.3). Alternatively, put \(D_k=\lambda^kd_0-d_k\). Equation (3.5) implies \[ D_{k+1}=\lambda D_k+e_k+\Delta d_k,\qquad D_0=0. \] Iterate this recurrence to obtain (4.4). The strict bound follows from \(0\le e_k<1\) and summing a finite geometric series. ∎ Multiplying these scalar discrepancy identities by any template point gives the corresponding vector discrepancies of the full labeled geometry. The ideal trajectory \(K_{\lambda^kd_0}\) and the quantized trajectory \(K_{d_k}\) are generally different. A complete valid ledger reconstructs \(d_0\), after which both trajectories can be regenerated. Repeated flooring is not generally the same operation as taking one floor after \(k\) exact scalings. ### Extinction is compatible with recovery, not recovery from zero alone For every positive integer \(d\), \(0S,\qquad 2Q1. \] For \(x=1/n\in(0,1)\), the finite geometric identity gives \[ \frac1{1+t^2}=\sum_{k=0}^{m-1}(-1)^kt^{2k} +\frac{(-1)^m t^{2m}}{1+t^2}. \] Integrating from 0 to \(x\) proves that the remainder after \(A_m(n)\) has sign \((-1)^m\). Thus even term counts give strict lower bounds on \(\arctan(1/n)\), and odd term counts give strict upper bounds. Use Machin's identity \[ \pi=16\arctan(1/5)-4\arctan(1/239). \] For completeness, let \(\alpha=\arctan(1/5)\) and \(\beta=\arctan(1/239)\). Tangent doubling gives \(\tan(2\alpha)=5/12\) and \(\tan(4\alpha)=120/119\); tangent subtraction then gives \(\tan(4\alpha-\beta)=1\). Also \(0<4\alpha-\beta<4/5\). Since \(\pi/2=2\arctan(1)>1\), the angle lies in \((0,\pi/2)\), where tangent is injective. Therefore \(4\alpha-\beta=\pi/4\), proving the identity. The inequality \(\arctan(1)>1/2\) follows directly by integrating \(1/(1+t^2)>1/2\) on \(00\), (6.1) squeezes \(\lambda d\) between these bounds; at \(d=0\), both floors are zero directly. Therefore the floor is \(t\) in every case. The exact programs below enumerate the entire claimed domain, not a random sample. ∎ The canonical domain is closed under \(T\), since \(0\le T(d)\le d\). Thus, from a canonical seed, repeated application of \(T\) agrees at every step with repeated application of \(d\mapsto\lfloor\lambda d\rfloor\). This still does not equate either iterated floor map with \(d\mapsto\lfloor\lambda^nd\rfloor\). There is no unrestricted floor equality. Both programs verify the specific counterexample \[ d=42189065:\quad \lfloor qd\rfloor=14342162,\qquad \lfloor\lambda d\rfloor=14342163. \] They verify the second floor using the same rational enclosure. **This version certifies a disagreement at that seed; it does not independently certify that it is the first disagreement.** --- ## 7. Geometric localization and its exact boundary ### Theorem 11 — Three retained circle anchors determine every planar point Because \(0<\varepsilon<\pi\), the points \[ A_0=(-1,0),\qquad A_1=(1,0),\qquad A_2=(0,1) \] are on the retained arc. At a known positive scale \(a\), measure the squared distances of a planar point \(x=(x_1,x_2)\): \[ \delta_i=\|x-aA_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{7.1} \] **Proof.** Expand: \[ \delta_0=(x_1+a)^2+x_2^2,\quad \delta_1=(x_1-a)^2+x_2^2,\quad \delta_2=x_1^2+(x_2-a)^2. \] Subtract to obtain \(\delta_0-\delta_1=4ax_1\) and \(\delta_0+\delta_1-2\delta_2=4ax_2\). Since \(a>0\), divide to obtain (7.1). ∎ This determines every point in the plane, not only points inside the circle or anchor triangle. It determines a position **relative to the calibrated, labeled reference**; it does not infer an external absolute orientation from distances. The formulas produce a candidate for any triple. A triple is a valid exact planar record only if the reconstructed point reproduces all three nonnegative squared distances. Both implementations enforce this consistency test. For two measured points with profiles \(\delta\) and \(\eta\), set \[ D_1(\delta)=\delta_0-\delta_1,\qquad D_2(\delta)=\delta_0+\delta_1-2\delta_2. \] Their squared separation is \[ \boxed{\|x-y\|^2= \frac{(D_1(\delta)-D_1(\eta))^2+ (D_2(\delta)-D_2(\eta))^2}{16a^2}.}\tag{7.2} \] This follows by subtracting (7.1) for the two points. The checkers verify its cleared-denominator polynomial identity in free variables. ### Theorem 12 — What any planar distance reference cannot distinguish Let \(P\) be the plane of the reference in a real Hilbert space. Write a point as \(x=p+w\), where \(p\in P\) is its orthogonal projection and \(w\) is perpendicular to the plane. For every anchor \(a\in P\), \[ \boxed{\|x-a\|^2=\|p-a\|^2+\|w\|^2.}\tag{7.3} \] For the noncollinear planar anchors above, their distances determine precisely \(p\) and \(\|w\|\), not the perpendicular direction. **Proof.** The two difference components are orthogonal, so expanding the squared norm gives (7.3). Subtracting the squared-distance equations cancels \(\|w\|^2\), and (7.1) recovers the planar projection. One remaining squared-distance equation gives \(\|w\|^2\). Conversely, every point with that projection and perpendicular magnitude satisfies the same equations for every planar anchor. ∎ In three dimensions a nonzero perpendicular magnitude gives two reflected positions. In four dimensions it gives a circle of possible normal vectors. More generally it gives the corresponding sphere in the normal space. At normal magnitude zero the point is already in the reference plane. A fourth anchor outside the plane resolves the three-dimensional ambiguity. More generally, distances to \(n+1\) affinely independent anchors determine every point of \(\mathbb R^n\): subtracting their squared-distance equations gives \(n\) independent linear equations. At most \(n\) anchors lie in a proper affine subspace, and reflection across that subspace supplies indistinguishable points. Thus \(n+1\) is the minimum for unrestricted recovery in \(\mathbb R^n\). **Hilbert-space form.** For any nonempty anchor set \(A\), labeled distances to all of \(A\) determine every point of a real Hilbert space \(H\) if and only if \(\overline{\operatorname{aff}}A=H\). To prove this, fix \(a_0\in A\) and let \(V=\overline{\operatorname{span}}(A-a_0)\). Equal squared-distance profiles imply, by subtraction, that the difference of the two projections onto \(V\) is orthogonal to every \(a-a_0\), hence to \(V\); that difference is also in \(V\), so it vanishes. The remaining equation fixes only the norm in \(V^\perp\). If \(V=H\), nothing remains. If \(V\ne H\), choose a nonzero \(w\in V^\perp\); the distinct points \(a_0+w\) and \(a_0-w\) have identical profiles. ∎ This Hilbert-space extension is proved deductively; the finite programs are not claimed to enumerate infinite-dimensional states. ### Theorem 13 — Combined geometric and arithmetic state recovery Suppose an initial state consists of an integer scale \(d_0>0\), the known template, and a planar point \(x_0=d_0u\), with fixed normalized position \(u\). Retain: - the terminal integer scale and a valid ordered witness ledger; - the initial calibrated squared-distance profile of \(x_0\) to the three anchors at scale \(d_0\). Then every quantized geometry \(K_{d_k}\) and every associated point \(x_k=d_ku\) is exactly reconstructible. **Proof.** Theorem 6 recovers \(d_0,\ldots,d_N\). Theorem 11 then recovers \(x_0\) using its initial profile and the recovered positive scale. Divide by \(d_0\) to obtain \(u\). Finally form \(d_ku\) and \(K_{d_k}\) for every \(k\). ∎ If only the terminal reference at scale zero is retained, its collapsed anchors cannot recover an unrecorded \(u\). A scale witness does not recover independent, unrecorded changes of shape, rotation, translation, or position. --- ## 8. Finite-message representation and preservation of relationships These results complete the earlier coverage discussion. They are separate from the forced geometric-discrepancy identity: a message code is a specified convention, not an inherent semantic meaning of a shape. ### Theorem 14 — An explicit reversible code for every finite byte message For a byte string \(m\) of length \(L\), define \[ \boxed{N(m)=256^L+\operatorname{value}_{256}(m).}\tag{8.1} \] Equivalently, prepend byte `0x01` and interpret the bytes as an unsigned big-endian integer. Then \(N\) is injective, including for leading-zero messages and the empty message. **Proof.** For a fixed length, \[ 256^L\le N(m)<2\cdot256^L, \] and base-256 place values distinguish the messages. The intervals for different lengths are disjoint because \(2\cdot256^L<256^{L+1}\). In the shortest big-endian representation, the first byte is exactly `0x01`; deleting it recovers all original bytes, including their leading zeros. The empty message has code 1. ∎ A calibrated reference at scale \(a=N(m)\) carries this code: the separation between its anchors \(aA_0\) and \(aA_1\) is \(2a\), which recovers \(a\) under exact measurement. A bounded-scale alternative is \[ \boxed{a(m)=1+\frac1{N(m)+1}\in(1,3/2],\qquad N(m)=\frac1{a(m)-1}-1.}\tag{8.2} \] Substitution proves the inverse. Validity requires that the recovered value is an integer with the leading-byte marker. The implementations validate both conditions. **Precision limit.** For consecutive integer values of \(N\), \[ a_N-a_{N+1}=\frac1{(N+1)(N+2)}\longrightarrow0. \] Arbitrarily long byte strings therefore do not fit into a fixed bounded scale range at a fixed positive resolution. Normalizing all copies to the same scale also erases this scale code. Exact representability is not a finite-precision storage or communication guarantee. ### Theorem 15 — Exact composition with a witness history For every finite message, encode \(N(m)\), run any finite number of rational floor steps, and retain the terminal state and a valid ordered remainder or rank ledger. The message is recoverable exactly. **Proof.** Theorem 6, or its rank-witness version using (5.3), recovers \(N(m)\). Theorem 14 decodes the message. Composition of these explicit inverses gives the result. ∎ For message integers outside the canonical limb domain, this theorem concerns the exact rational map \(T\). It does not silently extend the certified \(\lambda\)-floor agreement domain. ### Theorem 16 — Which relationships survive observation Let \(O:X\to Y\) be an observation map and \(P:X\to Z\) a specified property. There exists a function \(p:O(X)\to Z\) with \(P=p\circ O\) if and only if \(P\) is constant on every observation fiber. **Proof.** If \(P=p\circ O\), equal observations necessarily give equal property values. Conversely, define \(p(y)=P(x)\) for any \(x\) with \(O(x)=y\). Constancy on the fiber makes the definition independent of the selected preimage. ∎ For a relation on several inputs, apply this statement to the componentwise observation map on the corresponding product set. When an encoding \(E:X\to Y\) is injective, an operation \(f:X\to X\) transports exactly to its image by \[ f_E=E\circ f\circ E^{-1},\qquad f_E(E(x))=E(f(x)). \] Substitution proves the identity. This is a structural preservation result; it does not discover meanings or correspondence rules that were never specified. --- ## 9. The combined theorem and the limits of the conclusion ### Combined Geometric–Arithmetic Compatibility and Recovery Theorem Under the definitions in Section 1: 1. Uniform scaling preserves the OMEGA proportions, and the selected readouts determine the scale-independent number \(\lambda\). 2. The chosen \(\lambda\)-scale evolution is exactly conjugate to the affine update \(v\mapsto1+\lambda(v-1)\). 3. Rational scaling and integer quantization are connected by the unique scalar discrepancy \(\rho/S\); it corrects every labeled template point and every degree-one homogeneous scale readout simultaneously. 4. The actual \(\lambda\)-scaling discrepancy is exactly \(\rho/S+(\lambda-q)d\), with neither term omitted. 5. A terminal state and valid ordered witnesses recover every finite integer history, and hence all corresponding scaled copies of the known geometry. The canonical floor map has a two-bit optimal worst-case fixed-width predecessor witness. 6. On the certified 15-bit domain, the rational implementation gives exactly the same next integer state as flooring the actual geometric factor. Sufficient retained planar measurements also permit reconstruction of the associated planar configuration. **Proof.** Statements 1–2 are Theorems 1–2. Statements 3–4 are Theorems 3–4. Statement 5 is Theorems 5–9. Statement 6 is the exact finite certificate of Theorem 10 and the inverse construction in Theorem 13. Each composition uses explicitly matching inputs and outputs, so none depends on an unstated identification between the real and integer representations. ∎ The deeper connection is the **same scale variable and the same forced discrepancy** operating across the geometric and arithmetic descriptions. The remainder is not an unrelated payload: it is exactly the correction required by the chosen quantization. The theorem does **not** prove that geometry alone forces the evolution rule, that this system is unique among mathematical models, that arbitrary observations preserve all distinctions, that witnesses are free of storage cost, or that the construction automatically supplies physical transmission, cryptographic security, cognition, or neural-network advantages. --- ## 10. What the executable evidence establishes ### 10.1 Symbolic certificates are not sample-point tests Each implementation includes a small sparse polynomial normalizer with integer coefficients. A monomial is represented by a sorted string of variable names; for example `aax` represents \(a^2x\). Addition combines coefficients, multiplication concatenates and sorts monomials, and zero coefficients are removed. **Soundness of the method.** By induction on expression construction, these operations represent the corresponding sums and products in the commutative polynomial ring. If an expression normalizes to the empty coefficient map, it is the zero polynomial and vanishes for every real assignment of its variables. Cleared-denominator identities then imply the original rational identities wherever the denominators are nonzero. The programs check 11 free-variable identities: | Certificate | Identity represented | |---|---| | 1 | Cancellation of the common scale in the selected readout ratio | | 2 | Squared-distance scaling under uniform similarity | | 3 | Affine scale conjugacy with the reference denominator cleared | | 4 | Rational geometric correction after substituting \(t=qd-e\) | | 5 | Actual-factor correction with \(\lambda=q+\Delta\) | | 6–7 | The two planar inverse-coordinate numerators | | 8 | Orthogonal squared-distance decomposition | | 9 | Recovery of the separation of two points from their profiles | | 10 | Two-step rational discrepancy accumulation | | 11 | Two-step actual-factor discrepancy accumulation | The general all-horizon results still use the deductive induction and telescoping proofs above. The symbolic programs are not proof-assistant kernels and do not formally verify their own implementation, runtime, compiler, or hardware. ### 10.2 Exact finite certificates and implementation audits The \(\lambda\)-floor certificate derives rational bounds and checks every integer in its stated finite domain. History audits verify both the local division identity and the full accumulated telescoping identity, then reconstruct every intermediate state through both witness formats. Zero scale is counted as a geometric **scale identity** case, but never as a positive-scale planar localization. This corrects the ambiguity of describing all 32,768 earlier geometry cases as planar recovery cases: exactly 32,767 have positive scale. Both programs use exact integer arithmetic. Python additionally uses `fractions.Fraction` and `math.isqrt`; Java uses `BigInteger` and the included reduced-rational class. The relevant standard-library contracts are listed in Section 15 [P1, P2, J1]. Java state arithmetic deliberately uses `BigInteger`, not `long`: even \(Q\cdot32767\) is larger than the maximum signed 64-bit integer. Validation uses explicit exceptions, not language `assert` statements. This matters because Python's optimized mode can omit assertions [P3], and Java assertions are disabled by default [J2]. The checks remain active in all execution modes reported below. The two implementations are separately executed translations of the same mathematical specification. Agreement is useful cross-language evidence, not independent mathematical peer review. ### 10.3 Observed counts, per implementation | Check | Domain actually checked / observed result | |---|---:| | Free-variable polynomial identities | 11 | | Certified \(\lambda\)-versus-\(q\) floor agreement | All 32,768 states, 0 through 32,767 | | Disagreement outside that domain | 1 certified example | | Consecutive output fibers | 50,001 | | Predecessors in those fibers | 147,084 | | Geometric scale cases, including zero | 32,768 | | Labeled-point vector identities, four points per scale | 131,072 | | Positive-scale planar recoveries | 32,767 | | Canonical transition checks | 753,664 | | Full accumulated prefix identities | 753,664 | | Canonical complete-history reconstructions | 32,768 for each witness type | | Maximum canonical extinction horizon observed | 10 | | Zero-horizon reconstructions | 4 | | Byte messages of lengths 0, 1, and 2 | All 65,793, for each of two codecs | | Composed message/history examples | 7, for each witness type | | Malformed-input cases rejected | 15 | The seven composed examples include leading-zero messages, all 256 byte values in one message, and a 64-byte zero message. Such larger codes test arbitrary-precision arithmetic beyond the canonical limb domain; they do not enlarge the \(\lambda\)-floor certificate. The maximum fiber size and two-bit optimality are all-domain deductive results from Section 5, not extrapolations from the finite fiber audit. --- ## 11. Reproduce the calculations Save the complete Python block in Section 12 as **`omega_unified_proof.py`** and the complete Java block in Section 13 as **`OmegaUnifiedProof.java`**. Both require only their language's standard library. Python source targets Python 3.10 or later. Java source targets Java 17 or later; the Java build below explicitly uses the Java 17 release target. Run: ```bash python omega_unified_proof.py > python_run.txt python -O omega_unified_proof.py > python_optimized_run.txt javac --release 17 -Xlint:all OmegaUnifiedProof.java java -Xmx256m OmegaUnifiedProof > java_run.txt java -Xmx256m -ea OmegaUnifiedProof > java_assertions_enabled_run.txt ``` On a system providing `cmp`, compare the reports: ```bash cmp python_run.txt python_optimized_run.txt cmp python_run.txt java_run.txt cmp python_run.txt java_assertions_enabled_run.txt ``` A successful check exits with status zero and ends with `status=PASS`. Invalid input or a failed certificate raises an exception and exits unsuccessfully. The programs do not require external services, downloaded libraries, or floating-point constants. The current execution environment and the exact observed report are included in Section 14. Code hashes there identify the source bytes; hashes alone do not establish mathematical correctness. --- ## 12. Complete Python implementation Filename: **`omega_unified_proof.py`** ```python #!/usr/bin/env python3 """OMEGA NAUGHT: exact symbolic certificates and finite audits. Python 3.10+, standard library only. No floating-point arithmetic or assert statements. General theorems are proved in the accompanying Markdown; finite audits are reported with their actual domains. """ from __future__ import annotations from dataclasses import dataclass from fractions import Fraction as F from math import isqrt from typing import Callable, Iterable import sys Q = 339_949_771_344_778 S = 1_000_000_000_000_000 MAX_SEED = 32_767 HORIZON = 23 MAX_FIBER = 50_000 def require(condition: bool, message: str) -> None: """Always active, including under python -O.""" if not condition: raise RuntimeError(message) def natural(value: int, name: str) -> None: if type(value) is not int or value < 0: raise ValueError(f"{name} must be a nonnegative integer") def ceil_div(n: int, d: int) -> int: natural(n, "numerator") if type(d) is not int or d <= 0: raise ValueError("denominator must be a positive integer") return (n + d - 1) // d def boundary(y: int) -> int: natural(y, "output") return ceil_div(S * y, Q) @dataclass(frozen=True) class Step: output: int remainder: int rank: int def forward(d: int) -> Step: natural(d, "state") y, r = divmod(Q * d, S) w = d - boundary(y) require(0 <= r < S and 0 <= w <= 2, "forward invariant") return Step(y, r, w) def inverse_remainder(y: int, r: int) -> int: natural(y, "output") natural(r, "remainder") if r >= S: raise ValueError("remainder outside [0,S)") d, residue = divmod(S * y + r, Q) if residue != 0: raise ValueError("record is not divisible by Q") if divmod(Q * d, S) != (y, r): raise ValueError("inconsistent remainder record") return d def inverse_rank(y: int, w: int) -> int: natural(y, "output") natural(w, "rank witness") if w > 2: raise ValueError("rank witness must be 0, 1, or 2") d = boundary(y) + w if Q * d // S != y: raise ValueError("rank is not present in this output fiber") return d def recover_history(terminal: int, witnesses: Iterable[int], use_rank: bool = False) -> list[int]: natural(terminal, "terminal state") inverse = inverse_rank if use_rank else inverse_remainder history = [terminal] for witness in reversed(list(witnesses)): history.append(inverse(history[-1], witness)) return list(reversed(history)) def distances(a: F, x: F, y: F) -> tuple[F, F, F]: return ((x + a)**2 + y*y, (x - a)**2 + y*y, x*x + (y - a)**2) def recover_point(a: F, delta: tuple[F, F, F]) -> tuple[F, F]: if not isinstance(a, F) or any(not isinstance(z, F) for z in delta): raise ValueError("exact Fraction inputs required") if a <= 0 or len(delta) != 3 or any(z < 0 for z in delta): raise ValueError("positive scale and three squared distances required") d0, d1, d2 = delta x = (d0 - d1) / (4*a) y = (d0 + d1 - 2*d2) / (4*a) if distances(a, x, y) != tuple(delta): raise ValueError("inconsistent planar distance record") return x, y def encode_message(message: bytes) -> int: if not isinstance(message, bytes): raise ValueError("message must be bytes") return int.from_bytes(b"\x01" + message, "big") def decode_message(n: int) -> bytes: natural(n, "message integer") if n == 0: raise ValueError("zero has no leading marker") raw = n.to_bytes((n.bit_length() + 7) // 8, "big") if raw[0] != 1: raise ValueError("invalid message marker") return raw[1:] def encode_bounded(message: bytes) -> F: return F(1) + F(1, encode_message(message) + 1) def decode_bounded(a: F) -> bytes: if not isinstance(a, F): raise ValueError("exact Fraction scale required") if not F(1) < a <= F(3, 2): raise ValueError("bounded scale must lie in (1,3/2]") n = 1/(a - 1) - 1 if n.denominator != 1: raise ValueError("scale is not a message code") return decode_message(n.numerator) class Poly: """Sparse Z-polynomials; a monomial is a sorted string of variables. Example: 'aax' denotes a^2*x. This intentionally small normalizer checks algebraic identities, not just numerical sample evaluations. """ def __init__(self, terms: dict[str, int] | None = None): self.terms = {m: c for m, c in (terms or {}).items() if c != 0} @staticmethod def number(n: int) -> Poly: return Poly({"": n}) @staticmethod def variable(name: str) -> Poly: if len(name) != 1 or not name.isalpha(): raise ValueError("one-letter variable required") return Poly({name: 1}) @staticmethod def cast(value: Poly | int) -> Poly: return value if isinstance(value, Poly) else Poly.number(value) def __add__(self, other: Poly | int) -> Poly: other = Poly.cast(other) result = self.terms.copy() for monomial, coefficient in other.terms.items(): result[monomial] = result.get(monomial, 0) + coefficient return Poly(result) __radd__ = __add__ def __neg__(self) -> Poly: return Poly({m: -c for m, c in self.terms.items()}) def __sub__(self, other: Poly | int) -> Poly: return self + (-Poly.cast(other)) def __rsub__(self, other: Poly | int) -> Poly: return Poly.cast(other) + (-self) def __mul__(self, other: Poly | int) -> Poly: other = Poly.cast(other) result: dict[str, int] = {} for left, c in self.terms.items(): for right, d in other.terms.items(): monomial = "".join(sorted(left + right)) result[monomial] = result.get(monomial, 0) + c*d return Poly(result) __rmul__ = __mul__ def __pow__(self, n: int) -> Poly: natural(n, "polynomial exponent") result = Poly.number(1) for _ in range(n): result = result * self return result def symbolic_certificates() -> int: a, x, y, u, v, p, q, d, e, h, f, c, r, l, z, j = ( Poly.variable(name) for name in "axyuvpqdehfcrlzj") t = q*d - e nxt = q*t - j lam = q + h ds = lambda X, Y: ((X+a)**2 + Y**2, (X-a)**2 + Y**2, X**2 + (Y-a)**2) dx = ds(x, y) du = ds(u, v) first = dx[0] - dx[1] - du[0] + du[1] second = dx[0] + dx[1] - 2*dx[2] - du[0] - du[1] + 2*du[2] certificates = [ a*f*(f+c) - f*(a*f+a*c), (a*x-a*u)**2 + (a*y-a*v)**2 - a**2*((x-u)**2+(y-v)**2), (r+l*a) - (r+l*((r+a)-r)), q*d*p - (t*p+e*p), lam*d*p - (t*p+(e+h*d)*p), dx[0]-dx[1]-4*a*x, dx[0]+dx[1]-2*dx[2]-4*a*y, ((x+a)**2+y**2+z**2)-dx[0]-z**2, 16*a**2*((x-u)**2+(y-v)**2)-first**2-second**2, q**2*d-nxt-q*e-j, lam**2*d-nxt-lam*(e+h*d)-(j+h*t), ] for index, expression in enumerate(certificates, 1): require(not expression.terms, f"symbolic certificate {index}") # A nonidentity must not normalize to zero. require(bool((x*x + 1 - x*x).terms), "normalizer negative control") return len(certificates) def atan_sum(inverse: int, terms: int) -> F: return sum((F((-1)**k, (2*k+1)*inverse**(2*k+1)) for k in range(terms)), F(0)) def lambda_bracket() -> tuple[F, F]: b = 10**30 n = 5*b*b root = isqrt(n) require(root*root < n < (root+1)**2, "strict sqrt(5) bracket") phi_low = F(b+root, 2*b) phi_high = F(b+root+1, 2*b) pi_low = 16*atan_sum(5, 18)-4*atan_sum(239, 9) pi_high = 16*atan_sum(5, 19)-4*atan_sum(239, 8) require(F(3) < pi_low < pi_high < F(22, 7), "pi bracket") low = phi_low/(phi_low+pi_high) high = phi_high/(phi_high+pi_low) require(F(Q, S) < low < high < F(Q, S)+F(1, 10**14), "lambda bracket ordering") require(F(9295, 10**19) < low-F(Q, S) and high-F(Q, S) < F(9297, 10**19), "delta bracket") return low, high def audit_history(seed: int, horizon: int) -> tuple[list[int], list[int], list[int]]: natural(seed, "seed") natural(horizon, "horizon") states, remainders, ranks = [seed], [], [] q_power = s_power = 1 weighted_sum = 0 for _ in range(horizon): step = forward(states[-1]) require(Q*states[-1] == S*step.output+step.remainder, "step identity") require(inverse_remainder(step.output, step.remainder) == states[-1], "one-step remainder inverse") require(inverse_rank(step.output, step.rank) == states[-1], "one-step rank inverse") weighted_sum = Q*weighted_sum + step.remainder*s_power q_power *= Q s_power *= S require(q_power*seed == s_power*step.output+weighted_sum, "full telescoping prefix identity") states.append(step.output) remainders.append(step.remainder) ranks.append(step.rank) require(recover_history(states[-1], remainders) == states, "complete remainder-history inverse") require(recover_history(states[-1], ranks, True) == states, "complete rank-history inverse") return states, remainders, ranks def expect_rejection(action: Callable[[], object]) -> None: try: action() except ValueError: return raise RuntimeError("malformed input was accepted") def run() -> dict[str, int]: result: dict[str, int] = {} result["symbolic_polynomial_identities"] = symbolic_certificates() require(3*Q > S and 2*Q < S, "canonical ratio range") low, high = lambda_bracket() for d in range(MAX_SEED+1): t = Q*d//S require(t*low.denominator <= low.numerator*d, "lambda lower floor") require(high.numerator*d < (t+1)*high.denominator, "lambda upper floor") result["certified_lambda_floor_states"] = MAX_SEED+1 # A disagreement outside the certified domain; no minimality claim. counterexample = 42_189_065 t = Q*counterexample//S require(t == 14_342_162, "counterexample rational floor") require((t+1)*low.denominator <= low.numerator*counterexample, "counterexample lower bound") require(high.numerator*counterexample < (t+2)*high.denominator, "counterexample upper bound") result["out_of_domain_disagreement_examples"] = 1 predecessor_count = 0 first_two = None for y in range(MAX_FIBER+1): lo, hi = boundary(y), boundary(y+1) require(hi-lo in (2, 3), "floor fiber cardinality") if hi-lo == 2 and first_two is None: first_two = y for d in range(lo, hi): step = forward(d) require(step.output == y, "fiber membership") require(inverse_rank(y, step.rank) == d, "fiber rank inverse") require(inverse_remainder(y, step.remainder) == d, "fiber remainder inverse") predecessor_count += 1 require([forward(d).output for d in range(3)] == [0, 0, 0], "two-bit lower-bound example") result["consecutive_output_fibers"] = MAX_FIBER+1 result["fiber_predecessors"] = predecessor_count result["maximum_fiber_cardinality_proved"] = 3 result["optimal_fixed_width_witness_bits_proved"] = 2 max_extinction = 0 points = [(-1, 0), (1, 0), (0, 1), (3, 5)] for seed in range(MAX_SEED+1): step = forward(seed) for px, py in points: require(Q*seed*px == S*step.output*px+step.remainder*px, "geometric x discrepancy") require(Q*seed*py == S*step.output*py+step.remainder*py, "geometric y discrepancy") if seed > 0: a, x, y = F(seed), F(2*seed, 3), F(-5*seed, 7) require(recover_point(a, distances(a, x, y)) == (x, y), "positive-scale planar recovery") states, _, _ = audit_history(seed, HORIZON) require(states[-1] == 0, "canonical extinction by horizon 23") max_extinction = max(max_extinction, states.index(0)) result["geometric_scale_cases_including_zero"] = MAX_SEED+1 result["marked_point_vector_identities"] = (MAX_SEED+1)*len(points) result["positive_scale_planar_recoveries"] = MAX_SEED result["canonical_transition_checks"] = (MAX_SEED+1)*HORIZON result["canonical_telescoping_prefix_checks"] = (MAX_SEED+1)*HORIZON result["canonical_full_history_roundtrips_per_witness_type"] = MAX_SEED+1 result["maximum_extinction_horizon_observed"] = max_extinction for seed in (0, 1, MAX_SEED, 2**256+123): audit_history(seed, 0) result["zero_horizon_roundtrips"] = 4 message_count = 0 for length in range(3): for value in range(256**length): message = value.to_bytes(length, "big") require(decode_message(encode_message(message)) == message, "integer message code") require(decode_bounded(encode_bounded(message)) == message, "bounded-scale code") message_count += 1 result["messages_of_lengths_zero_through_two_per_codec"] = message_count samples = [b"", b"\0", b"\0\0", b"\0\1\xff", b"OMEGA", bytes(range(256)), bytes(64)] for message in samples: n = encode_message(message) states, remainders, ranks = audit_history(n, HORIZON) require(decode_message(recover_history(states[-1], remainders)[0]) == message, "message remainder pipeline") require(decode_message(recover_history(states[-1], ranks, True)[0]) == message, "message rank pipeline") result["composed_message_history_roundtrips_per_witness_type"] = len(samples) require(first_two is not None, "two-element fiber encountered") rejects = [lambda: forward(-1), lambda: inverse_remainder(-1, 0), lambda: inverse_remainder(0, -1), lambda: inverse_remainder(0, S), lambda: inverse_remainder(0, 1), lambda: inverse_rank(-1, 0), lambda: inverse_rank(0, -1), lambda: inverse_rank(0, 3), lambda: inverse_rank(first_two, 2), lambda: recover_point(F(0), (F(1), F(1), F(1))), lambda: recover_point(F(1), (F(0), F(0), F(0))), lambda: decode_message(0), lambda: decode_message(2), lambda: decode_bounded(F(1)), lambda: decode_bounded(F(2))] for action in rejects: expect_rejection(action) result["malformed_input_cases_rejected"] = len(rejects) return result if __name__ == "__main__": if len(sys.argv) != 1: raise SystemExit("Usage: python omega_unified_proof.py") report = run() print("OMEGA_UNIFIED_EXACT_CHECK_V2") for key, value in report.items(): print(f"{key}={value}") print("status=PASS") ``` --- ## 13. Complete Java implementation Filename: **`OmegaUnifiedProof.java`** ```java import java.math.BigInteger; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.TreeMap; /** * OMEGA NAUGHT: exact symbolic certificates and finite audits. * Java 17+, standard library only. Uses BigInteger and reduced rationals. * No floating-point arithmetic or Java assert statements. * General theorems and the scope of each audit are in the companion Markdown. */ public final class OmegaUnifiedProof { static final BigInteger ZERO = BigInteger.ZERO; static final BigInteger ONE = BigInteger.ONE; static final BigInteger Q = new BigInteger("339949771344778"); static final BigInteger S = new BigInteger("1000000000000000"); static final int MAX_SEED = 32767; static final int HORIZON = 23; static final int MAX_FIBER = 50000; static BigInteger b(long n) { return BigInteger.valueOf(n); } static void require(boolean condition, String message) { // Always active, even when Java assertions are disabled. if (!condition) throw new IllegalStateException(message); } static void natural(BigInteger n, String name) { if (n == null || n.signum() < 0) throw new IllegalArgumentException(name + " must be nonnegative"); } static BigInteger ceilDiv(BigInteger n, BigInteger d) { natural(n, "numerator"); if (d == null || d.signum() <= 0) throw new IllegalArgumentException("positive denominator required"); return n.add(d).subtract(ONE).divide(d); } static BigInteger boundary(BigInteger y) { natural(y, "output"); return ceilDiv(S.multiply(y), Q); } record Step(BigInteger output, BigInteger remainder, int rank) {} static Step forward(BigInteger d) { natural(d, "state"); BigInteger[] qr = Q.multiply(d).divideAndRemainder(S); int rank = d.subtract(boundary(qr[0])).intValueExact(); require(qr[1].signum() >= 0 && qr[1].compareTo(S) < 0 && rank >= 0 && rank <= 2, "forward invariant"); return new Step(qr[0], qr[1], rank); } static BigInteger inverseRemainder(BigInteger y, BigInteger r) { natural(y, "output"); natural(r, "remainder"); if (r.compareTo(S) >= 0) throw new IllegalArgumentException("remainder outside [0,S)"); BigInteger[] qr = S.multiply(y).add(r).divideAndRemainder(Q); if (qr[1].signum() != 0) throw new IllegalArgumentException("record is not divisible by Q"); BigInteger[] check = Q.multiply(qr[0]).divideAndRemainder(S); if (!check[0].equals(y) || !check[1].equals(r)) throw new IllegalArgumentException("inconsistent remainder record"); return qr[0]; } static BigInteger inverseRank(BigInteger y, int w) { natural(y, "output"); if (w < 0 || w > 2) throw new IllegalArgumentException("rank must be 0, 1, or 2"); BigInteger d = boundary(y).add(b(w)); if (!Q.multiply(d).divide(S).equals(y)) throw new IllegalArgumentException("rank not present in this fiber"); return d; } static List recoverRemainders(BigInteger terminal, List witnesses) { natural(terminal, "terminal state"); List history = new ArrayList<>(); history.add(terminal); for (int i = witnesses.size() - 1; i >= 0; --i) { terminal = inverseRemainder(terminal, witnesses.get(i)); history.add(terminal); } Collections.reverse(history); return history; } static List recoverRanks(BigInteger terminal, List witnesses) { natural(terminal, "terminal state"); List history = new ArrayList<>(); history.add(terminal); for (int i = witnesses.size() - 1; i >= 0; --i) { terminal = inverseRank(terminal, witnesses.get(i)); history.add(terminal); } Collections.reverse(history); return history; } /** Reduced exact rational with positive denominator. */ static final class Rat implements Comparable { final BigInteger n; final BigInteger d; Rat(BigInteger numerator, BigInteger denominator) { if (denominator.signum() == 0) throw new IllegalArgumentException("zero denominator"); if (denominator.signum() < 0) { numerator = numerator.negate(); denominator = denominator.negate(); } BigInteger gcd = numerator.gcd(denominator); n = numerator.divide(gcd); d = denominator.divide(gcd); } Rat(long numerator, long denominator) { this(b(numerator), b(denominator)); } static Rat of(long n) { return new Rat(b(n), ONE); } static Rat of(BigInteger n) { return new Rat(n, ONE); } Rat add(Rat other) { return new Rat(n.multiply(other.d).add(other.n.multiply(d)), d.multiply(other.d)); } Rat neg() { return new Rat(n.negate(), d); } Rat sub(Rat other) { return add(other.neg()); } Rat mul(Rat other) { return new Rat(n.multiply(other.n), d.multiply(other.d)); } Rat div(Rat other) { if (other.n.signum() == 0) throw new IllegalArgumentException("division by zero"); return new Rat(n.multiply(other.d), d.multiply(other.n)); } Rat square() { return new Rat(n.multiply(n), d.multiply(d)); } public int compareTo(Rat other) { return n.multiply(other.d).compareTo(other.n.multiply(d)); } boolean lt(Rat other) { return compareTo(other) < 0; } boolean le(Rat other) { return compareTo(other) <= 0; } @Override public boolean equals(Object other) { return other instanceof Rat r && n.equals(r.n) && d.equals(r.d); } @Override public int hashCode() { return 31*n.hashCode()+d.hashCode(); } @Override public String toString() { return n + "/" + d; } } static Rat[] distances(Rat a, Rat x, Rat y) { return new Rat[]{x.add(a).square().add(y.square()), x.sub(a).square().add(y.square()), x.square().add(y.sub(a).square())}; } static Rat[] recoverPoint(Rat a, Rat[] delta) { if (a.compareTo(Rat.of(0)) <= 0 || delta.length != 3) throw new IllegalArgumentException("positive scale and three distances required"); for (Rat r : delta) if (r.compareTo(Rat.of(0)) < 0) throw new IllegalArgumentException("negative squared distance"); Rat denominator = Rat.of(4).mul(a); Rat x = delta[0].sub(delta[1]).div(denominator); Rat y = delta[0].add(delta[1]).sub(Rat.of(2).mul(delta[2])).div(denominator); if (!Arrays.equals(distances(a, x, y), delta)) throw new IllegalArgumentException("inconsistent planar distance record"); return new Rat[]{x, y}; } static BigInteger encodeMessage(byte[] message) { byte[] marked = new byte[message.length + 1]; marked[0] = 1; System.arraycopy(message, 0, marked, 1, message.length); return new BigInteger(1, marked); } static byte[] decodeMessage(BigInteger n) { natural(n, "message integer"); if (n.signum() == 0) throw new IllegalArgumentException("zero has no marker"); byte[] raw = n.toByteArray(); // A valid marker is 0x01, so a valid code needs no leading sign byte. if (raw[0] != 1) throw new IllegalArgumentException("invalid message marker"); return Arrays.copyOfRange(raw, 1, raw.length); } static Rat encodeBounded(byte[] message) { return Rat.of(1).add(new Rat(ONE, encodeMessage(message).add(ONE))); } static byte[] decodeBounded(Rat a) { if (!Rat.of(1).lt(a) || !a.le(new Rat(3, 2))) throw new IllegalArgumentException("bounded scale must lie in (1,3/2]"); Rat n = Rat.of(1).div(a.sub(Rat.of(1))).sub(Rat.of(1)); if (!n.d.equals(ONE)) throw new IllegalArgumentException("noninteger message code"); return decodeMessage(n.n); } /** Sparse Z-polynomials. Sorted strings represent commutative monomials. */ static final class Poly { final Map terms; Poly(Map input) { terms = new TreeMap<>(); input.forEach((key, value) -> { if (value.signum() != 0) terms.put(key, value); }); } static Poly number(long n) { return new Poly(Map.of("", b(n))); } static Poly variable(String name) { if (name.length() != 1 || !Character.isLetter(name.charAt(0))) throw new IllegalArgumentException("one-letter variable required"); return new Poly(Map.of(name, ONE)); } Poly add(Poly other) { Map result = new TreeMap<>(terms); other.terms.forEach((key, value) -> result.merge(key, value, BigInteger::add)); return new Poly(result); } Poly neg() { Map result = new TreeMap<>(); terms.forEach((key, value) -> result.put(key, value.negate())); return new Poly(result); } Poly sub(Poly other) { return add(other.neg()); } Poly mul(Poly other) { Map result = new TreeMap<>(); for (Map.Entry left : terms.entrySet()) { for (Map.Entry right : other.terms.entrySet()) { char[] key = (left.getKey()+right.getKey()).toCharArray(); Arrays.sort(key); result.merge(new String(key), left.getValue().multiply(right.getValue()), BigInteger::add); } } return new Poly(result); } Poly scale(long n) { return mul(number(n)); } Poly pow(int n) { if (n < 0) throw new IllegalArgumentException("negative polynomial exponent"); Poly result = number(1); for (int k = 0; k < n; ++k) result = result.mul(this); return result; } } static Poly[] symbolicDistances(Poly a, Poly x, Poly y) { return new Poly[]{x.add(a).pow(2).add(y.pow(2)), x.sub(a).pow(2).add(y.pow(2)), x.pow(2).add(y.sub(a).pow(2))}; } static int symbolicCertificates() { Poly a=Poly.variable("a"), x=Poly.variable("x"), y=Poly.variable("y"); Poly u=Poly.variable("u"), v=Poly.variable("v"), p=Poly.variable("p"); Poly q=Poly.variable("q"), d=Poly.variable("d"), e=Poly.variable("e"); Poly h=Poly.variable("h"), f=Poly.variable("f"), c=Poly.variable("c"); Poly r=Poly.variable("r"), l=Poly.variable("l"), z=Poly.variable("z"); Poly j=Poly.variable("j"); Poly t=q.mul(d).sub(e), nxt=q.mul(t).sub(j), lam=q.add(h); Poly[] dx=symbolicDistances(a,x,y), du=symbolicDistances(a,u,v); Poly first=dx[0].sub(dx[1]).sub(du[0]).add(du[1]); Poly second=dx[0].add(dx[1]).sub(dx[2].scale(2)) .sub(du[0]).sub(du[1]).add(du[2].scale(2)); List certificates = List.of( a.mul(f).mul(f.add(c)).sub(f.mul(a.mul(f).add(a.mul(c)))), a.mul(x).sub(a.mul(u)).pow(2).add(a.mul(y).sub(a.mul(v)).pow(2)) .sub(a.pow(2).mul(x.sub(u).pow(2).add(y.sub(v).pow(2)))), r.add(l.mul(a)).sub(r.add(l.mul(r.add(a).sub(r)))), q.mul(d).mul(p).sub(t.mul(p).add(e.mul(p))), lam.mul(d).mul(p).sub(t.mul(p).add(e.add(h.mul(d)).mul(p))), dx[0].sub(dx[1]).sub(a.mul(x).scale(4)), dx[0].add(dx[1]).sub(dx[2].scale(2)).sub(a.mul(y).scale(4)), x.add(a).pow(2).add(y.pow(2)).add(z.pow(2)).sub(dx[0]).sub(z.pow(2)), a.pow(2).mul(x.sub(u).pow(2).add(y.sub(v).pow(2))).scale(16) .sub(first.pow(2)).sub(second.pow(2)), q.pow(2).mul(d).sub(nxt).sub(q.mul(e)).sub(j), lam.pow(2).mul(d).sub(nxt).sub(lam.mul(e.add(h.mul(d)))) .sub(j.add(h.mul(t))) ); for (int k=0; k states, List remainders, List ranks) {} static History auditHistory(BigInteger seed, int horizon) { natural(seed,"seed"); if (horizon<0) throw new IllegalArgumentException("negative horizon"); List states=new ArrayList<>(), remainders=new ArrayList<>(); List ranks=new ArrayList<>(); states.add(seed); BigInteger qPower=ONE, sPower=ONE, weightedSum=ZERO; for (int k=0;k run() { LinkedHashMap result=new LinkedHashMap<>(); result.put("symbolic_polynomial_identities",(long)symbolicCertificates()); require(Q.multiply(b(3)).compareTo(S)>0 && Q.multiply(b(2)).compareTo(S)<0, "canonical ratio range"); Rat[] bracket=lambdaBracket(); Rat low=bracket[0], high=bracket[1]; for (int i=0;i<=MAX_SEED;++i) { BigInteger d=b(i), t=Q.multiply(d).divide(S); require(t.multiply(low.d).compareTo(low.n.multiply(d))<=0, "lambda lower floor"); require(high.n.multiply(d).compareTo(t.add(ONE).multiply(high.d))<0, "lambda upper floor"); } result.put("certified_lambda_floor_states",(long)MAX_SEED+1); BigInteger counterexample=b(42189065), t=Q.multiply(counterexample).divide(S); require(t.equals(b(14342162)),"counterexample rational floor"); require(t.add(ONE).multiply(low.d).compareTo(low.n.multiply(counterexample))<=0, "counterexample lower bound"); require(high.n.multiply(counterexample).compareTo(t.add(b(2)).multiply(high.d))<0, "counterexample upper bound"); result.put("out_of_domain_disagreement_examples",1L); long predecessorCount=0; BigInteger firstTwo=null; for (int i=0;i<=MAX_FIBER;++i) { BigInteger y=b(i), lo=boundary(y), hi=boundary(y.add(ONE)); int size=hi.subtract(lo).intValueExact(); require(size==2 || size==3,"floor fiber cardinality"); if (size==2 && firstTwo==null) firstTwo=y; for (BigInteger d=lo;d.compareTo(hi)<0;d=d.add(ONE)) { Step step=forward(d); require(step.output().equals(y),"fiber membership"); require(inverseRank(y,step.rank()).equals(d),"fiber rank inverse"); require(inverseRemainder(y,step.remainder()).equals(d),"fiber remainder inverse"); ++predecessorCount; } } for (int i=0;i<3;++i) require(forward(b(i)).output().equals(ZERO),"two-bit lower-bound example"); result.put("consecutive_output_fibers",(long)MAX_FIBER+1); result.put("fiber_predecessors",predecessorCount); result.put("maximum_fiber_cardinality_proved",3L); result.put("optimal_fixed_width_witness_bits_proved",2L); int maxExtinction=0; int[][] points={{-1,0},{1,0},{0,1},{3,5}}; for (int i=0;i<=MAX_SEED;++i) { BigInteger seed=b(i); Step step=forward(seed); for (int[] point:points) { for (int coordinate:point) { BigInteger p=b(coordinate); require(Q.multiply(seed).multiply(p).equals( S.multiply(step.output()).multiply(p).add(step.remainder().multiply(p))), "geometric coordinate discrepancy"); } } if (i>0) { Rat a=Rat.of(seed), x=new Rat(seed.multiply(b(2)),b(3)); Rat y=new Rat(seed.multiply(b(-5)),b(7)); require(Arrays.equals(recoverPoint(a,distances(a,x,y)),new Rat[]{x,y}), "positive-scale planar recovery"); } History history=auditHistory(seed,HORIZON); require(history.states().get(HORIZON).equals(ZERO), "canonical extinction by 23"); maxExtinction=Math.max(maxExtinction,history.states().indexOf(ZERO)); } result.put("geometric_scale_cases_including_zero",(long)MAX_SEED+1); result.put("marked_point_vector_identities",((long)MAX_SEED+1)*points.length); result.put("positive_scale_planar_recoveries",(long)MAX_SEED); result.put("canonical_transition_checks",((long)MAX_SEED+1)*HORIZON); result.put("canonical_telescoping_prefix_checks",((long)MAX_SEED+1)*HORIZON); result.put("canonical_full_history_roundtrips_per_witness_type",(long)MAX_SEED+1); result.put("maximum_extinction_horizon_observed",(long)maxExtinction); for (BigInteger seed:List.of(ZERO,ONE,b(MAX_SEED),ONE.shiftLeft(256).add(b(123)))) auditHistory(seed,0); result.put("zero_horizon_roundtrips",4L); long messageCount=0; for (int length=0;length<=2;++length) { int limit=1<<(8*length); for (int value=0;value>> (8*j)); require(Arrays.equals(decodeMessage(encodeMessage(message)),message), "integer message code"); require(Arrays.equals(decodeBounded(encodeBounded(message)),message), "bounded-scale code"); ++messageCount; } } result.put("messages_of_lengths_zero_through_two_per_codec",messageCount); byte[] allBytes=new byte[256]; for (int i=0;i samples=List.of(new byte[0],new byte[]{0},new byte[]{0,0}, new byte[]{0,1,(byte)255},"OMEGA".getBytes(StandardCharsets.US_ASCII), allBytes,new byte[64]); for (byte[] message:samples) { History history=auditHistory(encodeMessage(message),HORIZON); BigInteger terminal=history.states().get(HORIZON); BigInteger nr=recoverRemainders(terminal,history.remainders()).get(0); BigInteger nw=recoverRanks(terminal,history.ranks()).get(0); require(Arrays.equals(decodeMessage(nr),message),"message remainder pipeline"); require(Arrays.equals(decodeMessage(nw),message),"message rank pipeline"); } result.put("composed_message_history_roundtrips_per_witness_type",(long)samples.size()); require(firstTwo!=null,"two-element fiber encountered"); final BigInteger twoFiber=firstTwo; List rejects=List.of( ()->forward(b(-1)), ()->inverseRemainder(b(-1),ZERO), ()->inverseRemainder(ZERO,b(-1)), ()->inverseRemainder(ZERO,S), ()->inverseRemainder(ZERO,ONE), ()->inverseRank(b(-1),0), ()->inverseRank(ZERO,-1), ()->inverseRank(ZERO,3), ()->inverseRank(twoFiber,2), ()->recoverPoint(Rat.of(0),new Rat[]{Rat.of(1),Rat.of(1),Rat.of(1)}), ()->recoverPoint(Rat.of(1),new Rat[]{Rat.of(0),Rat.of(0),Rat.of(0)}), ()->decodeMessage(ZERO), ()->decodeMessage(b(2)), ()->decodeBounded(Rat.of(1)), ()->decodeBounded(Rat.of(2)) ); rejects.forEach(OmegaUnifiedProof::expectRejection); result.put("malformed_input_cases_rejected",(long)rejects.size()); return result; } public static void main(String[] args) { if (args.length!=0) throw new IllegalArgumentException("Usage: java OmegaUnifiedProof"); LinkedHashMap report=run(); System.out.println("OMEGA_UNIFIED_EXACT_CHECK_V2"); report.forEach((key,value)->System.out.println(key+"="+value)); System.out.println("status=PASS"); } } ``` --- ## 14. Fresh execution evidence and source integrity The four normal/optimized/assertion-mode executions in Section 11 completed successfully in this session. Their report files are **byte-for-byte identical**. Java compilation with `--release 17 -Xlint:all` completed without diagnostics. ### Actual environment ```text $ python --version Python 3.13.5 $ java -version openjdk version "21.0.12.1" 2026-08-18 OpenJDK Runtime Environment (build 21.0.12.1+1-1-deb13u1-Debian) OpenJDK 64-Bit Server VM (build 21.0.12.1+1-1-deb13u1-Debian, mixed mode, sharing) $ javac -version javac 21.0.12.1 ``` These are the versions actually used, not a claim about the newest available releases. The Java compiler used a Java 17 release target while execution used the recorded Java 21 runtime. ### Exact common execution report ```text OMEGA_UNIFIED_EXACT_CHECK_V2 symbolic_polynomial_identities=11 certified_lambda_floor_states=32768 out_of_domain_disagreement_examples=1 consecutive_output_fibers=50001 fiber_predecessors=147084 maximum_fiber_cardinality_proved=3 optimal_fixed_width_witness_bits_proved=2 geometric_scale_cases_including_zero=32768 marked_point_vector_identities=131072 positive_scale_planar_recoveries=32767 canonical_transition_checks=753664 canonical_telescoping_prefix_checks=753664 canonical_full_history_roundtrips_per_witness_type=32768 maximum_extinction_horizon_observed=10 zero_horizon_roundtrips=4 messages_of_lengths_zero_through_two_per_codec=65793 composed_message_history_roundtrips_per_witness_type=7 malformed_input_cases_rejected=15 status=PASS ``` `maximum_fiber_cardinality_proved` and `optimal_fixed_width_witness_bits_proved` refer to the deductive theorem plus the checked defining inequalities. The finite fiber counts remain separately identified; their enumeration is not presented as an all-output exhaustive proof. ### Negative controls A normalizer control verifies that the nonzero polynomial 1 is not treated as zero. In addition, separate temporary copies of both programs were deliberately corrupted in two ways: increasing Q by one, and adding 1 to a purported zero polynomial. The Python mutations were run with optimization enabled; Java mutations were run with its default assertion setting. Every mutation failed at the intended check, exited with code 1, and did not produce a PASS report: ```text Python | wrong_Q | rejected | lambda bracket ordering | exit=1 Python | false_symbolic_identity | rejected | symbolic certificate 1 | exit=1 Java | wrong_Q | rejected | lambda bracket ordering | exit=1 Java | false_symbolic_identity | rejected | symbolic certificate 1 | exit=1 ``` The corrupted copies are not the source embedded above. These negative controls help test whether errors are detected; they do not establish that every possible bug would be detected. ### SHA-256 values of the tested UTF-8 source and report bytes | Artifact | SHA-256 | |---|---| | `omega_unified_proof.py` | `6d845f5646fcd9074d17b9eefca3c77640ea7e832aa70ca4f7b6237462306654` | | `OmegaUnifiedProof.java` | `ff46f41d7246786adfda2e6bb0107e20e56f125c7319df176202c89216db2330` | | Each of the four identical report files | `3c727ff3d73c936d26b97a5634d612a983beb296d8519893388e79e2bdea0996` | The code blocks include a final newline. Extract them verbatim with LF newlines to reproduce these source hashes. Code hashes identify bytes, not authorship, peer review, or theorem correctness. The assembled Markdown was checked to ensure that extracting its Python and Java fenced blocks reproduces the exact source bytes whose hashes appear above. The programs were then rerun from those extracted blocks, and both reports matched the common report above. --- ## 15. Provenance and implementation references ### Supplied mathematical source This document expands and audits the supplied **`OMEGA_Geometric_Arithmetic_Unification.md`**, dated 24 October 2026, together with the geometric-recovery and finite-message arguments supplied in the conversation. The earlier source note covered the pointwise remainder correction, ledger reversal, separation of the real and rational factors, two-bit witnesses, and planar localization. Its companion Python checker and execution record were inspected, but their historical PASS status was not substituted for the fresh runs above. The supplied proof-note bytes read for this revision have SHA-256: `b9100a552b25688157e8c9fbe69905f6e6cb3fe33ba44f94bbc6d6e3561035e7` The present version adds complete Java source, explicit always-active validation, full accumulated prefix checks, symbolic normal forms, negative controls, and a separately labeled positive-scale localization count. It does not modify the earlier source note or certify a website deployment. ### Official language-library documentation The mathematical conclusions above are supported by their included derivations and exact certificates. The following primary references document the implementation primitives and execution-mode behavior, rather than serving as external claims that OMEGA has been independently validated. Accessed 24 October 2026. **[P1] Python Software Foundation — `fractions`: rational-number arithmetic.** Integer numerator/denominator construction is used throughout; no float is used to create a rational constant. Source locator: `https://docs.python.org/3/library/fractions.html`. **[P2] Python Software Foundation — `math.isqrt`: integer square root.** Used to construct, then explicitly validate, the rational enclosure for square root of 5. Source locator: `https://docs.python.org/3/library/math.html#math.isqrt`. **[P3] Python Software Foundation — the `assert` statement.** The language documentation explains that optimized execution can omit assertion code. The supplied verifier instead uses explicit conditional exceptions. Source locator: `https://docs.python.org/3/reference/simple_stmts.html#the-assert-statement`. **[J1] Oracle — Java SE 17 `java.math.BigInteger`.** Documents arbitrary-precision integer operations, division with remainder, greatest common divisor, and integer square root. State inputs are nonnegative, so division has the floor semantics used by the theorem. Source locator: `https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigInteger.html`. **[J2] Oracle — Programming With Assertions.** Documents that Java assertions are disabled by default and must not perform required validation work. The supplied verifier uses explicit conditional exceptions. Source locator: `https://docs.oracle.com/javase/8/docs/technotes/guides/language/assert.html`. --- ## Final mathematical statement **OMEGA's geometry and recoverable arithmetic are linked by an exact, forced discrepancy law for a specified scale transformation. The same scalar witnesses the difference at every correspondingly labeled point; retaining valid witnesses makes every finite quantized history reversible. The affine, geometric, and integer descriptions therefore compose into one explicit compatibility-and-recovery model, without identifying rational approximation with the exact geometric factor or claiming that geometry alone selects the evolution rule.**