AFTD Auto-Formalizing Theoretical Domains

op75_fold_blocks

theoremverified

For a nonnegative initial accumulator and an initial point in the unit interval, folding the seven-layer blocks gives the final orbit coordinate, the initial accumulator plus the orbit sum, and zero in the third coordinate.

Statement

theorem op75_fold_blocks (as : List ℕ) (x p : ℝ)
    (hx : x ∈ Set.Icc 0 1) (hp : 0 ≤ p) :
    ((as.flatMap op75_compact_block).foldl (fun v l => evalHiddenLayer l v) ![x,p,0]) =
      ![(op75_run op75_compact_map op75_compact_digit (as.map fun a : ℕ => (a:ℝ)) x).1,
        p + (op75_run op75_compact_map op75_compact_digit (as.map fun a : ℕ => (a:ℝ)) x).2, 0]
Source
OP-75, arXiv:2610.06092: proof of the explicit single-pass subset-sum network.
Verified
15 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 7
  • op75_compact_blockSeven width-three hidden layers for one nonnegative integer weight in the one-pass subset-sum construction.
  • op75_compact_block_effectFor an input in the unit interval and a nonnegative accumulator, the seven-layer block for a nonnegative integer weight transforms the…
  • op75_runFor a map F, a digit function E, and real weights, iteratively apply F and return the final orbit value together with the sum of the…
  • op75_compact_mapThe compact piecewise-affine map x ↦ min(1, 4x, |4x−3|) used in the one-pass reduction.
  • op75_compact_digitThe digit selector x ↦ max(0, min(1, 4x−1)) used in the one-pass reduction.
  • evalHiddenLayerEvaluation of a hidden layer of width $k$ on an input vector $x \in \mathbb{R}^k$, computing for each neuron $i$ the rectified linear unit…
  • ReLUHiddenLayerA hidden layer of width k consists of a k-by-k rational weight matrix and a rational bias vector of length k.
Used by 1
  • op75_network_evalFor a unit-interval input, the explicit subset-sum network evaluates to the final orbit coordinate plus the absolute difference between…

Lean source view module on GitHub

theorem op75_fold_blocks (as : List ℕ) (x p : ℝ)
    (hx : x ∈ Set.Icc 0 1) (hp : 0 ≤ p) :
    ((as.flatMap op75_compact_block).foldl (fun v l => evalHiddenLayer l v) ![x,p,0]) =
      ![(op75_run op75_compact_map op75_compact_digit (as.map fun a : ℕ => (a:ℝ)) x).1,
        p + (op75_run op75_compact_map op75_compact_digit (as.map fun a : ℕ => (a:ℝ)) x).2, 0] := by
  induction as generalizing x p with
  | nil => simp [op75_run]
  | cons a as ih =>
      simp only [List.flatMap_cons, List.foldl_append]
      rw [op75_compact_block_effect x p a hx hp]
      have hF : op75_compact_map x ∈ Set.Icc (0:ℝ) 1 := by
        constructor
        · unfold op75_compact_map
          exact le_min (by norm_num) (le_min (by linarith [hx.1]) (abs_nonneg _))
        · exact min_le_left _ _
      have hE : 0 ≤ op75_compact_digit x := le_max_left _ _
      have hp' : 0 ≤ p + (a:ℝ)*op75_compact_digit x := by positivity
      rw [ih (op75_compact_map x) (p + (a:ℝ)*op75_compact_digit x) hF hp']
      simp only [List.map_cons, op75_run, add_assoc]
See it in the graphDiscuss this resultChallenge it