Documentation

Complexity.Foundations.Data.Polynomial.StagedJetArithmetic

Staged fixed-denominator jet arithmetic and integer Cramer recovery #

In the subexponential common-zero counting algorithm of OpenAI, The Exponential Time Hypothesis is False (§5.4 and Appendix B.2–B.3, printed pp. 48–50), intermediate polynomials in the Taylor variable z and the shared truncation marker V lie in the truncated bivariate algebra ℚ[V] / (V ^ ℓ)[z] / (z ^ J). Rather than performing rational arithmetic with growing denominators across exponentially many summands, the algorithm clears denominators in three fixed stages (Δ = d_den ^ k, Γ = Δ ^ (2 * ℓ - 1), and Ω = Γ ^ m_test), storing (J × ℓ) integer numerator tables and recovering the integer evaluations H_s(0) at T = 0 by exact integer division of Hermite Cramer determinants.

Main definitions #

Main results #

References #

1. Truncated bivariate jet tables for R[V] / (V ^ ℓ)[z] / (z ^ J) #

def Cslib.JetTable (J ℓ : ℕ) (R : Type u_1) :
Type u_1

A (J × ℓ) table of coefficients in R, representing a truncated bivariate polynomial in R[V] / (V ^ ℓ)[z] / (z ^ J) via (j, u) ↦ [z ^ j V ^ u].

