AFTD Auto-Formalizing Theoretical Domains

op223_weighted_shift_arithmetic_certificate

theoremverified

The displayed rational parameters satisfy two path-resolvent recurrences, two secular equations, and the strict diagonal inequalities used in a proposed fourteen-vertex weighted-shift counterexample. This arithmetic certificate does not itself prove the graph interpretation.

Statement

theorem op223_weighted_shift_arithmetic_certificate :
  let e : ℚ := 8826415565237209674298585338473 / 3517319676169570115263289800000
  let r : ℚ := 3681505299112476434191487709083 / 879329919042392528815822450000
  let z₀ : ℚ := 3
  let z₁ : ℚ := 617/200
  let s : ℚ := 19/100
  let m₀ : ℚ := 4/7
  let m₁ : ℚ := 3970527620571400/7727650084572769
  let c₀ : ℚ := 2/3
  let c₁ : ℚ := (1/4 : ℚ) * (14893022600/12582964721)
  let d₀ : ℚ := z₀/s
  let d₁ : ℚ := z₁/s
  let dv : ℚ := 1/(z₀-c₀) + ((1/2 : ℚ)/(z₀-c₀))^2*d₀
  let dg : ℚ := 8/3 + ((1/2 : ℚ)* (8/3))^2*dv
  let dx : ℚ := 28/3 + ((1/2 : ℚ)*(14/3))^2*dv
  let db : ℚ := 36/5 + ((1/2 : ℚ)*4)^2*dv
  let da : ℚ := 8/15 + ((1/2 : ℚ)*(2/3))^2*dv
  let finalx : ℚ := 45743022600/12582964721 +
        ((1/2 : ℚ) * (22241340000/12582964721))^2*d₁
  let pathdiag := fun k : Fin 6 =>
    let t : ℚ := (k : ℕ)
    2*(t+1)*(6-t)/(z₀*7) + e*d₀*m₀^2*((6-t)/6)^2
  0 < e ∧ 0 < r ∧
  ((fun x : ℚ => 1/(z₀-(9/4 : ℚ)*x))^[5]) (1/z₀) = m₀ ∧
  ((fun x : ℚ => 1/(z₁-(9/4 : ℚ)*x))^[5]) (1/z₁) = m₁ ∧
  z₀ - s/z₀ - r/z₀ - e*m₀ - (1/4 : ℚ)/(z₀-c₀) = 0 ∧
  z₁ - s/z₁ - r/z₁ - e*m₁ - (1/4 : ℚ)/z₁-c₁ = 0 ∧
  dv < d₀ ∧ dg < d₀ ∧ dx < d₀ ∧ db < d₀ ∧ da < d₀ ∧
  1/z₀ + r*d₀/z₀^2 < d₀ ∧
  (∀ k : Fin 6, pathdiag k < d₀) ∧ d₁ < finalx
Source
Exact finite arithmetic for a weighted analogue of Open Problem 6.1, https://arxiv.org/abs/2610.17078.
Verified
15 Nov 2026
Axioms
Classical.choiceQuot.soundpropext

The proof, explained

The theorem is an arithmetic certificate verifying fourteen explicit conditions on a collection of rational parameters associated with a proposed 14-vertex weighted-shift counterexample. The proof expands the local definitions and splits the conjunction into fourteen independent subgoals. Each condition—including parameter positivity, secular equation identities, five-fold path-resolvent recurrences unrolled via iteration, and strict diagonal inequalities—is closed by exact rational arithmetic, with the finite universal condition checked by case analysis on all six elements of `Fin 6`.

  1. The goal reduces to fourteen independent arithmetic conditions on the given rational parameters.

    We unfold the local `let` definitions using `dsimp only` and decompose the fourteen-part conjunction into separate subgoals with `refine`. These subgoals consist of two positivity checks, two path-resolvent recurrence relations, two secular equations, six strict diagonal bounds against d₀, a family of six path diagonal inequalities, and a final bound.

    lines 34–35

      dsimp only
      refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
  2. The rational parameters e and r are strictly positive.

    Both e and r are explicit fractions with positive numerators and denominators, so the inequalities 0 < e and 0 < r hold by direct rational arithmetic.

    lines 36–37

      · norm_num
      · norm_num
  3. The five-fold iterations of the path-resolvent recurrences at z₀ and z₁ evaluate to m₀ and m₁, respectively.

    Using `Function.iterate_succ_apply` to unroll the 5-fold function iterations f^[5](1/z), each recurrence reduces to evaluating an explicit finite continued-fraction-like rational expression. At z₀ = 3 the result evaluates to m₀ = 4/7, and at z₁ = 617/200 it evaluates to m₁ = 3970527620571400/7727650084572769.

    lines 38–39

    uses Function.iterate_succ_apply

      · norm_num [Function.iterate_succ_apply]
      · norm_num [Function.iterate_succ_apply]
  4. The two secular equations evaluate to zero.

    Substituting the values of the parameters into the expressions z₀ - s/z₀ - r/z₀ - e*m₀ - (1/4)/(z₀-c₀) and z₁ - s/z₁ - r/z₁ - e*m₁ - (1/4)/z₁ - c₁, both evaluate identically to 0 by exact rational arithmetic.

    lines 40–41

      · norm_num
      · norm_num
  5. The intermediate resolvent values dv, dg, dx, db, da and the shift term 1/z₀ + r*d₀/z₀² are all strictly less than d₀ = z₀/s.

    Each of the six strict inequalities compares an explicit rational quantity against d₀ = 3 / (19/100) = 300/19 and is verified by direct rational computation.

    lines 42–47

      · norm_num
      · norm_num
      · norm_num
      · norm_num
      · norm_num
      · norm_num
  6. For each path vertex k ∈ Fin 6, the path diagonal term pathdiag(k) is strictly less than d₀.

    After introducing the index k, we perform an exhaustive case analysis across the six elements k ∈ {0, 1, 2, 3, 4, 5}. For each case, the resulting rational value of pathdiag(k) is verified to be strictly less than d₀ = 300/19.

    lines 48–49

      · intro k
        fin_cases k <;> norm_num
  7. The strict inequality d₁ < finalx holds.

    Evaluating d₁ = z₁/s = 617/38 and the rational expression defining finalx, the strict inequality is verified by exact rational arithmetic.

    line 50

      · norm_num