Instances For
    theorem Cslib.JetTable.ext {J ℓ : ℕ} {R : Type u_1} {A B : JetTable J ℓ R} (h : ∀ (j : Fin J) (u : Fin ℓ), A j u = B j u) :
    A = B
    theorem Cslib.JetTable.ext_iff {J ℓ : ℕ} {R : Type u_1} {A B : JetTable J ℓ R} :
    A = B ↔ ∀ (j : Fin J) (u : Fin ℓ), A j u = B j u
    def Cslib.JetTable.of {J ℓ : ℕ} {R : Type u_1} (f : Fin J → Fin ℓ → R) :
    JetTable J ℓ R

    Explicit constructor casting Fin J → Fin ℓ → R to JetTable J ℓ R (analogous to Matrix.of).

    Instances For
      @[simp]
      theorem Cslib.JetTable.of_apply {J ℓ : ℕ} {R : Type u_1} (f : Fin J → Fin ℓ → R) (j : Fin J) (u : Fin ℓ) :
      of f j u = f j u
      def Cslib.JetTable.zero {J ℓ : ℕ} {R : Type u_1} [Zero R] :
      JetTable J ℓ R

      The zero (J × ℓ) jet table.

      Instances For
        def Cslib.JetTable.const {J ℓ : ℕ} {R : Type u_1} [Zero R] (c : R) :
        JetTable J ℓ R

        Embed a scalar c : R at degree (0, 0) of a (J × ℓ) jet table.

        Instances For
          def Cslib.JetTable.one {J ℓ : ℕ} {R : Type u_1} [Zero R] [One R] :
          JetTable J ℓ R

          The multiplicative identity jet table 1 = const 1.

          Instances For
            def Cslib.JetTable.add {J ℓ : ℕ} {R : Type u_1} [Add R] (A B : JetTable J ℓ R) :
            JetTable J ℓ R

            Pointwise addition of (J × ℓ) jet tables.

            Instances For
              def Cslib.JetTable.neg {J ℓ : ℕ} {R : Type u_1} [Neg R] (A : JetTable J ℓ R) :
              JetTable J ℓ R

              Pointwise negation of a (J × ℓ) jet table.

              Instances For
                def Cslib.JetTable.sub {J ℓ : ℕ} {R : Type u_1} [Sub R] (A B : JetTable J ℓ R) :
                JetTable J ℓ R

                Pointwise subtraction of (J × ℓ) jet tables.

                Instances For
                  def Cslib.JetTable.smul {J ℓ : ℕ} {R : Type u_1} {S : Type u_2} [SMul S R] (c : S) (A : JetTable J ℓ R) :
                  JetTable J ℓ R

                  Entrywise scalar multiplication on a (J × ℓ) jet table.

                  Instances For
                    def Cslib.JetTable.conv {J ℓ : ℕ} {R : Type u_1} [Semiring R] (A B : JetTable J ℓ R) :
                    JetTable J ℓ R

                    Truncated 2D convolution on (J × ℓ) jet tables, implementing multiplication in R[V] / (V ^ ℓ)[z] / (z ^ J).

                    Instances For
                      def Cslib.JetTable.vPow {J ℓ : ℕ} {R : Type u_1} [Zero R] [One R] (s : ℕ) :
                      JetTable J ℓ R

                      The monomial V ^ s modulo (z ^ J, V ^ ℓ) as a (J × ℓ) jet table.

                      Instances For
                        @[simp]
                        theorem Cslib.JetTable.zero_apply {J ℓ : ℕ} {R : Type u_1} [Zero R] (j : Fin J) (u : Fin ℓ) :
                        zero j u = 0
                        @[simp]
                        theorem Cslib.JetTable.const_apply {J ℓ : ℕ} {R : Type u_1} [Zero R] (c : R) (j : Fin J) (u : Fin ℓ) :
                        const c j u = if ↑j = 0 ∧ ↑u = 0 then c else 0
                        @[simp]
                        theorem Cslib.JetTable.one_apply {J ℓ : ℕ} {R : Type u_1} [Zero R] [One R] (j : Fin J) (u : Fin ℓ) :
                        one j u = if ↑j = 0 ∧ ↑u = 0 then 1 else 0
                        @[simp]
                        theorem Cslib.JetTable.add_apply {J ℓ : ℕ} {R : Type u_1} [Add R] (A B : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        A.add B j u = A j u + B j u
                        @[simp]
                        theorem Cslib.JetTable.neg_apply {J ℓ : ℕ} {R : Type u_1} [Neg R] (A : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        A.neg j u = -A j u
                        @[simp]
                        theorem Cslib.JetTable.sub_apply {J ℓ : ℕ} {R : Type u_1} [Sub R] (A B : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        A.sub B j u = A j u - B j u
                        @[simp]
                        theorem Cslib.JetTable.smul_apply {J ℓ : ℕ} {R : Type u_1} {S : Type u_2} [SMul S R] (c : S) (A : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        smul c A j u = c • A j u
                        @[simp]
                        theorem Cslib.JetTable.vPow_apply {J ℓ : ℕ} {R : Type u_1} [Zero R] [One R] (s : ℕ) (j : Fin J) (u : Fin ℓ) :
                        vPow s j u = if ↑j = 0 ∧ ↑u = s then 1 else 0
                        theorem Cslib.JetTable.conv_apply {J ℓ : ℕ} {R : Type u_1} [Semiring R] (A B : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        A.conv B j u = ∑ j₁ : Fin J, ∑ j₂ : Fin J with ↑j₁ + ↑j₂ = ↑j, ∑ u₁ : Fin ℓ, ∑ u₂ : Fin ℓ with ↑u₁ + ↑u₂ = ↑u, A j₁ u₁ * B j₂ u₂

                        Private index reindexing helpers #

                        Ring structure and homomorphisms on JetTable #

                        theorem Cslib.JetTable.const_conv {J ℓ : ℕ} {R : Type u_1} [CommRing R] (c : R) (A : JetTable J ℓ R) :
                        (const c).conv A = smul c A
                        theorem Cslib.JetTable.conv_const {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A : JetTable J ℓ R) (c : R) :
                        A.conv (const c) = smul c A
                        theorem Cslib.JetTable.one_conv {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A : JetTable J ℓ R) :
                        one.conv A = A
                        theorem Cslib.JetTable.conv_one {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A : JetTable J ℓ R) :
                        A.conv one = A
                        theorem Cslib.JetTable.zero_conv {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A : JetTable J ℓ R) :
                        theorem Cslib.JetTable.conv_zero {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A : JetTable J ℓ R) :
                        theorem Cslib.JetTable.conv_add {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A B C : JetTable J ℓ R) :
                        A.conv (B.add C) = (A.conv B).add (A.conv C)
                        theorem Cslib.JetTable.add_conv {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A B C : JetTable J ℓ R) :
                        (A.add B).conv C = (A.conv C).add (B.conv C)
                        theorem Cslib.JetTable.conv_comm {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A B : JetTable J ℓ R) :
                        A.conv B = B.conv A
                        theorem Cslib.JetTable.conv_assoc {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A B C : JetTable J ℓ R) :
                        (A.conv B).conv C = A.conv (B.conv C)
                        @[instance_reducible]
                        instance Cslib.JetTable.instCommRing {J ℓ : ℕ} {R : Type u_1} [CommRing R] :
                        CommRing (JetTable J ℓ R)
                        @[simp]
                        theorem Cslib.JetTable.coe_zero {J ℓ : ℕ} {R : Type u_1} [CommRing R] (j : Fin J) (u : Fin ℓ) :
                        0 j u = 0
                        @[simp]
                        theorem Cslib.JetTable.one_eq_const {J ℓ : ℕ} {R : Type u_1} [CommRing R] :
                        1 = const 1
                        @[simp]
                        theorem Cslib.JetTable.coe_add {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A B : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        (A + B) j u = A j u + B j u
                        @[simp]
                        theorem Cslib.JetTable.coe_neg {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        (-A) j u = -A j u
                        @[simp]
                        theorem Cslib.JetTable.coe_sub {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A B : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        (A - B) j u = A j u - B j u
                        @[simp]
                        theorem Cslib.JetTable.coe_nsmul {J ℓ : ℕ} {R : Type u_1} [CommRing R] (n : ℕ) (A : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        (n • A) j u = n • A j u
                        @[simp]
                        theorem Cslib.JetTable.coe_zsmul {J ℓ : ℕ} {R : Type u_1} [CommRing R] (n : ℤ) (A : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        (n • A) j u = n • A j u
                        theorem Cslib.JetTable.mul_eq_conv {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A B : JetTable J ℓ R) :
                        A * B = A.conv B
                        @[simp]
                        theorem Cslib.JetTable.sum_apply {J ℓ : ℕ} {R : Type u_1} [CommRing R] {ι : Type u_2} (s : Finset ι) (F : ι → JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                        (∑ i ∈ s, F i) j u = ∑ i ∈ s, F i j u
                        def Cslib.JetTable.constRingHom (J ℓ : ℕ) (R : Type u_2) [CommRing R] :
                        R →+* JetTable J ℓ R

                        Scalar embedding c ↦ const c as a ring homomorphism R →+* JetTable J ℓ R.

                        Instances For
                          theorem Cslib.JetTable.const_mul {J ℓ : ℕ} {R : Type u_1} [CommRing R] (c : R) (A : JetTable J ℓ R) :
                          const c * A = smul c A
                          @[simp]
                          theorem Cslib.JetTable.const_mul_const {J ℓ : ℕ} {R : Type u_1} [CommRing R] (a b : R) :
                          const a * const b = const (a * b)
                          @[simp]
                          theorem Cslib.JetTable.const_pow {J ℓ : ℕ} {R : Type u_1} [CommRing R] (c : R) (n : ℕ) :
                          const c ^ n = const (c ^ n)
                          theorem Cslib.JetTable.zsmul_eq_const_mul {J ℓ : ℕ} {R : Type u_1} [CommRing R] (c : ℤ) (A : JetTable J ℓ R) :
                          c • A = const ↑c * A
                          def Cslib.JetTable.mapRingHom {J ℓ : ℕ} {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] (f : R →+* S) :
                          JetTable J ℓ R →+* JetTable J ℓ S

                          Apply a ring homomorphism f : R →+* S entrywise to a (J × ℓ) jet table.

                          Instances For
                            @[simp]
                            theorem Cslib.JetTable.mapRingHom_apply {J ℓ : ℕ} {R : Type u_1} [CommRing R] {S : Type u_2} [CommRing S] (f : R →+* S) (A : JetTable J ℓ R) (j : Fin J) (u : Fin ℓ) :
                            (mapRingHom f) A j u = f (A j u)
                            def Cslib.JetTable.castRingHom {J ℓ : ℕ} (R : Type u_2) [CommRing R] :
                            JetTable J ℓ ℤ →+* JetTable J ℓ R

                            Canonical integer-cast homomorphism JetTable J ℓ ℤ →+* JetTable J ℓ R (in particular JetTable J ℓ ℤ →+* JetTable J ℓ ℚ for R = ℚ).

                            Instances For
                              @[simp]
                              theorem Cslib.JetTable.castRingHom_apply {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A : JetTable J ℓ ℤ) (j : Fin J) (u : Fin ℓ) :
                              (castRingHom R) A j u = ↑(A j u)
                              @[simp]
                              theorem Cslib.JetTable.castRingHom_const {J ℓ : ℕ} {R : Type u_1} [CommRing R] (c : ℤ) :
                              (castRingHom R) (const c) = const ↑c
                              @[simp]
                              theorem Cslib.JetTable.castRingHom_vPow {J ℓ : ℕ} {R : Type u_1} [CommRing R] (s : ℕ) :
                              noncomputable def Cslib.JetTable.ofBivarPoly (J ℓ : ℕ) {R : Type u_2} [CommRing R] :

                              Quotient extraction homomorphism R[V][z] →+* JetTable J ℓ R sending a bivariate polynomial p : Polynomial (Polynomial R) to its low-degree coefficient table (j, u) ↦ (p.coeff j).coeff u.

                              Instances For
                                @[simp]
                                theorem Cslib.JetTable.ofBivarPoly_apply {J ℓ : ℕ} {R : Type u_1} [CommRing R] (p : Polynomial (Polynomial R)) (j : Fin J) (u : Fin ℓ) :
                                (ofBivarPoly J ℓ) p j u = (p.coeff ↑j).coeff ↑u
                                noncomputable def Cslib.JetTable.ofPolyZ (J ℓ : ℕ) {R : Type u_2} [CommRing R] :

                                Embed a univariate z-polynomial p : R[X] into JetTable J ℓ R along V ^ 0.

                                Instances For
                                  @[simp]
                                  theorem Cslib.JetTable.ofPolyZ_apply {J ℓ : ℕ} {R : Type u_1} [CommRing R] (p : Polynomial R) (j : Fin J) (u : Fin ℓ) :
                                  (ofPolyZ J ℓ) p j u = if ↑u = 0 then p.coeff ↑j else 0
                                  def Cslib.JetTable.transpose {J ℓ : ℕ} {R : Type u_2} [CommRing R] :
                                  JetTable ℓ J R →+* JetTable J ℓ R

                                  Transpose homomorphism JetTable ℓ J R →+* JetTable J ℓ R swapping the two table indices (u, j) ↔ (j, u).

                                  Instances For
                                    @[simp]
                                    theorem Cslib.JetTable.transpose_apply {J ℓ : ℕ} {R : Type u_2} [CommRing R] (A : JetTable ℓ J R) (j : Fin J) (u : Fin ℓ) :
                                    transpose A j u = A u j
                                    noncomputable def Cslib.JetTable.ofPolyVPolyZ (J ℓ : ℕ) {R : Type u_2} [CommRing R] :

                                    Quotient extraction homomorphism R[z][V] →+* JetTable J ℓ R sending a bivariate polynomial Q : Polynomial (Polynomial R) (outer variable V, inner variable z) to its (J × ℓ) coefficient table (j, u) ↦ (Q.coeff u).coeff j, obtained by composing ofBivarPoly ℓ J with transpose.

                                    Instances For
                                      @[simp]
                                      theorem Cslib.JetTable.ofPolyVPolyZ_apply {J ℓ : ℕ} {R : Type u_2} [CommRing R] (Q : Polynomial (Polynomial R)) (j : Fin J) (u : Fin ℓ) :
                                      (ofPolyVPolyZ J ℓ) Q j u = (Q.coeff ↑u).coeff ↑j
                                      @[simp]
                                      theorem Cslib.JetTable.ofPolyVPolyZ_C {J ℓ : ℕ} {R : Type u_2} [CommRing R] (p : Polynomial R) :
                                      (ofPolyVPolyZ J ℓ) (Polynomial.C p) = (ofPolyZ J ℓ) p

                                      Embedding a z-polynomial p : Polynomial R into R[z][V] via Polynomial.C and extracting its (J × ℓ) table via ofPolyVPolyZ J ℓ agrees with ofPolyZ J ℓ p.

                                      theorem Cslib.JetTable.ofPolyVPolyZ_C_C {J ℓ : ℕ} {R : Type u_2} [CommRing R] (c : R) :

                                      Extracting Polynomial.C (Polynomial.C c) via ofPolyVPolyZ J ℓ yields const c.

                                      @[simp]
                                      theorem Cslib.JetTable.ofPolyVPolyZ_X_pow {J ℓ : ℕ} {R : Type u_2} [CommRing R] (s : ℕ) :

                                      Extracting Polynomial.X ^ s : Polynomial (Polynomial R) via ofPolyVPolyZ J ℓ yields vPow s.

                                      @[simp]
                                      theorem Cslib.JetTable.ofPolyZ_C {J ℓ : ℕ} {R : Type u_2} [CommRing R] (c : R) :
                                      (ofPolyZ J ℓ) (Polynomial.C c) = const c

                                      ofPolyZ J ℓ (Polynomial.C c) is const c.

                                      theorem Cslib.JetTable.mul_vPow_apply {J ℓ : ℕ} {R : Type u_1} [CommRing R] (A : JetTable J ℓ R) (s : ℕ) (j : Fin J) (u : Fin ℓ) :
                                      (A * vPow s) j u = if _h : s ≤ ↑u then A j ⟨↑u - s, ⋯⟩ else 0

                                      2. Integer ℓ₁ coefficient norm on JetTable #

                                      def Cslib.JetTable.l1Norm {J ℓ : ℕ} (A : JetTable J ℓ ℤ) :

                                      The integer ℓ₁ coefficient norm ‖A‖₁ = ∑ j, ∑ u, |A j u| on JetTable J ℓ ℤ ([OpenAI2026ETH, Appendix B, p. 47]).

                                      Instances For
                                        @[simp]
                                        theorem Cslib.JetTable.l1Norm_zero {J ℓ : ℕ} :
                                        l1Norm 0 = 0
                                        theorem Cslib.JetTable.natAbs_apply_le_l1Norm {J ℓ : ℕ} (A : JetTable J ℓ ℤ) (j : Fin J) (u : Fin ℓ) :
                                        (A j u).natAbs ≤ A.l1Norm
                                        theorem Cslib.JetTable.l1Norm_const_of_pos {J ℓ : ℕ} (hJ : 0 < J) (hℓ : 0 < ℓ) (c : ℤ) :
                                        @[simp]
                                        theorem Cslib.JetTable.l1Norm_neg {J ℓ : ℕ} (A : JetTable J ℓ ℤ) :
                                        theorem Cslib.JetTable.l1Norm_add_le {J ℓ : ℕ} (A B : JetTable J ℓ ℤ) :
                                        theorem Cslib.JetTable.l1Norm_sub_le {J ℓ : ℕ} (A B : JetTable J ℓ ℤ) :
                                        theorem Cslib.JetTable.l1Norm_smul {J ℓ : ℕ} (c : ℤ) (A : JetTable J ℓ ℤ) :
                                        theorem Cslib.JetTable.l1Norm_conv_le {J ℓ : ℕ} (A B : JetTable J ℓ ℤ) :

                                        Submultiplicativity of l1Norm under truncated 2D convolution: ‖conv A B‖₁ ≤ ‖A‖₁ * ‖B‖₁ ([OpenAI2026ETH, Appendix B.1–B.2, pp. 47–48]).

                                        theorem Cslib.JetTable.l1Norm_mul_le {J ℓ : ℕ} (A B : JetTable J ℓ ℤ) :
                                        theorem Cslib.JetTable.l1Norm_vPow_le {J ℓ : ℕ} (s : ℕ) :
                                        theorem Cslib.JetTable.l1Norm_mul_vPow_le {J ℓ : ℕ} (A : JetTable J ℓ ℤ) (s : ℕ) :
                                        theorem Cslib.JetTable.l1Norm_sum_le {J ℓ : ℕ} {ι : Type u_1} (s : Finset ι) (F : ι → JetTable J ℓ ℤ) :
                                        (∑ i ∈ s, F i).l1Norm ≤ ∑ i ∈ s, (F i).l1Norm
                                        theorem Cslib.JetTable.l1Norm_prod_le {J ℓ : ℕ} {ι : Type u_1} (s : Finset ι) (F : ι → JetTable J ℓ ℤ) :
                                        (∏ i ∈ s, F i).l1Norm ≤ ∏ i ∈ s, (F i).l1Norm
                                        theorem Cslib.JetTable.l1Norm_pow_le {J ℓ : ℕ} (A : JetTable J ℓ ℤ) (m : ℕ) :
                                        (A ^ m).l1Norm ≤ A.l1Norm ^ m

                                        3. Staged fixed-denominator clearing and prefix norm bounds (Appendix B.2) #

                                        def Cslib.JetTable.clearedMonomialJet {J ℓ : ℕ} {ι : Type u_2} (d_den : ℤ) (k : ℕ) (θ_int : ι → JetTable J ℓ ℤ) (M : Finset ι) :

                                        Stage-1 integer numerator for a single monomial M of degree #M ≤ k, cleared by Δ = d_den ^ k via padding d_den ^ (k - #M) ([OpenAI2026ETH, Appendix B.2, p. 48]).

                                        Instances For
                                          def Cslib.JetTable.clearedMonomialSumJet {J ℓ : ℕ} {α : Type u_2} {ι : Type u_3} (d_den : ℤ) (k : ℕ) (θ_int : ι → JetTable J ℓ ℤ) (s : Finset α) (M : α → Finset ι) :

                                          Stage-1 integer numerator for a sum of listed monomials of degree at most k, cleared by Δ = d_den ^ k ([OpenAI2026ETH, Appendix B.2, p. 48]).

                                          Instances For
                                            theorem Cslib.JetTable.cast_clearedMonomialJet {J ℓ : ℕ} {K : Type u_1} [CommRing K] {ι : Type u_2} (d_den : ℤ) (k : ℕ) (θ_rat : ι → JetTable J ℓ K) (θ_int : ι → JetTable J ℓ ℤ) (hθ : ∀ (v : ι), d_den • θ_rat v = (castRingHom K) (θ_int v)) {M : Finset ι} (hM : M.card ≤ k) :
                                            d_den ^ k • ∏ v ∈ M, θ_rat v = (castRingHom K) (clearedMonomialJet d_den k θ_int M)
                                            theorem Cslib.JetTable.cast_clearedMonomialSumJet {J ℓ : ℕ} {K : Type u_1} [CommRing K] {α : Type u_2} {ι : Type u_3} (d_den : ℤ) (k : ℕ) (θ_rat : ι → JetTable J ℓ K) (θ_int : ι → JetTable J ℓ ℤ) (hθ : ∀ (v : ι), d_den • θ_rat v = (castRingHom K) (θ_int v)) (s : Finset α) (M : α → Finset ι) (hdeg : ∀ m ∈ s, (M m).card ≤ k) :
                                            d_den ^ k • ∑ m ∈ s, ∏ v ∈ M m, θ_rat v = (castRingHom K) (clearedMonomialSumJet d_den k θ_int s M)

                                            Stage-1 denominator clearing (Appendix B.2, p. 48). If d_den • θ_rat v is represented by θ_int v, then Δ = d_den ^ k clears any sum of monomials of degree at most k.

                                            theorem Cslib.JetTable.l1Norm_clearedMonomialJet_le {J ℓ : ℕ} {ι : Type u_2} {d_den : ℤ} {k B₀ : ℕ} (hd : d_den.natAbs ≤ B₀) {θ_int : ι → JetTable J ℓ ℤ} (hθ : ∀ (v : ι), (θ_int v).l1Norm ≤ B₀) {M : Finset ι} (hM : M.card ≤ k) :
                                            (clearedMonomialJet d_den k θ_int M).l1Norm ≤ B₀ ^ k
                                            theorem Cslib.JetTable.l1Norm_clearedMonomialSumJet_le {J ℓ : ℕ} {α : Type u_2} {ι : Type u_3} {d_den : ℤ} {k B₀ M₀ : ℕ} (hd : d_den.natAbs ≤ B₀) {θ_int : ι → JetTable J ℓ ℤ} (hθ : ∀ (v : ι), (θ_int v).l1Norm ≤ B₀) {s : Finset α} (hs : s.card ≤ M₀) {M : α → Finset ι} (hdeg : ∀ m ∈ s, (M m).card ≤ k) :
                                            (clearedMonomialSumJet d_den k θ_int s M).l1Norm ≤ M₀ * B₀ ^ k

                                            Stage-1 ℓ₁-norm bound (Appendix B.2, p. 48). When d_den.natAbs ≤ B₀ and every input jet θ_int v has ℓ₁-norm at most B₀, a sum of at most M₀ monomials of degree at most k cleared by Δ = d_den ^ k has ℓ₁-norm at most M₀ * B₀ ^ k.

                                            def Cslib.JetTable.clearedUnivariateJet {J ℓ : ℕ} (Δ : ℤ) (D : ℕ) (a : ℕ → ℤ) (A_int : JetTable J ℓ ℤ) :

                                            Homogeneous Δ ^ D-cleared integer evaluation of a degree-≤ D univariate polynomial ∑ u ∈ range (D + 1), a u * Y ^ u on a Δ-cleared jet table A_int.

                                            Instances For
                                              theorem Cslib.JetTable.cast_clearedUnivariateJet {J ℓ : ℕ} {K : Type u_1} [CommRing K] (Δ : ℤ) (D : ℕ) (a : ℕ → ℤ) (L_rat : JetTable J ℓ K) (A_int : JetTable J ℓ ℤ) (hL : Δ • L_rat = (castRingHom K) A_int) :
                                              Δ ^ D • ∑ u ∈ Finset.range (D + 1), a u • L_rat ^ u = (castRingHom K) (clearedUnivariateJet Δ D a A_int)

                                              Univariate homogeneous denominator clearing. If Δ • L_rat = castRingHom K A_int, then Δ ^ D clears ∑ u ∈ range (D + 1), a u • L_rat ^ u.

                                              theorem Cslib.JetTable.l1Norm_clearedUnivariateJet_le {J ℓ : ℕ} {Δ : ℤ} {D B_max C_amp : ℕ} {a : ℕ → ℤ} {A_int : JetTable J ℓ ℤ} (hA : A_int.l1Norm ≤ B_max) (hΔ : Δ.natAbs ≤ B_max) (ha : ∑ u ∈ Finset.range (D + 1), (a u).natAbs ≤ C_amp) :
                                              (clearedUnivariateJet Δ D a A_int).l1Norm ≤ C_amp * B_max ^ D

                                              Univariate homogeneous ℓ₁-norm bound. If ‖A_int‖₁ ≤ B_max, Δ.natAbs ≤ B_max, and ∑ u ∈ range (D + 1), |a u| ≤ C_amp, then ‖clearedUnivariateJet Δ D a A_int‖₁ ≤ C_amp * B_max ^ D.

                                              def Cslib.JetTable.parityFactorJet {J ℓ : ℕ} {K : Type u_1} [CommRing K] (L : JetTable J ℓ K) (a b : Fin ℓ → ℤ) :
                                              JetTable J ℓ K

                                              The substituted shared-V parity factor B_i(z, V) = ∑ s < ℓ, (a_s + b_s L) (L (L - 1)) ^ s V ^ s modulo (z ^ J, V ^ ℓ) ([OpenAI2026ETH, §5.3 eq. (5.4) and Appendix B.2, p. 48]).

                                              Instances For
                                                def Cslib.JetTable.clearedParityFactorJet {J ℓ : ℕ} (Δ : ℤ) (A_int : JetTable J ℓ ℤ) (a b : Fin ℓ → ℤ) :

                                                Stage-2 integer numerator Γ • B_i(z, V) for Γ = Δ ^ (2 * ℓ - 1) and A_int = Δ • L, obtained by clearing e_s(L) with Δ, L (L - 1) with Δ ^ 2, and padding term s by Δ ^ (2 * (ℓ - 1 - s)) ([OpenAI2026ETH, Appendix B.2, pp. 48–49]).

                                                Instances For
                                                  theorem Cslib.JetTable.cast_clearedParityFactorJet {J ℓ : ℕ} {K : Type u_1} [CommRing K] (Δ : ℤ) (L_rat : JetTable J ℓ K) (A_int : JetTable J ℓ ℤ) (hL : Δ • L_rat = (castRingHom K) A_int) (a b : Fin ℓ → ℤ) :
                                                  Δ ^ (2 * ℓ - 1) • L_rat.parityFactorJet a b = (castRingHom K) (clearedParityFactorJet Δ A_int a b)

                                                  Stage-2 denominator clearing (Appendix B.2, pp. 48–49). If Δ • L_rat = castRingHom K A_int, then Γ = Δ ^ (2 * ℓ - 1) clears parityFactorJet L_rat a b.

                                                  theorem Cslib.JetTable.l1Norm_clearedParityFactorJet_le {J ℓ : ℕ} {Δ : ℤ} {B E_ℓ : ℕ} {A_int : JetTable J ℓ ℤ} (hA : A_int.l1Norm ≤ B) {a b : Fin ℓ → ℤ} (he : ∀ (s : Fin ℓ), (a s).natAbs + (b s).natAbs ≤ E_ℓ) :
                                                  (clearedParityFactorJet Δ A_int a b).l1Norm ≤ ℓ * E_ℓ * (B + Δ.natAbs) ^ (2 * ℓ - 1)

                                                  Stage-2 ℓ₁-norm bound (Appendix B.2, p. 49). If ‖A_int‖₁ ≤ B and every linear remainder e_s(Y) = a_s + b_s Y satisfies |a_s| + |b_s| ≤ E_ℓ, then ‖clearedParityFactorJet Δ A_int a b‖₁ ≤ ℓ * E_ℓ * (B + Δ.natAbs) ^ (2 * ℓ - 1).

                                                  theorem Cslib.JetTable.l1Norm_clearedParityFactorJet_le_B1 {J ℓ : ℕ} {Δ : ℤ} {B E_ℓ : ℕ} {A_int : JetTable J ℓ ℤ} (hA : A_int.l1Norm ≤ B) {a b : Fin ℓ → ℤ} (he : ∀ (s : Fin ℓ), (a s).natAbs + (b s).natAbs ≤ E_ℓ) :
                                                  (clearedParityFactorJet Δ A_int a b).l1Norm ≤ ℓ * E_ℓ * (B + Δ.natAbs + 2) ^ (2 * ℓ - 1)

                                                  Specialization of l1Norm_clearedParityFactorJet_le to the manuscript's explicit parameter B₁ = ℓ * E_ℓ * (B + Δ.natAbs + 2) ^ (2 * ℓ - 1) ([OpenAI2026ETH, Appendix B.2, p. 49]).

                                                  theorem Cslib.JetTable.pow_natAbs_le_B1 (Δ : ℤ) (B : ℕ) {ℓ E_ℓ : ℕ} (hℓ : 1 ≤ ℓ) (hE : 1 ≤ E_ℓ) :
                                                  Δ.natAbs ^ (2 * ℓ - 1) ≤ ℓ * E_ℓ * (B + Δ.natAbs + 2) ^ (2 * ℓ - 1)

                                                  The manuscript's dominance inequality Γ ≤ B₁ (Δ.natAbs ^ (2 * ℓ - 1) ≤ B₁) when 1 ≤ ℓ and 1 ≤ E_ℓ ([OpenAI2026ETH, Appendix B.2, p. 49]).

                                                  theorem Cslib.JetTable.cast_prod_cleared {J ℓ : ℕ} {K : Type u_1} [CommRing K] {ι : Type u_2} (Γ : ℤ) (s : Finset ι) (F_rat : ι → JetTable J ℓ K) (F_int : ι → JetTable J ℓ ℤ) (hF : ∀ i ∈ s, Γ • F_rat i = (castRingHom K) (F_int i)) :
                                                  Γ ^ s.card • ∏ i ∈ s, F_rat i = (castRingHom K) (∏ i ∈ s, F_int i)

                                                  Product of m Γ-cleared factors. Multiplying m rational factor tables cleared by Γ gives an integer table clearing the product by Γ ^ m.

                                                  theorem Cslib.JetTable.l1Norm_prod_cleared_le {J ℓ : ℕ} {ι : Type u_2} (s : Finset ι) (F_int : ι → JetTable J ℓ ℤ) {B₁ : ℕ} (hF : ∀ i ∈ s, (F_int i).l1Norm ≤ B₁) :
                                                  (∏ i ∈ s, F_int i).l1Norm ≤ B₁ ^ s.card
                                                  theorem Cslib.JetTable.cast_groupProd_cleared {J ℓ : ℕ} {K : Type u_1} [CommRing K] {r m_test : ℕ} (Γ : ℤ) (m_group : Fin r → ℕ) (hm : ∑ g : Fin r, m_group g = m_test) (S_rat : Fin r → JetTable J ℓ K) (S_int : Fin r → JetTable J ℓ ℤ) (hS : ∀ (g : Fin r), Γ ^ m_group g • S_rat g = (castRingHom K) (S_int g)) :
                                                  Γ ^ m_test • ∏ g : Fin r, S_rat g = (castRingHom K) (∏ g : Fin r, S_int g)

                                                  Group-product denominator clearing (Appendix B.2, p. 49). If group g's sum S_rat g is cleared by Γ ^ (m_group g) and ∑ g, m_group g = m_test, then Ω = Γ ^ m_test clears the full product ∏ g, S_rat g.

                                                  theorem Cslib.JetTable.l1Norm_groupProd_cleared_le {J ℓ r n m_test B₁ : ℕ} (s_group m_group : Fin r → ℕ) (hs : ∑ g : Fin r, s_group g ≤ n) (hm : ∑ g : Fin r, m_group g = m_test) (S_int : Fin r → JetTable J ℓ ℤ) (hS : ∀ (g : Fin r), (S_int g).l1Norm ≤ 2 ^ s_group g * B₁ ^ m_group g) :
                                                  (∏ g : Fin r, S_int g).l1Norm ≤ 2 ^ n * B₁ ^ m_test

                                                  Group-product ℓ₁-norm bound (Appendix B.2, p. 49). If each group sum S_int g satisfies ‖S_int g‖₁ ≤ 2 ^ (s_group g) * B₁ ^ (m_group g) with ∑ g, s_group g ≤ n and ∑ g, m_group g = m_test, then ‖∏ g, S_int g‖₁ ≤ 2 ^ n * B₁ ^ m_test.

                                                  def Cslib.JetTable.signedPrefixJet {J ℓ : ℕ} {R : Type u_2} [CommRing R] (updates : List (ℤ × JetTable J ℓ R)) (t : ℕ) :
                                                  JetTable J ℓ R

                                                  Intermediate value of the node accumulator T_t after t signed contribution updates ([OpenAI2026ETH, Appendix B.2, p. 49]).

                                                  Instances For
                                                    theorem Cslib.JetTable.cast_signedPrefixJet {J ℓ : ℕ} {K : Type u_1} [CommRing K] (Ω : ℤ) (updates_rat : List (ℤ × JetTable J ℓ K)) (updates_int : List (ℤ × JetTable J ℓ ℤ)) (hlen : updates_rat.length = updates_int.length) (hrel : ∀ (idx : ℕ) (hr : idx < updates_rat.length) (hi : idx < updates_int.length), updates_rat[idx].1 = updates_int[idx].1 ∧ Ω • updates_rat[idx].2 = (castRingHom K) updates_int[idx].2) (t : ℕ) :
                                                    Ω • signedPrefixJet updates_rat t = (castRingHom K) (signedPrefixJet updates_int t)

                                                    Prefix accumulator denominator clearing (Appendix B.2, p. 49). At every step t, Ω clears the intermediate accumulator signedPrefixJet.

                                                    theorem Cslib.JetTable.l1Norm_signedPrefixJet_le {J ℓ n m_test B₁ M_star : ℕ} (updates_int : List (ℤ × JetTable J ℓ ℤ)) (hbound : ∀ p ∈ updates_int, p.1.natAbs ≤ 1 ∧ p.2.l1Norm ≤ 2 ^ n * B₁ ^ m_test) {t : ℕ} (ht : min t updates_int.length ≤ M_star) :
                                                    (signedPrefixJet updates_int t).l1Norm ≤ M_star * 2 ^ n * B₁ ^ m_test

                                                    Intermediate prefix accumulator ℓ₁-norm bound (Appendix B.2, p. 49). If every signed contribution (ε, Π_int) has |ε| ≤ 1 and ‖Π_int‖₁ ≤ 2 ^ n * B₁ ^ m_test, then at every step t with min t updates_int.length ≤ M_star, the integer accumulator Ω • T_t satisfies ‖Ω • T_t‖₁ ≤ M_star * 2 ^ n * B₁ ^ m_test.

                                                    theorem Cslib.JetTable.l1Norm_clearedSliceSum_le {J ℓ : ℕ} {α : Type u_2} {β : Type u_3} {n m_test B₁ M_star : ℕ} (slices : Finset α) (hslices : slices.card ≤ M_star * 2 ^ n) (factors : Finset β) (hfactors : factors.card = m_test) (ε : α → ℤ) (hε : ∀ u ∈ slices, (ε u).natAbs ≤ 1) (F_int : α → β → JetTable J ℓ ℤ) (hF : ∀ u ∈ slices, ∀ i ∈ factors, (F_int u i).l1Norm ≤ B₁) :
                                                    (∑ u ∈ slices, ε u • ∏ i ∈ factors, F_int u i).l1Norm ≤ M_star * 2 ^ n * B₁ ^ m_test

                                                    Finset slice-sum ℓ₁-norm bound (Appendix B.2, p. 49). Summing m_test-factor products with signs |ε u| ≤ 1 across an index set slices of cardinality #slices ≤ M_star * 2 ^ n, where each factor has ℓ₁-norm at most B₁, yields an integer (J × ℓ) table of ℓ₁-norm at most M_star * 2 ^ n * B₁ ^ m_test.

                                                    4. Exact integer Cramer divisibility and modulo-2 ^ ℓ recovery (Appendix B.3) #

                                                    def Cslib.hermiteCramerNumerator {Q J : ℕ} (nodes : Fin Q → ℤ) (hQ : 0 < Q) (hJ : 0 < J) (J_int : Fin Q → Fin J → ℤ) :

                                                    The integer Cramer numerator N_H = det V_{(0)} ([OpenAI2026ETH, Appendix B.3, eq. (B.1), p. 50]), obtained by replacing column (0, 0) (corresponding to X ^ 0) of the integer confluent Vandermonde matrix Polynomial.hermiteMatrix nodes J with the Ω-scaled integer Taylor jet J_int.

                                                    Instances For
                                                      theorem Cslib.hermiteCramerNumerator_eq_mul {Q J : ℕ} (nodes : Fin Q → ℤ) (hQ : 0 < Q) (hJ : 0 < J) (Ω H_zero : ℤ) (J_int : Fin Q → Fin J → ℤ) {H : Polynomial ℚ} (hdeg : H.natDegree < Q * J) (hzero : Polynomial.eval 0 H = ↑H_zero) (hjet : ∀ (i : Fin Q) (j : Fin J), ↑(J_int i j) = ↑Ω * ((Polynomial.taylor ↑(nodes i)) H).coeff ↑j) :
                                                      hermiteCramerNumerator nodes hQ hJ J_int = Ω * (Polynomial.hermiteMatrix nodes J).det * H_zero

                                                      Integer Cramer factorization (Appendix B.3, p. 50). If H : ℚ[X] has degree less than Q * J, integer value H.eval 0 = (H_zero : ℚ) at 0, and Ω-scaled integer Taylor jet J_int at nodes, then N_H = Ω * D_H * H_zero in ℤ.

                                                      theorem Cslib.mul_det_hermiteMatrix_ne_zero {Q J : ℕ} {nodes : Fin Q → ℤ} (hnodes : Function.Injective nodes) {Ω : ℤ} (hΩ : Ω ≠ 0) :

                                                      At distinct integer nodes and nonzero denominator Ω ≠ 0, the integer Cramer denominator Ω * det (hermiteMatrix nodes J) is nonzero ([OpenAI2026ETH, Appendix B.3, p. 50]).

                                                      theorem Cslib.mul_det_hermiteMatrix_dvd_hermiteCramerNumerator {Q J : ℕ} (nodes : Fin Q → ℤ) (hQ : 0 < Q) (hJ : 0 < J) (Ω H_zero : ℤ) (J_int : Fin Q → Fin J → ℤ) {H : Polynomial ℚ} (hdeg : H.natDegree < Q * J) (hzero : Polynomial.eval 0 H = ↑H_zero) (hjet : ∀ (i : Fin Q) (j : Fin J), ↑(J_int i j) = ↑Ω * ((Polynomial.taylor ↑(nodes i)) H).coeff ↑j) :

                                                      Exact integer Cramer divisibility (Appendix B.3, p. 50). Under the hypotheses of hermiteCramerNumerator_eq_mul, Ω * D_H divides N_H over ℤ.

                                                      theorem Cslib.hermiteCramerNumerator_ediv_eq {Q J : ℕ} {nodes : Fin Q → ℤ} (hnodes : Function.Injective nodes) (hQ : 0 < Q) (hJ : 0 < J) {Ω : ℤ} (hΩ : Ω ≠ 0) (H_zero : ℤ) (J_int : Fin Q → Fin J → ℤ) {H : Polynomial ℚ} (hdeg : H.natDegree < Q * J) (hzero : Polynomial.eval 0 H = ↑H_zero) (hjet : ∀ (i : Fin Q) (j : Fin J), ↑(J_int i j) = ↑Ω * ((Polynomial.taylor ↑(nodes i)) H).coeff ↑j) :
                                                      hermiteCramerNumerator nodes hQ hJ J_int / (Ω * (Polynomial.hermiteMatrix nodes J).det) = H_zero

                                                      Exact integer Cramer recovery (Appendix B.3, eq. (B.1), p. 50). At distinct integer nodes with Ω ≠ 0, exact Euclidean integer division N_H / (Ω * D_H) recovers the integer H_zero.

                                                      theorem Cslib.hermiteCramerNumerator_emod_two_pow_eq {Q J ℓ : ℕ} {nodes : Fin Q → ℤ} (hnodes : Function.Injective nodes) (hQ : 0 < Q) (hJ : 0 < J) {Ω : ℤ} (hΩ : Ω ≠ 0) (H_zero Z : ℤ) (J_int : Fin Q → Fin J → ℤ) {H : Polynomial ℚ} (hdeg : H.natDegree < Q * J) (hzero : Polynomial.eval 0 H = ↑H_zero) (hjet : ∀ (i : Fin Q) (j : Fin J), ↑(J_int i j) = ↑Ω * ((Polynomial.taylor ↑(nodes i)) H).coeff ↑j) (hmod : H_zero ≡ Z [ZMOD 2 ^ ℓ]) (hZ0 : 0 ≤ Z) (hZlt : Z < 2 ^ ℓ) :
                                                      hermiteCramerNumerator nodes hQ hJ J_int / (Ω * (Polynomial.hermiteMatrix nodes J).det) % 2 ^ ℓ = Z

                                                      Modulo-2 ^ ℓ recovery from integer-scaled jets. If H_zero ≡ Z [ZMOD 2 ^ ℓ] with 0 ≤ Z < 2 ^ ℓ, then (N_H / (Ω * D_H)) % 2 ^ ℓ = Z.

                                                      theorem Cslib.sum_hermiteCramerNumerator_emod_two_pow_eq {Q J ℓ : ℕ} {nodes : Fin Q → ℤ} (hnodes : Function.Injective nodes) (hQ : 0 < Q) (hJ : 0 < J) {Ω : ℤ} (hΩ : Ω ≠ 0) (H_zero : Fin ℓ → ℤ) (Z : ℤ) (T_int : Fin Q → JetTable J ℓ ℤ) (H : Fin ℓ → Polynomial ℚ) (hdeg : ∀ (s : Fin ℓ), (H s).natDegree < Q * J) (hzero : ∀ (s : Fin ℓ), Polynomial.eval 0 (H s) = ↑(H_zero s)) (hjet : ∀ (i : Fin Q) (j : Fin J) (s : Fin ℓ), ↑(T_int i j s) = ↑Ω * ((Polynomial.taylor ↑(nodes i)) (H s)).coeff ↑j) (hmod : ∑ s : Fin ℓ, H_zero s ≡ Z [ZMOD 2 ^ ℓ]) (hZ0 : 0 ≤ Z) (hZlt : Z < 2 ^ ℓ) :
                                                      (∑ s : Fin ℓ, (hermiteCramerNumerator nodes hQ hJ fun (i : Fin Q) (j : Fin J) => T_int i j s) / (Ω * (Polynomial.hermiteMatrix nodes J).det)) % 2 ^ ℓ = Z

                                                      Summed ℓ-coordinate recovery modulo 2 ^ ℓ (Appendix B.3, p. 50). Given (J × ℓ) integer jet tables T_int i at distinct integer nodes nodes i representing Ω-scaled Taylor jets of coordinate polynomials H s (s < ℓ) whose values at 0 are integers H_zero s, if ∑ s, H_zero s ≡ Z [ZMOD 2 ^ ℓ] with 0 ≤ Z < 2 ^ ℓ, then the least nonnegative residue modulo 2 ^ ℓ of the summed Cramer quotients equals Z.