Function.iterate_succ_apply
For any endofunction f, the (n+1)-st iterate applied to x equals the n-th iterate applied to f(x): f^[n+1](x) = f^[n](f(x)).

Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.

Lean source view module on GitHub

set_option maxHeartbeats 1000000set_option maxRecDepth 10000theorem op223_weighted_shift_arithmetic_certificate :  let e : ℚ := 8826415565237209674298585338473 / 3517319676169570115263289800000  let r : ℚ := 3681505299112476434191487709083 / 879329919042392528815822450000  let z₀ : ℚ := 3  let z₁ : ℚ := 617/200  let s : ℚ := 19/100  let m₀ : ℚ := 4/7  let m₁ : ℚ := 3970527620571400/7727650084572769  let c₀ : ℚ := 2/3  let c₁ : ℚ := (1/4 : ℚ) * (14893022600/12582964721)  let d₀ : ℚ := z₀/s  let d₁ : ℚ := z₁/s  let dv : ℚ := 1/(z₀-c₀) + ((1/2 : ℚ)/(z₀-c₀))^2*d₀  let dg : ℚ := 8/3 + ((1/2 : ℚ)* (8/3))^2*dv  let dx : ℚ := 28/3 + ((1/2 : ℚ)*(14/3))^2*dv  let db : ℚ := 36/5 + ((1/2 : ℚ)*4)^2*dv  let da : ℚ := 8/15 + ((1/2 : ℚ)*(2/3))^2*dv  let finalx : ℚ := 45743022600/12582964721 +        ((1/2 : ℚ) * (22241340000/12582964721))^2*d₁  let pathdiag := fun k : Fin 6 =>    let t : ℚ := (k : ℕ)    2*(t+1)*(6-t)/(z₀*7) + e*d₀*m₀^2*((6-t)/6)^2  0 < e ∧ 0 < r ∧  ((fun x : ℚ => 1/(z₀-(9/4 : ℚ)*x))^[5]) (1/z₀) = m₀ ∧  ((fun x : ℚ => 1/(z₁-(9/4 : ℚ)*x))^[5]) (1/z₁) = m₁ ∧  z₀ - s/z₀ - r/z₀ - e*m₀ - (1/4 : ℚ)/(z₀-c₀) = 0 ∧  z₁ - s/z₁ - r/z₁ - e*m₁ - (1/4 : ℚ)/z₁-c₁ = 0 ∧  dv < d₀ ∧ dg < d₀ ∧ dx < d₀ ∧ db < d₀ ∧ da < d₀ ∧  1/z₀ + r*d₀/z₀^2 < d₀ ∧  (∀ k : Fin 6, pathdiag k < d₀) ∧ d₁ < finalx := by  dsimp only  refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩  · norm_num  · norm_num  · norm_num [Function.iterate_succ_apply]  · norm_num [Function.iterate_succ_apply]  · norm_num  · norm_num  · norm_num  · norm_num  · norm_num  · norm_num  · norm_num  · norm_num  · intro k    fin_cases k <;> norm_num  · norm_num
See it in the graphDiscuss this resultChallenge it