Proposition 2.1's decoder with the weakened det contract: root search + verifier
DefinitionLinearSetReconciliation327_Main_P21DetBack20261121decoderlinear-set-reconciliationpinsketchword-ram
The root-search and verifier stages of Proposition 2.1's decoder, re-derived with the det
hypothesis weakened to DetAgrees (agreement with detStd t N b ι on the ten header slots the
decoder reads and on every table address ). With
Def_…_P21DetFront20261121 these assemble into pinsketch_decoding_at_det.
Definition code
import Definitions.Def_LinearSetReconciliation327_Main_P21DetFront20261121
/-!
# Proposition 2.1's decoder, weakened `det` contract — the root-search and verifier stages
The last two stage contracts of `pinsketch_decoding_at`, re-derived with `DetAgrees` instead of
`E.det = detStd t N b ι`. Together with `Def_…_P21DetFront20261121` they assemble into
`pinsketch_decoding_at_det` (`Sol_p21_decode_at_det.lean`).
-/
set_option maxHeartbeats 1000000
set_option maxRecDepth 100000
set_option autoImplicit false
set_option linter.unusedSimpArgs false
set_option linter.unnecessarySeqFocus false
set_option linter.unusedTactic false
set_option linter.unreachableTactic false
set_option linter.unusedVariables false
set_option linter.style.haveILetI false
set_option linter.unusedSectionVars false
namespace LinearSetReconciliation327.Main
/-! Child C4: `LinearSetReconciliation327.Main.pinsketch_decoder_root_search`.
Generated by `p21opt/gen/emit.py` by skeleton subtraction from
`Solutions/_p21_opt3.lean` (Stage-2 declaration spans). -/
set_option autoImplicit false
open scoped ENNReal
open Finset Polynomial
section FieldFacts
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end FieldFacts
section PowerSums
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
variable {N : ℕ}
end PowerSums
theorem gcd_eval_iff {F : Type} [Field F] [DecidableEq F]
(f g : F[X]) (u : F) :
(EuclideanDomain.gcd f g).eval u = 0 ↔ f.eval u = 0 ∧ g.eval u = 0 := by
change (EuclideanDomain.gcd f g).IsRoot u ↔ f.IsRoot u ∧ g.IsRoot u
exact Polynomial.isRoot_gcd_iff_isRoot_left_right
theorem gcd_ne_zero_left {F : Type} [Field F] [DecidableEq F]
{f : F[X]} (hf : f ≠ 0) (g : F[X]) : EuclideanDomain.gcd f g ≠ 0 := by
intro hz
have hd := EuclideanDomain.gcd_dvd_left f g
rw [hz] at hd
exact hf (by simpa only [zero_dvd_iff] using hd)
theorem linearRoot_eval_iff {F : Type} [Field F] {f : F[X]}
(hf : f ≠ 0) (hdeg : f.natDegree = 1) (u : F) :
f.eval u = 0 ↔ u = linearRoot f := by
have h1 : f.coeff 1 ≠ 0 := by
simpa only [Polynomial.leadingCoeff, hdeg] using (Polynomial.leadingCoeff_ne_zero.mpr hf)
have hp := Polynomial.eq_X_add_C_of_natDegree_le_one hdeg.le
have heval : f.eval u = f.coeff 1 * u + f.coeff 0 := by
calc
f.eval u = (C (f.coeff 1) * X + C (f.coeff 0)).eval u := congrArg (fun p => p.eval u) hp
_ = f.coeff 1 * u + f.coeff 0 := by simp
rw [heval]
change f.coeff 1 * u + f.coeff 0 = 0 ↔ u = -f.coeff 0 / f.coeff 1
constructor
· intro h
apply (eq_div_iff h1).mpr
linear_combination h
· intro h
have he := (eq_div_iff h1).mp h
linear_combination he
theorem dvd_sub_mod {F : Type} [Field F] (p f : F[X]) : f ∣ p - p % f := by
refine ⟨p / f, ?_⟩
linear_combination -(EuclideanDomain.div_add_mod p f)
theorem traceRemainder_congr {F : Type} [Field F] (a : F) (f : F[X]) (n : ℕ) :
f ∣ tracePolynomial a n - traceRemainder a f n := by
induction n with
| zero => simp [tracePolynomial, traceRemainder]
| succ n ih =>
have hs : f ∣ tracePolynomial a n ^ 2 - traceRemainder a f n ^ 2 := by
have hd := dvd_mul_of_dvd_left ih (tracePolynomial a n + traceRemainder a f n)
convert hd using 1 <;> ring
have hm := dvd_sub_mod (traceRemainder a f n ^ 2 + C a * X) f
have hd := dvd_add hs hm
change f ∣ (tracePolynomial a n ^ 2 + C a * X) -
(traceRemainder a f n ^ 2 + C a * X) % f
convert hd using 1 <;> ring
theorem traceRemainder_natDegree_lt {F : Type} [Field F]
(a : F) {f : F[X]} (hf : 0 < f.natDegree) (n : ℕ) :
(traceRemainder a f n).natDegree < f.natDegree := by
cases n with
| zero => simpa only [traceRemainder, Polynomial.natDegree_zero] using hf
| succ n => exact Polynomial.natDegree_mod_lt _ hf.ne'
/-- Equal remainders give literally equal Euclidean gcds. -/
theorem gcd_eq_of_dvd_sub {F : Type} [Field F] [DecidableEq F]
(f p q : F[X]) (h : f ∣ p - q) :
EuclideanDomain.gcd f p = EuclideanDomain.gcd f q := by
rw [EuclideanDomain.gcd_val f p, EuclideanDomain.gcd_val f q,
Polynomial.mod_eq_of_dvd_sub h]
/-- Refinement from low-degree modular computations to the mathematical
splitter specification. -/
theorem traceRootSearch_eq {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (as : List F) (f : F[X]) :
traceRootSearch w as f = rootSearch (as.map (fun a => tracePolynomial a w)) f := by
induction as generalizing f with
| nil => rfl
| cons a as ih =>
by_cases hzero : f.natDegree = 0
· simp only [traceRootSearch, List.map_cons, rootSearch, if_pos hzero]
· have h0 : EuclideanDomain.gcd f (tracePolynomial a w) =
EuclideanDomain.gcd f (traceRemainder a f w) :=
gcd_eq_of_dvd_sub f _ _ (traceRemainder_congr a f w)
have h1 : EuclideanDomain.gcd f (tracePolynomial a w - 1) =
EuclideanDomain.gcd f (traceRemainder a f w - 1) := by
apply gcd_eq_of_dvd_sub
convert traceRemainder_congr a f w using 1 <;> ring
simp only [traceRootSearch, List.map_cons, rootSearch, if_neg hzero]
simp only [ih, h0, h1]
/-- Sibling factors are coprime, since the splitter differs by one. Their
combined degree therefore cannot exceed the parent's degree, even for an
undecodable input polynomial. -/
theorem split_degree_budget {F : Type} [Field F] [DecidableEq F]
(f p : F[X]) (hf : f ≠ 0) :
(EuclideanDomain.gcd f p).natDegree +
(EuclideanDomain.gcd f (p - 1)).natDegree ≤ f.natDegree := by
let g0 := EuclideanDomain.gcd f p
let g1 := EuclideanDomain.gcd f (p - 1)
have h0 : g0 ≠ 0 := gcd_ne_zero_left hf p
have h1 : g1 ≠ 0 := gcd_ne_zero_left hf (p - 1)
have hcop : IsCoprime g0 g1 := by
obtain ⟨u, hu⟩ := EuclideanDomain.gcd_dvd_right f p
obtain ⟨v, hv⟩ := EuclideanDomain.gcd_dvd_right f (p - 1)
refine ⟨u, -v, ?_⟩
change u * EuclideanDomain.gcd f p + -v * EuclideanDomain.gcd f (p - 1) = 1
linear_combination hv - hu
have hd := hcop.mul_dvd (EuclideanDomain.gcd_dvd_left f p)
(EuclideanDomain.gcd_dvd_left f (p - 1))
have hdeg := Polynomial.natDegree_le_of_dvd hd hf
rwa [Polynomial.natDegree_mul h0 h1] at hdeg
section Enc
variable {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
end Enc
section Tables
variable {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
end Tables
section ReadInt
end ReadInt
section ReadLoop
end ReadLoop
section ProgramAt
end ProgramAt
section ReadSpec
end ReadSpec
section ReadStmt
end ReadStmt
section Bounds
end Bounds
section Prologue
end Prologue
section ReadAssembly
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end ReadAssembly
section Expand
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end Expand
section ExpandStd
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end ExpandStd
/-- Even a nonsplitting input yields only distinct genuine roots, and at
most as many outputs as its degree. -/
theorem rootSearch_sound {F : Type} [Field F] [DecidableEq F]
(ps : List F[X]) (f : F[X]) (hf : f ≠ 0) :
(rootSearch ps f).Nodup ∧
(∀ u ∈ rootSearch ps f, f.eval u = 0) ∧
(rootSearch ps f).length ≤ f.natDegree := by
induction ps generalizing f with
| nil =>
by_cases h : f.natDegree = 1
· rw [rootSearch, if_pos h]
refine ⟨by simp, ?_, ?_⟩
· intro u hu
have hu' : u = linearRoot f := List.mem_singleton.mp hu
exact (linearRoot_eval_iff hf h u).mpr hu'
· simp [h]
· rw [rootSearch, if_neg h]
exact ⟨by simp, by simp, by simp⟩
| cons p ps ih =>
by_cases h : f.natDegree = 0
· rw [rootSearch, if_pos h]
exact ⟨by simp, by simp, by simp⟩
· let g0 := EuclideanDomain.gcd f p
let g1 := EuclideanDomain.gcd f (p - 1)
obtain ⟨hnd0, hroot0, hlen0⟩ := ih g0 (gcd_ne_zero_left hf p)
obtain ⟨hnd1, hroot1, hlen1⟩ := ih g1 (gcd_ne_zero_left hf (p - 1))
have hdisj : List.Disjoint (rootSearch ps g0) (rootSearch ps g1) := by
apply List.disjoint_left.mpr
intro u hu0 hu1
have hp0 := ((gcd_eval_iff f p u).mp (hroot0 u hu0)).2
have hp1 := ((gcd_eval_iff f (p - 1) u).mp (hroot1 u hu1)).2
rw [Polynomial.eval_sub, Polynomial.eval_one, sub_eq_zero] at hp1
exact zero_ne_one (hp0.symm.trans hp1)
rw [rootSearch, if_neg h]
refine ⟨List.nodup_append'.mpr ⟨hnd0, hnd1, hdisj⟩, ?_, ?_⟩
· intro u hu
rcases List.mem_append.mp hu with hu | hu
· exact ((gcd_eval_iff f p u).mp (hroot0 u hu)).1
· exact ((gcd_eval_iff f (p - 1) u).mp (hroot1 u hu)).1
· have hbudget := split_degree_budget f p hf
change g0.natDegree + g1.natDegree ≤ f.natDegree at hbudget
change (rootSearch ps g0 ++ rootSearch ps g1).length ≤ f.natDegree
rw [List.length_append]
omega
/-- Unconditional guarantees for the implemented modular root search. -/
theorem rootsByBasis_sound {F : Type} [Field F] [DecidableEq F]
[Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (f : F[X]) (hf : f ≠ 0) :
(rootsByBasis b f).Nodup ∧
(∀ u ∈ rootsByBasis b f, f.eval u = 0) ∧
(rootsByBasis b f).length ≤ f.natDegree := by
rw [rootsByBasis, traceRootSearch_eq]
exact rootSearch_sound _ f hf
/-- In characteristic two, odd square coefficients vanish. -/
theorem polynomial_square_coeff {F : Type} [Field F] [Algebra (ZMod 2) F] (p : F[X]) (k : ℕ) :
(p ^ 2).coeff k = if k % 2 = 0 then p.coeff (k / 2) ^ 2 else 0 := by
haveI : CharP F 2 := pinsketch_charP
rw [← Polynomial.map_frobenius_expand 2 p, Polynomial.coeff_map,
Polynomial.coeff_expand (by decide : 0 < 2)]
simp only [Nat.dvd_iff_mod_eq_zero]
split_ifs <;> simp [frobenius_def]
theorem squareBody_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(E : RAMEnv) (pc dst src L cap : ℕ) (p : F[X]) (m : ℕ → ℕ) (r : Fin 16 → ℕ) (k : ℕ)
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hcap : cap = 2 * L) (hk : k < cap) (hcapWord : cap < 2 ^ E.W)
(hdst : dst + cap ≤ 2 ^ E.W) (hsrc : src + L ≤ 2 ^ E.W)
(hdisj : src + L ≤ dst ∨ dst + cap ≤ src) (hp : PolynomialStored b m src L p) :
runBlock squareBody E { runBlock squareCond.code E (squareState b pc dst src cap p m r k) with pc := pc + 2 } =
{ squareState b pc dst src cap p m r (k + 1) with pc := pc + 17 } := by
have hkL : k / 2 < L := by omega
have hWord2 : (2 : ℕ) < 2 ^ E.W := by
have hp8 : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]
exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (2 : ℕ) < 2 ^ 8) hp8
have h1 : (1 : ℕ) % 2 ^ E.W = 1 := Nat.mod_eq_of_lt (by omega)
have h2 : (2 : ℕ) % 2 ^ E.W = 2 := Nat.mod_eq_of_lt hWord2
have hj : (k / 2) % 2 ^ E.W = k / 2 := Nat.mod_eq_of_lt (by omega)
have hsrcj : (src + k / 2) % 2 ^ E.W = src + k / 2 := Nat.mod_eq_of_lt (by omega)
have hdstk : (dst + k) % 2 ^ E.W = dst + k := Nat.mod_eq_of_lt (by omega)
have hnext : (k + 1) % 2 ^ E.W = k + 1 := Nat.mod_eq_of_lt (by omega)
have hpow : (2 : ℕ) ^ w ≤ 2 ^ E.W := by
rw [hW]
exact Nat.pow_le_pow_right (by norm_num) (by omega)
have hEnc (z : F) : enc b z % 2 ^ E.W = enc b z :=
Nat.mod_eq_of_lt (lt_of_lt_of_le (enc_lt b z) hpow)
have htabAddr : detSqBase w + enc b (p.coeff (k / 2)) < 2 ^ E.W := by
have he := detEnd_lt hw
have hp := enc_lt b (p.coeff (k / 2))
have hle : (2 : ℕ) ^ w ≤ 2 ^ (2 * w) := Nat.pow_le_pow_right (by norm_num) (by omega)
rw [hW]
unfold detEnd detImgBase detPosBase detInvBase at he
omega
have htable : E.det (detSqBase w + enc b (p.coeff (k / 2))) = enc b (p.coeff (k / 2) ^ 2) := by
rw [hdet.2 _ (by have h := detMulBase_le_detSqBase w; omega), detStd_sq t N w b ι (enc_lt b _), sqTab, dec_enc]
have hm : writeArray dst m (fun i => enc b ((p ^ 2).coeff i)) k (src + k / 2) =
enc b (p.coeff (k / 2)) := by
rw [writeArray_frame _ _ _ _ _ (by omega)]
exact hp (k / 2) hkL
have hCoeff := polynomial_square_coeff p k
have hpar : k % 2 < 2 := Nat.mod_lt _ (by decide)
have hsub0 : (1 + 2 ^ E.W - 0) % 2 ^ E.W = 1 := by simp [Nat.add_mod, h1]
have hsub1 : (1 + 2 ^ E.W - 1) % 2 ^ E.W = 0 := by simp
by_cases heven : k % 2 = 0
· apply ramState_eq_of
· simp [squareBody, squareCond, Cond.code, runBlock_cons, runBlock_nil, execInstr, squareState] <;> omega
· simp only [squareBody, Fin.isValue, Cond.code, squareCond, squareState, runBlock_cons, execInstr,
↓reduceIte, one_ne_zero, runBlock_nil, ne_eq, Fin.reduceEq, not_false_eq_true, Function.update_of_ne,
hj, Function.update_self, hsrcj, hm, hEnc, Nat.mod_eq_of_lt htabAddr, htable, heven, Nat.zero_mod,
tsub_zero, Nat.add_mod_right, h1, Function.update_idem, mul_one, hdstk, writeArray, hCoeff]
· intro d
simp only [squareBody, Fin.isValue, Cond.code, squareCond, squareState, runBlock_cons, execInstr,
↓reduceIte, one_ne_zero, runBlock_nil, ne_eq, Fin.reduceEq, not_false_eq_true, Function.update_of_ne,
Function.update_self, Nat.add_mod_mod, Function.update_idem, Nat.mul_mod_mod, Nat.mod_mul_mod, hnext,
Nat.zero_mod, Classical.choice]
fin_cases d <;> simp only [squareBody, Fin.isValue, Cond.code, squareCond, squareState, runBlock_cons, execInstr,
↓reduceIte, one_ne_zero, runBlock_nil, ne_eq, Fin.reduceEq, not_false_eq_true, Function.update_of_ne,
Function.update_self, Nat.add_mod_mod, Function.update_idem, Nat.mul_mod_mod, Nat.mod_mul_mod, hnext,
Nat.zero_mod, Fin.zero_eta, Nat.add_left_cancel_iff, Fin.mk_one, Fin.reduceFinMk, Classical.choice]
· have hodd : k % 2 = 1 := by omega
apply ramState_eq_of
· simp [squareBody, squareCond, Cond.code, runBlock_cons, runBlock_nil, execInstr, squareState] <;> omega
· simp [squareBody, squareCond, Cond.code, runBlock_cons, runBlock_nil, execInstr,
squareState, h1, h2, hj, hsrcj, hdstk, hm, hEnc, Nat.mod_eq_of_lt htabAddr,
htable, hodd, hsub1, writeArray, hCoeff, heven]
· intro d
simp only [squareBody, Fin.isValue, Cond.code, squareCond, squareState, runBlock_cons, execInstr,
↓reduceIte, one_ne_zero, runBlock_nil, ne_eq, Fin.reduceEq, not_false_eq_true, Function.update_of_ne,
Function.update_self, Nat.add_mod_mod, Function.update_idem, Nat.mul_mod_mod, Nat.mod_mul_mod, hnext,
Nat.zero_mod, Classical.choice]
fin_cases d <;> simp only [squareBody, Fin.isValue, Cond.code, squareCond, squareState, runBlock_cons, execInstr,
↓reduceIte, one_ne_zero, runBlock_nil, ne_eq, Fin.reduceEq, not_false_eq_true, Function.update_of_ne,
Function.update_self, Nat.add_mod_mod, Function.update_idem, Nat.mul_mod_mod, Nat.mod_mul_mod, hnext,
Nat.zero_mod, Fin.zero_eta, Nat.add_left_cancel_iff, Fin.mk_one, Fin.reduceFinMk, Classical.choice]
theorem squareCond_eval {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (pc dst src cap : ℕ) (p : F[X])
(m : ℕ → ℕ) (r : Fin 16 → ℕ) (k : ℕ) :
squareCond.eval (squareState b pc dst src cap p m r k) ↔ k < cap := by
simp [squareCond, Cond.eval, squareState]
theorem squareBodyIter {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc dst src L cap : ℕ) (p : F[X]) (m : ℕ → ℕ) (r : Fin 16 → ℕ) (k : ℕ)
(hAt : At P pc (Stmt.compile squareStmt pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hcap : cap = 2 * L) (hk : k < cap) (hcapWord : cap < 2 ^ E.W)
(hdst : dst + cap ≤ 2 ^ E.W) (hsrc : src + L ≤ 2 ^ E.W)
(hdisj : src + L ≤ dst ∨ dst + cap ≤ src) (hp : PolynomialStored b m src L p) :
Sem P E (pc + 2) pc { runBlock squareCond.code E (squareState b pc dst src cap p m r k) with pc := pc + 2 }
(fun c z => c = 16 ∧ z = squareState b pc dst src cap p m r (k + 1)) := by
obtain ⟨_, _, hBodyAt, hJumpAt⟩ := at_loop hAt
have hrun : Sem P E (pc + 2) (pc + 17)
{ runBlock squareCond.code E (squareState b pc dst src cap p m r k) with pc := pc + 2 }
(fun c z => c = 15 ∧ z = { squareState b pc dst src cap p m r (k + 1) with pc := pc + 17 }) := by
refine Sem.mono (Sem.block P E _ squareBody _ hBodyAt (by simp [squareBody]) rfl) ?_
intro c z hQ
obtain ⟨hc, hz⟩ := hQ
exact ⟨hc, hz.trans (squareBody_spec b ι t N E pc dst src L cap p m r k hw hW hdet hcap hk hcapWord hdst hsrc hdisj hp)⟩
refine Sem.jmp_append (hAt := hJumpAt) (Sem.mono hrun ?_)
intro c z hQ
obtain ⟨hc, hz⟩ := hQ
refine ⟨by omega, ?_⟩
rw [hz]
rfl
theorem squareCond_exit {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (E : RAMEnv) (pc dst src cap : ℕ) (p : F[X])
(m : ℕ → ℕ) (r : Fin 16 → ℕ) :
({ runBlock squareCond.code E (squareState b pc dst src cap p m r cap) with pc := pc + 18 } : RAMState) =
{ squareState b pc dst src cap p m r cap with pc := pc + 18 } := by
apply ramState_eq_of
· rfl
· rfl
· intro d
fin_cases d <;> simp [squareCond, Cond.code, runBlock_cons, runBlock_nil, execInstr, squareState]
theorem squareArray_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc dst src L cap : ℕ) (p : F[X]) (m : ℕ → ℕ) (r : Fin 16 → ℕ)
(hAt : At P pc (Stmt.compile squareStmt pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hcap : cap = 2 * L) (hcapWord : cap < 2 ^ E.W)
(hdst : dst + cap ≤ 2 ^ E.W) (hsrc : src + L ≤ 2 ^ E.W)
(hdisj : src + L ≤ dst ∨ dst + cap ≤ src) (hp : PolynomialStored b m src L p) :
Sem P E pc (pc + 18) (squareState b pc dst src cap p m r 0)
(fun k z => k ≤ 18 * cap + 2 ∧ z = { squareState b pc dst src cap p m r cap with pc := pc + 18 }) := by
have hW1 : 1 < 2 ^ E.W := by
have hp := Nat.two_pow_pos w
have he : (2 : ℕ) ^ 1 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
omega
have h := Sem.loop P E pc squareCond (.code squareBody) hAt hW1 cap
(fun k => squareState b pc dst src cap p m r k) (fun _ => 16)
(fun _ => rfl)
(fun k hk => (squareCond_eval b pc dst src cap p m r k).mpr hk)
(fun h => (Nat.lt_irrefl cap) ((squareCond_eval b pc dst src cap p m r cap).mp h))
(fun k hk => squareBodyIter b ι t N P E pc dst src L cap p m r k hAt hw hW hdet hcap hk hcapWord hdst hsrc hdisj hp)
refine Sem.mono h ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨?_, ?_⟩
· have hsum : (∑ j ∈ Finset.range cap, (squareCond.code.length + 1 + 16)) = 18 * cap := by
change (∑ j ∈ Finset.range cap, (18 : ℕ)) = 18 * cap
exact sum_range_const_mul cap 18
rw [hsum] at hk
change k ≤ 2 + 18 * cap at hk
omega
· rw [hz]
exact squareCond_exit b E pc dst src cap p m r
theorem squareArgs_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(E : RAMEnv) (pc dst src cap : ℕ) (p : F[X]) (m : ℕ → ℕ)
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hdst : dst < 2 ^ E.W) (hsrc : src < 2 ^ E.W) (hcap : cap < 2 ^ E.W)
(hm64 : m 64 = dst) (hm65 : m 65 = src) (hm66 : m 66 = cap) :
runBlock squareArgsCode E (boundaryState pc m) = squareState b (pc + 11) dst src cap p m (fun _ => 0) 0 := by
have hbase : detSqBase w < 2 ^ E.W := by rw [hW]; exact detSqBase_lt hw
have hwidth : (66 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (66 : ℕ) < 2 ^ 8) hp
have hsmall : ∀ i ≤ 66, i % 2 ^ E.W = i := by
intro i hi
exact Nat.mod_eq_of_lt (by omega)
have htable6 : E.det 6 = detSqBase w := by
rw [hdet.1 6 (by decide), detStd_hdr t N w b ι (by decide : 6 < 13)]
rfl
apply ramState_eq_of
· simp only [squareArgsCode, Fin.isValue, boundaryState, runBlock_cons, execInstr, Function.update_self,
Nat.zero_mod, runBlock_nil, squareState, ite_self, Nat.add_right_cancel_iff, Nat.add_left_cancel_iff] <;> omega
· rfl
· intro d
fin_cases d <;> simp only [squareArgsCode, Fin.isValue, boundaryState, runBlock_cons, execInstr,
Nat.reduceLeDiff, hsmall, Function.update_self, hm64, Nat.mod_eq_of_lt hdst, hm65,
Nat.mod_eq_of_lt hsrc, Std.le_refl, hm66, Nat.mod_eq_of_lt hcap, Nat.one_le_ofNat,
htable6, Nat.mod_eq_of_lt hbase, zero_le, runBlock_nil, Fin.zero_eta, ne_eq,
Fin.reduceEq, not_false_eq_true, Function.update_of_ne, zero_ne_one, squareState,
ite_self, ↓reduceIte, Fin.mk_one, one_ne_zero, Fin.reduceFinMk]
/-- A callable polynomial square, overwriting the whole destination array
including its odd zero coefficients. -/
theorem squareProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc dst src L cap : ℕ) (p : F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile squareProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hcap : cap = 2 * L) (hcapWord : cap < 2 ^ E.W)
(hdstWord : dst < 2 ^ E.W) (hsrcWord : src < 2 ^ E.W)
(hdst : dst + cap ≤ 2 ^ E.W) (hsrc : src + L ≤ 2 ^ E.W)
(hdisj : src + L ≤ dst ∨ dst + cap ≤ src) (hp : PolynomialStored b m src L p)
(hm64 : m 64 = dst) (hm65 : m 65 = src) (hm66 : m 66 = cap) :
Sem P E pc (pc + 45) (boundaryState pc m)
(fun k z => k ≤ 18 * cap + 29 ∧
z = boundaryState (pc + 45) (writeArray dst m (fun i => enc b ((p ^ 2).coeff i)) cap)) := by
obtain ⟨hArgsAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hSquareAt, hZeroAt⟩ := At.seqStmt hRestAt
have hArgs : Sem P E pc (pc + 11) (boundaryState pc m)
(fun k z => k ≤ 11 ∧ z = squareState b (pc + 11) dst src cap p m (fun _ => 0) 0) := by
refine Sem.mono (Sem.block P E pc squareArgsCode _ hArgsAt (by simp [squareArgsCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
exact ⟨by change k = 11 at hk; omega,
hz.trans (squareArgs_spec b ι t N E pc dst src cap p m hw hW hdet hdstWord hsrcWord hcapWord hm64 hm65 hm66)⟩
have hSquare := squareArray_spec b ι t N P E (pc + 11) dst src L cap p m (fun _ => 0)
hSquareAt hw hW hdet hcap hcapWord hdst hsrc hdisj hp
have hZero : Sem P E (pc + 29) (pc + 45)
{ squareState b (pc + 11) dst src cap p m (fun _ => 0) cap with pc := pc + 29 }
(fun k z => k ≤ 16 ∧ z = boundaryState (pc + 45) (writeArray dst m (fun i => enc b ((p ^ 2).coeff i)) cap)) := by
refine Sem.mono (Sem.block P E _ zeroRegsCode _ hZeroAt (by simp [zeroRegsCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change k = 16 at hk; omega, ?_⟩
rw [hz, zeroRegs_spec]
rfl
have hFull := Sem.seq_bound hArgs (fun z _ hz => by
subst z
exact Sem.seq_bound hSquare (fun z _ hz => by subst z; exact hZero))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem divisionFullFuel_spec (E : RAMEnv) (s : RAMState) (L : ℕ)
(hmeta : (76 : ℕ) < 2 ^ E.W) (hL : L < 2 ^ E.W) (hm76 : s.mem 76 = L) :
runBlock divisionFullFuelCode E s = boundaryState (s.pc + 22) (Function.update s.mem 71 L) := by
have hsmall : ∀ i ≤ 76, i % 2 ^ E.W = i := by
intro i hi
exact Nat.mod_eq_of_lt (by omega)
rw [divisionFullFuelCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc divisionFullFuelCode E s (by
simp [divisionFullFuelCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [divisionFullFuelCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 22 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, hsmall, hm76, Nat.mod_eq_of_lt hL, boundaryState]
· intro _; rfl
/-- A general polynomial remainder procedure reuses the paired row division.
The second coefficient row may be zero, as in the trace and gcd routines. -/
theorem polynomialModulo_strong_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB L cap : ℕ) (s : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile polynomialModuloProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m s)
(hR : s.prevR.natDegree < L) (hDpos : 0 < s.rem.natDegree)
(hD : s.rem.natDegree < L) (hC : s.curC.natDegree < L)
(hscan : m 95 = s.rem.natDegree + 1) :
Sem P E pc (pc + 295) (boundaryState pc m)
(fun k z => k ≤ (48 * L + 187) * L + 65 ∧
∃ m', z = boundaryState (pc + 295) m' ∧
PadeRows b E RB UB DB CB L cap m' (reducedPadeRows s) ∧
MemoryFrame (padeWritable RB UB DB CB cap) m m' ∧
∀ slot, 72 ≤ slot → slot < 128 → m' slot = m slot) := by
let m1 := Function.update (Function.update m 69 s.rem.natDegree) 70 (enc b s.rem.leadingCoeff⁻¹)
let m2 := Function.update m1 71 L
have hf1 : MemoryFrame padeScratch m m1 :=
MemoryFrame.trans (MemoryFrame.update_allowed padeScratch m 69 _ (by simp [padeScratch]))
(MemoryFrame.update_allowed padeScratch _ 70 _ (by simp [padeScratch]))
have hf2 : MemoryFrame padeScratch m1 m2 :=
MemoryFrame.update_allowed padeScratch m1 71 L (by simp [padeScratch])
have hr1 := hrows.of_scratch hf1
have hr2 := hr1.of_scratch hf2
have hLWord : L < 2 ^ E.W := by have h := hrows.Rword; have h' := hrows.layout.Rlow; omega
have hwidth : (95 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (95 : ℕ) < 2 ^ 8) hp
obtain ⟨hCacheAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hFuelAt, hDivAt⟩ := At.seqStmt hRestAt
have hCache : Sem P E pc (pc + 39) (boundaryState pc m)
(fun k z => k ≤ 39 ∧ z = boundaryState (pc + 39) m1) := by
exact Sem.boundary_block P E _ cacheDivisorCode m m1 hCacheAt
(by simp [cacheDivisorCode, cacheDivisorReadCode, metaReadCode, metaStoreCode, fieldInvCode, zeroRegsCode])
(cacheDivisor_spec b ι t N E _ s.rem DB cap hrows.layout.Dlow hw hW hdet
(by have h := hrows.Dword; omega) (by omega) (by omega) hrows.rem hscan hrows.ptr74 hrows.dimension)
have hFuel : Sem P E (pc + 39) (pc + 61) (boundaryState (pc + 39) m1)
(fun k z => k ≤ 22 ∧ z = boundaryState (pc + 61) m2) := by
exact Sem.boundary_block P E _ divisionFullFuelCode m1 m2 hFuelAt
(by simp [divisionFullFuelCode, metaReadCode, metaStoreCode, zeroRegsCode])
(divisionFullFuel_spec E _ L (by omega) hLWord hr1.length)
have hc2 : RowCache b s.rem RB UB DB CB L m2 L :=
⟨by simp [m2, m1], by simp [m2, m1], by simp [m2],
hr2.ptr72, hr2.ptr73, hr2.ptr74, hr2.ptr75, hr2.length, hr2.dimension⟩
have hDiv := longDivProcedure_spec b ι t N P E (pc + 61) RB UB DB CB L cap L
s.prevR s.prevC s.rem s.curC m2 hDivAt hw hW hdet hrows.layout (by omega)
hrows.Rword hrows.Uword hrows.Dword hrows.Cword hDpos hD hC
hr2.prevR hr2.prevC hr2.rem hr2.curC hc2 (by omega)
have hFull := Sem.seq_bound hCache (fun z _ hz => by
subst z
exact Sem.seq_bound hFuel (fun z _ hz => by subst z; exact hDiv))
refine Sem.mono hFull ?_
intro k z hQ
obtain ⟨hk, m3, hz, hc3, hf3, hR3, hU3, hD3, hC3⟩ := hQ
have hcap3 : m3 81 = cap := by
rw [hf3 81 (by dsimp [divisionWritable]; have h := hrows.layout.Rlow; have h' := hrows.layout.Ulow; omega)]
exact hr2.capacity
refine ⟨by omega, m3, hz, ?_, ?_, ?_⟩
· exact ⟨hrows.layout, hrows.Rword, hrows.Uword, hrows.Dword, hrows.Cword,
hR3, hU3, hD3, hC3, hc3.prevR, hc3.prevC, hc3.curR, hc3.curC, hc3.length, hc3.dim, hcap3⟩
· apply MemoryFrame.trans ((MemoryFrame.trans hf1 hf2).mono ?_)
(hf3.mono (divisionWritable_le_pade RB UB DB CB cap))
intro addr ha
dsimp [padeScratch] at ha
dsimp [padeWritable]
omega
· intro slot hlo hhi
have hnot : ¬ divisionWritable RB UB cap slot := by
dsimp [divisionWritable]
have hRlo := hrows.layout.Rlow
have hUlo := hrows.layout.Ulow
omega
rw [hf3 slot hnot]
have h69 : slot ≠ 69 := by omega
have h70 : slot ≠ 70 := by omega
have h71 : slot ≠ 71 := by omega
simp [m2, m1, h69, h70, h71]
theorem polynomialModulo_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB L cap : ℕ) (s : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile polynomialModuloProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m s)
(hR : s.prevR.natDegree < L) (hDpos : 0 < s.rem.natDegree)
(hD : s.rem.natDegree < L) (hC : s.curC.natDegree < L)
(hscan : m 95 = s.rem.natDegree + 1) :
Sem P E pc (pc + 295) (boundaryState pc m)
(fun k z => k ≤ (48 * L + 187) * L + 65 ∧
∃ m', z = boundaryState (pc + 295) m' ∧
PadeRows b E RB UB DB CB L cap m' (reducedPadeRows s) ∧
MemoryFrame (padeWritable RB UB DB CB cap) m m') := by
refine Sem.mono (polynomialModulo_strong_spec b ι t N P E pc RB UB DB CB L cap s m hAt
hw hW hdet hL hcap hrows hR hDpos hD hC hscan) ?_
intro k z hQ
obtain ⟨hk, m', hz, hr, hf, _⟩ := hQ
exact ⟨hk, m', hz, hr, hf⟩
theorem traceAddX_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (E : RAMEnv) (s : RAMState) (dst : ℕ) (a : F)
(hmeta : (96 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W) (hdst : dst + 1 < 2 ^ E.W)
(hm64 : s.mem 64 = dst) (hm96 : s.mem 96 = enc b a) :
runBlock traceAddXCode E s = boundaryState (s.pc + 25) (Function.update s.mem (dst + 1) (enc b a)) := by
have hsmall : ∀ i ≤ 96, i % 2 ^ E.W = i := by
intro i hi
exact Nat.mod_eq_of_lt (by omega)
have hdst0 : dst % 2 ^ E.W = dst := Nat.mod_eq_of_lt (by omega)
have hdst1 : (dst + 1) % 2 ^ E.W = dst + 1 := Nat.mod_eq_of_lt hdst
have ha : enc b a % 2 ^ E.W = enc b a :=
Nat.mod_eq_of_lt (lt_of_lt_of_le (enc_lt b a) (Nat.pow_le_pow_right (by norm_num) hwe))
rw [traceAddXCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc traceAddXCode E s (by
simp [traceAddXCode, metaReadCode, zeroRegsCode])
rw [traceAddXCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 25 at hp
exact hp
· simp [runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
hsmall, hm64, hm96, hdst0, hdst1, ha, boundaryState]
· intro _; rfl
theorem polynomial_square_add_X_stored {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (m : ℕ → ℕ) (dst cap : ℕ) (p : F[X]) (a : F) :
PolynomialStored b (Function.update (writeArray dst m (fun i => enc b ((p ^ 2).coeff i)) cap)
(dst + 1) (enc b a)) dst cap (p ^ 2 + Polynomial.C a * Polynomial.X) := by
intro i hi
by_cases hone : i = 1
· subst i
rw [Function.update_self]
simp [Polynomial.coeff_add, Polynomial.coeff_C_mul, polynomial_square_coeff]
· rw [Function.update_of_ne (by omega : dst + i ≠ dst + 1), writeArray_get _ _ _ cap i hi]
congr 1
simp [Polynomial.coeff_add, Polynomial.coeff_C_mul, Polynomial.coeff_X, hone, Ne.symm hone]
theorem traceSquareProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc dst src L cap : ℕ) (p : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile traceSquareProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L) (hcapWord : cap < 2 ^ E.W)
(hdstLow : 128 ≤ dst) (hdstWord : dst < 2 ^ E.W) (hsrcWord : src < 2 ^ E.W)
(hdst : dst + cap ≤ 2 ^ E.W) (hsrc : src + L ≤ 2 ^ E.W)
(hdisj : src + L ≤ dst ∨ dst + cap ≤ src) (hp : PolynomialStored b m src L p)
(hm64 : m 64 = dst) (hm65 : m 65 = src) (hm66 : m 66 = cap) (hm96 : m 96 = enc b a) :
Sem P E pc (pc + 70) (boundaryState pc m)
(fun k z => k ≤ 18 * cap + 54 ∧ ∃ m', z = boundaryState (pc + 70) m' ∧
PolynomialStored b m' dst cap (p ^ 2 + Polynomial.C a * Polynomial.X) ∧
MemoryFrame (fun addr => dst ≤ addr ∧ addr < dst + cap) m m') := by
let m1 := writeArray dst m (fun i => enc b ((p ^ 2).coeff i)) cap
let m2 := Function.update m1 (dst + 1) (enc b a)
obtain ⟨hSquareAt, hAddAt⟩ := At.seqStmt hAt
have hSquare := squareProcedure_spec b ι t N P E pc dst src L cap p m hSquareAt hw hW hdet
hcap hcapWord hdstWord hsrcWord hdst hsrc hdisj hp hm64 hm65 hm66
have hwidth : (96 : ℕ) < 2 ^ E.W := by
have hp8 : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (96 : ℕ) < 2 ^ 8) hp8
have hm1meta (slot : ℕ) (hslot : slot < 128) : m1 slot = m slot :=
writeArray_frame dst m _ cap slot (by omega)
have hAdd : Sem P E (pc + 45) (pc + 70) (boundaryState (pc + 45) m1)
(fun k z => k ≤ 25 ∧ z = boundaryState (pc + 70) m2) := by
exact Sem.boundary_block P E _ traceAddXCode m1 m2 hAddAt
(by simp [traceAddXCode, metaReadCode, zeroRegsCode])
(traceAddX_spec b E _ dst a hwidth (by omega) (by omega)
(by change m1 64 = dst; rw [hm1meta 64 (by norm_num)]; exact hm64)
(by change m1 96 = enc b a; rw [hm1meta 96 (by norm_num)]; exact hm96))
have hFull := Sem.seq_bound hSquare (fun z _ hz => by subst z; exact hAdd)
refine Sem.mono hFull ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by omega, m2, hz, polynomial_square_add_X_stored b m dst cap p a, ?_⟩
intro addr haddr
have hne : addr ≠ dst + 1 := by omega
change Function.update m1 (dst + 1) (enc b a) addr = m addr
rw [Function.update_of_ne hne]
exact writeArray_frame dst m _ cap addr (by omega)
/-- Pointer exchange for arbitrary stored Euclidean rows. -/
theorem PadeRows.swap_memory {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {E : RAMEnv} {RB UB DB CB L cap : ℕ}
{m : ℕ → ℕ} {s : PadeState F} (h : PadeRows b E RB UB DB CB L cap m s) :
PadeRows b E DB CB RB UB L cap (swapRowMemory m RB UB DB CB)
(⟨s.rem, s.curC, s.prevR, s.prevC⟩ : PadeState F) := by
have hf : MemoryFrame (fun addr => addr < 128) m (swapRowMemory m RB UB DB CB) :=
MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans
(MemoryFrame.meta_update m 72 DB (by norm_num))
(MemoryFrame.meta_update _ 73 CB (by norm_num)))
(MemoryFrame.meta_update _ 74 RB (by norm_num)))
(MemoryFrame.meta_update _ 75 UB (by norm_num))
refine ⟨h.layout.swap, h.Dword, h.Cword, h.Rword, h.Uword,
h.rem.of_metaFrame h.layout.Dlow hf, h.curC.of_metaFrame h.layout.Clow hf,
h.prevR.of_metaFrame h.layout.Rlow hf, h.prevC.of_metaFrame h.layout.Ulow hf, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· simp [swapRowMemory]
· simp [swapRowMemory]
· simp [swapRowMemory]
· simp [swapRowMemory]
· simpa [swapRowMemory] using h.length
· simpa [swapRowMemory] using h.dimension
· simpa [swapRowMemory] using h.capacity
theorem swapRowMemory_frame (m : ℕ → ℕ) (RB UB DB CB cap : ℕ) :
MemoryFrame (padeWritable RB UB DB CB cap) m (swapRowMemory m RB UB DB CB) := by
apply MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans
(MemoryFrame.update_allowed _ m 72 DB (by simp [padeWritable]))
(MemoryFrame.update_allowed _ _ 73 CB (by simp [padeWritable])))
(MemoryFrame.update_allowed _ _ 74 RB (by simp [padeWritable])))
(MemoryFrame.update_allowed _ _ 75 UB (by simp [padeWritable]))
/-- General Euclidean row transition, using uniform fuel instead of the
key-equation degree-balance invariant. -/
theorem gcdQuotient_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB L cap : ℕ) (s : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile gcdQuotientProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m s)
(hR : s.prevR.natDegree < L) (hDpos : 0 < s.rem.natDegree)
(hD : s.rem.natDegree < L) (hC : s.curC.natDegree < L)
(hscan : m 95 = s.rem.natDegree + 1) :
Sem P E pc (pc + 335) (boundaryState pc m)
(fun k z => k ≤ (48 * L + 187) * L + 105 ∧
∃ m', z = boundaryState (pc + 335) m' ∧
PadeRows b E DB CB RB UB L cap m' (padeNext s) ∧
MemoryFrame (padeWritable RB UB DB CB cap) m m') := by
obtain ⟨hModAt, hSwapAt⟩ := At.seqStmt hAt
have hMod := polynomialModulo_spec b ι t N P E pc RB UB DB CB L cap s m hModAt
hw hW hdet hL hcap hrows hR hDpos hD hC hscan
have hFull := Sem.seq_bound hMod (fun z _ hQ => by
obtain ⟨m1, hz, hr, hf⟩ := hQ
subst z
have hwidth : (75 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (75 : ℕ) < 2 ^ 8) hp
have hSwap : Sem P E (pc + 295) (pc + 335) (boundaryState (pc + 295) m1)
(fun k z => k ≤ 40 ∧ z = boundaryState (pc + 335) (swapRowMemory m1 RB UB DB CB)) := by
exact Sem.boundary_block P E _ swapRowsCode m1 _ hSwapAt
(by simp [swapRowsCode, metaReadCode, metaStoreCode, zeroRegsCode])
(swapRows_spec E _ RB UB DB CB hwidth
(by have h := hrows.Rword; have h' := hrows.layout.Rlow; omega)
(by have h := hrows.Uword; have h' := hrows.layout.Ulow; omega)
(by have h := hrows.Dword; have h' := hrows.layout.Dlow; omega)
(by have h := hrows.Cword; have h' := hrows.layout.Clow; omega)
hr.ptr72 hr.ptr73 hr.ptr74 hr.ptr75)
refine Sem.mono (Q' := fun k z => k ≤ 40 ∧ ∃ m', z = boundaryState (pc + 335) m' ∧
PadeRows b E DB CB RB UB L cap m' (padeNext s) ∧
MemoryFrame (padeWritable RB UB DB CB cap) m m') hSwap ?_
intro k z hQ
exact ⟨hQ.1, swapRowMemory m1 RB UB DB CB, hQ.2, hr.swap_memory,
MemoryFrame.trans hf (swapRowMemory_frame m1 RB UB DB CB cap)⟩)
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem gcd_constant_finish {F : Type} [Field F] [DecidableEq F] (s : PadeState F)
(hdeg : s.rem.natDegree = 0) : EuclideanDomain.gcd s.rem s.prevR = gcdFinish s := by
by_cases hz : s.rem = 0
· simp [hz, gcdFinish]
· have hmod : s.prevR % s.rem = 0 := by
have h := Polynomial.degree_mod_lt s.prevR hz
rw [Polynomial.degree_eq_natDegree hz, hdeg] at h
apply Polynomial.ext
intro i
rw [Polynomial.coeff_zero]
exact (Polynomial.degree_lt_iff_coeff_zero _ 0).mp h i (Nat.zero_le i)
rw [EuclideanDomain.gcd_val s.rem s.prevR, hmod, EuclideanDomain.gcd_zero_left]
simp [gcdFinish, hz]
/-- The existing padded Euclidean iteration also computes gcd when t=1. -/
theorem padeRun_gcd {F : Type} [Field F] [DecidableEq F]
(fuel : ℕ) (s : PadeState F) (hfuel : s.rem.natDegree < fuel) :
gcdFinish (padeRun 1 fuel s) = EuclideanDomain.gcd s.rem s.prevR := by
induction fuel generalizing s with
| zero => omega
| succ n ih =>
by_cases hs : s.rem.natDegree < 1
· rw [padeRun, if_pos hs]
exact (gcd_constant_finish s (by omega)).symm
· have hdeg : (padeNext s).rem.natDegree < s.rem.natDegree :=
Polynomial.natDegree_mod_lt _ (by omega)
rw [padeRun, if_neg hs, ih (padeNext s) (by omega)]
exact (EuclideanDomain.gcd_val s.rem s.prevR).symm
theorem gcdInv_tick {F : Type} [Field F] {L : ℕ} {s : PadeState F} (h : GcdInv L s) :
GcdInv L (padeTick 1 s) := by
by_cases hs : s.rem.natDegree < 1
· simpa only [padeTick, if_pos hs] using h
· rw [padeTick, if_neg hs]
refine ⟨h.2.1, lt_trans (Polynomial.natDegree_mod_lt _ (by omega)) h.2.1, h.2.2.2, ?_⟩
change s.prevC - (s.prevR / s.rem) * s.curC = 0
simp [h.2.2.1, h.2.2.2]
theorem padeRun_gcd_stop {F : Type} [Field F] (fuel : ℕ) (s : PadeState F)
(hfuel : s.rem.natDegree < fuel) : (padeRun 1 fuel s).rem.natDegree = 0 := by
induction fuel generalizing s with
| zero => omega
| succ n ih =>
by_cases hs : s.rem.natDegree < 1
· rw [padeRun, if_pos hs]; omega
· have hdeg : (padeNext s).rem.natDegree < s.rem.natDegree :=
Polynomial.natDegree_mod_lt _ (by omega)
rw [padeRun, if_neg hs]
exact ih (padeNext s) (by omega)
theorem gcdTestLoad_spec (E : RAMEnv) (pc : ℕ) (m : ℕ → ℕ) (d : ℕ)
(hmeta : (95 : ℕ) < 2 ^ E.W) (hd : d < 2 ^ E.W) (hm95 : m 95 = d) :
runBlock gcdTestLoadCode E (boundaryState pc m) = padeTestState (pc + 4) m 1 d := by
rw [gcdTestLoadCode, runBlock_append, metaRead_spec E _ r1 95 (by decide)]
have h95 : (95 : ℕ) % 2 ^ E.W = 95 := Nat.mod_eq_of_lt hmeta
have h1 : (1 : ℕ) % 2 ^ E.W = 1 := Nat.mod_eq_of_lt (by omega)
apply ramState_eq_of
· rfl
· rfl
· intro r
fin_cases r <;> simp [runBlock_cons, runBlock_nil, execInstr, boundaryState, padeTestState,
h95, h1, hm95, Nat.mod_eq_of_lt hd]
theorem gcdSelect_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB L cap : ℕ) (s : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile gcdSelectStmt pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m s) (hinv : GcdInv L s)
(hm95 : m 95 = degreeScan s.rem cap) :
Sem P E pc (pc + 375) (boundaryState pc m)
(fun k z => k ≤ (48 * L + 187) * L + 128 ∧
∃ m', z = boundaryState (pc + 375) m' ∧
PadeAdvance b E RB UB DB CB L cap m m' (padeTick 1 s)) := by
have hwidth : (95 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (95 : ℕ) < 2 ^ 8) hp
have hcapWord : cap < 2 ^ E.W := by have h := hrows.layout.Rlow; have h' := hrows.Rword; omega
have hdWord : degreeScan s.rem cap < 2 ^ E.W := lt_of_le_of_lt (degreeScan_le _ _) hcapWord
have hDcap : s.rem.natDegree < cap := by have h := hinv.2.1; omega
obtain ⟨hLoadAt, hSelectAt⟩ := At.seqStmt hAt
obtain ⟨_, _, hTrueAt, _, hFalseAt, _⟩ := at_ite hSelectAt
obtain ⟨hZeroAt, hQuotAt⟩ := At.seqStmt hTrueAt
have hLoad : Sem P E pc (pc + 4) (boundaryState pc m)
(fun k z => k ≤ 4 ∧ z = padeTestState (pc + 4) m 1 (degreeScan s.rem cap)) := by
refine Sem.mono (Sem.block P E pc gcdTestLoadCode _ hLoadAt
(by simp [gcdTestLoadCode, metaReadCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
exact ⟨by change k = 4 at hk; omega, hz.trans (gcdTestLoad_spec E pc m _ hwidth hdWord hm95)⟩
let z0 := padeTestState (pc + 4) m 1 (degreeScan s.rem cap)
let c : Cond := .lt r15 r0 r1
have htest : c.eval z0 ↔ 1 ≤ s.rem.natDegree := by
change (1 < degreeScan s.rem cap) ↔ _
exact padeScan_go 1 cap s.rem le_rfl hDcap
have hIf : Sem P E (pc + 4) (pc + 375) z0
(fun k z => k ≤ (48 * L + 187) * L + 124 ∧
∃ m', z = boundaryState (pc + 375) m' ∧
PadeAdvance b E RB UB DB CB L cap m m' (padeTick 1 s)) := by
apply Sem.ite P E (pc + 4) c (.seq (.code zeroRegsCode) gcdQuotientProcedure) (.code zeroRegsCode)
z0 _ hSelectAt (by omega) rfl
· intro hgo
have hg : 1 ≤ s.rem.natDegree := htest.mp hgo
have hne : s.rem ≠ 0 := by intro hz; simp [hz] at hg
have hscan : m 95 = s.rem.natDegree + 1 := by rw [hm95, degreeScan_eq s.rem hne cap hDcap]
have hZero : Sem P E (pc + 6) (pc + 22)
{ runBlock c.code E z0 with pc := pc + 6 }
(fun k z => k ≤ 16 ∧ z = boundaryState (pc + 22) m) := by
refine Sem.mono (Sem.block P E _ zeroRegsCode _ hZeroAt (by simp [zeroRegsCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change k = 16 at hk; omega, ?_⟩
rw [hz, zeroRegs_spec]
rfl
have hC : s.curC.natDegree < L := by rw [hinv.2.2.2, Polynomial.natDegree_zero]; omega
have hQuot := gcdQuotient_spec b ι t N P E (pc + 22) RB UB DB CB L cap s m hQuotAt
hw hW hdet hL hcap hrows hinv.1 hg hinv.2.1 hC hscan
have hTrue := Sem.seq_bound hZero (fun z _ hz => by subst z; exact hQuot)
refine Sem.mono hTrue ?_
intro k z hQ
obtain ⟨hk, m', hz, hr, hf⟩ := hQ
refine ⟨by change 1 + 1 + k + 1 ≤ _; omega, m', ?_, DB, CB, RB, UB, ?_, hf, ?_⟩
· rw [hz]; rfl
· simpa only [padeTick, if_neg (by omega : ¬ s.rem.natDegree < 1)] using hr
· exact padeWritable_swap RB UB DB CB cap
· intro hstop
have hs : s.rem.natDegree < 1 := by have h := (not_congr htest).mp hstop; omega
have hZero : Sem P E (pc + 358) (pc + 374)
{ runBlock c.code E z0 with pc := pc + 358 }
(fun k z => k ≤ 16 ∧ z = boundaryState (pc + 374) m) := by
refine Sem.mono (Sem.block P E _ zeroRegsCode _ hFalseAt (by simp [zeroRegsCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change k = 16 at hk; omega, ?_⟩
rw [hz, zeroRegs_spec]
rfl
refine Sem.mono hZero ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change 1 + 1 + k + 1 ≤ _; omega, m, ?_, RB, UB, DB, CB, ?_, ?_, ?_⟩
· rw [hz]; rfl
· simpa only [padeTick, if_pos hs] using hrows
· intro addr _; rfl
· intro addr; rfl
have hFull := Sem.seq_bound hLoad (fun z _ hz => by subst z; exact hIf)
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem gcdStep_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB L cap : ℕ) (s : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile gcdStepProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m s) (hinv : GcdInv L s) :
Sem P E pc (pc + 445) (boundaryState pc m)
(fun k z => k ≤ 17 * cap + (48 * L + 187) * L + 183 ∧
∃ m', z = boundaryState (pc + 445) m' ∧
PadeAdvance b E RB UB DB CB L cap m m' (padeTick 1 s)) := by
let m1 := Function.update (Function.update m 64 DB) 66 cap
let m2 := Function.update m1 95 (degreeScan s.rem cap)
have hf1 : MemoryFrame padeScratch m m1 :=
MemoryFrame.trans (MemoryFrame.update_allowed padeScratch m 64 _ (by simp [padeScratch]))
(MemoryFrame.update_allowed padeScratch _ 66 _ (by simp [padeScratch]))
have hf2 : MemoryFrame padeScratch m1 m2 := MemoryFrame.update_allowed padeScratch m1 95 _ (by simp [padeScratch])
have hr1 := hrows.of_scratch hf1
have hr2 := hr1.of_scratch hf2
have hwidth : (95 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (95 : ℕ) < 2 ^ 8) hp
have hcapWord : cap < 2 ^ E.W := by have h := hrows.layout.Rlow; have h' := hrows.Rword; omega
have hDBword : DB < 2 ^ E.W := by have h := hrows.Dword; omega
obtain ⟨hSetupAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hScanAt, hSelectAt⟩ := At.seqStmt hRestAt
have hSetup : Sem P E pc (pc + 28) (boundaryState pc m)
(fun k z => k ≤ 28 ∧ z = boundaryState (pc + 28) m1) := by
exact Sem.boundary_block P E _ (scanSetupCode 74) m m1 hSetupAt
(by simp [scanSetupCode, metaReadCode, metaStoreCode, zeroRegsCode])
(scanSetup_spec E _ 74 DB cap (by omega) (by omega) hDBword hcapWord hrows.ptr74 hrows.capacity)
have hScan := scanProcedure_spec b P E (pc + 28) DB cap s.rem m1 hScanAt hwidth (by omega)
hDBword hcapWord hrows.Dword hr1.rem (by simp [m1]) (by simp [m1])
have hSelect := gcdSelect_spec b ι t N P E (pc + 70) RB UB DB CB L cap s m2 hSelectAt
hw hW hdet hL hcap hr2 hinv (by simp [m2])
have hFull := Sem.seq_bound hSetup (fun z _ hz => by
subst z
exact Sem.seq_bound hScan (fun z _ hz => by subst z; exact hSelect))
refine Sem.mono hFull ?_
intro k z hQ
obtain ⟨hk, m', hz, RB', UB', DB', CB', hr', hf', hfoot⟩ := hQ
refine ⟨by omega, m', hz, RB', UB', DB', CB', hr', ?_, hfoot⟩
apply MemoryFrame.trans ((MemoryFrame.trans hf1 hf2).mono ?_) hf'
intro addr ha
dsimp [padeScratch] at ha
dsimp [padeWritable]
omega
theorem PadeRows.gcdCounter_update {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {E : RAMEnv} {RB UB DB CB L cap : ℕ}
{m : ℕ → ℕ} {s : PadeState F} (h : PadeRows b E RB UB DB CB L cap m s) (n : ℕ) :
PadeRows b E RB UB DB CB L cap (Function.update m 93 n) s := by
apply h.of_scratchFrame (MemoryFrame.meta_update m 93 n (by norm_num))
intro slot hs
rw [Function.update_of_ne (by omega : slot ≠ 93)]
theorem gcdLoopBody_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB L cap n : ℕ) (s : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile gcdLoopBody pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m s) (hinv : GcdInv L s)
(hn : n + 1 < 2 ^ E.W) (hm93 : m 93 = n + 1) :
Sem P E pc (pc + 488) (rankState pc m (n + 1))
(fun k z => k ≤ 17 * cap + (48 * L + 187) * L + 226 ∧
∃ m' RB' UB' DB' CB', z = rankState (pc + 488) m' n ∧ m' 93 = n ∧
PadeRows b E RB' UB' DB' CB' L cap m' (padeTick 1 s) ∧
MemoryFrame (gcdLoopWritable RB UB DB CB cap) m m' ∧
∀ addr, padeWritable RB' UB' DB' CB' cap addr ↔ padeWritable RB UB DB CB cap addr) := by
obtain ⟨hZeroAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hStepAt, hTailAt⟩ := At.seqStmt hRestAt
have hwidth : (93 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (93 : ℕ) < 2 ^ 8) hp
have hZero : Sem P E pc (pc + 16) (rankState pc m (n + 1))
(fun k z => k ≤ 16 ∧ z = boundaryState (pc + 16) m) := by
refine Sem.mono (Sem.block P E _ zeroRegsCode _ hZeroAt (by simp [zeroRegsCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change k = 16 at hk; omega, ?_⟩
rw [hz, zeroRegs_spec]
rfl
have hStep := gcdStep_spec b ι t N P E (pc + 16) RB UB DB CB L cap s m hStepAt
hw hW hdet hL hcap hrows hinv
have hRest : Sem P E (pc + 16) (pc + 488) (boundaryState (pc + 16) m)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 183) + 27 ∧
∃ m' RB' UB' DB' CB', z = rankState (pc + 488) m' n ∧ m' 93 = n ∧
PadeRows b E RB' UB' DB' CB' L cap m' (padeTick 1 s) ∧
MemoryFrame (gcdLoopWritable RB UB DB CB cap) m m' ∧
∀ addr, padeWritable RB' UB' DB' CB' cap addr ↔ padeWritable RB UB DB CB cap addr) := by
refine Sem.seq_bound hStep ?_
intro z hzpc hQ
obtain ⟨m1, hz, RB', UB', DB', CB', hr, hf, hfoot⟩ := hQ
subst z
have hnot : ¬ padeWritable RB UB DB CB cap 93 := by
dsimp [padeWritable]
have hR := hrows.layout.Rlow
have hU := hrows.layout.Ulow
have hD := hrows.layout.Dlow
have hC := hrows.layout.Clow
omega
have h93 : m1 93 = n + 1 := (hf 93 hnot).trans hm93
have hTailRun := countdown_spec E (boundaryState (pc + 461) m1) 93 n hwidth hn h93
refine Sem.mono (Sem.block P E (pc + 461) (countdownCode 93) _ hTailAt
(by simp [countdownCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change k = 27 at hk; omega,
Function.update m1 93 n, RB', UB', DB', CB', ?_, by simp, hr.gcdCounter_update n, ?_, hfoot⟩
· rw [hz, hTailRun]; rfl
· exact MemoryFrame.trans (hf.mono (by intro addr ha; exact Or.inr ha))
(MemoryFrame.update_allowed _ m1 93 n (Or.inl rfl))
have hFull := Sem.seq_bound hZero (fun z _ hz => by subst z; exact hRest)
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem gcdLoop_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB L cap n0 : ℕ) (s0 : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile gcdLoopStmt pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m s0) (hinv : GcdInv L s0)
(hn0 : n0 < 2 ^ E.W) (hm93 : m 93 = n0) :
Sem P E pc (pc + 490) (rankState pc m n0)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 228) * n0 + 1 ∧
z.regs = (fun _ => 0) ∧ z.mem 93 = 0 ∧
MemoryFrame (gcdLoopWritable RB UB DB CB cap) m z.mem ∧
∃ RB' UB' DB' CB', PadeRows b E RB' UB' DB' CB' L cap z.mem (padeRun 1 n0 s0) ∧
∀ addr, padeWritable RB' UB' DB' CB' cap addr ↔ padeWritable RB UB DB CB cap addr) := by
let I := fun n z => n ≤ n0 ∧ gcdLoopInvariant b E RB UB DB CB L cap (padeRun 1 n0 s0) m n z
have hW1 : 1 < 2 ^ E.W := by have h := hrows.layout.Rlow; have h' := hrows.Rword; omega
have hframe : ∀ n z pc', I n z → I n { z with pc := pc' } := by
intro n z pc' h
simpa only [I, gcdLoopInvariant] using h
have hcounter : ∀ n z, I n z → z.regs r9 = n := by
intro n z h
rw [h.2.1, Function.update_self]
obtain ⟨_, _, hBodyAt, hJumpAt⟩ := at_loop hAt
have hbody : ∀ n z, I (n + 1) z → z.pc = pc →
Sem P E (pc + 1) pc { z with pc := pc + 1 }
(fun k z' => k ≤ 17 * cap + (48 * L + 187) * L + 227 ∧ I n z') := by
intro n z hI hpc
obtain ⟨hn, hregs, h93, hf0, RB1, UB1, DB1, CB1, s, hr, hi, hremaining, hfoot0⟩ := hI
have hz : { z with pc := pc + 1 } = rankState (pc + 1) z.mem (n + 1) := by
apply ramState_eq_of
· rfl
· rfl
· intro r; exact congrFun hregs r
rw [hz]
have hrun := gcdLoopBody_spec b ι t N P E (pc + 1) RB1 UB1 DB1 CB1 L cap n s z.mem
hBodyAt hw hW hdet hL hcap hr hi (by omega) h93
refine Sem.jmp_append (hAt := hJumpAt) (Sem.mono hrun ?_)
intro k z' hQ
obtain ⟨hk, m', RB2, UB2, DB2, CB2, hz', h93', hr', hf', hfoot'⟩ := hQ
refine ⟨by omega, by omega, ?_⟩
rw [hz']
refine ⟨rfl, h93', ?_, RB2, UB2, DB2, CB2, padeTick 1 s, hr', gcdInv_tick hi, ?_, ?_⟩
· exact MemoryFrame.trans hf0 (hf'.mono (by
intro addr ha
rcases ha with h93 | hp
· exact Or.inl h93
· exact Or.inr ((hfoot0 addr).mp hp)))
· exact (padeRun_succ_tick 1 n s).trans hremaining
· intro addr
exact (hfoot' addr).trans (hfoot0 addr)
have hinit : I n0 (rankState pc m n0) := by
refine ⟨le_rfl, rfl, hm93, ?_, RB, UB, DB, CB, s0, hrows, hinv, rfl, ?_⟩
· intro addr _; rfl
· intro addr; rfl
have hloop := Sem.loop_invariant P E pc gcdLoopBody hAt hW1 I
(17 * cap + (48 * L + 187) * L + 227) hframe hcounter hbody n0 (rankState pc m n0) hinit rfl
refine Sem.mono hloop ?_
intro k z hQ
obtain ⟨hk, _, hregs, h93, hf, RB', UB', DB', CB', s, hr, _, hremaining, hfoot⟩ := hQ
have hs : s = padeRun 1 n0 s0 := hremaining
refine ⟨hk, ?_, h93, hf, RB', UB', DB', CB', ?_, hfoot⟩
· rw [hregs]
funext r
simp [Function.update_apply]
· simpa only [hs] using hr
theorem gcdSolveProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB L cap n0 : ℕ) (s0 : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile gcdSolveProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m s0) (hinv : GcdInv L s0)
(hn0 : n0 < 2 ^ E.W) (hm93 : m 93 = n0) :
Sem P E pc (pc + 493) (boundaryState pc m)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 228) * n0 + 4 ∧
∃ m' RB' UB' DB' CB', z = boundaryState (pc + 493) m' ∧ m' 93 = 0 ∧
MemoryFrame (gcdLoopWritable RB UB DB CB cap) m m' ∧
PadeRows b E RB' UB' DB' CB' L cap m' (padeRun 1 n0 s0) ∧
∀ addr, padeWritable RB' UB' DB' CB' cap addr ↔ padeWritable RB UB DB CB cap addr) := by
obtain ⟨hReadAt, hLoopAt⟩ := At.seqStmt hAt
have hwidth : (93 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (93 : ℕ) < 2 ^ 8) hp
have hRead : Sem P E pc (pc + 3) (boundaryState pc m)
(fun k z => k ≤ 3 ∧ z = rankState (pc + 3) m n0) := by
refine Sem.mono (Sem.block P E pc (metaReadCode r9 93) _ hReadAt (by simp [metaReadCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
exact ⟨by change k = 3 at hk; omega, hz.trans (rankReadSlot_spec E pc m 93 n0 hwidth hn0 hm93)⟩
have hLoop := gcdLoop_spec b ι t N P E (pc + 3) RB UB DB CB L cap n0 s0 m hLoopAt
hw hW hdet hL hcap hrows hinv hn0 hm93
have hFull := Sem.seq_bound hRead (fun z _ hz => by subst z; exact hLoop)
obtain ⟨hpc, k, z, hrun, hreturn, hk, hregs, h93, hf, RB', UB', DB', CB', hr, hfoot⟩ := hFull
refine ⟨hpc, k, z, hrun, hreturn, by omega, z.mem, RB', UB', DB', CB', ?_, h93, hf, hr, hfoot⟩
apply ramState_eq_of
· exact hreturn
· rfl
· intro r
simpa only [boundaryState] using congrFun hregs r
theorem gcdReturnCode_spec (E : RAMEnv) (s : RAMState) (RB DB d : ℕ)
(hmeta : (97 : ℕ) < 2 ^ E.W) (hR : RB < 2 ^ E.W) (hD : DB < 2 ^ E.W)
(hd : d ≤ 1) (hm72 : s.mem 72 = RB) (hm74 : s.mem 74 = DB) (hm95 : s.mem 95 = d) :
runBlock gcdReturnCode E s = boundaryState (s.pc + 33)
(Function.update s.mem 97 (if d = 0 then RB else DB)) := by
have hsmall : ∀ i ≤ 97, i % 2 ^ E.W = i := by
intro i hi
exact Nat.mod_eq_of_lt (by omega)
have hR0 : RB % 2 ^ E.W = RB := Nat.mod_eq_of_lt hR
have hD0 : DB % 2 ^ E.W = DB := Nat.mod_eq_of_lt hD
have hsub0 : (1 + 2 ^ E.W - 0) % 2 ^ E.W = 1 := by simp [Nat.add_mod, hsmall 1 (by norm_num)]
have hsub1 : (1 + 2 ^ E.W - 1) % 2 ^ E.W = 0 := by simp
rw [gcdReturnCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc gcdReturnCode E s (by
simp [gcdReturnCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [gcdReturnCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 33 at hp
exact hp
· rcases (show d = 0 ∨ d = 1 by omega) with h0 | h1
· simp [runBlock_append, metaRead_spec, metaStore_spec, runBlock_cons, runBlock_nil,
execInstr, hsmall, hm72, hm74, hm95, h0, hR0, hD0, hsub0, boundaryState]
· simp [runBlock_append, metaRead_spec, metaStore_spec, runBlock_cons, runBlock_nil,
execInstr, hsmall, hm72, hm74, hm95, h1, hR0, hD0, hsub1, boundaryState]
· intro _; rfl
theorem gcdReturnProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv)
(pc RB UB DB CB L cap : ℕ) (s : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile gcdReturnProcedure pc))
(hmeta : (97 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W) (hcap : 1 ≤ cap)
(hrows : PadeRows b E RB UB DB CB L cap m s) (hdeg : s.rem.natDegree = 0) :
Sem P E pc (pc + 103) (boundaryState pc m)
(fun k z => k ≤ 17 * cap + 88 ∧ ∃ m' out, z = boundaryState (pc + 103) m' ∧
m' 97 = out ∧ 128 ≤ out ∧ out + cap ≤ 2 ^ E.W ∧
PolynomialStored b m' out cap (gcdFinish s) ∧
MemoryFrame (fun addr => addr = 64 ∨ addr = 66 ∨ addr = 95 ∨ addr = 97) m m' ∧ (out = RB ∨ out = DB)) := by
let d := degreeScan s.rem cap
let m1 := Function.update (Function.update m 64 DB) 66 cap
let m2 := Function.update m1 95 d
let out := if d = 0 then RB else DB
let m3 := Function.update m2 97 out
have hd : d ≤ 1 := by
by_cases hz : s.rem = 0
· simp [d, hz]
· rw [show d = s.rem.natDegree + 1 from degreeScan_eq s.rem hz cap (by omega), hdeg]
have hout : out = if s.rem = 0 then RB else DB := by
by_cases hz : s.rem = 0
· simp [out, d, hz]
· simp [out, d, degreeScan_eq s.rem hz cap (by omega), hdeg, hz]
have hcapWord : cap < 2 ^ E.W := by have h := hrows.layout.Rlow; have h' := hrows.Rword; omega
have hDBword : DB < 2 ^ E.W := by have h := hrows.Dword; omega
have hf1 : MemoryFrame padeScratch m m1 :=
MemoryFrame.trans (MemoryFrame.update_allowed padeScratch m 64 _ (by simp [padeScratch]))
(MemoryFrame.update_allowed padeScratch _ 66 _ (by simp [padeScratch]))
have hf2 : MemoryFrame padeScratch m1 m2 := MemoryFrame.update_allowed padeScratch m1 95 d (by simp [padeScratch])
have hr1 := hrows.of_scratch hf1
have hr2 := hr1.of_scratch hf2
obtain ⟨hSetupAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hScanAt, hReturnAt⟩ := At.seqStmt hRestAt
have hSetup : Sem P E pc (pc + 28) (boundaryState pc m)
(fun k z => k ≤ 28 ∧ z = boundaryState (pc + 28) m1) := by
exact Sem.boundary_block P E _ (scanSetupCode 74) m m1 hSetupAt
(by simp [scanSetupCode, metaReadCode, metaStoreCode, zeroRegsCode])
(scanSetup_spec E _ 74 DB cap (by omega) (by omega) hDBword hcapWord hrows.ptr74 hrows.capacity)
have hScan := scanProcedure_spec b P E (pc + 28) DB cap s.rem m1 hScanAt (by omega) hwe
hDBword hcapWord hrows.Dword hr1.rem (by simp [m1]) (by simp [m1])
have hReturn : Sem P E (pc + 70) (pc + 103) (boundaryState (pc + 70) m2)
(fun k z => k ≤ 33 ∧ z = boundaryState (pc + 103) m3) := by
exact Sem.boundary_block P E _ gcdReturnCode m2 m3 hReturnAt
(by simp [gcdReturnCode, metaReadCode, metaStoreCode, zeroRegsCode])
(gcdReturnCode_spec E _ RB DB d hmeta
(by have h := hrows.Rword; omega) hDBword hd hr2.ptr72 hr2.ptr74 (by simp [boundaryState, m2]))
have hFull := Sem.seq_bound hSetup (fun z _ hz => by
subst z
exact Sem.seq_bound hScan (fun z _ hz => by subst z; exact hReturn))
have hfinalmeta : MemoryFrame (fun addr => addr < 128) m2 m3 := MemoryFrame.meta_update m2 97 out (by norm_num)
have hstored : PolynomialStored b m3 out cap (gcdFinish s) := by
rw [hout]
by_cases hz : s.rem = 0
· simpa [gcdFinish, hz] using hr2.prevR.of_metaFrame hrows.layout.Rlow hfinalmeta
· simpa [gcdFinish, hz] using hr2.rem.of_metaFrame hrows.layout.Dlow hfinalmeta
refine Sem.mono hFull ?_
intro k z hQ
refine ⟨by omega, m3, out, hQ.2, by simp [m3], ?_, ?_, hstored, ?_, ?_⟩
· rw [hout]
split <;> first | exact hrows.layout.Rlow | exact hrows.layout.Dlow
· rw [hout]
split <;> first | exact hrows.Rword | exact hrows.Dword
· apply MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans
(MemoryFrame.update_allowed _ m 64 DB (by simp))
(MemoryFrame.update_allowed _ _ 66 cap (by simp)))
(MemoryFrame.update_allowed _ _ 95 d (by simp)))
(MemoryFrame.update_allowed _ _ 97 out (by simp))
· by_cases hzero : d = 0 <;> simp [out, hzero]
/-- Complete gcd routine: its returned pointer stores the exact Euclidean
gcd, with no normalization or field enumeration. -/
theorem gcdProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB L cap : ℕ) (s0 : PadeState F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile gcdProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hL : 1 ≤ L) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m s0) (hinv : GcdInv L s0) (hm93 : m 93 = L) :
Sem P E pc (pc + 596) (boundaryState pc m)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 228) * L + 17 * cap + 92 ∧
∃ out, z.mem 97 = out ∧ 128 ≤ out ∧ out + cap ≤ 2 ^ E.W ∧
PolynomialStored b z.mem out cap (EuclideanDomain.gcd s0.rem s0.prevR) ∧
MemoryFrame (gcdProcedureWritable RB UB DB CB cap) m z.mem ∧ z.regs = (fun _ => 0) ∧
∀ i < cap, padeWritable RB UB DB CB cap (out + i)) := by
obtain ⟨hSolveAt, hReturnAt⟩ := At.seqStmt hAt
have hLWord : L < 2 ^ E.W := by have h := hrows.Rword; have h' := hrows.layout.Rlow; omega
have hmeta : (97 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (97 : ℕ) < 2 ^ 8) hp
have hSolve := gcdSolveProcedure_spec b ι t N P E pc RB UB DB CB L cap L s0 m hSolveAt
hw hW hdet hL hcap hrows hinv hLWord hm93
have hFull := Sem.seq_bound hSolve (fun z _ hQ => by
obtain ⟨m1, RB', UB', DB', CB', hz, _, hfSolve, hr, hfoot⟩ := hQ
subst z
have hReturn := gcdReturnProcedure_spec b P E (pc + 493) RB' UB' DB' CB' L cap
(padeRun 1 L s0) m1 hReturnAt hmeta (by omega) (by omega) hr (padeRun_gcd_stop L s0 hinv.2.1)
refine Sem.mono (Q' := fun k z => k ≤ 17 * cap + 88 ∧ ∃ out, z.mem 97 = out ∧
128 ≤ out ∧ out + cap ≤ 2 ^ E.W ∧
PolynomialStored b z.mem out cap (EuclideanDomain.gcd s0.rem s0.prevR) ∧
MemoryFrame (gcdProcedureWritable RB UB DB CB cap) m z.mem ∧ z.regs = (fun _ => 0) ∧
∀ i < cap, padeWritable RB UB DB CB cap (out + i)) hReturn ?_
intro k z hQ
obtain ⟨hk, m2, out, hz, hout, hlo, hword, hp, hfReturn, hchoice⟩ := hQ
refine ⟨hk, out, ?_, hlo, hword, ?_, ?_, ?_, ?_⟩
· rw [hz]; exact hout
· rw [hz]
simpa only [boundaryState, padeRun_gcd L s0 hinv.2.1] using hp
· rw [hz]
apply MemoryFrame.trans (hfSolve.mono (by intro addr ha; exact Or.inr ha))
(hfReturn.mono ?_)
intro addr ha
dsimp [gcdProcedureWritable, gcdLoopWritable, padeWritable]
omega
· rw [hz]; rfl
· intro i hi
apply (hfoot (out + i)).mp
rcases hchoice with hR | hD
· rw [hR]
dsimp [padeWritable]
omega
· rw [hD]
dsimp [padeWritable]
omega)
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem PadeRows.array_arguments {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {E : RAMEnv} {RB UB DB CB L cap : ℕ}
{m : ℕ → ℕ} {s : PadeState F} (h : PadeRows b E RB UB DB CB L cap m s) (dst src len : ℕ) :
PadeRows b E RB UB DB CB L cap (arrayArguments m dst src len) s := by
apply h.of_scratchFrame ((arrayArguments_frame m dst src len).mono (by intro addr ha; omega))
intro slot hs
exact arrayArguments_frame m dst src len slot (by omega)
/-- A write to the first row leaves the other rows and all pointers intact. -/
theorem PadeRows.replace_prevR {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {E : RAMEnv} {RB UB DB CB L cap : ℕ}
{m m' : ℕ → ℕ} {s : PadeState F} (h : PadeRows b E RB UB DB CB L cap m s) (q : F[X])
(hf : MemoryFrame (fun addr => RB ≤ addr ∧ addr < RB + cap) m m')
(hq : PolynomialStored b m' RB cap q) :
PadeRows b E RB UB DB CB L cap m' (⟨q, s.prevC, s.rem, s.curC⟩ : PadeState F) := by
have hmeta (slot : ℕ) (hs : slot < 128) : m' slot = m slot :=
hf slot (by have h' := h.layout.Rlow; omega)
refine ⟨h.layout, h.Rword, h.Uword, h.Dword, h.Cword, hq,
h.prevC.of_frame hf (by intro i hi; have h' := h.layout.RU; omega),
h.rem.of_frame hf (by intro i hi; have h' := h.layout.RD; omega),
h.curC.of_frame hf (by intro i hi; have h' := h.layout.RC; omega), ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· exact (hmeta 72 (by norm_num)).trans h.ptr72
· exact (hmeta 73 (by norm_num)).trans h.ptr73
· exact (hmeta 74 (by norm_num)).trans h.ptr74
· exact (hmeta 75 (by norm_num)).trans h.ptr75
· exact (hmeta 76 (by norm_num)).trans h.length
· exact (hmeta 77 (by norm_num)).trans h.dimension
· exact (hmeta 81 (by norm_num)).trans h.capacity
/-- Writes to a separate trace buffer preserve the four Euclidean rows. -/
theorem PadeRows.external_write {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {E : RAMEnv} {RB UB DB CB L cap TB : ℕ}
{m m' : ℕ → ℕ} {s : PadeState F} (h : PadeRows b E RB UB DB CB L cap m s)
(hTB : 128 ≤ TB)
(hR : TB + cap ≤ RB ∨ RB + cap ≤ TB) (hU : TB + cap ≤ UB ∨ UB + cap ≤ TB)
(hD : TB + cap ≤ DB ∨ DB + cap ≤ TB) (hC : TB + cap ≤ CB ∨ CB + cap ≤ TB)
(hf : MemoryFrame (fun addr => TB ≤ addr ∧ addr < TB + cap) m m') :
PadeRows b E RB UB DB CB L cap m' s := by
have hmeta (slot : ℕ) (hs : slot < 128) : m' slot = m slot := hf slot (by omega)
refine ⟨h.layout, h.Rword, h.Uword, h.Dword, h.Cword,
h.prevR.of_frame hf (by intro i hi; omega), h.prevC.of_frame hf (by intro i hi; omega),
h.rem.of_frame hf (by intro i hi; omega), h.curC.of_frame hf (by intro i hi; omega), ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· exact (hmeta 72 (by norm_num)).trans h.ptr72
· exact (hmeta 73 (by norm_num)).trans h.ptr73
· exact (hmeta 74 (by norm_num)).trans h.ptr74
· exact (hmeta 75 (by norm_num)).trans h.ptr75
· exact (hmeta 76 (by norm_num)).trans h.length
· exact (hmeta 77 (by norm_num)).trans h.dimension
· exact (hmeta 81 (by norm_num)).trans h.capacity
theorem traceSquare_degree_lt {F : Type} [Field F] (p : F[X]) (a : F) (t L : ℕ)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hp : p.natDegree < t) :
(p ^ 2 + Polynomial.C a * Polynomial.X).natDegree < L := by
have hs : (p ^ 2).natDegree ≤ 2 * p.natDegree := by
simpa only [pow_two, two_mul] using Polynomial.natDegree_mul_le (p := p) (q := p)
have hl : (Polynomial.C a * Polynomial.X : F[X]).natDegree ≤ 1 := by
simpa only [pow_one] using Polynomial.natDegree_C_mul_X_pow_le a 1
have ha := Polynomial.natDegree_add_le (p ^ 2) (Polynomial.C a * Polynomial.X)
omega
/-- One exact modular trace recurrence, retaining the factor and a separate
trace buffer so subsequent squarings never overwrite their source. -/
theorem traceStep_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB TB L cap : ℕ) (p f : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile traceStepProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m (⟨p, 0, f, 0⟩ : PadeState F))
(hTB : 128 ≤ TB) (hTBword : TB + cap ≤ 2 ^ E.W)
(hTR : TB + cap ≤ RB ∨ RB + cap ≤ TB) (hTU : TB + cap ≤ UB ∨ UB + cap ≤ TB)
(hTD : TB + cap ≤ DB ∨ DB + cap ≤ TB) (hTC : TB + cap ≤ CB ∨ CB + cap ≤ TB)
(htrace : PolynomialStored b m TB cap p) (hFpos : 0 < f.natDegree) (hF : f.natDegree ≤ t)
(hp : p.natDegree < f.natDegree)
(hm95 : m 95 = f.natDegree + 1) (hm96 : m 96 = enc b a) (hm98 : m 98 = TB) :
Sem P E pc (pc + 469) (boundaryState pc m)
(fun k z => k ≤ 30 * cap + (48 * L + 187) * L + 213 ∧ ∃ m', z = boundaryState (pc + 469) m' ∧
PadeRows b E RB UB DB CB L cap m' (⟨(p ^ 2 + Polynomial.C a * Polynomial.X) % f, 0, f, 0⟩ : PadeState F) ∧
PolynomialStored b m' TB cap ((p ^ 2 + Polynomial.C a * Polynomial.X) % f) ∧
m' 95 = f.natDegree + 1 ∧ m' 96 = enc b a ∧ m' 98 = TB ∧
MemoryFrame (traceWritable RB UB DB CB TB cap) m m') := by
let q := p ^ 2 + Polynomial.C a * Polynomial.X
let m1 := arrayArguments m RB TB cap
have hcapWord : cap < 2 ^ E.W := by have h := hrows.Rword; have h' := hrows.layout.Rlow; omega
have hRBword : RB < 2 ^ E.W := by have h := hrows.Rword; omega
have hTBword0 : TB < 2 ^ E.W := by omega
have hwidth : (98 : ℕ) < 2 ^ E.W := by
have hp8 : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (98 : ℕ) < 2 ^ 8) hp8
have hLpos : 1 ≤ L := by omega
have hq : q.natDegree < L := traceSquare_degree_lt p a t L ht hL (by omega)
have hm1meta (slot : ℕ) (hlo : 72 ≤ slot) : m1 slot = m slot :=
arrayArguments_frame m RB TB cap slot (by omega)
have hr1 := hrows.array_arguments RB TB cap
have ht1 : PolynomialStored b m1 TB L p := by
intro i hi
change arrayArguments m RB TB cap (TB + i) = enc b (p.coeff i)
rw [arrayArguments_frame m RB TB cap (TB + i) (by omega)]
exact htrace i (by omega)
obtain ⟨hSetup1At, hRest1⟩ := At.seqStmt hAt
obtain ⟨hSquareAt, hRest2⟩ := At.seqStmt hRest1
obtain ⟨hModAt, hRest3⟩ := At.seqStmt hRest2
obtain ⟨hSetup2At, hCopyAt⟩ := At.seqStmt hRest3
have hSetup1 : Sem P E pc (pc + 34) (boundaryState pc m)
(fun k z => k ≤ 34 ∧ z = boundaryState (pc + 34) m1) := by
exact Sem.boundary_block P E _ (arraySetupCode 72 98) m m1 hSetup1At
(by simp [arraySetupCode, metaReadCode, metaStoreCode, zeroRegsCode])
(arraySetup_spec E _ 72 98 RB TB cap (by omega) (by omega) hwidth hRBword hTBword0 hcapWord
hrows.ptr72 hm98 hrows.capacity)
have hSquare := traceSquareProcedure_spec b ι t N P E (pc + 34) RB TB L cap p a m1 hSquareAt
hw hW hdet hLpos hcap hcapWord hrows.layout.Rlow hRBword hTBword0 hrows.Rword
(by omega) (by omega) ht1 (by simp [m1, arrayArguments]) (by simp [m1, arrayArguments])
(by simp [m1, arrayArguments]) (by rw [hm1meta 96 (by norm_num)]; exact hm96)
obtain ⟨_, ks, zs, hrunS, hpcS, hcostS, m2, hzS, hqStored, hfSquare⟩ := hSquare
have hr2 := hr1.replace_prevR q hfSquare hqStored
have hm2meta (slot : ℕ) (hhi : slot < 128) : m2 slot = m1 slot :=
hfSquare slot (by have h := hrows.layout.Rlow; omega)
have hSquareExact : Sem P E (pc + 34) (pc + 104) (boundaryState (pc + 34) m1)
(fun k z => k ≤ 18 * cap + 54 ∧ z = boundaryState (pc + 104) m2) :=
⟨rfl, ks, zs, hrunS, hpcS, hcostS, hzS⟩
have hMod := polynomialModulo_strong_spec b ι t N P E (pc + 104) RB UB DB CB L cap
(⟨q, 0, f, 0⟩ : PadeState F) m2 hModAt hw hW hdet hLpos hcap hr2 hq hFpos (by change f.natDegree < L; omega)
(by simpa only [Polynomial.natDegree_zero] using (show 0 < L by omega))
(by change m2 95 = f.natDegree + 1; rw [hm2meta 95 (by norm_num), hm1meta 95 (by norm_num)]; exact hm95)
obtain ⟨_, km, zm, hrunM, hpcM, hcostM, m3, hzM, hr3raw, hfMod, hm3meta⟩ := hMod
have hr3 : PadeRows b E RB UB DB CB L cap m3 (⟨q % f, 0, f, 0⟩ : PadeState F) := by
simpa [reducedPadeRows] using hr3raw
have hModExact : Sem P E (pc + 104) (pc + 399) (boundaryState (pc + 104) m2)
(fun k z => k ≤ (48 * L + 187) * L + 65 ∧ z = boundaryState (pc + 399) m3) :=
⟨rfl, km, zm, hrunM, hpcM, hcostM, hzM⟩
let m4 := arrayArguments m3 TB RB cap
let m5 := writeArray TB m4 (fun i => m4 (RB + i)) cap
have hr4 := hr3.array_arguments TB RB cap
have hm4meta (slot : ℕ) (hlo : 72 ≤ slot) : m4 slot = m3 slot :=
arrayArguments_frame m3 TB RB cap slot (by omega)
have hSetup2 : Sem P E (pc + 399) (pc + 433) (boundaryState (pc + 399) m3)
(fun k z => k ≤ 34 ∧ z = boundaryState (pc + 433) m4) := by
exact Sem.boundary_block P E _ (arraySetupCode 98 72) m3 m4 hSetup2At
(by simp [arraySetupCode, metaReadCode, metaStoreCode, zeroRegsCode])
(arraySetup_spec E _ 98 72 TB RB cap (by omega) hwidth (by omega) hTBword0 hRBword hcapWord
(by change m3 98 = TB; rw [hm3meta 98 (by norm_num) (by norm_num), hm2meta 98 (by norm_num), hm1meta 98 (by norm_num)]; exact hm98)
hr3.ptr72 hr3.capacity)
have hCopy := copyProcedure_spec P E (pc + 433) TB RB cap m4 hCopyAt (by omega) hTBword0 hRBword hcapWord
hTBword hrows.Rword (by omega)
(fun i hi => by
have hv : m4 (RB + i) = enc b ((q % f).coeff i) := hr4.prevR i hi
rw [hv]
exact lt_of_lt_of_le (enc_lt b _) (by rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)))
(by simp [m4, arrayArguments]) (by simp [m4, arrayArguments]) (by simp [m4, arrayArguments])
have hfCopy : MemoryFrame (fun addr => TB ≤ addr ∧ addr < TB + cap) m4 m5 := by
intro addr ha
exact writeArray_frame TB m4 _ cap addr (by omega)
have hr5 := hr4.external_write hTB hTR hTU hTD hTC hfCopy
have ht5 : PolynomialStored b m5 TB cap (q % f) := by
intro i hi
change writeArray TB m4 (fun j => m4 (RB + j)) cap (TB + i) = enc b ((q % f).coeff i)
rw [writeArray_get TB m4 _ cap i hi]
exact hr4.prevR i hi
have hm5meta (slot : ℕ) (hhi : slot < 128) : m5 slot = m4 slot := hfCopy slot (by omega)
have hmFinal (slot : ℕ) (hlo : 72 ≤ slot) (hhi : slot < 128) : m5 slot = m slot := by
rw [hm5meta slot hhi, hm4meta slot hlo, hm3meta slot hlo hhi, hm2meta slot hhi, hm1meta slot hlo]
have hf01 : MemoryFrame (traceWritable RB UB DB CB TB cap) m m1 :=
(arrayArguments_frame m RB TB cap).mono (by intro addr ha; dsimp [traceWritable, padeWritable]; omega)
have hf12 : MemoryFrame (traceWritable RB UB DB CB TB cap) m1 m2 :=
hfSquare.mono (by intro addr ha; dsimp [traceWritable, padeWritable]; omega)
have hf23 : MemoryFrame (traceWritable RB UB DB CB TB cap) m2 m3 := hfMod.mono (by intro addr ha; exact Or.inl ha)
have hf34 : MemoryFrame (traceWritable RB UB DB CB TB cap) m3 m4 :=
(arrayArguments_frame m3 TB RB cap).mono (by intro addr ha; dsimp [traceWritable, padeWritable]; omega)
have hf45 : MemoryFrame (traceWritable RB UB DB CB TB cap) m4 m5 := hfCopy.mono (by intro addr ha; exact Or.inr ha)
have hFull := Sem.seq_bound hSetup1 (fun z _ hz => by
subst z
exact Sem.seq_bound hSquareExact (fun z _ hz => by
subst z
exact Sem.seq_bound hModExact (fun z _ hz => by
subst z
exact Sem.seq_bound hSetup2 (fun z _ hz => by subst z; exact hCopy))))
refine Sem.mono hFull ?_
intro k z hQ
refine ⟨by omega, m5, hQ.2, hr5, ht5, ?_, ?_, ?_, ?_⟩
· exact (hmFinal 95 (by norm_num) (by norm_num)).trans hm95
· exact (hmFinal 96 (by norm_num) (by norm_num)).trans hm96
· exact (hmFinal 98 (by norm_num) (by norm_num)).trans hm98
· exact MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans hf01 hf12) hf23) hf34) hf45
theorem PadeRows.traceCounter_update {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {E : RAMEnv} {RB UB DB CB L cap : ℕ}
{m : ℕ → ℕ} {s : PadeState F} (h : PadeRows b E RB UB DB CB L cap m s) (n : ℕ) :
PadeRows b E RB UB DB CB L cap (Function.update m 92 n) s := by
apply h.of_scratchFrame (MemoryFrame.meta_update m 92 n (by norm_num))
intro slot hs
rw [Function.update_of_ne (by omega : slot ≠ 92)]
theorem traceLoopBody_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB TB L cap n k0 : ℕ) (f : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile traceLoopBody pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m (⟨traceRemainder a f k0, 0, f, 0⟩ : PadeState F))
(hTB : 128 ≤ TB) (hTBword : TB + cap ≤ 2 ^ E.W)
(hTR : TB + cap ≤ RB ∨ RB + cap ≤ TB) (hTU : TB + cap ≤ UB ∨ UB + cap ≤ TB)
(hTD : TB + cap ≤ DB ∨ DB + cap ≤ TB) (hTC : TB + cap ≤ CB ∨ CB + cap ≤ TB)
(htrace : PolynomialStored b m TB cap (traceRemainder a f k0)) (hFpos : 0 < f.natDegree) (hF : f.natDegree ≤ t)
(hn : n + 1 < 2 ^ E.W) (hm92 : m 92 = n + 1)
(hm95 : m 95 = f.natDegree + 1) (hm96 : m 96 = enc b a) (hm98 : m 98 = TB) :
Sem P E pc (pc + 512) (rankState pc m (n + 1))
(fun k z => k ≤ 30 * cap + (48 * L + 187) * L + 256 ∧ ∃ m',
z = rankState (pc + 512) m' n ∧ m' 92 = n ∧
PadeRows b E RB UB DB CB L cap m' (⟨traceRemainder a f (k0 + 1), 0, f, 0⟩ : PadeState F) ∧
PolynomialStored b m' TB cap (traceRemainder a f (k0 + 1)) ∧
m' 95 = f.natDegree + 1 ∧ m' 96 = enc b a ∧ m' 98 = TB ∧
MemoryFrame (traceLoopWritable RB UB DB CB TB cap) m m') := by
obtain ⟨hZeroAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hStepAt, hTailAt⟩ := At.seqStmt hRestAt
have hwidth : (92 : ℕ) < 2 ^ E.W := by
have hp8 : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (92 : ℕ) < 2 ^ 8) hp8
have hZero : Sem P E pc (pc + 16) (rankState pc m (n + 1))
(fun k z => k ≤ 16 ∧ z = boundaryState (pc + 16) m) := by
refine Sem.mono (Sem.block P E _ zeroRegsCode _ hZeroAt (by simp [zeroRegsCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change k = 16 at hk; omega, ?_⟩
rw [hz, zeroRegs_spec]
rfl
have hStep := traceStep_spec b ι t N P E (pc + 16) RB UB DB CB TB L cap (traceRemainder a f k0) f a m
hStepAt hw hW hdet ht hL hcap hrows hTB hTBword hTR hTU hTD hTC htrace hFpos hF
(traceRemainder_natDegree_lt a hFpos k0) hm95 hm96 hm98
have hRest : Sem P E (pc + 16) (pc + 512) (boundaryState (pc + 16) m)
(fun k z => k ≤ (30 * cap + (48 * L + 187) * L + 213) + 27 ∧ ∃ m',
z = rankState (pc + 512) m' n ∧ m' 92 = n ∧
PadeRows b E RB UB DB CB L cap m' (⟨traceRemainder a f (k0 + 1), 0, f, 0⟩ : PadeState F) ∧
PolynomialStored b m' TB cap (traceRemainder a f (k0 + 1)) ∧
m' 95 = f.natDegree + 1 ∧ m' 96 = enc b a ∧ m' 98 = TB ∧
MemoryFrame (traceLoopWritable RB UB DB CB TB cap) m m') := by
refine Sem.seq_bound hStep ?_
intro z hzpc hQ
obtain ⟨m1, hz, hr, htr, h95, h96, h98, hf⟩ := hQ
subst z
have hnot : ¬ traceWritable RB UB DB CB TB cap 92 := by
dsimp [traceWritable, padeWritable]
have hR := hrows.layout.Rlow
have hU := hrows.layout.Ulow
have hD := hrows.layout.Dlow
have hC := hrows.layout.Clow
omega
have h92 : m1 92 = n + 1 := (hf 92 hnot).trans hm92
have hTailRun := countdown_spec E (boundaryState (pc + 485) m1) 92 n hwidth hn h92
refine Sem.mono (Sem.block P E (pc + 485) (countdownCode 92) _ hTailAt
(by simp [countdownCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change k = 27 at hk; omega, Function.update m1 92 n, ?_, by simp, ?_, ?_, ?_, ?_, ?_, ?_⟩
· rw [hz, hTailRun]; rfl
· exact hr.traceCounter_update n
· exact htr.meta_update hTB 92 n (by norm_num)
· simpa using h95
· simpa using h96
· simpa using h98
· exact MemoryFrame.trans (hf.mono (by intro addr ha; exact Or.inr ha))
(MemoryFrame.update_allowed _ m1 92 n (Or.inl rfl))
have hFull := Sem.seq_bound hZero (fun z _ hz => by subst z; exact hRest)
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem traceLoop_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB TB L cap n0 : ℕ) (f : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile traceLoopStmt pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m (⟨0, 0, f, 0⟩ : PadeState F))
(hTB : 128 ≤ TB) (hTBword : TB + cap ≤ 2 ^ E.W)
(hTR : TB + cap ≤ RB ∨ RB + cap ≤ TB) (hTU : TB + cap ≤ UB ∨ UB + cap ≤ TB)
(hTD : TB + cap ≤ DB ∨ DB + cap ≤ TB) (hTC : TB + cap ≤ CB ∨ CB + cap ≤ TB)
(htrace : PolynomialStored b m TB cap 0) (hFpos : 0 < f.natDegree) (hF : f.natDegree ≤ t)
(hn0 : n0 < 2 ^ E.W) (hm92 : m 92 = n0)
(hm95 : m 95 = f.natDegree + 1) (hm96 : m 96 = enc b a) (hm98 : m 98 = TB) :
Sem P E pc (pc + 514) (rankState pc m n0)
(fun k z => k ≤ (30 * cap + (48 * L + 187) * L + 258) * n0 + 1 ∧
z.regs = (fun _ => 0) ∧ z.mem 92 = 0 ∧
PadeRows b E RB UB DB CB L cap z.mem (⟨traceRemainder a f n0, 0, f, 0⟩ : PadeState F) ∧
PolynomialStored b z.mem TB cap (traceRemainder a f n0) ∧
z.mem 95 = f.natDegree + 1 ∧ z.mem 96 = enc b a ∧ z.mem 98 = TB ∧
MemoryFrame (traceLoopWritable RB UB DB CB TB cap) m z.mem) := by
let I := fun (n : ℕ) (z : RAMState) => n ≤ n0 ∧ z.regs = Function.update (fun _ => 0) r9 n ∧ z.mem 92 = n ∧
z.mem 95 = f.natDegree + 1 ∧ z.mem 96 = enc b a ∧ z.mem 98 = TB ∧
PadeRows b E RB UB DB CB L cap z.mem (⟨traceRemainder a f (n0 - n), 0, f, 0⟩ : PadeState F) ∧
PolynomialStored b z.mem TB cap (traceRemainder a f (n0 - n)) ∧
MemoryFrame (traceLoopWritable RB UB DB CB TB cap) m z.mem
have hW1 : 1 < 2 ^ E.W := by have h := hrows.Rword; have h' := hrows.layout.Rlow; omega
have hframe : ∀ n z pc', I n z → I n { z with pc := pc' } := by
intro n z pc' h
simpa only [I] using h
have hcounter : ∀ n z, I n z → z.regs r9 = n := by
intro n z h
rw [h.2.1, Function.update_self]
obtain ⟨_, _, hBodyAt, hJumpAt⟩ := at_loop hAt
have hbody : ∀ n z, I (n + 1) z → z.pc = pc →
Sem P E (pc + 1) pc { z with pc := pc + 1 }
(fun k z' => k ≤ 30 * cap + (48 * L + 187) * L + 257 ∧ I n z') := by
intro n z hI hpc
obtain ⟨hn, hregs, h92, h95, h96, h98, hr, htr, hf⟩ := hI
have hz : { z with pc := pc + 1 } = rankState (pc + 1) z.mem (n + 1) := by
apply ramState_eq_of
· rfl
· rfl
· intro r; exact congrFun hregs r
rw [hz]
have hrun := traceLoopBody_spec b ι t N P E (pc + 1) RB UB DB CB TB L cap n (n0 - (n + 1)) f a z.mem
hBodyAt hw hW hdet ht hL hcap hr hTB hTBword hTR hTU hTD hTC htr hFpos hF (by omega) h92 h95 h96 h98
refine Sem.jmp_append (hAt := hJumpAt) (Sem.mono hrun ?_)
intro k z' hQ
obtain ⟨hk, m', hz', h92', hr', htr', h95', h96', h98', hf'⟩ := hQ
have hidx : n0 - (n + 1) + 1 = n0 - n := by omega
refine ⟨by omega, by omega, ?_⟩
rw [hz']
refine ⟨rfl, h92', h95', h96', h98', ?_, ?_, MemoryFrame.trans hf hf'⟩
· simpa only [hidx, rankState, boundaryState] using hr'
· simpa only [hidx, rankState, boundaryState] using htr'
have hinit : I n0 (rankState pc m n0) := by
refine ⟨le_rfl, rfl, hm92, hm95, hm96, hm98, ?_, ?_, ?_⟩
· simpa only [Nat.sub_self, traceRemainder, rankState, boundaryState] using hrows
· simpa only [Nat.sub_self, traceRemainder, rankState, boundaryState] using htrace
· intro addr _; rfl
have hloop := Sem.loop_invariant P E pc traceLoopBody hAt hW1 I
(30 * cap + (48 * L + 187) * L + 257) hframe hcounter hbody n0 (rankState pc m n0) hinit rfl
refine Sem.mono hloop ?_
intro k z hQ
obtain ⟨hk, _, hregs, h92, h95, h96, h98, hr, htr, hf⟩ := hQ
refine ⟨hk, ?_, h92, ?_, ?_, h95, h96, h98, hf⟩
· rw [hregs]
funext r
simp [Function.update_apply]
· simpa only [Nat.sub_zero] using hr
· simpa only [Nat.sub_zero] using htr
/-- Callable modular trace. Use n0=w for a basis splitter; the whole
calculation stays in the fixed low-degree buffers. -/
theorem traceProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ)
(P : Program) (E : RAMEnv) (pc RB UB DB CB TB L cap n0 : ℕ) (f : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile traceProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hrows : PadeRows b E RB UB DB CB L cap m (⟨0, 0, f, 0⟩ : PadeState F))
(hTB : 128 ≤ TB) (hTBword : TB + cap ≤ 2 ^ E.W)
(hTR : TB + cap ≤ RB ∨ RB + cap ≤ TB) (hTU : TB + cap ≤ UB ∨ UB + cap ≤ TB)
(hTD : TB + cap ≤ DB ∨ DB + cap ≤ TB) (hTC : TB + cap ≤ CB ∨ CB + cap ≤ TB)
(htrace : PolynomialStored b m TB cap 0) (hFpos : 0 < f.natDegree) (hF : f.natDegree ≤ t)
(hn0 : n0 < 2 ^ E.W) (hm92 : m 92 = n0)
(hm95 : m 95 = f.natDegree + 1) (hm96 : m 96 = enc b a) (hm98 : m 98 = TB) :
Sem P E pc (pc + 517) (boundaryState pc m)
(fun k z => k ≤ (30 * cap + (48 * L + 187) * L + 258) * n0 + 4 ∧ ∃ m',
z = boundaryState (pc + 517) m' ∧
PadeRows b E RB UB DB CB L cap m' (⟨traceRemainder a f n0, 0, f, 0⟩ : PadeState F) ∧
PolynomialStored b m' TB cap (traceRemainder a f n0) ∧
m' 92 = 0 ∧ m' 95 = f.natDegree + 1 ∧ m' 96 = enc b a ∧ m' 98 = TB ∧
MemoryFrame (traceLoopWritable RB UB DB CB TB cap) m m') := by
obtain ⟨hReadAt, hLoopAt⟩ := At.seqStmt hAt
have hwidth : (92 : ℕ) < 2 ^ E.W := by
have hp8 : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (92 : ℕ) < 2 ^ 8) hp8
have hRead : Sem P E pc (pc + 3) (boundaryState pc m)
(fun k z => k ≤ 3 ∧ z = rankState (pc + 3) m n0) := by
refine Sem.mono (Sem.block P E pc (metaReadCode r9 92) _ hReadAt (by simp [metaReadCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
exact ⟨by change k = 3 at hk; omega, hz.trans (rankReadSlot_spec E pc m 92 n0 hwidth hn0 hm92)⟩
have hLoop := traceLoop_spec b ι t N P E (pc + 3) RB UB DB CB TB L cap n0 f a m hLoopAt hw hW hdet
ht hL hcap hrows hTB hTBword hTR hTU hTD hTC htrace hFpos hF hn0 hm92 hm95 hm96 hm98
have hFull := Sem.seq_bound hRead (fun z _ hz => by subst z; exact hLoop)
obtain ⟨hpc, k, z, hrun, hreturn, hk, hregs, h92, hr, htr, h95, h96, h98, hf⟩ := hFull
refine ⟨hpc, k, z, hrun, hreturn, by omega, z.mem, ?_, hr, htr, h92, h95, h96, h98, hf⟩
apply ramState_eq_of
· exact hreturn
· rfl
· intro r
simpa only [boundaryState] using congrFun hregs r
theorem mem_keepFactor {F : Type} [Field F] (g f : F[X]) :
g ∈ keepFactor f ↔ g = f ∧ f.natDegree ≠ 0 := by
by_cases h : f.natDegree = 0 <;> simp [keepFactor, h]
theorem traceRootSearch_constant {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (as : List F) (f : F[X]) (h : f.natDegree = 0) : traceRootSearch w as f = [] := by
cases as <;> simp [traceRootSearch, h]
theorem rootForest_cons {F : Type} [Field F] [DecidableEq F] (w : ℕ) (as : List F) (f : F[X]) (fs : List F[X]) :
rootForest w as (f :: fs) = traceRootSearch w as f ++ rootForest w as fs := by
simp [rootForest]
theorem rootForest_append {F : Type} [Field F] [DecidableEq F] (w : ℕ) (as : List F) (fs gs : List F[X]) :
rootForest w as (fs ++ gs) = rootForest w as fs ++ rootForest w as gs := by
simp [rootForest]
theorem rootForest_keep {F : Type} [Field F] [DecidableEq F] (w : ℕ) (as : List F) (f : F[X]) :
rootForest w as (keepFactor f) = traceRootSearch w as f := by
by_cases h : f.natDegree = 0
· simp [keepFactor, h, rootForest, traceRootSearch_constant w as f h]
· simp [keepFactor, h, rootForest]
/-- Breadth-first factor splitting preserves the exact recursive root list,
including its order, for arbitrary non-decodable input polynomials. -/
theorem rootForest_split {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (a : F) (as : List F) (fs : List F[X]) :
rootForest w as (splitFrontier w a fs) = rootForest w (a :: as) fs := by
induction fs with
| nil => simp [splitFrontier, rootForest]
| cons f fs ih =>
by_cases h : f.natDegree = 0
· rw [splitFrontier, if_pos h, ih, rootForest_cons, traceRootSearch, if_pos h, List.nil_append]
· rw [splitFrontier, if_neg h, rootForest_append, rootForest_append,
rootForest_keep, rootForest_keep, ih, rootForest_cons, traceRootSearch, if_neg h]
theorem frontierMass_append {F : Type} [Field F] (fs gs : List F[X]) :
frontierMass (fs ++ gs) = frontierMass fs + frontierMass gs := by
induction fs with
| nil => simp [frontierMass]
| cons f fs ih => simp [frontierMass, ih, Nat.add_assoc]
theorem frontierMass_keep {F : Type} [Field F] (f : F[X]) : frontierMass (keepFactor f) = f.natDegree := by
by_cases h : f.natDegree = 0 <;> simp [keepFactor, h, frontierMass]
theorem splitFrontier_positive {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (a : F) (fs : List F[X]) : ∀ g ∈ splitFrontier w a fs, 0 < g.natDegree := by
induction fs with
| nil => simp [splitFrontier]
| cons f fs ih =>
intro g hg
by_cases h : f.natDegree = 0
· rw [splitFrontier, if_pos h] at hg
exact ih g hg
· rw [splitFrontier, if_neg h] at hg
rcases List.mem_append.mp hg with hleft | htail
· rcases List.mem_append.mp hleft with h0 | h1
· obtain ⟨heq, hne⟩ := (mem_keepFactor g _).mp h0
simpa only [heq] using Nat.pos_of_ne_zero hne
· obtain ⟨heq, hne⟩ := (mem_keepFactor g _).mp h1
simpa only [heq] using Nat.pos_of_ne_zero hne
· exact ih g htail
theorem splitFrontier_mass_le {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (a : F) (fs : List F[X]) (hfs : ∀ f ∈ fs, f ≠ 0) :
frontierMass (splitFrontier w a fs) ≤ frontierMass fs := by
induction fs with
| nil => simp [splitFrontier, frontierMass]
| cons f fs ih =>
have hf : f ≠ 0 := hfs f (by simp)
have htail := ih (fun g hg => hfs g (by simp [hg]))
by_cases h : f.natDegree = 0
· rw [splitFrontier, if_pos h]
simp only [frontierMass, h, zero_add]
exact htail
· rw [splitFrontier, if_neg h, frontierMass_append, frontierMass_append, frontierMass_keep, frontierMass_keep]
have hbudget := split_degree_budget f (traceRemainder a f w) hf
change _ ≤ f.natDegree + frontierMass fs
omega
theorem frontier_length_le_mass {F : Type} [Field F] (fs : List F[X])
(hfs : ∀ f ∈ fs, 0 < f.natDegree) : fs.length ≤ frontierMass fs := by
induction fs with
| nil => simp [frontierMass]
| cons f fs ih =>
have hf := hfs f (by simp)
have ht := ih (fun g hg => hfs g (by simp [hg]))
simp only [List.length_cons, frontierMass]
omega
theorem enc_basis {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (j : Fin w) : enc b (b j) = 2 ^ (j : ℕ) := by
classical
simp only [enc, b.repr_self, Finsupp.single_apply]
rw [Finset.sum_eq_single j]
· norm_num <;> decide
· intro k _ hk
simp [Ne.symm hk]
· simp
theorem posTab_le {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (v : F) : posTab N ι v ≤ N := by
classical
by_cases h : ∃ i, i < N ∧ ι i = v
· have hi := (Classical.choose_spec h).1
simp only [posTab, dif_pos h]
omega
· simp [posTab, h]
theorem detStd_pos {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(t N : ℕ) (b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) {a : ℕ} (ha : a < 2 ^ w) :
detStd t N b ι (detPosBase w + a) = posTab N ι (dec b a) := by
have hm : detMulBase w = 64 := rfl
have hs : detSqBase w = 64 + 2 ^ (2 * w) := rfl
have hi : detInvBase w = 64 + 2 ^ (2 * w) + 2 ^ (2 * w) := rfl
have hp : detPosBase w = detInvBase w + 2 ^ w := rfl
have hg : detImgBase w = detPosBase w + 2 ^ w := rfl
have hpow := Nat.two_pow_pos (2 * w)
have h0 : ¬ detPosBase w + a < 13 := by omega
have h1 : ¬ detPosBase w + a < detMulBase w := by omega
have h2 : ¬ detPosBase w + a < detSqBase w := by omega
have h3 : ¬ detPosBase w + a < detInvBase w := by omega
have h4 : ¬ detPosBase w + a < detPosBase w := by omega
have h5 : detPosBase w + a < detImgBase w := by omega
unfold detStd
rw [if_neg h0, if_neg h1, if_neg h2, if_neg h3, if_neg h4, if_pos h5, Nat.add_sub_cancel_left]
theorem basisScalar_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (E : RAMEnv) (s : RAMState) (j : Fin w)
(hmeta : (96 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W) (hm88 : s.mem 88 = (j : ℕ)) :
runBlock basisScalarCode E s = boundaryState (s.pc + 24) (Function.update s.mem 96 (enc b (b j))) := by
have hsmall : ∀ i ≤ 96, i % 2 ^ E.W = i := by
intro i hi
exact Nat.mod_eq_of_lt (by omega)
have hjWord : (j : ℕ) % 2 ^ E.W = j :=
Nat.mod_eq_of_lt (lt_of_lt_of_le j.isLt (le_trans hwe (Nat.le_of_lt (Nat.lt_two_pow_self (n := E.W)))))
have hpow : (2 : ℕ) ^ (j : ℕ) < 2 ^ E.W := Nat.pow_lt_pow_right (by norm_num) (lt_of_lt_of_le j.isLt hwe)
rw [basisScalarCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc basisScalarCode E s (by
simp [basisScalarCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [basisScalarCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 24 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, runBlock_cons, runBlock_nil, execInstr,
hsmall, hm88, hjWord, Nat.mod_eq_of_lt hpow, enc_basis, boundaryState]
· intro _; rfl
theorem degreeBranch_spec (P : Program) (E : RAMEnv) (pc : ℕ) (body : Stmt)
(m : ℕ → ℕ) (d B : ℕ) (Q : (ℕ → ℕ) → Prop)
(hAt : At P pc (Stmt.compile (degreeBranch body) pc))
(hmeta : (95 : ℕ) < 2 ^ E.W) (hd : d < 2 ^ E.W) (hm95 : m 95 = d)
(hcall : 1 < d → ∀ base, At P base (Stmt.compile body base) →
Sem P E base (base + body.len) (boundaryState base m)
(fun k z => k ≤ B ∧ z.regs = (fun _ => 0) ∧ Q z.mem))
(hstop : ¬ 1 < d → Q m) :
Sem P E pc (pc + (degreeBranch body).len) (boundaryState pc m)
(fun k z => k ≤ B + 23 ∧ z.regs = (fun _ => 0) ∧ Q z.mem) := by
obtain ⟨hLoadAt, hIfAt⟩ := At.seqStmt hAt
obtain ⟨_, _, hTrueAt, _, hFalseAt, _⟩ := at_ite hIfAt
obtain ⟨hZeroAt, hBodyAt⟩ := At.seqStmt hTrueAt
have hLoad : Sem P E pc (pc + 4) (boundaryState pc m)
(fun k z => k ≤ 4 ∧ z = padeTestState (pc + 4) m 1 d) := by
refine Sem.mono (Sem.block P E pc gcdTestLoadCode _ hLoadAt
(by simp [gcdTestLoadCode, metaReadCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
exact ⟨by change k = 4 at hk; omega, hz.trans (gcdTestLoad_spec E pc m d hmeta hd hm95)⟩
let c : Cond := .lt r15 r0 r1
let a := pc + 4
let z0 := padeTestState a m 1 d
let endpc := a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + (Stmt.code zeroRegsCode).len + 3
have hIf : Sem P E a endpc z0
(fun k z => k ≤ B + 19 ∧ z.regs = (fun _ => 0) ∧ Q z.mem) := by
apply Sem.ite P E a c (Stmt.seq (Stmt.code zeroRegsCode) body) (Stmt.code zeroRegsCode) z0 _ hIfAt (by omega) rfl
· intro hgo
have hg : 1 < d := hgo
have hZero := Sem.zero_block P E (a + 2) { runBlock c.code E z0 with pc := a + 2 } hZeroAt rfl
have hBody := hcall hg (a + 18) hBodyAt
have hTrue := Sem.seq_bound hZero (fun z _ hz => by subst z; exact hBody)
have htend : a + c.code.length + 1 + (Stmt.seq (Stmt.code zeroRegsCode) body).len = a + 18 + body.len := by
simp only [c, Cond.code, Stmt.len, zeroRegsCode, List.length_cons, List.length_nil]
omega
rw [htend]
refine Sem.mono hTrue ?_
intro k z hQ
exact ⟨by change 1 + 1 + k + 1 ≤ B + 19; omega, hQ.2.1, hQ.2.2⟩
· intro hno
have hng : ¬ 1 < d := hno
have hFalseAt' : At P (a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2) zeroRegsCode := by
have hh : At P (a + c.code.length + 1 + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 1) zeroRegsCode := hFalseAt
have heq : a + c.code.length + 1 + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 1 =
a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2 := by omega
rw [heq] at hh
exact hh
have hZero := Sem.zero_block P E (a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2)
{ runBlock c.code E z0 with pc := a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2 } hFalseAt' rfl
have hfend : a + c.code.length + 1 + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 1 + (Stmt.code zeroRegsCode).len =
(a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2) + 16 := by
simp only [Stmt.len, zeroRegsCode, List.length_cons, List.length_nil]
omega
rw [hfend]
refine Sem.mono hZero ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change 1 + 1 + k + 1 ≤ B + 19; omega, ?_, ?_⟩
· rw [hz]; rfl
· rw [hz]
exact hstop hng
have hFull := Sem.seq_bound hLoad (fun z _ hz => by subst z; exact hIf)
have hpc : endpc = pc + (degreeBranch body).len := by
simp only [endpc, a, c, degreeBranch, Stmt.len, Cond.code, List.length_singleton, gcdTestLoadCode,
metaReadCode, List.length_append, List.length_cons, List.length_nil]
omega
rw [hpc] at hFull
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem queue_slot_before_next (B cap n j i : ℕ) (hj : j < n) (hi : i < cap) :
B + j * cap + i < B + n * cap := by
have hm : (j + 1) * cap ≤ n * cap := Nat.mul_le_mul_right cap (by omega)
have he : (j + 1) * cap = j * cap + cap := by ring
omega
theorem FrontierStored.array_arguments {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m : ℕ → ℕ} {B cap : ℕ} {fs : List F[X]}
(h : FrontierStored b m B cap fs) (hB : 128 ≤ B) (dst src len : ℕ) :
FrontierStored b (arrayArguments m dst src len) B cap fs := by
intro j hj i hi
rw [arrayArguments_frame m dst src len (B + j * cap + i) (by omega)]
exact h j hj i hi
theorem FrontierStored.meta_update {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m : ℕ → ℕ} {B cap : ℕ} {fs : List F[X]}
(h : FrontierStored b m B cap fs) (hB : 128 ≤ B) (slot value : ℕ) (hs : slot < 128) :
FrontierStored b (Function.update m slot value) B cap fs := by
intro j hj
exact (h j hj).meta_update (by omega) slot value hs
/-- Copying one coefficient array into the next queue slot appends exactly
one polynomial and preserves all preceding factors. -/
theorem FrontierStored.append_copy {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m : ℕ → ℕ} {B cap src : ℕ} {fs : List F[X]} {f : F[X]}
(h : FrontierStored b m B cap fs) (hf : PolynomialStored b m src cap f) :
FrontierStored b (writeArray (B + fs.length * cap) m (fun i => m (src + i)) cap) B cap (fs ++ [f]) := by
intro j hj
by_cases hjold : j < fs.length
· rw [List.getD_append fs [f] 0 j hjold]
intro i hi
rw [writeArray_frame _ _ _ _ _ (Or.inl (queue_slot_before_next B cap fs.length j i hjold hi))]
exact h j hjold i hi
· have hjlast : j = fs.length := by simp only [List.length_append, List.length_singleton] at hj; omega
subst j
rw [List.getD_append_right fs [f] 0 fs.length le_rfl, Nat.sub_self]
intro i hi
rw [writeArray_get _ _ _ cap i hi]
exact hf i hi
theorem queueAppendArgs_spec (E : RAMEnv) (s : RAMState) (B n cap src : ℕ)
(hmeta : (97 : ℕ) < 2 ^ E.W) (hB : B < 2 ^ E.W) (hn : n < 2 ^ E.W)
(hnc : n * cap < 2 ^ E.W) (hdst : B + n * cap < 2 ^ E.W)
(hc : cap < 2 ^ E.W) (hsrc : src < 2 ^ E.W)
(hm84 : s.mem 84 = B) (hm90 : s.mem 90 = n) (hm81 : s.mem 81 = cap) (hm97 : s.mem 97 = src) :
runBlock queueAppendArgsCode E s = boundaryState (s.pc + 39) (arrayArguments s.mem (B + n * cap) src cap) := by
have hsmall : ∀ i ≤ 97, i % 2 ^ E.W = i := by
intro i hi
exact Nat.mod_eq_of_lt (by omega)
rw [queueAppendArgsCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc queueAppendArgsCode E s (by
simp [queueAppendArgsCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [queueAppendArgsCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 39 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, runBlock_cons, runBlock_nil,
execInstr, arrayArguments, hsmall, hm84, hm90, hm81, hm97,
Nat.mod_eq_of_lt hB, Nat.mod_eq_of_lt hn, Nat.mod_eq_of_lt hnc,
Nat.mod_eq_of_lt hdst, Nat.mod_eq_of_lt hc, Nat.mod_eq_of_lt hsrc, boundaryState]
· intro _; rfl
theorem queueIncrement_spec (E : RAMEnv) (s : RAMState) (n : ℕ)
(hmeta : (90 : ℕ) < 2 ^ E.W) (hn : n + 1 < 2 ^ E.W) (hm90 : s.mem 90 = n) :
runBlock queueIncrementCode E s = boundaryState (s.pc + 24) (Function.update s.mem 90 (n + 1)) := by
have h90 : (90 : ℕ) % 2 ^ E.W = 90 := Nat.mod_eq_of_lt hmeta
have h1 : (1 : ℕ) % 2 ^ E.W = 1 := Nat.mod_eq_of_lt (by omega)
rw [queueIncrementCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc queueIncrementCode E s (by
simp [queueIncrementCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [queueIncrementCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 24 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, runBlock_cons, runBlock_nil,
execInstr, h90, h1, hm90, Nat.mod_eq_of_lt (show n < 2 ^ E.W by omega),
Nat.mod_eq_of_lt hn, boundaryState]
· intro _; rfl
theorem queueAppendProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv) (pc B src cap T : ℕ)
(fs : List F[X]) (f : F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile queueAppendProcedure pc))
(hmeta : (97 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W) (hcap : 1 ≤ cap)
(hB : 128 ≤ B) (hsrc : 128 ≤ src) (hQword : B + T * cap ≤ 2 ^ E.W) (hSword : src + cap ≤ 2 ^ E.W)
(hcount : fs.length < T) (hdisj : src + cap ≤ B ∨ B + T * cap ≤ src)
(hq : FrontierStored b m B cap fs) (hf : PolynomialStored b m src cap f)
(hm84 : m 84 = B) (hm90 : m 90 = fs.length) (hm81 : m 81 = cap) (hm97 : m 97 = src) :
Sem P E pc (pc + 99) (boundaryState pc m)
(fun k z => k ≤ 12 * cap + 89 ∧ ∃ m', z = boundaryState (pc + 99) m' ∧
m' 90 = fs.length + 1 ∧ FrontierStored b m' B cap (fs ++ [f]) ∧
MemoryFrame (queueAppendWritable B fs.length cap) m m') := by
let dst := B + fs.length * cap
let m1 := arrayArguments m dst src cap
let m2 := writeArray dst m1 (fun i => m1 (src + i)) cap
let m3 := Function.update m2 90 (fs.length + 1)
have hmul : (fs.length + 1) * cap ≤ T * cap := Nat.mul_le_mul_right cap (by omega)
have hmul' : (fs.length + 1) * cap = fs.length * cap + cap := by ring
have hdst : dst + cap ≤ 2 ^ E.W := by dsimp [dst]; omega
have hdstWord : dst < 2 ^ E.W := by omega
have hcapWord : cap < 2 ^ E.W := by omega
have hnWord : fs.length + 1 < 2 ^ E.W := by
have hm : fs.length + 1 ≤ (fs.length + 1) * cap := by
simpa only [Nat.mul_one] using Nat.mul_le_mul_left (fs.length + 1) hcap
omega
have hsrcWord : src < 2 ^ E.W := by omega
have hq1 := hq.array_arguments hB dst src cap
have hf1 : PolynomialStored b m1 src cap f := by
intro i hi
change arrayArguments m dst src cap (src + i) = enc b (f.coeff i)
rw [arrayArguments_frame m dst src cap (src + i) (by omega)]
exact hf i hi
have hq2 := hq1.append_copy hf1
have hq3 : FrontierStored b m3 B cap (fs ++ [f]) := hq2.meta_update hB 90 (fs.length + 1) (by norm_num)
have hm2meta (slot : ℕ) (hlo : 72 ≤ slot) (hhi : slot < 128) : m2 slot = m slot := by
change writeArray dst m1 (fun i => m1 (src + i)) cap slot = m slot
rw [writeArray_frame dst m1 _ cap slot (by dsimp [dst]; omega)]
exact arrayArguments_frame m dst src cap slot (by omega)
obtain ⟨hArgsAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hCopyAt, hIncAt⟩ := At.seqStmt hRestAt
have hArgs : Sem P E pc (pc + 39) (boundaryState pc m)
(fun k z => k ≤ 39 ∧ z = boundaryState (pc + 39) m1) := by
exact Sem.boundary_block P E _ queueAppendArgsCode m m1 hArgsAt
(by simp [queueAppendArgsCode, metaReadCode, metaStoreCode, zeroRegsCode])
(queueAppendArgs_spec E _ B fs.length cap src hmeta (by omega) (by omega)
(by dsimp [dst] at hdstWord; omega) hdstWord hcapWord hsrcWord hm84 hm90 hm81 hm97)
have hCopy := copyProcedure_spec P E (pc + 39) dst src cap m1 hCopyAt (by omega) hdstWord hsrcWord hcapWord
hdst hSword (by dsimp [dst]; omega)
(fun i hi => by
have hv : m1 (src + i) = enc b (f.coeff i) := hf1 i hi
rw [hv]
exact lt_of_lt_of_le (enc_lt b _) (Nat.pow_le_pow_right (by norm_num) hwe))
(by simp [m1, arrayArguments]) (by simp [m1, arrayArguments]) (by simp [m1, arrayArguments])
have hInc : Sem P E (pc + 75) (pc + 99) (boundaryState (pc + 75) m2)
(fun k z => k ≤ 24 ∧ z = boundaryState (pc + 99) m3) := by
exact Sem.boundary_block P E _ queueIncrementCode m2 m3 hIncAt
(by simp [queueIncrementCode, metaReadCode, metaStoreCode, zeroRegsCode])
(queueIncrement_spec E _ fs.length (by omega) hnWord (by
change m2 90 = fs.length
rw [hm2meta 90 (by norm_num) (by norm_num)]; exact hm90))
have hFull := Sem.seq_bound hArgs (fun z _ hz => by
subst z
exact Sem.seq_bound hCopy (fun z _ hz => by subst z; exact hInc))
refine Sem.mono hFull ?_
intro k z hQ
refine ⟨by omega, m3, hQ.2, by simp [m3], hq3, ?_⟩
have hf01 : MemoryFrame (queueAppendWritable B fs.length cap) m m1 := (arrayArguments_frame m dst src cap).mono (by
intro addr ha
dsimp [queueAppendWritable]
omega)
have hf12 : MemoryFrame (queueAppendWritable B fs.length cap) m1 m2 := by
intro addr ha
apply writeArray_frame dst m1 _ cap addr
dsimp [queueAppendWritable, dst] at ha ⊢
omega
exact MemoryFrame.trans (MemoryFrame.trans hf01 hf12)
(MemoryFrame.update_allowed _ m2 90 (fs.length + 1) (by simp [queueAppendWritable]))
theorem queueKeepProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv) (pc B src cap T : ℕ)
(fs : List F[X]) (f : F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile queueKeepProcedure pc))
(hmeta : (97 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W) (hcap : 1 ≤ cap)
(hB : 128 ≤ B) (hsrc : 128 ≤ src) (hQword : B + T * cap ≤ 2 ^ E.W) (hSword : src + cap ≤ 2 ^ E.W)
(hcount : 0 < f.natDegree → fs.length < T) (hdisj : src + cap ≤ B ∨ B + T * cap ≤ src)
(hq : FrontierStored b m B cap fs) (hf : PolynomialStored b m src cap f) (hdeg : f.natDegree < cap)
(hm84 : m 84 = B) (hm90 : m 90 = fs.length) (hm81 : m 81 = cap) (hm97 : m 97 = src) :
Sem P E pc (pc + 209) (boundaryState pc m)
(fun k z => k ≤ 29 * cap + 167 ∧ z.regs = (fun _ => 0) ∧
z.mem 90 = (fs ++ keepFactor f).length ∧ FrontierStored b z.mem B cap (fs ++ keepFactor f) ∧
MemoryFrame (queueKeepWritable B fs.length cap f.natDegree) m z.mem) := by
let m1 := Function.update (Function.update m 64 src) 66 cap
let m2 := Function.update m1 95 (degreeScan f cap)
have hcapWord : cap < 2 ^ E.W := by omega
have hsrcWord : src < 2 ^ E.W := by omega
have hm1meta (slot : ℕ) (hlo : 72 ≤ slot) : m1 slot = m slot := by simp [m1, show slot ≠ 64 by omega, show slot ≠ 66 by omega]
have hm2meta (slot : ℕ) (hlo : 72 ≤ slot) (hne : slot ≠ 95) : m2 slot = m slot := by
change Function.update m1 95 (degreeScan f cap) slot = m slot
rw [Function.update_of_ne hne, hm1meta slot hlo]
have hq1 := (hq.meta_update hB 64 src (by norm_num)).meta_update hB 66 cap (by norm_num)
have hq2 := hq1.meta_update hB 95 (degreeScan f cap) (by norm_num)
have hf1 := (hf.meta_update hsrc 64 src (by norm_num)).meta_update hsrc 66 cap (by norm_num)
have hf2 : PolynomialStored b m2 src cap f := hf1.meta_update hsrc 95 (degreeScan f cap) (by norm_num)
let Q := fun m' => m' 90 = (fs ++ keepFactor f).length ∧ FrontierStored b m' B cap (fs ++ keepFactor f) ∧
MemoryFrame (queueKeepWritable B fs.length cap f.natDegree) m m'
have hf01 : MemoryFrame (queueKeepWritable B fs.length cap f.natDegree) m m1 :=
MemoryFrame.trans (MemoryFrame.update_allowed _ m 64 src (by simp [queueKeepWritable, queueAppendWritable]))
(MemoryFrame.update_allowed _ _ 66 cap (by simp [queueKeepWritable, queueAppendWritable]))
have hf02 : MemoryFrame (queueKeepWritable B fs.length cap f.natDegree) m m2 :=
MemoryFrame.trans hf01 (MemoryFrame.update_allowed _ m1 95 _ (Or.inl rfl))
obtain ⟨hSetupAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hScanAt, hKeepAt⟩ := At.seqStmt hRestAt
have hSetup : Sem P E pc (pc + 28) (boundaryState pc m)
(fun k z => k ≤ 28 ∧ z = boundaryState (pc + 28) m1) := by
exact Sem.boundary_block P E _ (scanSetupCode 97) m m1 hSetupAt
(by simp [scanSetupCode, metaReadCode, metaStoreCode, zeroRegsCode])
(scanSetup_spec E _ 97 src cap (by omega) hmeta hsrcWord hcapWord hm97 hm81)
have hScan := scanProcedure_spec b P E (pc + 28) src cap f m1 hScanAt (by omega) hwe
hsrcWord hcapWord hSword hf1 (by simp [m1]) (by simp [m1])
have hBranch := degreeBranch_spec P E (pc + 70) queueAppendProcedure m2 (degreeScan f cap)
(12 * cap + 89) Q hKeepAt (by omega)
(lt_of_le_of_lt (degreeScan_le _ _) hcapWord) (by simp [m2])
(by
intro hpos base hBodyAt
have hfpos : 0 < f.natDegree := by
have h := (padeScan_go 1 cap f le_rfl hdeg).mp hpos
omega
have hAppend := queueAppendProcedure_spec b P E base B src cap T fs f m2 hBodyAt hmeta hwe hcap
hB hsrc hQword hSword (hcount hfpos) hdisj hq2 hf2
((hm2meta 84 (by norm_num) (by norm_num)).trans hm84)
((hm2meta 90 (by norm_num) (by norm_num)).trans hm90)
((hm2meta 81 (by norm_num) (by norm_num)).trans hm81)
((hm2meta 97 (by norm_num) (by norm_num)).trans hm97)
refine Sem.mono hAppend ?_
intro k z hPost
obtain ⟨hk, m3, hz, h90, hq3, hf23⟩ := hPost
refine ⟨hk, ?_, ?_⟩
· rw [hz]; rfl
· change Q z.mem
rw [hz]
change Q m3
have hkeep : keepFactor f = [f] := by simp [keepFactor, Nat.ne_of_gt hfpos]
dsimp only [Q]
rw [hkeep]
refine ⟨?_, hq3, MemoryFrame.trans hf02 (hf23.mono (by
intro addr ha
dsimp [queueKeepWritable, queueAppendWritable] at *
omega))⟩
simpa using h90)
(by
intro hstop
have hdeg0 : f.natDegree = 0 := by
have h := (not_congr (padeScan_go 1 cap f le_rfl hdeg)).mp hstop
omega
have hkeep : keepFactor f = [] := by simp [keepFactor, hdeg0]
dsimp only [Q]
rw [hkeep, List.append_nil]
exact ⟨(hm2meta 90 (by norm_num) (by norm_num)).trans hm90, hq2, hf02⟩)
have hFull := Sem.seq_bound hSetup (fun z _ hz => by
subst z
exact Sem.seq_bound hScan (fun z _ hz => by subst z; exact hBranch))
refine Sem.mono hFull ?_
intro k z hQ
exact ⟨by omega, hQ.2.1, hQ.2.2⟩
theorem copyMeta_spec (E : RAMEnv) (s : RAMState) (src dst value : ℕ)
(hsrc : src < 2 ^ E.W) (hdst : dst < 2 ^ E.W) (hv : value < 2 ^ E.W) (hm : s.mem src = value) :
runBlock (copyMetaCode src dst) E s = boundaryState (s.pc + 22) (Function.update s.mem dst value) := by
rw [copyMetaCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc (copyMetaCode src dst) E s (by simp [copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [copyMetaCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 22 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, Nat.mod_eq_of_lt hsrc,
Nat.mod_eq_of_lt hdst, Nat.mod_eq_of_lt hv, hm, boundaryState]
· intro _; rfl
theorem setMeta_spec (E : RAMEnv) (s : RAMState) (slot value : ℕ)
(hs : slot < 2 ^ E.W) (hv : value < 2 ^ E.W) :
runBlock (setMetaCode slot value) E s = boundaryState (s.pc + 20) (Function.update s.mem slot value) := by
rw [setMetaCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc (setMetaCode slot value) E s (by simp [setMetaCode, metaStoreCode, zeroRegsCode])
rw [setMetaCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 20 at hp
exact hp
· simp [runBlock_append, metaStore_spec, runBlock_cons, runBlock_nil, execInstr,
Nat.mod_eq_of_lt hs, Nat.mod_eq_of_lt hv, boundaryState]
· intro _; rfl
theorem resetRootRows_spec (E : RAMEnv) (s : RAMState) (RB UB DB CB : ℕ)
(hmeta : (105 : ℕ) < 2 ^ E.W)
(hR : RB < 2 ^ E.W) (hU : UB < 2 ^ E.W) (hD : DB < 2 ^ E.W) (hC : CB < 2 ^ E.W)
(hm102 : s.mem 102 = RB) (hm104 : s.mem 104 = UB) (hm103 : s.mem 103 = DB) (hm105 : s.mem 105 = CB) :
runBlock resetRootRowsCode E s = boundaryState (s.pc + 40)
(Function.update (Function.update (Function.update (Function.update s.mem 72 RB) 73 UB) 74 DB) 75 CB) := by
have hsmall : ∀ i ≤ 105, i % 2 ^ E.W = i := by
intro i hi
exact Nat.mod_eq_of_lt (by omega)
rw [resetRootRowsCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc resetRootRowsCode E s (by
simp [resetRootRowsCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [resetRootRowsCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 40 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, hsmall, hm102, hm104, hm103, hm105,
Nat.mod_eq_of_lt hR, Nat.mod_eq_of_lt hU, Nat.mod_eq_of_lt hD, Nat.mod_eq_of_lt hC, boundaryState]
· intro _; rfl
theorem rootComputeMeta.of_range {a : ℕ} (h1 : 64 ≤ a) (h2 : a ≤ 75) : rootComputeMeta a := by
dsimp [rootComputeMeta]
exact Or.inl ⟨h1, h2⟩
theorem rootComputeWritable.of_meta {R U D C TB cap a : ℕ} (h : rootComputeMeta a) :
rootComputeWritable R U D C TB cap a := by
dsimp [rootComputeWritable]
exact Or.inl h
theorem rootComputeWritable.of_R {R U D C TB cap a : ℕ} (h1 : R ≤ a) (h2 : a < R + cap) :
rootComputeWritable R U D C TB cap a := by
dsimp [rootComputeWritable]
exact Or.inr (Or.inl ⟨h1, h2⟩)
theorem rootComputeWritable.of_U {R U D C TB cap a : ℕ} (h1 : U ≤ a) (h2 : a < U + cap) :
rootComputeWritable R U D C TB cap a := by
dsimp [rootComputeWritable]
exact Or.inr (Or.inr (Or.inl ⟨h1, h2⟩))
theorem rootComputeWritable.of_D {R U D C TB cap a : ℕ} (h1 : D ≤ a) (h2 : a < D + cap) :
rootComputeWritable R U D C TB cap a := by
dsimp [rootComputeWritable]
exact Or.inr (Or.inr (Or.inr (Or.inl ⟨h1, h2⟩)))
theorem rootComputeWritable.of_C {R U D C TB cap a : ℕ} (h1 : C ≤ a) (h2 : a < C + cap) :
rootComputeWritable R U D C TB cap a := by
dsimp [rootComputeWritable]
exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inl ⟨h1, h2⟩))))
theorem rootComputeWritable.of_TB {R U D C TB cap a : ℕ} (h1 : TB ≤ a) (h2 : a < TB + cap) :
rootComputeWritable R U D C TB cap a := by
dsimp [rootComputeWritable]
exact Or.inr (Or.inr (Or.inr (Or.inr (Or.inr ⟨h1, h2⟩))))
theorem rootNodeWritable.of_90 {R U D C TB cap QB T : ℕ} :
rootNodeWritable R U D C TB cap QB T 90 := by
dsimp [rootNodeWritable]
exact Or.inl rfl
theorem rootNodeWritable.of_compute {R U D C TB cap QB T a : ℕ}
(h : rootComputeWritable R U D C TB cap a) : rootNodeWritable R U D C TB cap QB T a := by
dsimp [rootNodeWritable]
exact Or.inr (Or.inl h)
theorem rootNodeWritable.of_queue {R U D C TB cap QB T a : ℕ} (h1 : QB ≤ a)
(h2 : a < QB + T * cap) : rootNodeWritable R U D C TB cap QB T a := by
dsimp [rootNodeWritable]
exact Or.inr (Or.inr ⟨h1, h2⟩)
/-- Any polynomial-row footprint is inside the root-computation footprint. -/
theorem padeWritable_le_rootComputeWritable (R U D C TB cap addr : ℕ)
(h : padeWritable R U D C cap addr) : rootComputeWritable R U D C TB cap addr := by
dsimp [padeWritable] at h
rcases h with h | h | h | h | h | h
· exact rootComputeWritable.of_meta (rootComputeMeta.of_range h.1 h.2)
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· exact rootComputeWritable.of_R h.1 h.2
· exact rootComputeWritable.of_U h.1 h.2
· exact rootComputeWritable.of_D h.1 h.2
· exact rootComputeWritable.of_C h.1 h.2
/-- The scratch area is part of the fixed metadata slots. -/
theorem padeScratch_le_rootComputeWritable (R U D C TB cap addr : ℕ) (h : padeScratch addr) :
rootComputeWritable R U D C TB cap addr := by
dsimp [padeScratch] at h
rcases h with h | h | h | h | h | h
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
theorem RootWorkspace.zero_readonly {R U D C TB ZB cap : ℕ} (h : RootWorkspace R U D C TB ZB cap)
(i : ℕ) (hi : i < cap) : ¬ rootComputeWritable R U D C TB cap (ZB + i) := by
have hz := h.Zlow
have hR := h.ZR
have hU := h.ZU
have hD := h.ZD
have hC := h.ZC
have hT := h.ZT
dsimp [rootComputeWritable, rootComputeMeta]
omega
theorem RootWorkspace.node_zero_readonly {R U D C TB ZB cap QB T : ℕ}
(h : RootWorkspace R U D C TB ZB cap) (hq : QB + T * cap ≤ ZB ∨ ZB + cap ≤ QB)
(i : ℕ) (hi : i < cap) : ¬ rootNodeWritable R U D C TB cap QB T (ZB + i) := by
have hz := h.Zlow
have hzero := h.zero_readonly i hi
intro hbad
rcases hbad with h90 | hwork | hqueue
· omega
· exact hzero hwork
· omega
theorem RootWorkspace.meta_readonly {R U D C TB ZB cap QB T : ℕ}
(h : RootWorkspace R U D C TB ZB cap) (hQB : 128 ≤ QB)
(slot : ℕ) (hs : slot < 128) (hslot : ¬ rootNodeMeta slot) :
¬ rootNodeWritable R U D C TB cap QB T slot := by
have hR := h.rows.Rlow
have hU := h.rows.Ulow
have hD := h.rows.Dlow
have hC := h.rows.Clow
have hT := h.Tlow
dsimp [rootNodeWritable, rootComputeWritable, rootNodeMeta, rootComputeMeta] at *
omega
theorem RootWorkspace.copy_writable {R U D C TB ZB cap dst : ℕ}
(h : RootWorkspace R U D C TB ZB cap) (hd : dst = R ∨ dst = U ∨ dst = D ∨ dst = C ∨ dst = TB)
(addr : ℕ) (ha : copyFromSlotsWritable dst cap addr) : rootComputeWritable R U D C TB cap addr := by
dsimp [copyFromSlotsWritable] at ha
rcases ha with h1 | h1 | h1 | h1
· subst h1
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· subst h1
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· subst h1
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· obtain ⟨hlo, hhi⟩ := h1
rcases hd with h2 | h2 | h2 | h2 | h2
· subst h2; exact rootComputeWritable.of_R hlo hhi
· subst h2; exact rootComputeWritable.of_U hlo hhi
· subst h2; exact rootComputeWritable.of_D hlo hhi
· subst h2; exact rootComputeWritable.of_C hlo hhi
· subst h2; exact rootComputeWritable.of_TB hlo hhi
theorem trace_writable_le_root (R U D C TB cap addr : ℕ) (h : traceLoopWritable R U D C TB cap addr) :
rootComputeWritable R U D C TB cap addr := by
dsimp [traceLoopWritable, traceWritable] at h
rcases h with h | h | h
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· exact padeWritable_le_rootComputeWritable R U D C TB cap addr h
· exact rootComputeWritable.of_TB h.1 h.2
theorem gcd_writable_le_root (R U D C TB cap addr : ℕ) (h : gcdProcedureWritable R U D C cap addr) :
rootComputeWritable R U D C TB cap addr := by
dsimp [gcdProcedureWritable, gcdLoopWritable] at h
rcases h with h | h | h
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· exact padeWritable_le_rootComputeWritable R U D C TB cap addr h
/-- The factor is read from the old queue, while writes stay inside the next
queue. The conditional footprint has no queue write on a constant factor. -/
theorem queue_keep_writable_le_node (R U D C TB cap QB T n degree addr : ℕ)
(hroom : 0 < degree → n < T)
(h : queueKeepWritable QB n cap degree addr) : rootNodeWritable R U D C TB cap QB T addr := by
by_cases hp : 0 < degree
· have hn := hroom hp
have hm : (n + 1) * cap ≤ T * cap := Nat.mul_le_mul_right cap (Nat.succ_le_of_lt hn)
dsimp [queueKeepWritable] at h
rcases h with h1 | h1 | h1 | h1 | h1 | h1
· subst h1
exact rootNodeWritable.of_compute (rootComputeWritable.of_meta (by norm_num [rootComputeMeta]))
· subst h1
exact rootNodeWritable.of_compute (rootComputeWritable.of_meta (by norm_num [rootComputeMeta]))
· subst h1
exact rootNodeWritable.of_compute (rootComputeWritable.of_meta (by norm_num [rootComputeMeta]))
· subst h1
exact rootNodeWritable.of_compute (rootComputeWritable.of_meta (by norm_num [rootComputeMeta]))
· subst h1
exact rootNodeWritable.of_90
· obtain ⟨-, hlo, hhi⟩ := h1
have h3 : n * cap + cap ≤ T * cap := by
rw [show n * cap + cap = (n + 1) * cap by ring]
exact hm
have h4 : addr < QB + T * cap := by
calc addr < QB + n * cap + cap := hhi
_ = QB + (n * cap + cap) := by ring
_ ≤ QB + T * cap := Nat.add_le_add_left h3 QB
exact rootNodeWritable.of_queue (le_trans (Nat.le_add_right QB (n * cap)) hlo) h4
· dsimp [queueKeepWritable] at h
rcases h with h1 | h1 | h1 | h1 | h1 | h1
· subst h1
exact rootNodeWritable.of_compute (rootComputeWritable.of_meta (by norm_num [rootComputeMeta]))
· subst h1
exact rootNodeWritable.of_compute (rootComputeWritable.of_meta (by norm_num [rootComputeMeta]))
· subst h1
exact rootNodeWritable.of_compute (rootComputeWritable.of_meta (by norm_num [rootComputeMeta]))
· subst h1
exact rootNodeWritable.of_compute (rootComputeWritable.of_meta (by norm_num [rootComputeMeta]))
· subst h1
exact rootNodeWritable.of_90
· obtain ⟨hpos, -, -⟩ := h1
exact absurd hpos hp
theorem RootPersistent.of_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L src QB T : ℕ}
{f : F[X]} {a : F} {m m' : ℕ → ℕ} (h : RootPersistent b R U D C TB ZB cap L src f a m)
(hl : RootWorkspace R U D C TB ZB cap) (hQB : 128 ≤ QB)
(hZQ : QB + T * cap ≤ ZB ∨ ZB + cap ≤ QB)
(hSrc : ∀ i < cap, ¬ rootNodeWritable R U D C TB cap QB T (src + i))
(hf : MemoryFrame (rootNodeWritable R U D C TB cap QB T) m m') :
RootPersistent b R U D C TB ZB cap L src f a m' := by
have hmeta (slot : ℕ) (hs : slot < 128) (hn : ¬ rootNodeMeta slot) : m' slot = m slot :=
hf slot (hl.meta_readonly hQB slot hs hn)
refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_,
h.factor.of_frame hf hSrc, h.zero.of_frame hf (hl.node_zero_readonly hZQ)⟩
· exact (hmeta 76 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.length
· exact (hmeta 77 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.dimension
· exact (hmeta 78 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.unit
· exact (hmeta 81 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.capacity
· exact (hmeta 96 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.scalar
· exact (hmeta 99 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.source
· exact (hmeta 102 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.fixedR
· exact (hmeta 103 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.fixedD
· exact (hmeta 104 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.fixedU
· exact (hmeta 105 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.fixedC
· exact (hmeta 106 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.fixedT
· exact (hmeta 108 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])).trans h.fixedZ
/-- Computation-only frames are sufficient before either queue append. -/
theorem RootPersistent.of_compute_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L src : ℕ}
{f : F[X]} {a : F} {m m' : ℕ → ℕ} (h : RootPersistent b R U D C TB ZB cap L src f a m)
(hl : RootWorkspace R U D C TB ZB cap) (hsrc : 128 ≤ src)
(hSrc : ∀ i < cap, ¬ rootComputeWritable R U D C TB cap (src + i))
(hf : MemoryFrame (rootComputeWritable R U D C TB cap) m m') :
RootPersistent b R U D C TB ZB cap L src f a m' := by
apply h.of_frame (QB := ZB + cap) (T := 0) hl (by have h' := hl.Zlow; omega) (Or.inr le_rfl) ?_
(hf.mono (by intro addr ha; exact Or.inr (Or.inl ha)))
intro i hi hbad
rcases hbad with h90 | hwork | hqueue
· omega
· exact hSrc i hi hwork
· simp only [Nat.zero_mul, Nat.add_zero] at hqueue
omega
/-- Copy a work row while retaining all immutable root-node arguments. The
precise single-array frame is retained for the other live work rows. -/
theorem rootCopy_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L rootSrc dstSlot srcSlot dst src : ℕ) (f q : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile (copyFromSlotsProcedure dstSlot srcSlot) pc))
(hl : RootWorkspace R U D C TB ZB cap) (hp : RootPersistent b R U D C TB ZB cap L rootSrc f a m)
(hrootSrc : 128 ≤ rootSrc)
(hSrc : ∀ i < cap, ¬ rootComputeWritable R U D C TB cap (rootSrc + i))
(hd : dst = R ∨ dst = U ∨ dst = D ∨ dst = C ∨ dst = TB)
(hmeta : (81 : ℕ) < 2 ^ E.W) (hds : dstSlot < 2 ^ E.W) (hss : srcSlot < 2 ^ E.W)
(hwe : w ≤ E.W) (hcap : 1 ≤ cap) (hsrc : 128 ≤ src)
(hDstWord : dst + cap ≤ 2 ^ E.W) (hSrcWord : src + cap ≤ 2 ^ E.W)
(hdisj : src + cap ≤ dst ∨ dst + cap ≤ src) (hq : PolynomialStored b m src cap q)
(hmd : m dstSlot = dst) (hms : m srcSlot = src) :
Sem P E pc (pc + 70) (boundaryState pc m)
(fun k z => k ≤ 12 * cap + 60 ∧ ∃ m', z = boundaryState (pc + 70) m' ∧
PolynomialStored b m' dst cap q ∧ RootPersistent b R U D C TB ZB cap L rootSrc f a m' ∧
MemoryFrame (copyFromSlotsWritable dst cap) m m') := by
have hdstLow : 128 ≤ dst := by
have hR := hl.rows.Rlow
have hU := hl.rows.Ulow
have hD := hl.rows.Dlow
have hC := hl.rows.Clow
have hT := hl.Tlow
omega
have hCopy := copyFromSlots_spec b P E pc dstSlot srcSlot dst src cap q m hAt
hmeta hds hss hwe hcap hdstLow hsrc hDstWord hSrcWord hdisj hq hmd hms hp.capacity
refine Sem.mono hCopy ?_
intro k z hQ
obtain ⟨hk, m', hz, hq', hf⟩ := hQ
have hcomp := hf.mono (hl.copy_writable hd)
exact ⟨hk, m', hz, hq', hp.of_compute_frame hl hrootSrc hSrc hcomp, hf⟩
theorem resetRootMemory_frame (m : ℕ → ℕ) (R U D C TB cap : ℕ) :
MemoryFrame (rootComputeWritable R U D C TB cap) m (resetRootMemory m R U D C) := by
apply MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans
(MemoryFrame.update_allowed _ m 72 R (by simp [rootComputeWritable, rootComputeMeta]))
(MemoryFrame.update_allowed _ _ 73 U (by simp [rootComputeWritable, rootComputeMeta])))
(MemoryFrame.update_allowed _ _ 74 D (by simp [rootComputeWritable, rootComputeMeta])))
(MemoryFrame.update_allowed _ _ 75 C (by simp [rootComputeWritable, rootComputeMeta]))
theorem keepFactor_positive {F : Type} [Field F] (f : F[X]) : ∀ g ∈ keepFactor f, 0 < g.natDegree := by
intro g hg
obtain ⟨heq, hne⟩ := (mem_keepFactor g f).mp hg
rw [heq]
exact Nat.pos_of_ne_zero hne
theorem frontier_append_keep_positive {F : Type} [Field F] (fs : List F[X]) (f : F[X])
(hfs : ∀ g ∈ fs, 0 < g.natDegree) : ∀ g ∈ fs ++ keepFactor f, 0 < g.natDegree := by
intro g hg
rcases List.mem_append.mp hg with hleft | hright
· exact hfs g hleft
· exact keepFactor_positive f g hright
/-- The two gcd children fit even when the first child consumes the last
available queue slot; a constant second child does not occupy a slot. -/
theorem frontier_children_room {F : Type} [Field F] [DecidableEq F]
(f p : F[X]) (fs : List F[X]) (T : ℕ) (hf : f ≠ 0)
(hfs : ∀ g ∈ fs, 0 < g.natDegree) (hbudget : frontierMass fs + f.natDegree ≤ T) :
(0 < (EuclideanDomain.gcd f p).natDegree → fs.length < T) ∧
(0 < (EuclideanDomain.gcd f (p - 1)).natDegree → (fs ++ keepFactor (EuclideanDomain.gcd f p)).length < T) ∧
frontierMass (fs ++ keepFactor (EuclideanDomain.gcd f p) ++ keepFactor (EuclideanDomain.gcd f (p - 1))) ≤ T := by
have hsplit := split_degree_budget f p hf
have hzero0 := Nat.zero_le (EuclideanDomain.gcd f p).natDegree
have hzero1 := Nat.zero_le (EuclideanDomain.gcd f (p - 1)).natDegree
have hlen := frontier_length_le_mass fs hfs
have hlen' := frontier_length_le_mass (fs ++ keepFactor (EuclideanDomain.gcd f p))
(frontier_append_keep_positive fs _ hfs)
rw [frontierMass_append, frontierMass_keep] at hlen'
refine ⟨by intro h; omega, by intro h; omega, ?_⟩
rw [frontierMass_append, frontierMass_append, frontierMass_keep, frontierMass_keep]
omega
/-- An already reduced splitter can enter the Euclidean routine in reversed
order without introducing a unit ambiguity in its exact gcd. -/
theorem gcd_swap_of_natDegree_lt {F : Type} [Field F] [DecidableEq F]
(f p : F[X]) (hf : f ≠ 0) (hdeg : p.natDegree < f.natDegree) :
EuclideanDomain.gcd f p = EuclideanDomain.gcd p f := by
have hd : p.degree < f.degree := by
by_cases hp : p = 0
· simp [hp, Polynomial.degree_eq_natDegree hf]
· rw [Polynomial.degree_eq_natDegree hp, Polynomial.degree_eq_natDegree hf]
exact_mod_cast hdeg
rw [EuclideanDomain.gcd_val f p, (Polynomial.mod_eq_self_iff hf).mpr hd]
theorem RootSourceSeparated.readonly {R U D C TB cap src : ℕ}
(h : RootSourceSeparated R U D C TB cap src) (hsrc : 128 ≤ src) (i : ℕ) (hi : i < cap) :
¬ rootComputeWritable R U D C TB cap (src + i) := by
have hR := h.SR
have hU := h.SU
have hD := h.SD
have hC := h.SC
have hT := h.ST
dsimp [rootComputeWritable, rootComputeMeta]
omega
theorem RootPersistent.meta_update {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L src : ℕ}
{f : F[X]} {a : F} {m : ℕ → ℕ} (h : RootPersistent b R U D C TB ZB cap L src f a m)
(hl : RootWorkspace R U D C TB ZB cap) (hsrc : 128 ≤ src)
(hSrc : ∀ i < cap, ¬ rootComputeWritable R U D C TB cap (src + i))
(slot value : ℕ) (hs : rootComputeMeta slot) :
RootPersistent b R U D C TB ZB cap L src f a (Function.update m slot value) := by
exact h.of_compute_frame hl hsrc hSrc
(MemoryFrame.update_allowed _ m slot value (Or.inl hs))
/-- The initialized arrays satisfy exactly the entry contract of traceProcedure. -/
theorem rootPrepareProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L src : ℕ) (f : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootPrepareProcedure pc))
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hp : RootPersistent b R U D C TB ZB cap L src f a m)
(hsrc : 128 ≤ src) (hSrcWord : src + cap ≤ 2 ^ E.W)
(hsep : RootSourceSeparated R U D C TB cap src)
(hmeta : (108 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W) (hcap : 1 ≤ cap)
(hf : f ≠ 0) (hdeg : f.natDegree < cap) :
Sem P E pc (pc + 504) (boundaryState pc m)
(fun k z => k ≤ 77 * cap + 439 ∧ ∃ m', z = boundaryState (pc + 504) m' ∧
RootPersistent b R U D C TB ZB cap L src f a m' ∧
PadeRows b E R U D C L cap m' (⟨0, 0, f, 0⟩ : PadeState F) ∧
PolynomialStored b m' TB cap 0 ∧ m' 92 = w ∧ m' 95 = f.natDegree + 1 ∧ m' 98 = TB ∧
MemoryFrame (rootComputeWritable R U D C TB cap) m m') := by
have hSrc := hsep.readonly hsrc
have hcapWord : cap < 2 ^ E.W := by have h := hl.rows.Rlow; have h' := hwords.Rword; omega
have hwWord : w < 2 ^ E.W := lt_of_le_of_lt hwe (Nat.lt_two_pow_self (n := E.W))
obtain ⟨hResetAt, hRest0⟩ := At.seqStmt hAt
obtain ⟨hParentAt, hRest1⟩ := At.seqStmt hRest0
obtain ⟨hRAt, hRest2⟩ := At.seqStmt hRest1
obtain ⟨hUAt, hRest3⟩ := At.seqStmt hRest2
obtain ⟨hCAt, hRest4⟩ := At.seqStmt hRest3
obtain ⟨hTAt, hRest5⟩ := At.seqStmt hRest4
obtain ⟨hTracePtrAt, hRest6⟩ := At.seqStmt hRest5
obtain ⟨hScanSetupAt, hRest7⟩ := At.seqStmt hRest6
obtain ⟨hScanAt, hCountAt⟩ := At.seqStmt hRest7
let m1 := resetRootMemory m R U D C
have hf01 := resetRootMemory_frame m R U D C TB cap
have hp1 := hp.of_compute_frame hl hsrc hSrc hf01
have hReset : Sem P E pc (pc + 40) (boundaryState pc m)
(fun k z => k ≤ 40 ∧ z = boundaryState (pc + 40) m1) := by
exact Sem.boundary_block P E _ resetRootRowsCode m m1 hResetAt
(by simp [resetRootRowsCode, metaReadCode, metaStoreCode, zeroRegsCode])
(resetRootRows_spec E _ R U D C (by omega)
(by have h := hwords.Rword; omega) (by have h := hwords.Uword; omega)
(by have h := hwords.Dword; omega) (by have h := hwords.Cword; omega)
hp.fixedR hp.fixedU hp.fixedD hp.fixedC)
have hParent := rootCopy_spec b P E (pc + 40) R U D C TB ZB cap L src 103 99 D src
f f a m1 hParentAt hl hp1 hsrc hSrc (by simp) (by omega) (by omega) (by omega)
hwe hcap hsrc hwords.Dword hSrcWord hsep.SD hp1.factor hp1.fixedD hp1.source
obtain ⟨_, k1, z1, hRun1, hPc1, hCost1, m2, hz1, hStored2, hp2, hf12⟩ := hParent
have hParentExact : Sem P E (pc + 40) (pc + 110) (boundaryState (pc + 40) m1)
(fun k z => k ≤ 12 * cap + 60 ∧ z = boundaryState (pc + 110) m2) :=
⟨rfl, k1, z1, hRun1, hPc1, hCost1, hz1⟩
have hR := rootCopy_spec b P E (pc + 110) R U D C TB ZB cap L src 102 108 R ZB
f 0 a m2 hRAt hl hp2 hsrc hSrc (by simp) (by omega) (by omega) (by omega)
hwe hcap hl.Zlow hwords.Rword hwords.Zword hl.ZR hp2.zero hp2.fixedR hp2.fixedZ
obtain ⟨_, k2, z2, hRun2, hPc2, hCost2, m3, hz2, hStored3, hp3, hf23⟩ := hR
have hRExact : Sem P E (pc + 110) (pc + 180) (boundaryState (pc + 110) m2)
(fun k z => k ≤ 12 * cap + 60 ∧ z = boundaryState (pc + 180) m3) :=
⟨rfl, k2, z2, hRun2, hPc2, hCost2, hz2⟩
have hU := rootCopy_spec b P E (pc + 180) R U D C TB ZB cap L src 104 108 U ZB
f 0 a m3 hUAt hl hp3 hsrc hSrc (by simp) (by omega) (by omega) (by omega)
hwe hcap hl.Zlow hwords.Uword hwords.Zword hl.ZU hp3.zero hp3.fixedU hp3.fixedZ
obtain ⟨_, k3, z3, hRun3, hPc3, hCost3, m4, hz3, hStored4, hp4, hf34⟩ := hU
have hUExact : Sem P E (pc + 180) (pc + 250) (boundaryState (pc + 180) m3)
(fun k z => k ≤ 12 * cap + 60 ∧ z = boundaryState (pc + 250) m4) :=
⟨rfl, k3, z3, hRun3, hPc3, hCost3, hz3⟩
have hC := rootCopy_spec b P E (pc + 250) R U D C TB ZB cap L src 105 108 C ZB
f 0 a m4 hCAt hl hp4 hsrc hSrc (by simp) (by omega) (by omega) (by omega)
hwe hcap hl.Zlow hwords.Cword hwords.Zword hl.ZC hp4.zero hp4.fixedC hp4.fixedZ
obtain ⟨_, k4, z4, hRun4, hPc4, hCost4, m5, hz4, hStored5, hp5, hf45⟩ := hC
have hCExact : Sem P E (pc + 250) (pc + 320) (boundaryState (pc + 250) m4)
(fun k z => k ≤ 12 * cap + 60 ∧ z = boundaryState (pc + 320) m5) :=
⟨rfl, k4, z4, hRun4, hPc4, hCost4, hz4⟩
have hT := rootCopy_spec b P E (pc + 320) R U D C TB ZB cap L src 106 108 TB ZB
f 0 a m5 hTAt hl hp5 hsrc hSrc (by simp) (by omega) (by omega) (by omega)
hwe hcap hl.Zlow hwords.Tword hwords.Zword hl.ZT hp5.zero hp5.fixedT hp5.fixedZ
obtain ⟨_, k5, z5, hRun5, hPc5, hCost5, m6, hz5, hStored6, hp6, hf56⟩ := hT
have hTExact : Sem P E (pc + 320) (pc + 390) (boundaryState (pc + 320) m5)
(fun k z => k ≤ 12 * cap + 60 ∧ z = boundaryState (pc + 390) m6) :=
⟨rfl, k5, z5, hRun5, hPc5, hCost5, hz5⟩
have hD3 := hStored2.after_root_copy hl.rows.Dlow hl.rows.RD hf23
have hD4 := hD3.after_root_copy hl.rows.Dlow hl.rows.UD hf34
have hD5 := hD4.after_root_copy hl.rows.Dlow (hl.rows.DC.elim Or.inr Or.inl) hf45
have hD6 := hD5.after_root_copy hl.rows.Dlow hl.TD hf56
have hR4 := hStored3.after_root_copy hl.rows.Rlow (hl.rows.RU.elim Or.inr Or.inl) hf34
have hR5 := hR4.after_root_copy hl.rows.Rlow (hl.rows.RC.elim Or.inr Or.inl) hf45
have hR6 := hR5.after_root_copy hl.rows.Rlow hl.TR hf56
have hU5 := hStored4.after_root_copy hl.rows.Ulow (hl.rows.UC.elim Or.inr Or.inl) hf45
have hU6 := hU5.after_root_copy hl.rows.Ulow hl.TU hf56
have hC6 := hStored5.after_root_copy hl.rows.Clow hl.TC hf56
have hMeta6 (slot : ℕ) (hlo : 67 ≤ slot) (hhi : slot < 128) : m6 slot = m1 slot := by
rw [root_copy_meta hf56 hl.Tlow hlo hhi, root_copy_meta hf45 hl.rows.Clow hlo hhi,
root_copy_meta hf34 hl.rows.Ulow hlo hhi, root_copy_meta hf23 hl.rows.Rlow hlo hhi,
root_copy_meta hf12 hl.rows.Dlow hlo hhi]
have hRows6 : PadeRows b E R U D C L cap m6 (⟨0, 0, f, 0⟩ : PadeState F) := by
refine ⟨hl.rows, hwords.Rword, hwords.Uword, hwords.Dword, hwords.Cword,
hR6, hU6, hD6, hC6, ?_, ?_, ?_, ?_, hp6.length, hp6.dimension, hp6.capacity⟩
· rw [hMeta6 72 (by norm_num) (by norm_num)]; simp [m1, resetRootMemory]
· rw [hMeta6 73 (by norm_num) (by norm_num)]; simp [m1, resetRootMemory]
· rw [hMeta6 74 (by norm_num) (by norm_num)]; simp [m1, resetRootMemory]
· rw [hMeta6 75 (by norm_num) (by norm_num)]; simp [m1, resetRootMemory]
let m7 := Function.update m6 98 TB
have hp7 := hp6.meta_update hl hsrc hSrc 98 TB (by simp [rootComputeMeta])
have hRows7 : PadeRows b E R U D C L cap m7 (⟨0, 0, f, 0⟩ : PadeState F) := by
apply hRows6.of_scratchFrame (MemoryFrame.meta_update m6 98 TB (by norm_num))
intro slot hs
rw [Function.update_of_ne (by omega : slot ≠ 98)]
have hT7 := hStored6.meta_update hl.Tlow 98 TB (by norm_num)
have hTracePtr : Sem P E (pc + 390) (pc + 412) (boundaryState (pc + 390) m6)
(fun k z => k ≤ 22 ∧ z = boundaryState (pc + 412) m7) := by
exact Sem.boundary_block P E _ (copyMetaCode 106 98) m6 m7 hTracePtrAt
(by simp [copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(copyMeta_spec E _ 106 98 TB (by omega) (by omega)
(by have h := hwords.Tword; omega) hp6.fixedT)
let m8 := Function.update (Function.update m7 64 D) 66 cap
have hp8 := (hp7.meta_update hl hsrc hSrc 64 D (by simp [rootComputeMeta])).meta_update hl hsrc hSrc 66 cap (by simp [rootComputeMeta])
have hf78scratch : MemoryFrame padeScratch m7 m8 :=
MemoryFrame.trans (MemoryFrame.update_allowed padeScratch m7 64 D (by simp [padeScratch]))
(MemoryFrame.update_allowed padeScratch _ 66 cap (by simp [padeScratch]))
have hRows8 := hRows7.of_scratch hf78scratch
have hT8 := (hT7.meta_update hl.Tlow 64 D (by norm_num)).meta_update hl.Tlow 66 cap (by norm_num)
have hScanSetup : Sem P E (pc + 412) (pc + 440) (boundaryState (pc + 412) m7)
(fun k z => k ≤ 28 ∧ z = boundaryState (pc + 440) m8) := by
exact Sem.boundary_block P E _ (scanSetupCode 74) m7 m8 hScanSetupAt
(by simp [scanSetupCode, metaReadCode, metaStoreCode, zeroRegsCode])
(scanSetup_spec E _ 74 D cap (by omega) (by omega)
(by have h := hwords.Dword; omega) hcapWord hRows7.ptr74 hp7.capacity)
let m9 := Function.update m8 95 (degreeScan f cap)
have hp9 := hp8.meta_update hl hsrc hSrc 95 (degreeScan f cap) (by simp [rootComputeMeta])
have hRows9 := hRows8.of_scratch (MemoryFrame.update_allowed padeScratch m8 95 (degreeScan f cap) (by simp [padeScratch]))
have hT9 := hT8.meta_update hl.Tlow 95 (degreeScan f cap) (by norm_num)
have hScan := scanProcedure_spec b P E (pc + 440) D cap f m8 hScanAt (by omega) hwe
(by have h := hwords.Dword; omega) hcapWord hwords.Dword hRows8.rem (by simp [m8]) (by simp [m8])
let m10 := Function.update m9 92 w
have hp10 := hp9.meta_update hl hsrc hSrc 92 w (by simp [rootComputeMeta])
have hRows10 := hRows9.traceCounter_update w
have hT10 := hT9.meta_update hl.Tlow 92 w (by norm_num)
have hCount : Sem P E (pc + 482) (pc + 504) (boundaryState (pc + 482) m9)
(fun k z => k ≤ 22 ∧ z = boundaryState (pc + 504) m10) := by
exact Sem.boundary_block P E _ (copyMetaCode 77 92) m9 m10 hCountAt
(by simp [copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(copyMeta_spec E _ 77 92 w (by omega) (by omega) hwWord hp9.dimension)
have hf06 : MemoryFrame (rootComputeWritable R U D C TB cap) m m6 :=
MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans hf01
(hf12.mono (hl.copy_writable (by simp)))) (hf23.mono (hl.copy_writable (by simp))))
(hf34.mono (hl.copy_writable (by simp)))) (hf45.mono (hl.copy_writable (by simp))))
(hf56.mono (hl.copy_writable (by simp)))
have hf67 : MemoryFrame (rootComputeWritable R U D C TB cap) m6 m7 :=
MemoryFrame.update_allowed _ m6 98 TB (by simp [rootComputeWritable, rootComputeMeta])
have hf78 : MemoryFrame (rootComputeWritable R U D C TB cap) m7 m8 :=
hf78scratch.mono (by intro addr ha
exact padeScratch_le_rootComputeWritable R U D C TB cap addr ha)
have hf89 : MemoryFrame (rootComputeWritable R U D C TB cap) m8 m9 :=
MemoryFrame.update_allowed _ m8 95 (degreeScan f cap) (by simp [rootComputeWritable, rootComputeMeta])
have hf910 : MemoryFrame (rootComputeWritable R U D C TB cap) m9 m10 :=
MemoryFrame.update_allowed _ m9 92 w (by simp [rootComputeWritable, rootComputeMeta])
have hFull := Sem.seq_bound hReset (fun z _ hz => by
subst z
exact Sem.seq_bound hParentExact (fun z _ hz => by
subst z
exact Sem.seq_bound hRExact (fun z _ hz => by
subst z
exact Sem.seq_bound hUExact (fun z _ hz => by
subst z
exact Sem.seq_bound hCExact (fun z _ hz => by
subst z
exact Sem.seq_bound hTExact (fun z _ hz => by
subst z
exact Sem.seq_bound hTracePtr (fun z _ hz => by
subst z
exact Sem.seq_bound hScanSetup (fun z _ hz => by
subst z
exact Sem.seq_bound hScan (fun z _ hz => by subst z; exact hCount)))))))))
refine Sem.mono hFull ?_
intro k z hQ
refine ⟨by omega, m10, hQ.2, hp10, hRows10, hT10, by simp [m10], ?_, ?_, ?_⟩
· simp [m10, m9, degreeScan_eq f hf cap hdeg]
· simp [m10, m9, m8, m7]
· exact MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans hf06 hf67) hf78) hf89) hf910
/-- A root node computes its trace splitter from a factor in the old queue. -/
theorem rootTraceProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L src : ℕ) (f : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootTraceProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hp : RootPersistent b R U D C TB ZB cap L src f a m)
(hsrc : 128 ≤ src) (hSrcWord : src + cap ≤ 2 ^ E.W)
(hsep : RootSourceSeparated R U D C TB cap src) (hmeta : (108 : ℕ) < 2 ^ E.W)
(hFpos : 0 < f.natDegree) (hF : f.natDegree ≤ t) :
Sem P E pc (pc + 1021) (boundaryState pc m)
(fun k z => k ≤ (30 * cap + (48 * L + 187) * L + 258) * w + 77 * cap + 443 ∧
∃ m', z = boundaryState (pc + 1021) m' ∧ RootPersistent b R U D C TB ZB cap L src f a m' ∧
PadeRows b E R U D C L cap m' (⟨traceRemainder a f w, 0, f, 0⟩ : PadeState F) ∧
PolynomialStored b m' TB cap (traceRemainder a f w) ∧
MemoryFrame (rootComputeWritable R U D C TB cap) m m') := by
have hwe : w ≤ E.W := by omega
have hcapPos : 1 ≤ cap := by omega
have hf : f ≠ 0 := by intro hz; simp [hz] at hFpos
have hfdeg : f.natDegree < cap := by omega
have hwWord : w < 2 ^ E.W := lt_of_le_of_lt hwe (Nat.lt_two_pow_self (n := E.W))
obtain ⟨hPrepAt, hTraceAt⟩ := At.seqStmt hAt
have hPrep := rootPrepareProcedure_spec b P E pc R U D C TB ZB cap L src f a m hPrepAt
hl hwords hp hsrc hSrcWord hsep hmeta hwe hcapPos hf hfdeg
have hFull := Sem.seq_bound hPrep (fun z _ hQ => by
obtain ⟨m1, hz, hp1, hr1, ht1, h92, h95, h98, hf01⟩ := hQ
subst z
have hTrace := traceProcedure_spec b ι t N P E (pc + 504) R U D C TB L cap w f a m1 hTraceAt
hw hW hdet ht hL hcap hr1 hl.Tlow hwords.Tword hl.TR hl.TU hl.TD hl.TC ht1 hFpos hF
hwWord h92 h95 hp1.scalar h98
refine Sem.mono (Q' := fun k z => k ≤ (30 * cap + (48 * L + 187) * L + 258) * w + 4 ∧
∃ m', z = boundaryState (pc + 1021) m' ∧ RootPersistent b R U D C TB ZB cap L src f a m' ∧
PadeRows b E R U D C L cap m' (⟨traceRemainder a f w, 0, f, 0⟩ : PadeState F) ∧
PolynomialStored b m' TB cap (traceRemainder a f w) ∧
MemoryFrame (rootComputeWritable R U D C TB cap) m m') hTrace ?_
intro k z hQ
obtain ⟨hk, m2, hz, hr2, ht2, _, _, _, _, hf12⟩ := hQ
have hf12' := hf12.mono (trace_writable_le_root R U D C TB cap)
exact ⟨hk, m2, hz, hp1.of_compute_frame hl hsrc (hsep.readonly hsrc) hf12', hr2, ht2,
MemoryFrame.trans hf01 hf12'⟩)
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
/-- The first child gcd uses the computed splitter, while retaining a copy
of that splitter and the original factor for the second child. -/
theorem rootFirstGcdProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L src : ℕ) (f p : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootFirstGcdProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hp : RootPersistent b R U D C TB ZB cap L src f a m)
(hsrc : 128 ≤ src) (hsep : RootSourceSeparated R U D C TB cap src)
(hmeta : (108 : ℕ) < 2 ^ E.W)
(hrows : PadeRows b E R U D C L cap m (⟨p, 0, f, 0⟩ : PadeState F))
(htrace : PolynomialStored b m TB cap p) (hFpos : 0 < f.natDegree) (hF : f.natDegree ≤ t)
(hpf : p.natDegree < f.natDegree) :
Sem P E pc (pc + 658) (boundaryState pc m)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 228) * L + 17 * cap + 154 ∧
∃ m' out, z = boundaryState (pc + 658) m' ∧ m' 97 = out ∧ 128 ≤ out ∧ out + cap ≤ 2 ^ E.W ∧
PolynomialStored b m' out cap (EuclideanDomain.gcd f p) ∧
RootPersistent b R U D C TB ZB cap L src f a m' ∧ PolynomialStored b m' TB cap p ∧
MemoryFrame (rootComputeWritable R U D C TB cap) m m' ∧
∀ i < cap, padeWritable R U D C cap (out + i)) := by
let m1 := swapRowMemory m R U D C
let m2 := Function.update m1 93 L
have hSrc := hsep.readonly hsrc
have hLWord : L < 2 ^ E.W := by have h := hwords.Rword; have h' := hl.rows.Rlow; omega
have hRWord : R < 2 ^ E.W := by have h := hwords.Rword; omega
have hUWord : U < 2 ^ E.W := by have h := hwords.Uword; omega
have hDWord : D < 2 ^ E.W := by have h := hwords.Dword; omega
have hCWord : C < 2 ^ E.W := by have h := hwords.Cword; omega
have hf01raw := swapRowMemory_frame m R U D C cap
have hf01 : MemoryFrame (rootComputeWritable R U D C TB cap) m m1 := hf01raw.mono (by
intro addr ha
exact padeWritable_le_rootComputeWritable R U D C TB cap addr ha)
have hp1 := hp.of_compute_frame hl hsrc hSrc hf01
have hr1 := hrows.swap_memory
have ht1 : PolynomialStored b m1 TB cap p := htrace.of_frame hf01raw (by
intro i hi
have hT := hl.Tlow
have hR := hl.TR
have hU := hl.TU
have hD := hl.TD
have hC := hl.TC
dsimp [padeWritable]
omega)
have hp2 := hp1.meta_update hl hsrc hSrc 93 L (by simp [rootComputeMeta])
have hr2 := hr1.gcdCounter_update L
have ht2 := ht1.meta_update hl.Tlow 93 L (by norm_num)
have hf12 : MemoryFrame (rootComputeWritable R U D C TB cap) m1 m2 :=
MemoryFrame.update_allowed _ m1 93 L (by simp [rootComputeWritable, rootComputeMeta])
obtain ⟨hSwapAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hCountAt, hGcdAt⟩ := At.seqStmt hRestAt
have hSwap : Sem P E pc (pc + 40) (boundaryState pc m)
(fun k z => k ≤ 40 ∧ z = boundaryState (pc + 40) m1) := by
exact Sem.boundary_block P E _ swapRowsCode m m1 hSwapAt
(by simp [swapRowsCode, metaReadCode, metaStoreCode, zeroRegsCode])
(swapRows_spec E _ R U D C (by omega) hRWord hUWord hDWord hCWord
hrows.ptr72 hrows.ptr73 hrows.ptr74 hrows.ptr75)
have hCount : Sem P E (pc + 40) (pc + 62) (boundaryState (pc + 40) m1)
(fun k z => k ≤ 22 ∧ z = boundaryState (pc + 62) m2) := by
exact Sem.boundary_block P E _ (copyMetaCode 76 93) m1 m2 hCountAt
(by simp [copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(copyMeta_spec E _ 76 93 L (by omega) (by omega) hLWord hp1.length)
have hi : GcdInv L (⟨f, 0, p, 0⟩ : PadeState F) := by
refine ⟨?_, ?_, rfl, rfl⟩
· change f.natDegree < L; omega
· change p.natDegree < L; omega
have hGcd := gcdProcedure_spec b ι t N P E (pc + 62) D C R U L cap (⟨f, 0, p, 0⟩ : PadeState F)
m2 hGcdAt hw hW hdet (by omega) hcap hr2 hi (by simp [m2])
obtain ⟨_, kg, zg, hRunG, hPcG, hCostG, out, h97, houtLow, houtWord, hOut, hf23raw, hRegsG, hRangeG⟩ := hGcd
let m3 := zg.mem
have hzG : zg = boundaryState (pc + 658) m3 := by
apply ramState_eq_of
· exact hPcG
· rfl
· intro r
simpa only [boundaryState] using congrFun hRegsG r
have hf23 : MemoryFrame (rootComputeWritable R U D C TB cap) m2 m3 := hf23raw.mono (by
intro addr ha
dsimp [gcdProcedureWritable, gcdLoopWritable] at ha
rcases ha with h | h | h
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· subst h
exact rootComputeWritable.of_meta (by norm_num [rootComputeMeta])
· exact padeWritable_le_rootComputeWritable R U D C TB cap addr
((padeWritable_swap R U D C cap addr).mp h))
have hp3 := hp2.of_compute_frame hl hsrc hSrc hf23
have ht3 : PolynomialStored b m3 TB cap p := ht2.of_frame hf23raw (by
intro i hi
have hT := hl.Tlow
have hR := hl.TR
have hU := hl.TU
have hD := hl.TD
have hC := hl.TC
dsimp [gcdProcedureWritable, gcdLoopWritable, padeWritable]
omega)
have hfne : f ≠ 0 := by intro hz; simp [hz] at hFpos
have hOut' : PolynomialStored b m3 out cap (EuclideanDomain.gcd f p) := by
rw [gcd_swap_of_natDegree_lt f p hfne hpf]
exact hOut
have hGcdDone : Sem P E (pc + 62) (pc + 658) (boundaryState (pc + 62) m2)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 228) * L + 17 * cap + 92 ∧
∃ m' out, z = boundaryState (pc + 658) m' ∧ m' 97 = out ∧ 128 ≤ out ∧ out + cap ≤ 2 ^ E.W ∧
PolynomialStored b m' out cap (EuclideanDomain.gcd f p) ∧
RootPersistent b R U D C TB ZB cap L src f a m' ∧ PolynomialStored b m' TB cap p ∧
MemoryFrame (rootComputeWritable R U D C TB cap) m m' ∧
∀ i < cap, padeWritable R U D C cap (out + i)) :=
⟨rfl, kg, zg, hRunG, hPcG, hCostG, m3, out, hzG, h97, houtLow, houtWord, hOut', hp3, ht3,
MemoryFrame.trans (MemoryFrame.trans hf01 hf12) hf23,
fun i hi => (padeWritable_swap R U D C cap (out + i)).mp (hRangeG i hi)⟩
have hFull := Sem.seq_bound hSwap (fun z _ hz => by
subst z
exact Sem.seq_bound hCount (fun z _ hz => by subst z; exact hGcdDone))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
/-- Change a square/trace polynomial into the other bit-valued splitter. -/
theorem polynomial_sub_one_stored {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (m : ℕ → ℕ) (B cap : ℕ) (p : F[X])
(hp : PolynomialStored b m B cap p) :
PolynomialStored b (Function.update m B (enc b (p.coeff 0 + 1))) B cap (p - 1) := by
haveI : CharP F 2 := pinsketch_charP
intro i hi
by_cases hz : i = 0
· subst i
simp [Polynomial.coeff_sub, CharTwo.sub_eq_add]
· rw [Function.update_of_ne (by omega : B + i ≠ B), hp i hi]
congr 1
simp [Polynomial.coeff_sub, Polynomial.coeff_one, hz, Ne.symm hz]
theorem toggleConstant_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (E : RAMEnv) (s : RAMState) (slot B cap : ℕ) (p : F[X])
(hslot : slot < 2 ^ E.W) (hmeta : (78 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W)
(hB : B < 2 ^ E.W) (hcap : 1 ≤ cap) (hp : PolynomialStored b s.mem B cap p)
(hmSlot : s.mem slot = B) (hm78 : s.mem 78 = enc b 1) :
runBlock (toggleConstantCode slot) E s =
boundaryState (s.pc + 25) (Function.update s.mem B (enc b (p.coeff 0 + 1))) := by
have hSlot : slot % 2 ^ E.W = slot := Nat.mod_eq_of_lt hslot
have h78 : (78 : ℕ) % 2 ^ E.W = 78 := Nat.mod_eq_of_lt hmeta
have hB0 : B % 2 ^ E.W = B := Nat.mod_eq_of_lt hB
have hEnc (z : F) : enc b z % 2 ^ E.W = enc b z :=
Nat.mod_eq_of_lt (lt_of_lt_of_le (enc_lt b z) (Nat.pow_le_pow_right (by norm_num) hwe))
have hmB : s.mem B = enc b (p.coeff 0) := by simpa only [Nat.add_zero] using hp 0 (by omega)
let sA := runBlock (toggleReadCode slot) E s
have hA2 : sA.regs r2 = B := by
simp [sA, toggleReadCode, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil,
execInstr, hSlot, h78, hmSlot, hm78, hB0, hEnc]
have hA10 : sA.regs r10 = enc b (p.coeff 0) := by
simp [sA, toggleReadCode, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil,
execInstr, hSlot, h78, hmSlot, hm78, hB0, hmB, hEnc]
have hA11 : sA.regs r11 = enc b 1 := by
simp [sA, toggleReadCode, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil,
execInstr, hSlot, h78, hmSlot, hm78, hB0, hEnc]
let sB := runBlock [iBxor r10 r10 r11, iSt r2 r10] E sA
have hmem : sB.mem = Function.update s.mem B (enc b (p.coeff 0 + 1)) := by
simp [sB, runBlock_cons, runBlock_nil, execInstr, hA2, hA10, hA11,
← enc_add_xor, hEnc] <;> rfl
have hfinish : runBlock (toggleConstantCode slot) E s = boundaryState (sB.pc + 16) sB.mem := by
have he : runBlock (toggleConstantCode slot) E s = runBlock zeroRegsCode E sB := by
simp only [toggleConstantCode, runBlock_append] <;> rfl
rw [he, zeroRegs_spec]
have hpc : sB.pc + 16 = s.pc + 25 := by
have h := runBlock_pc (toggleConstantCode slot) E s (by
simp [toggleConstantCode, toggleReadCode, metaReadCode, zeroRegsCode])
rw [hfinish] at h
exact h
rw [hfinish, hpc, hmem]
/-- A divisor-row update preserves the other three Euclidean rows. -/
theorem PadeRows.replace_rem {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {E : RAMEnv} {R U D C L cap : ℕ}
{m m' : ℕ → ℕ} {s : PadeState F} (h : PadeRows b E R U D C L cap m s) (q : F[X])
(hf : MemoryFrame (fun addr => D ≤ addr ∧ addr < D + cap) m m')
(hq : PolynomialStored b m' D cap q) :
PadeRows b E R U D C L cap m' (⟨s.prevR, s.prevC, q, s.curC⟩ : PadeState F) := by
have hmeta (slot : ℕ) (hs : slot < 128) : m' slot = m slot := hf slot (by have h' := h.layout.Dlow; omega)
refine ⟨h.layout, h.Rword, h.Uword, h.Dword, h.Cword,
h.prevR.of_frame hf (by intro i hi; have h' := h.layout.RD; omega),
h.prevC.of_frame hf (by intro i hi; have h' := h.layout.UD; omega), hq,
h.curC.of_frame hf (by intro i hi; have h' := h.layout.DC; omega), ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· exact (hmeta 72 (by norm_num)).trans h.ptr72
· exact (hmeta 73 (by norm_num)).trans h.ptr73
· exact (hmeta 74 (by norm_num)).trans h.ptr74
· exact (hmeta 75 (by norm_num)).trans h.ptr75
· exact (hmeta 76 (by norm_num)).trans h.length
· exact (hmeta 77 (by norm_num)).trans h.dimension
· exact (hmeta 81 (by norm_num)).trans h.capacity
/-- Restore the parent and saved splitter for the second gcd. Both dummy
coefficient rows are explicitly cleared from the independent zero source. -/
theorem rootSecondPrepareProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L src : ℕ) (f p : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootSecondPrepareProcedure pc))
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hp : RootPersistent b R U D C TB ZB cap L src f a m)
(hsrc : 128 ≤ src) (hSrcWord : src + cap ≤ 2 ^ E.W)
(hsep : RootSourceSeparated R U D C TB cap src)
(hmeta : (108 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W) (hcap : 1 ≤ cap)
(htrace : PolynomialStored b m TB cap p) :
Sem P E pc (pc + 345) (boundaryState pc m)
(fun k z => k ≤ 48 * cap + 305 ∧ ∃ m', z = boundaryState (pc + 345) m' ∧
RootPersistent b R U D C TB ZB cap L src f a m' ∧
PadeRows b E R U D C L cap m' (⟨f, 0, p - 1, 0⟩ : PadeState F) ∧
PolynomialStored b m' TB cap p ∧ MemoryFrame (rootComputeWritable R U D C TB cap) m m') := by
have hSrc := hsep.readonly hsrc
obtain ⟨hResetAt, hRest0⟩ := At.seqStmt hAt
obtain ⟨hRAt, hRest1⟩ := At.seqStmt hRest0
obtain ⟨hDAt, hRest2⟩ := At.seqStmt hRest1
obtain ⟨hUAt, hRest3⟩ := At.seqStmt hRest2
obtain ⟨hCAt, hToggleAt⟩ := At.seqStmt hRest3
let m1 := resetRootMemory m R U D C
have hf01 := resetRootMemory_frame m R U D C TB cap
have hp1 := hp.of_compute_frame hl hsrc hSrc hf01
have hT1 : PolynomialStored b m1 TB cap p :=
(((htrace.meta_update hl.Tlow 72 R (by norm_num)).meta_update hl.Tlow 73 U (by norm_num)).meta_update hl.Tlow 74 D (by norm_num)).meta_update hl.Tlow 75 C (by norm_num)
have hReset : Sem P E pc (pc + 40) (boundaryState pc m)
(fun k z => k ≤ 40 ∧ z = boundaryState (pc + 40) m1) := by
exact Sem.boundary_block P E _ resetRootRowsCode m m1 hResetAt
(by simp [resetRootRowsCode, metaReadCode, metaStoreCode, zeroRegsCode])
(resetRootRows_spec E _ R U D C (by omega)
(by have h := hwords.Rword; omega) (by have h := hwords.Uword; omega)
(by have h := hwords.Dword; omega) (by have h := hwords.Cword; omega)
hp.fixedR hp.fixedU hp.fixedD hp.fixedC)
have hR := rootCopy_spec b P E (pc + 40) R U D C TB ZB cap L src 102 99 R src
f f a m1 hRAt hl hp1 hsrc hSrc (by simp) (by omega) (by omega) (by omega)
hwe hcap hsrc hwords.Rword hSrcWord hsep.SR hp1.factor hp1.fixedR hp1.source
obtain ⟨_, k1, z1, hRun1, hPc1, hCost1, m2, hz1, hStored2, hp2, hf12⟩ := hR
have hRExact : Sem P E (pc + 40) (pc + 110) (boundaryState (pc + 40) m1)
(fun k z => k ≤ 12 * cap + 60 ∧ z = boundaryState (pc + 110) m2) :=
⟨rfl, k1, z1, hRun1, hPc1, hCost1, hz1⟩
have hT2 := hT1.after_root_copy hl.Tlow (hl.TR.elim Or.inr Or.inl) hf12
have hD := rootCopy_spec b P E (pc + 110) R U D C TB ZB cap L src 103 106 D TB
f p a m2 hDAt hl hp2 hsrc hSrc (by simp) (by omega) (by omega) (by omega)
hwe hcap hl.Tlow hwords.Dword hwords.Tword hl.TD hT2 hp2.fixedD hp2.fixedT
obtain ⟨_, k2, z2, hRun2, hPc2, hCost2, m3, hz2, hStored3, hp3, hf23⟩ := hD
have hDExact : Sem P E (pc + 110) (pc + 180) (boundaryState (pc + 110) m2)
(fun k z => k ≤ 12 * cap + 60 ∧ z = boundaryState (pc + 180) m3) :=
⟨rfl, k2, z2, hRun2, hPc2, hCost2, hz2⟩
have hU := rootCopy_spec b P E (pc + 180) R U D C TB ZB cap L src 104 108 U ZB
f 0 a m3 hUAt hl hp3 hsrc hSrc (by simp) (by omega) (by omega) (by omega)
hwe hcap hl.Zlow hwords.Uword hwords.Zword hl.ZU hp3.zero hp3.fixedU hp3.fixedZ
obtain ⟨_, k3, z3, hRun3, hPc3, hCost3, m4, hz3, hStored4, hp4, hf34⟩ := hU
have hUExact : Sem P E (pc + 180) (pc + 250) (boundaryState (pc + 180) m3)
(fun k z => k ≤ 12 * cap + 60 ∧ z = boundaryState (pc + 250) m4) :=
⟨rfl, k3, z3, hRun3, hPc3, hCost3, hz3⟩
have hC := rootCopy_spec b P E (pc + 250) R U D C TB ZB cap L src 105 108 C ZB
f 0 a m4 hCAt hl hp4 hsrc hSrc (by simp) (by omega) (by omega) (by omega)
hwe hcap hl.Zlow hwords.Cword hwords.Zword hl.ZC hp4.zero hp4.fixedC hp4.fixedZ
obtain ⟨_, k4, z4, hRun4, hPc4, hCost4, m5, hz4, hStored5, hp5, hf45⟩ := hC
have hCExact : Sem P E (pc + 250) (pc + 320) (boundaryState (pc + 250) m4)
(fun k z => k ≤ 12 * cap + 60 ∧ z = boundaryState (pc + 320) m5) :=
⟨rfl, k4, z4, hRun4, hPc4, hCost4, hz4⟩
have hR3 := hStored2.after_root_copy hl.rows.Rlow (hl.rows.RD.elim Or.inr Or.inl) hf23
have hR4 := hR3.after_root_copy hl.rows.Rlow (hl.rows.RU.elim Or.inr Or.inl) hf34
have hR5 := hR4.after_root_copy hl.rows.Rlow (hl.rows.RC.elim Or.inr Or.inl) hf45
have hD4 := hStored3.after_root_copy hl.rows.Dlow hl.rows.UD hf34
have hD5 := hD4.after_root_copy hl.rows.Dlow (hl.rows.DC.elim Or.inr Or.inl) hf45
have hU5 := hStored4.after_root_copy hl.rows.Ulow (hl.rows.UC.elim Or.inr Or.inl) hf45
have hT3 := hT2.after_root_copy hl.Tlow (hl.TD.elim Or.inr Or.inl) hf23
have hT4 := hT3.after_root_copy hl.Tlow (hl.TU.elim Or.inr Or.inl) hf34
have hT5 := hT4.after_root_copy hl.Tlow (hl.TC.elim Or.inr Or.inl) hf45
have hMeta5 (slot : ℕ) (hlo : 67 ≤ slot) (hhi : slot < 128) : m5 slot = m1 slot := by
rw [root_copy_meta hf45 hl.rows.Clow hlo hhi, root_copy_meta hf34 hl.rows.Ulow hlo hhi,
root_copy_meta hf23 hl.rows.Dlow hlo hhi, root_copy_meta hf12 hl.rows.Rlow hlo hhi]
have hRows5 : PadeRows b E R U D C L cap m5 (⟨f, 0, p, 0⟩ : PadeState F) := by
refine ⟨hl.rows, hwords.Rword, hwords.Uword, hwords.Dword, hwords.Cword,
hR5, hU5, hD5, hStored5, ?_, ?_, ?_, ?_, hp5.length, hp5.dimension, hp5.capacity⟩
· rw [hMeta5 72 (by norm_num) (by norm_num)]; simp [m1, resetRootMemory]
· rw [hMeta5 73 (by norm_num) (by norm_num)]; simp [m1, resetRootMemory]
· rw [hMeta5 74 (by norm_num) (by norm_num)]; simp [m1, resetRootMemory]
· rw [hMeta5 75 (by norm_num) (by norm_num)]; simp [m1, resetRootMemory]
let m6 := Function.update m5 D (enc b (p.coeff 0 + 1))
have hf56 : MemoryFrame (fun addr => D ≤ addr ∧ addr < D + cap) m5 m6 :=
(MemoryFrame.update m5 D _).mono (by intro addr ha; subst addr; omega)
have hStored6 := polynomial_sub_one_stored b m5 D cap p hD5
have hRows6 := hRows5.replace_rem (p - 1) hf56 hStored6
have hT6 : PolynomialStored b m6 TB cap p := hT5.of_frame hf56 (by intro i hi; have h := hl.TD; omega)
have hf56comp : MemoryFrame (rootComputeWritable R U D C TB cap) m5 m6 := hf56.mono (by
intro addr ha
dsimp [rootComputeWritable]
first | omega | tauto)
have hp6 := hp5.of_compute_frame hl hsrc hSrc hf56comp
have hToggle : Sem P E (pc + 320) (pc + 345) (boundaryState (pc + 320) m5)
(fun k z => k ≤ 25 ∧ z = boundaryState (pc + 345) m6) := by
exact Sem.boundary_block P E _ (toggleConstantCode 103) m5 m6 hToggleAt
(by simp [toggleConstantCode, toggleReadCode, metaReadCode, zeroRegsCode])
(toggleConstant_spec b E _ 103 D cap p (by omega) (by omega) hwe
(by have h := hwords.Dword; omega) hcap hD5 hp5.fixedD hp5.unit)
have hf05 : MemoryFrame (rootComputeWritable R U D C TB cap) m m5 :=
MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans (MemoryFrame.trans hf01
(hf12.mono (hl.copy_writable (by simp)))) (hf23.mono (hl.copy_writable (by simp))))
(hf34.mono (hl.copy_writable (by simp)))) (hf45.mono (hl.copy_writable (by simp)))
have hFull := Sem.seq_bound hReset (fun z _ hz => by
subst z
exact Sem.seq_bound hRExact (fun z _ hz => by
subst z
exact Sem.seq_bound hDExact (fun z _ hz => by
subst z
exact Sem.seq_bound hUExact (fun z _ hz => by
subst z
exact Sem.seq_bound hCExact (fun z _ hz => by subst z; exact hToggle)))))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, m6, hQ.2, hp6, hRows6, hT6, MemoryFrame.trans hf05 hf56comp⟩)
/-- The second child uses the saved trace minus one; it is recomputed from
immutable sources after the first gcd has reused the Euclidean workspace. -/
theorem rootSecondGcdProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L src : ℕ) (f p : F[X]) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootSecondGcdProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hp : RootPersistent b R U D C TB ZB cap L src f a m)
(hsrc : 128 ≤ src) (hSrcWord : src + cap ≤ 2 ^ E.W)
(hsep : RootSourceSeparated R U D C TB cap src) (hmeta : (108 : ℕ) < 2 ^ E.W)
(htrace : PolynomialStored b m TB cap p) (hFpos : 0 < f.natDegree) (hF : f.natDegree ≤ t)
(hpf : p.natDegree < f.natDegree) :
Sem P E pc (pc + 963) (boundaryState pc m)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 228) * L + 65 * cap + 419 ∧
∃ m' out, z = boundaryState (pc + 963) m' ∧ m' 97 = out ∧ 128 ≤ out ∧ out + cap ≤ 2 ^ E.W ∧
PolynomialStored b m' out cap (EuclideanDomain.gcd f (p - 1)) ∧
RootPersistent b R U D C TB ZB cap L src f a m' ∧ PolynomialStored b m' TB cap p ∧
MemoryFrame (rootComputeWritable R U D C TB cap) m m' ∧
∀ i < cap, padeWritable R U D C cap (out + i)) := by
have hwe : w ≤ E.W := by omega
have hcapPos : 1 ≤ cap := by omega
have hLWord : L < 2 ^ E.W := by have h := hwords.Rword; have h' := hl.rows.Rlow; omega
have hminus : (p - 1).natDegree < f.natDegree :=
lt_of_le_of_lt (by simpa using Polynomial.natDegree_sub_le p (1 : F[X])) hpf
have hf : f ≠ 0 := by intro hz; simp [hz] at hFpos
obtain ⟨hPrepAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hCountAt, hGcdAt⟩ := At.seqStmt hRestAt
have hPrep := rootSecondPrepareProcedure_spec b P E pc R U D C TB ZB cap L src f p a m
hPrepAt hl hwords hp hsrc hSrcWord hsep hmeta hwe hcapPos htrace
have hFull := Sem.seq_bound hPrep (fun z _ hQ => by
obtain ⟨m1, hz, hp1, hr1, ht1, hf01⟩ := hQ
subst z
let m2 := Function.update m1 93 L
have hp2 := hp1.meta_update hl hsrc (hsep.readonly hsrc) 93 L (by simp [rootComputeMeta])
have hr2 := hr1.gcdCounter_update L
have ht2 := ht1.meta_update hl.Tlow 93 L (by norm_num)
have hf12 : MemoryFrame (rootComputeWritable R U D C TB cap) m1 m2 :=
MemoryFrame.update_allowed _ m1 93 L (by simp [rootComputeWritable, rootComputeMeta])
have hCount : Sem P E (pc + 345) (pc + 367) (boundaryState (pc + 345) m1)
(fun k z => k ≤ 22 ∧ z = boundaryState (pc + 367) m2) := by
exact Sem.boundary_block P E _ (copyMetaCode 76 93) m1 m2 hCountAt
(by simp [copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(copyMeta_spec E _ 76 93 L (by omega) (by omega) hLWord hp1.length)
have hi : GcdInv L (⟨f, 0, p - 1, 0⟩ : PadeState F) := by
refine ⟨?_, ?_, rfl, rfl⟩
· change f.natDegree < L; omega
· change (p - 1).natDegree < L; omega
have hGcd := gcdProcedure_spec b ι t N P E (pc + 367) R U D C L cap (⟨f, 0, p - 1, 0⟩ : PadeState F)
m2 hGcdAt hw hW hdet (by omega) hcap hr2 hi (by simp [m2])
obtain ⟨_, kg, zg, hRunG, hPcG, hCostG, out, h97, houtLow, houtWord, hOut, hf23raw, hRegsG, hRangeG⟩ := hGcd
let m3 := zg.mem
have hzG : zg = boundaryState (pc + 963) m3 := by
apply ramState_eq_of
· exact hPcG
· rfl
· intro r
simpa only [boundaryState] using congrFun hRegsG r
have hf23 : MemoryFrame (rootComputeWritable R U D C TB cap) m2 m3 :=
hf23raw.mono (gcd_writable_le_root R U D C TB cap)
have hp3 := hp2.of_compute_frame hl hsrc (hsep.readonly hsrc) hf23
have ht3 : PolynomialStored b m3 TB cap p := ht2.of_frame hf23raw (by
intro i hi
have hT := hl.Tlow
have hR := hl.TR
have hU := hl.TU
have hD := hl.TD
have hC := hl.TC
dsimp [gcdProcedureWritable, gcdLoopWritable, padeWritable]
omega)
have hOut' : PolynomialStored b m3 out cap (EuclideanDomain.gcd f (p - 1)) := by
rw [gcd_swap_of_natDegree_lt f (p - 1) hf hminus]
exact hOut
have hGcdDone : Sem P E (pc + 367) (pc + 963) (boundaryState (pc + 367) m2)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 228) * L + 17 * cap + 92 ∧
∃ m' out, z = boundaryState (pc + 963) m' ∧ m' 97 = out ∧ 128 ≤ out ∧ out + cap ≤ 2 ^ E.W ∧
PolynomialStored b m' out cap (EuclideanDomain.gcd f (p - 1)) ∧
RootPersistent b R U D C TB ZB cap L src f a m' ∧ PolynomialStored b m' TB cap p ∧
MemoryFrame (rootComputeWritable R U D C TB cap) m m' ∧
∀ i < cap, padeWritable R U D C cap (out + i)) :=
⟨rfl, kg, zg, hRunG, hPcG, hCostG, m3, out, hzG, h97, houtLow, houtWord, hOut', hp3, ht3,
MemoryFrame.trans (MemoryFrame.trans hf01 hf12) hf23, hRangeG⟩
exact Sem.seq_bound hCount (fun z _ hz => by subst z; exact hGcdDone))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem RootWorkspace.compute_meta_readonly {R U D C TB ZB cap : ℕ}
(h : RootWorkspace R U D C TB ZB cap) (slot : ℕ) (hs : slot < 128) (hn : ¬ rootComputeMeta slot) :
¬ rootComputeWritable R U D C TB cap slot := by
have hR := h.rows.Rlow
have hU := h.rows.Ulow
have hD := h.rows.Dlow
have hC := h.rows.Clow
have hT := h.Tlow
dsimp [rootComputeWritable]
intro hbad
rcases hbad with hmeta | hR' | hU' | hD' | hC' | hT'
· exact hn hmeta
all_goals omega
theorem RootSourceSeparated.node_readonly {R U D C TB cap src QB T : ℕ}
(h : RootSourceSeparated R U D C TB cap src) (hsrc : 128 ≤ src)
(hQ : src + cap ≤ QB ∨ QB + T * cap ≤ src) (i : ℕ) (hi : i < cap) :
¬ rootNodeWritable R U D C TB cap QB T (src + i) := by
intro hbad
rcases hbad with h90 | hwork | hqueue
· omega
· exact h.readonly hsrc i hi hwork
· omega
theorem FrontierStored.of_compute_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m m' : ℕ → ℕ}
{R U D C TB ZB cap QB T : ℕ} {fs : List F[X]}
(h : FrontierStored b m QB cap fs) (hq : QueueWorkspaceSeparated R U D C TB ZB cap QB T)
(hQB : 128 ≤ QB) (hn : fs.length ≤ T)
(hf : MemoryFrame (rootComputeWritable R U D C TB cap) m m') : FrontierStored b m' QB cap fs := by
intro j hj
apply (h j hj).of_frame hf
intro i hi
have hprod := Nat.zero_le (j * cap)
exact hq.readonly hQB _ (by omega) (queue_slot_before_next QB cap T j i (by omega) hi)
theorem queue_keep_writable_le_whole (QB T cap n degree addr : ℕ)
(hroom : 0 < degree → n < T) (h : queueKeepWritable QB n cap degree addr) :
wholeQueueWritable QB T cap addr := by
by_cases hp : 0 < degree
· have hn := hroom hp
have hm : (n + 1) * cap ≤ T * cap := Nat.mul_le_mul_right cap (by omega)
have he : (n + 1) * cap = n * cap + cap := by ring
dsimp [queueKeepWritable] at h
dsimp [wholeQueueWritable]
omega
· dsimp [queueKeepWritable] at h
dsimp [wholeQueueWritable]
omega
theorem PolynomialStored.after_queue_keep {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m m' : ℕ → ℕ} {B QB T cap n degree : ℕ} {f : F[X]}
(h : PolynomialStored b m B cap f) (hB : 128 ≤ B) (hsep : B + cap ≤ QB ∨ QB + T * cap ≤ B)
(hroom : 0 < degree → n < T)
(hf : MemoryFrame (queueKeepWritable QB n cap degree) m m') : PolynomialStored b m' B cap f := by
apply h.of_frame (hf.mono (fun addr ha => queue_keep_writable_le_whole QB T cap n degree addr hroom ha))
intro i hi
dsimp [wholeQueueWritable]
omega
/-- A complete breadth-first root node: modular trace, the two gcd branches,
and bounded appends to the next frontier. -/
theorem rootNodeProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L src QB T : ℕ) (f : F[X]) (a : F) (gs : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootNodeProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hp : RootPersistent b R U D C TB ZB cap L src f a m)
(hsrc : 128 ≤ src) (hSrcWord : src + cap ≤ 2 ^ E.W) (hsep : RootSourceSeparated R U D C TB cap src)
(hQB : 128 ≤ QB) (hQWord : QB + T * cap ≤ 2 ^ E.W)
(hQSep : QueueWorkspaceSeparated R U D C TB ZB cap QB T)
(hSrcQ : src + cap ≤ QB ∨ QB + T * cap ≤ src) (hmeta : (108 : ℕ) < 2 ^ E.W)
(hFpos : 0 < f.natDegree) (hF : f.natDegree ≤ t)
(hgs : FrontierStored b m QB cap gs) (hgsPos : ∀ g ∈ gs, 0 < g.natDegree)
(hbudget : frontierMass gs + f.natDegree ≤ T) (hm84 : m 84 = QB) (hm90 : m 90 = gs.length) :
Sem P E pc (pc + 3060) (boundaryState pc m)
(fun k z => k ≤ (30 * cap + (48 * L + 187) * L + 258) * w +
2 * ((17 * cap + (48 * L + 187) * L + 228) * L) + 217 * cap + 1350 ∧
∃ m', z = boundaryState (pc + 3060) m' ∧ RootPersistent b R U D C TB ZB cap L src f a m' ∧
m' 90 = ((gs ++ keepFactor (EuclideanDomain.gcd f (traceRemainder a f w))) ++
keepFactor (EuclideanDomain.gcd f (traceRemainder a f w - 1))).length ∧
FrontierStored b m' QB cap ((gs ++ keepFactor (EuclideanDomain.gcd f (traceRemainder a f w))) ++
keepFactor (EuclideanDomain.gcd f (traceRemainder a f w - 1))) ∧
MemoryFrame (rootNodeWritable R U D C TB cap QB T) m m') := by
let p := traceRemainder a f w
let g0 := EuclideanDomain.gcd f p
let g1 := EuclideanDomain.gcd f (p - 1)
have hwe : w ≤ E.W := by omega
have hcapPos : 1 ≤ cap := by omega
have hT : 1 ≤ T := by have h := Nat.zero_le (frontierMass gs); omega
have hf : f ≠ 0 := by intro hz; simp [hz] at hFpos
have hpf : p.natDegree < f.natDegree := traceRemainder_natDegree_lt a hFpos w
have hlen : gs.length ≤ T := by have h := frontier_length_le_mass gs hgsPos; omega
have hroom := frontier_children_room f p gs T hf hgsPos hbudget
have hG0 : g0.natDegree < cap := by
have h := Polynomial.natDegree_le_of_dvd (EuclideanDomain.gcd_dvd_left f p) hf
change (EuclideanDomain.gcd f p).natDegree < cap
omega
have hG1 : g1.natDegree < cap := by
have h := Polynomial.natDegree_le_of_dvd (EuclideanDomain.gcd_dvd_left f (p - 1)) hf
change (EuclideanDomain.gcd f (p - 1)).natDegree < cap
omega
have hSrcNode := hsep.node_readonly hsrc hSrcQ
obtain ⟨hTraceAt, hRest1⟩ := At.seqStmt hAt
obtain ⟨hFirstAt, hRest2⟩ := At.seqStmt hRest1
obtain ⟨hKeep0At, hRest3⟩ := At.seqStmt hRest2
obtain ⟨hSecondAt, hKeep1At⟩ := At.seqStmt hRest3
have hTrace := rootTraceProcedure_spec b ι t N P E pc R U D C TB ZB cap L src f a m hTraceAt
hw hW hdet ht hL hcap hl hwords hp hsrc hSrcWord hsep hmeta hFpos hF
obtain ⟨_, k1, z1, hRun1, hPc1, hCost1, m1, hz1, hp1, hr1, ht1, hf01⟩ := hTrace
have hTraceExact : Sem P E pc (pc + 1021) (boundaryState pc m)
(fun k z => k ≤ (30 * cap + (48 * L + 187) * L + 258) * w + 77 * cap + 443 ∧
z = boundaryState (pc + 1021) m1) := ⟨rfl, k1, z1, hRun1, hPc1, hCost1, hz1⟩
have hFirst := rootFirstGcdProcedure_spec b ι t N P E (pc + 1021) R U D C TB ZB cap L src f p a m1
hFirstAt hw hW hdet ht hL hcap hl hwords hp1 hsrc hsep hmeta hr1 ht1 hFpos hF hpf
obtain ⟨_, k2, z2, hRun2, hPc2, hCost2, m2, out0, hz2, h970, hlo0, hword0, hstored0, hp2, ht2, hf12, hRange0⟩ := hFirst
have hFirstExact : Sem P E (pc + 1021) (pc + 1679) (boundaryState (pc + 1021) m1)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 228) * L + 17 * cap + 154 ∧
z = boundaryState (pc + 1679) m2) := ⟨rfl, k2, z2, hRun2, hPc2, hCost2, hz2⟩
have hf02 := MemoryFrame.trans hf01 hf12
have hgs2 := hgs.of_compute_frame hQSep hQB hlen hf02
have hm284 : m2 84 = QB :=
(hf02 84 (hl.compute_meta_readonly 84 (by norm_num) (by norm_num [rootComputeMeta]))).trans hm84
have hm290 : m2 90 = gs.length :=
(hf02 90 (hl.compute_meta_readonly 90 (by norm_num) (by norm_num [rootComputeMeta]))).trans hm90
have hdisj0 := hQSep.gcd_output_disjoint hQB hcapPos hT hRange0
have hKeep0 := queueKeepProcedure_spec b P E (pc + 1679) QB out0 cap T gs g0 m2 hKeep0At
(by omega) hwe hcapPos hQB hlo0 hQWord hword0 hroom.1 hdisj0 hgs2 hstored0 hG0 hm284 hm290 hp2.capacity h970
obtain ⟨_, k3, z3, hRun3, hPc3, hCost3, hRegs3, hCount3, hQueue3, hf23raw⟩ := hKeep0
let m3 := z3.mem
have hz3 : z3 = boundaryState (pc + 1888) m3 := by
apply ramState_eq_of
· exact hPc3
· rfl
· intro r; simpa only [boundaryState] using congrFun hRegs3 r
have hKeep0Exact : Sem P E (pc + 1679) (pc + 1888) (boundaryState (pc + 1679) m2)
(fun k z => k ≤ 29 * cap + 167 ∧ z = boundaryState (pc + 1888) m3) :=
⟨rfl, k3, z3, hRun3, hPc3, hCost3, hz3⟩
have hf23 : MemoryFrame (rootNodeWritable R U D C TB cap QB T) m2 m3 :=
hf23raw.mono (fun addr ha => queue_keep_writable_le_node R U D C TB cap QB T gs.length g0.natDegree addr hroom.1 ha)
have hp3 := hp2.of_frame hl hQB hQSep.QZ hSrcNode hf23
have ht3 := ht2.after_queue_keep hl.Tlow (hQSep.QT.elim Or.inr Or.inl) hroom.1 hf23raw
have hf03 : MemoryFrame (rootNodeWritable R U D C TB cap QB T) m m3 :=
MemoryFrame.trans (hf02.mono (by intro addr ha; exact Or.inr (Or.inl ha))) hf23
have hSecond := rootSecondGcdProcedure_spec b ι t N P E (pc + 1888) R U D C TB ZB cap L src f p a m3
hSecondAt hw hW hdet ht hL hcap hl hwords hp3 hsrc hSrcWord hsep hmeta ht3 hFpos hF hpf
obtain ⟨_, k4, z4, hRun4, hPc4, hCost4, m4, out1, hz4, h971, hlo1, hword1, hstored1, hp4, ht4, hf34, hRange1⟩ := hSecond
have hSecondExact : Sem P E (pc + 1888) (pc + 2851) (boundaryState (pc + 1888) m3)
(fun k z => k ≤ (17 * cap + (48 * L + 187) * L + 228) * L + 65 * cap + 419 ∧
z = boundaryState (pc + 2851) m4) := ⟨rfl, k4, z4, hRun4, hPc4, hCost4, hz4⟩
have hlen0 : (gs ++ keepFactor g0).length ≤ T := by
have hmass : frontierMass (gs ++ keepFactor g0) + g1.natDegree ≤ T := by
simpa only [g0, g1, frontierMass_append, frontierMass_keep, Nat.add_assoc] using hroom.2.2
have hnonneg := Nat.zero_le g1.natDegree
have hlen' := frontier_length_le_mass (gs ++ keepFactor g0) (frontier_append_keep_positive gs g0 hgsPos)
omega
have hgs4 := hQueue3.of_compute_frame hQSep hQB hlen0 hf34
have hf04 : MemoryFrame (rootNodeWritable R U D C TB cap QB T) m m4 :=
MemoryFrame.trans hf03 (hf34.mono (by intro addr ha; exact Or.inr (Or.inl ha)))
have hm484 : m4 84 = QB :=
(hf04 84 (hl.meta_readonly hQB 84 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta]))).trans hm84
have hm490 : m4 90 = (gs ++ keepFactor g0).length :=
(hf34 90 (hl.compute_meta_readonly 90 (by norm_num) (by norm_num [rootComputeMeta]))).trans hCount3
have hdisj1 := hQSep.gcd_output_disjoint hQB hcapPos hT hRange1
have hKeep1 := queueKeepProcedure_spec b P E (pc + 2851) QB out1 cap T (gs ++ keepFactor g0) g1 m4 hKeep1At
(by omega) hwe hcapPos hQB hlo1 hQWord hword1 hroom.2.1 hdisj1 hgs4 hstored1 hG1 hm484 hm490 hp4.capacity h971
obtain ⟨_, k5, z5, hRun5, hPc5, hCost5, hRegs5, hCount5, hQueue5, hf45raw⟩ := hKeep1
let m5 := z5.mem
have hz5 : z5 = boundaryState (pc + 3060) m5 := by
apply ramState_eq_of
· exact hPc5
· rfl
· intro r; simpa only [boundaryState] using congrFun hRegs5 r
have hf45 : MemoryFrame (rootNodeWritable R U D C TB cap QB T) m4 m5 :=
hf45raw.mono (fun addr ha => queue_keep_writable_le_node R U D C TB cap QB T
(gs ++ keepFactor g0).length g1.natDegree addr hroom.2.1 ha)
have hp5 := hp4.of_frame hl hQB hQSep.QZ hSrcNode hf45
have hKeep1Exact : Sem P E (pc + 2851) (pc + 3060) (boundaryState (pc + 2851) m4)
(fun k z => k ≤ 29 * cap + 167 ∧ z = boundaryState (pc + 3060) m5) :=
⟨rfl, k5, z5, hRun5, hPc5, hCost5, hz5⟩
have hFull := Sem.seq_bound hTraceExact (fun z _ hz => by
subst z
exact Sem.seq_bound hFirstExact (fun z _ hz => by
subst z
exact Sem.seq_bound hKeep0Exact (fun z _ hz => by
subst z
exact Sem.seq_bound hSecondExact (fun z _ hz => by subst z; exact hKeep1Exact))))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, m5, hQ.2, hp5, hCount5, hQueue5, MemoryFrame.trans hf04 hf45⟩)
theorem RootEnvironment.persistent {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L : ℕ} {a : F} {m : ℕ → ℕ}
(h : RootEnvironment b R U D C TB ZB cap L a m) (src : ℕ) (f : F[X])
(hm99 : m 99 = src) (hf : PolynomialStored b m src cap f) : RootPersistent b R U D C TB ZB cap L src f a m :=
⟨h.length, h.dimension, h.unit, h.capacity, h.scalar, hm99, h.fixedR, h.fixedD, h.fixedU, h.fixedC, h.fixedT, h.fixedZ, hf, h.zero⟩
theorem RootWorkspace.level_meta_readonly {R U D C TB ZB cap QB T : ℕ}
(h : RootWorkspace R U D C TB ZB cap) (hQB : 128 ≤ QB)
(slot : ℕ) (hs : slot < 128) (hn : ¬ rootLevelMeta slot) :
¬ rootLevelWritable R U D C TB cap QB T slot := by
intro hbad
rcases hbad with h91 | h99 | h111 | hnode
· exact hn (Or.inl h91)
· exact hn (Or.inr (Or.inl h99))
· exact hn (Or.inr (Or.inr (Or.inl h111)))
· exact h.meta_readonly hQB slot hs (by intro ha; exact hn (Or.inr (Or.inr (Or.inr ha)))) hnode
theorem RootWorkspace.level_zero_readonly {R U D C TB ZB cap QB T : ℕ}
(h : RootWorkspace R U D C TB ZB cap) (hQ : QB + T * cap ≤ ZB ∨ ZB + cap ≤ QB)
(i : ℕ) (hi : i < cap) : ¬ rootLevelWritable R U D C TB cap QB T (ZB + i) := by
intro hbad
have hZ := h.Zlow
rcases hbad with h91 | h99 | h111 | hnode
· omega
· omega
· omega
· exact h.node_zero_readonly hQ i hi hnode
theorem RootEnvironment.of_level_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L QB T : ℕ} {a : F} {m m' : ℕ → ℕ}
(h : RootEnvironment b R U D C TB ZB cap L a m) (hl : RootWorkspace R U D C TB ZB cap)
(hQB : 128 ≤ QB) (hQZ : QB + T * cap ≤ ZB ∨ ZB + cap ≤ QB)
(hf : MemoryFrame (rootLevelWritable R U D C TB cap QB T) m m') :
RootEnvironment b R U D C TB ZB cap L a m' := by
have hmeta (slot : ℕ) (hs : slot < 128) (hn : ¬ rootLevelMeta slot) : m' slot = m slot :=
hf slot (hl.level_meta_readonly hQB slot hs hn)
refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, h.zero.of_frame hf (hl.level_zero_readonly hQZ)⟩
· exact (hmeta 76 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.length
· exact (hmeta 77 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.dimension
· exact (hmeta 78 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.unit
· exact (hmeta 81 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.capacity
· exact (hmeta 96 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.scalar
· exact (hmeta 102 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedR
· exact (hmeta 103 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedD
· exact (hmeta 104 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedU
· exact (hmeta 105 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedC
· exact (hmeta 106 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedT
· exact (hmeta 108 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedZ
theorem queueReadPointer_spec (E : RAMEnv) (s : RAMState) (B j cap : ℕ)
(hmeta : (99 : ℕ) < 2 ^ E.W) (hB : B < 2 ^ E.W) (hj : j < 2 ^ E.W)
(hc : cap < 2 ^ E.W) (hprod : j * cap < 2 ^ E.W) (haddr : B + j * cap < 2 ^ E.W)
(hm83 : s.mem 83 = B) (hm91 : s.mem 91 = j) (hm81 : s.mem 81 = cap) :
runBlock queueReadPointerCode E s = boundaryState (s.pc + 30) (Function.update s.mem 99 (B + j * cap)) := by
have hsmall : ∀ i ≤ 99, i % 2 ^ E.W = i := by intro i hi; exact Nat.mod_eq_of_lt (by omega)
rw [queueReadPointerCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc queueReadPointerCode E s (by
simp [queueReadPointerCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [queueReadPointerCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 30 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, runBlock_cons, runBlock_nil, execInstr,
hsmall, hm83, hm91, hm81, Nat.mod_eq_of_lt hB, Nat.mod_eq_of_lt hj, Nat.mod_eq_of_lt hc,
Nat.mod_eq_of_lt hprod, Nat.mod_eq_of_lt haddr, boundaryState]
· intro _; rfl
theorem incrementMeta_spec (E : RAMEnv) (s : RAMState) (slot n : ℕ)
(hslot : slot < 2 ^ E.W) (hn : n + 1 < 2 ^ E.W) (hm : s.mem slot = n) :
runBlock (incrementMetaCode slot) E s = boundaryState (s.pc + 24) (Function.update s.mem slot (n + 1)) := by
have hs : slot % 2 ^ E.W = slot := Nat.mod_eq_of_lt hslot
have h1 : (1 : ℕ) % 2 ^ E.W = 1 := Nat.mod_eq_of_lt (by omega)
rw [incrementMetaCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc (incrementMetaCode slot) E s (by
simp [incrementMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [incrementMetaCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 24 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, runBlock_cons, runBlock_nil, execInstr,
hs, h1, hm, Nat.mod_eq_of_lt (show n < 2 ^ E.W by omega), Nat.mod_eq_of_lt hn, boundaryState]
· intro _; rfl
theorem rootLevelTail_spec (E : RAMEnv) (s : RAMState) (j n : ℕ)
(hmeta : (111 : ℕ) < 2 ^ E.W) (hj : j + 1 < 2 ^ E.W) (hn : n + 1 < 2 ^ E.W)
(hm91 : s.mem 91 = j) (hm111 : s.mem 111 = n + 1) :
runBlock rootLevelTailCode E s = rankState (s.pc + 51)
(Function.update (Function.update s.mem 91 (j + 1)) 111 n) n := by
rw [rootLevelTailCode, runBlock_append, incrementMeta_spec E s 91 j (by omega) hj hm91]
have hcounter : (boundaryState (s.pc + 24) (Function.update s.mem 91 (j + 1))).mem 111 = n + 1 := by
simp [boundaryState, hm111]
rw [countdown_spec E _ 111 n hmeta hn hcounter] <;> rfl
/-- Appending one parent to the processed prefix appends its two children. -/
theorem splitFrontier_append {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (a : F) (fs gs : List F[X]) :
splitFrontier w a (fs ++ gs) = splitFrontier w a fs ++ splitFrontier w a gs := by
induction fs with
| nil => simp [splitFrontier]
| cons f fs ih =>
by_cases h : f.natDegree = 0 <;> simp [splitFrontier, h, ih, List.append_assoc]
theorem splitFrontier_snoc {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (a : F) (fs : List F[X]) (f : F[X]) (hf : 0 < f.natDegree) :
splitFrontier w a (fs ++ [f]) =
(splitFrontier w a fs ++ keepFactor (EuclideanDomain.gcd f (traceRemainder a f w))) ++
keepFactor (EuclideanDomain.gcd f (traceRemainder a f w - 1)) := by
rw [splitFrontier_append]
simp [splitFrontier, Nat.ne_of_gt hf, List.append_assoc]
theorem frontier_degree_le_mass {F : Type} [Field F] (fs : List F[X]) (f : F[X]) (hf : f ∈ fs) :
f.natDegree ≤ frontierMass fs := by
induction fs with
| nil => simp at hf
| cons g fs ih =>
rcases List.mem_cons.mp hf with heq | hmem
· subst g
simp only [frontierMass]
omega
· have ht := ih hmem
have hnonneg := Nat.zero_le g.natDegree
simp only [frontierMass]
omega
theorem frontier_prefix_budget {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (a : F) (fs done pending : List F[X]) (T : ℕ)
(heq : fs = done ++ pending) (hpos : ∀ f ∈ fs, 0 < f.natDegree) (hmass : frontierMass fs ≤ T) :
frontierMass (splitFrontier w a done) + frontierMass pending ≤ T := by
have hdone : ∀ f ∈ done, f ≠ 0 := by
intro f hf hz
have hp := hpos f (by rw [heq]; exact List.mem_append.mpr (Or.inl hf))
simp [hz] at hp
have hs := splitFrontier_mass_le w a done hdone
rw [heq, frontierMass_append] at hmass
omega
theorem QueueWorkspaceSeparated.source_separated {R U D C TB ZB cap BQ T src : ℕ}
(h : QueueWorkspaceSeparated R U D C TB ZB cap BQ T) (hlo : BQ ≤ src) (hhi : src + cap ≤ BQ + T * cap) :
RootSourceSeparated R U D C TB cap src := by
refine ⟨?_, ?_, ?_, ?_, ?_⟩
· have hR := h.QR; omega
· have hU := h.QU; omega
· have hD := h.QD; omega
· have hC := h.QC; omega
· have hT := h.QT; omega
theorem old_queue_level_readonly {R U D C TB ZB cap BQ QB T : ℕ}
(h : QueueWorkspaceSeparated R U D C TB ZB cap BQ T) (hBQ : 128 ≤ BQ)
(hdisj : BQ + T * cap ≤ QB ∨ QB + T * cap ≤ BQ)
(addr : ℕ) (hlo : BQ ≤ addr) (hhi : addr < BQ + T * cap) :
¬ rootLevelWritable R U D C TB cap QB T addr := by
intro hbad
rcases hbad with h91 | h99 | h111 | hnode
· omega
· omega
· omega
· rcases hnode with h90 | hwork | hnext
· omega
· exact h.readonly hBQ addr hlo hhi hwork
· omega
theorem FrontierStored.of_level_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m m' : ℕ → ℕ}
{R U D C TB ZB cap BQ QB T : ℕ} {fs : List F[X]}
(h : FrontierStored b m BQ cap fs) (hsep : QueueWorkspaceSeparated R U D C TB ZB cap BQ T)
(hBQ : 128 ≤ BQ) (hdisj : BQ + T * cap ≤ QB ∨ QB + T * cap ≤ BQ) (hn : fs.length ≤ T)
(hf : MemoryFrame (rootLevelWritable R U D C TB cap QB T) m m') : FrontierStored b m' BQ cap fs := by
intro j hj
apply (h j hj).of_frame hf
intro i hi
have hprod := Nat.zero_le (j * cap)
exact old_queue_level_readonly hsep hBQ hdisj _ (by omega) (queue_slot_before_next BQ cap T j i (by omega) hi)
/-- Word bounds for the currently selected fixed-capacity queue slot. -/
theorem queue_slot_word_bounds (B cap T j W : ℕ) (hB : 128 ≤ B) (hc : 1 ≤ cap)
(hj : j < T) (hword : B + T * cap ≤ 2 ^ W) :
B + j * cap + cap ≤ 2 ^ W ∧ B + j * cap < 2 ^ W ∧ j * cap < 2 ^ W ∧ j < 2 ^ W ∧ cap < 2 ^ W := by
have hm : (j + 1) * cap ≤ T * cap := Nat.mul_le_mul_right cap (by omega)
have he : (j + 1) * cap = j * cap + cap := by ring
have hjprod : j ≤ j * cap := by simpa only [Nat.mul_one] using Nat.mul_le_mul_left j hc
have hprod := Nat.zero_le (j * cap)
omega
theorem rootLevelBody_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L BQ QB : ℕ) (a : F) (fs done pending : List F[X]) (f : F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootLevelBody pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hBQ : 128 ≤ BQ) (hQB : 128 ≤ QB)
(hBQword : BQ + t * cap ≤ 2 ^ E.W) (hQBword : QB + t * cap ≤ 2 ^ E.W)
(hBQsep : QueueWorkspaceSeparated R U D C TB ZB cap BQ t)
(hQBsep : QueueWorkspaceSeparated R U D C TB ZB cap QB t)
(hdisj : BQ + t * cap ≤ QB ∨ QB + t * cap ≤ BQ) (hmeta : (111 : ℕ) < 2 ^ E.W)
(hfs : fs = done ++ (f :: pending)) (hpos : ∀ g ∈ fs, 0 < g.natDegree) (hmass : frontierMass fs ≤ t)
(hv : RootLevelView b R U D C TB ZB cap L BQ QB a fs done (f :: pending) m) :
Sem P E pc (pc + 3141) (rankState pc m (pending.length + 1))
(fun k z => k ≤ rootNodeBudget cap L w + 81 ∧ ∃ m', z = rankState (pc + 3141) m' pending.length ∧
RootLevelView b R U D C TB ZB cap L BQ QB a fs (done ++ [f]) pending m' ∧
MemoryFrame (rootLevelWritable R U D C TB cap QB t) m m') := by
have hlen := frontier_length_le_mass fs hpos
have hfmem : f ∈ fs := by rw [hfs]; simp
have hfpos := hpos f hfmem
have hfdeg : f.natDegree ≤ t := le_trans (frontier_degree_le_mass fs f hfmem) hmass
have hbudget := frontier_prefix_budget w a fs done (f :: pending) t hfs hpos hmass
have hnodeBudget : frontierMass (splitFrontier w a done) + f.natDegree ≤ t := by
simp only [frontierMass] at hbudget
omega
have hj : done.length < t := by
have he : fs.length = done.length + (pending.length + 1) := by simp [hfs]
omega
have hcapPos : 1 ≤ cap := by omega
have hslot := queue_slot_word_bounds BQ cap t done.length E.W hBQ hcapPos hj hBQword
have hn : pending.length + 1 < 2 ^ E.W := by
have he : fs.length = done.length + (pending.length + 1) := by simp [hfs]
have htw : t < 2 ^ E.W := by
have hm : t ≤ t * cap := by simpa only [Nat.mul_one] using Nat.mul_le_mul_left t hcapPos
omega
omega
have hjword : done.length + 1 < 2 ^ E.W := by
have hm : t ≤ t * cap := by simpa only [Nat.mul_one] using Nat.mul_le_mul_left t hcapPos
omega
let src := BQ + done.length * cap
let m1 := Function.update m 99 src
have hf01 : MemoryFrame (rootLevelWritable R U D C TB cap QB t) m m1 :=
MemoryFrame.update_allowed _ m 99 src (Or.inr (Or.inl rfl))
have henv1 := hv.environment.of_level_frame hl hQB hQBsep.QZ hf01
have hfactor : PolynomialStored b m1 src cap f := by
have hjfs : done.length < fs.length := by simp [hfs]
have hg := hv.oldQueue done.length hjfs
have he : fs.getD done.length 0 = f := by
rw [hfs, List.getD_append_right done (f :: pending) 0 done.length le_rfl, Nat.sub_self]
rfl
rw [he] at hg
exact hg.meta_update (by omega) 99 src (by norm_num)
have hp1 := henv1.persistent src f (by simp [m1]) hfactor
have hsrcEnd : src + cap ≤ BQ + t * cap := by
have hm := Nat.mul_le_mul_right cap (show done.length + 1 ≤ t by omega)
have he : (done.length + 1) * cap = done.length * cap + cap := by ring
dsimp [src]
omega
have hsource' := hBQsep.source_separated (show BQ ≤ src by dsimp [src]; omega) hsrcEnd
have hsrcQ : src + cap ≤ QB ∨ QB + t * cap ≤ src := by
have hstart : BQ ≤ src := by dsimp [src]; omega
omega
obtain ⟨hPointerAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hNodeAt, hTailAt⟩ := At.seqStmt hRestAt
have hPointer : Sem P E pc (pc + 30) (rankState pc m (pending.length + 1))
(fun k z => k ≤ 30 ∧ z = boundaryState (pc + 30) m1) := by
refine Sem.mono (Sem.block P E pc queueReadPointerCode _ hPointerAt
(by simp [queueReadPointerCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl) ?_
intro k z hQ
have hk : k = 30 := hQ.1
refine ⟨by omega, ?_⟩
exact hQ.2.trans (queueReadPointer_spec E _ BQ done.length cap (by omega) (by omega)
hslot.2.2.2.1 hslot.2.2.2.2 hslot.2.2.1 hslot.2.1 hv.oldBase hv.index hv.environment.capacity)
have hNode := rootNodeProcedure_spec b ι t N P E (pc + 30) R U D C TB ZB cap L src QB t f a
(splitFrontier w a done) m1 hNodeAt hw hW hdet ht hL hcap hl hwords hp1
(by dsimp [src]; omega) hslot.1 hsource' hQB hQBword hQBsep hsrcQ (by omega) hfpos hfdeg
(hv.newQueue.meta_update hQB 99 src (by norm_num)) (splitFrontier_positive w a done) hnodeBudget
(by simpa [m1] using hv.newBase) (by simpa [m1] using hv.newCount)
obtain ⟨_, k2, z2, hRun2, hPc2, hCost2, m2, hz2, hp2, hCount2, hQueue2, hf12raw⟩ := hNode
have hf12 : MemoryFrame (rootLevelWritable R U D C TB cap QB t) m1 m2 :=
hf12raw.mono (fun _ ha => Or.inr (Or.inr (Or.inr ha)))
have hf02 := MemoryFrame.trans hf01 hf12
have hmeta2 (slot : ℕ) (hs : slot < 128) (hn : ¬ rootNodeMeta slot) : m2 slot = m1 slot :=
hf12raw slot (hl.meta_readonly hQB slot hs hn)
have h91 : m2 91 = done.length := by
rw [hmeta2 91 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])]
simpa [m1] using hv.index
have h111 : m2 111 = pending.length + 1 := by
rw [hmeta2 111 (by norm_num) (by norm_num [rootNodeMeta, rootComputeMeta])]
simpa [m1] using hv.remaining
let m3 := Function.update (Function.update m2 91 (done.length + 1)) 111 pending.length
have hf23 : MemoryFrame (rootLevelWritable R U D C TB cap QB t) m2 m3 :=
MemoryFrame.trans (MemoryFrame.update_allowed _ m2 91 (done.length + 1) (Or.inl rfl))
(MemoryFrame.update_allowed _ _ 111 pending.length (Or.inr (Or.inr (Or.inl rfl))))
have hf03 := MemoryFrame.trans hf02 hf23
have hnew3 : FrontierStored b m3 QB cap (splitFrontier w a (done ++ [f])) := by
rw [splitFrontier_snoc w a done f hfpos]
exact (hQueue2.meta_update hQB 91 (done.length + 1) (by norm_num)).meta_update hQB 111 pending.length (by norm_num)
have hfixed (slot : ℕ) (hs : slot < 128) (hn : ¬ rootLevelMeta slot) : m3 slot = m slot :=
hf03 slot (hl.level_meta_readonly hQB slot hs hn)
have hv3 : RootLevelView b R U D C TB ZB cap L BQ QB a fs (done ++ [f]) pending m3 := by
refine ⟨hv.environment.of_level_frame hl hQB hQBsep.QZ hf03,
hv.oldQueue.of_level_frame hBQsep hBQ hdisj (by omega) hf03, hnew3, ?_, ?_, ?_, ?_, ?_, ?_⟩
· exact (hfixed 83 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans hv.oldBase
· exact (hfixed 84 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans hv.newBase
· exact (hfixed 89 (by norm_num) (by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans hv.oldCount
· simpa [m3, splitFrontier_snoc w a done f hfpos] using hCount2
· simp [m3]
· simp [m3]
have hNodeExact : Sem P E (pc + 30) (pc + 3090) (boundaryState (pc + 30) m1)
(fun k z => k ≤ rootNodeBudget cap L w ∧ z = boundaryState (pc + 3090) m2) :=
⟨rfl, k2, z2, hRun2, hPc2, hCost2, hz2⟩
have hTail : Sem P E (pc + 3090) (pc + 3141) (boundaryState (pc + 3090) m2)
(fun k z => k ≤ 51 ∧ z = rankState (pc + 3141) m3 pending.length) := by
refine Sem.mono (Sem.block P E _ rootLevelTailCode _ hTailAt
(by simp [rootLevelTailCode, incrementMetaCode, countdownCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl) ?_
intro k z hQ
have hk : k = 51 := hQ.1
exact ⟨by omega, hQ.2.trans (rootLevelTail_spec E _ done.length pending.length hmeta hjword hn h91 h111)⟩
have hFull := Sem.seq_bound hPointer (fun z _ hz => by
subst z
exact Sem.seq_bound hNodeExact (fun z _ hz => by subst z; exact hTail))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, m3, hQ.2, hv3, hf03⟩)
theorem rootLevelLoop_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L BQ QB : ℕ) (a : F) (fs : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootLevelLoop pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hBQ : 128 ≤ BQ) (hQB : 128 ≤ QB)
(hBQword : BQ + t * cap ≤ 2 ^ E.W) (hQBword : QB + t * cap ≤ 2 ^ E.W)
(hBQsep : QueueWorkspaceSeparated R U D C TB ZB cap BQ t)
(hQBsep : QueueWorkspaceSeparated R U D C TB ZB cap QB t)
(hdisj : BQ + t * cap ≤ QB ∨ QB + t * cap ≤ BQ) (hmeta : (111 : ℕ) < 2 ^ E.W)
(hpos : ∀ f ∈ fs, 0 < f.natDegree) (hmass : frontierMass fs ≤ t)
(hv : RootLevelView b R U D C TB ZB cap L BQ QB a fs [] fs m) :
Sem P E pc (pc + 3143) (rankState pc m fs.length)
(fun k z => k ≤ (rootNodeBudget cap L w + 83) * fs.length + 1 ∧ z.regs = (fun _ => 0) ∧
RootLevelView b R U D C TB ZB cap L BQ QB a fs fs [] z.mem ∧
MemoryFrame (rootLevelWritable R U D C TB cap QB t) m z.mem) := by
let I := fun (n : ℕ) (z : RAMState) => n ≤ fs.length ∧ z.regs = Function.update (fun _ => 0) r9 n ∧
∃ done pending, fs = done ++ pending ∧ pending.length = n ∧
RootLevelView b R U D C TB ZB cap L BQ QB a fs done pending z.mem ∧
MemoryFrame (rootLevelWritable R U D C TB cap QB t) m z.mem
have hframe : ∀ n z pc', I n z → I n { z with pc := pc' } := by
intro n z pc' h
simpa only [I] using h
have hcounter : ∀ n z, I n z → z.regs r9 = n := by
intro n z h
rw [h.2.1, Function.update_self]
obtain ⟨_, _, hBodyAt, hJumpAt⟩ := at_loop hAt
have hbody : ∀ n z, I (n + 1) z → z.pc = pc →
Sem P E (pc + 1) pc { z with pc := pc + 1 }
(fun k z' => k ≤ rootNodeBudget cap L w + 82 ∧ I n z') := by
intro n z hI hpc
obtain ⟨hn, hregs, done, pending, heq, hrem, hvz, hf⟩ := hI
cases pending with
| nil => simp at hrem
| cons f pending =>
have heN : n = pending.length := by simp only [List.length_cons] at hrem; omega
subst n
have hz : { z with pc := pc + 1 } = rankState (pc + 1) z.mem (pending.length + 1) := by
apply ramState_eq_of
· rfl
· rfl
· intro r; exact congrFun hregs r
rw [hz]
have hrun := rootLevelBody_spec b ι t N P E (pc + 1) R U D C TB ZB cap L BQ QB a fs done pending f z.mem
hBodyAt hw hW hdet ht hL hcap hl hwords hBQ hQB hBQword hQBword hBQsep hQBsep hdisj hmeta heq hpos hmass hvz
refine Sem.jmp_append (hAt := hJumpAt) (Sem.mono hrun ?_)
intro k z' hQ
obtain ⟨hk, m', hz', hv', hf'⟩ := hQ
refine ⟨by omega, by omega, ?_⟩
rw [hz']
refine ⟨rfl, done ++ [f], pending, ?_, rfl, hv', MemoryFrame.trans hf hf'⟩
simpa only [List.append_assoc, List.singleton_append] using heq
have hinit : I fs.length (rankState pc m fs.length) := by
refine ⟨le_rfl, rfl, [], fs, by simp, rfl, hv, ?_⟩
intro addr _; rfl
have hloop := Sem.loop_invariant P E pc rootLevelBody hAt (by omega) I
(rootNodeBudget cap L w + 82) hframe hcounter hbody fs.length (rankState pc m fs.length) hinit rfl
refine Sem.mono hloop ?_
intro k z hQ
obtain ⟨hk, _, hregs, done, pending, heq, hrem, hvz, hf⟩ := hQ
have hp : pending = [] := by
cases pending with
| nil => rfl
| cons f pending => simp at hrem
subst pending
have hd : done = fs := by simpa using heq.symm
subst done
refine ⟨hk, ?_, hvz, hf⟩
rw [hregs]
funext r
simp [Function.update_apply]
theorem rootLevelProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L BQ QB : ℕ) (a : F) (fs : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootLevelProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hBQ : 128 ≤ BQ) (hQB : 128 ≤ QB)
(hBQword : BQ + t * cap ≤ 2 ^ E.W) (hQBword : QB + t * cap ≤ 2 ^ E.W)
(hBQsep : QueueWorkspaceSeparated R U D C TB ZB cap BQ t)
(hQBsep : QueueWorkspaceSeparated R U D C TB ZB cap QB t)
(hdisj : BQ + t * cap ≤ QB ∨ QB + t * cap ≤ BQ) (hmeta : (111 : ℕ) < 2 ^ E.W)
(hpos : ∀ f ∈ fs, 0 < f.natDegree) (hmass : frontierMass fs ≤ t)
(hv : RootLevelView b R U D C TB ZB cap L BQ QB a fs [] fs m) :
Sem P E pc (pc + 3146) (boundaryState pc m)
(fun k z => k ≤ (rootNodeBudget cap L w + 83) * fs.length + 4 ∧ ∃ m',
z = boundaryState (pc + 3146) m' ∧ RootLevelView b R U D C TB ZB cap L BQ QB a fs fs [] m' ∧
MemoryFrame (rootLevelWritable R U D C TB cap QB t) m m') := by
have hlen := frontier_length_le_mass fs hpos
have hc : 1 ≤ cap := by omega
have hmul : t ≤ t * cap := by simpa only [Nat.mul_one] using Nat.mul_le_mul_left t hc
have hn : fs.length < 2 ^ E.W := by omega
obtain ⟨hReadAt, hLoopAt⟩ := At.seqStmt hAt
have hRead : Sem P E pc (pc + 3) (boundaryState pc m)
(fun k z => k ≤ 3 ∧ z = rankState (pc + 3) m fs.length) := by
refine Sem.mono (Sem.block P E pc (metaReadCode r9 111) _ hReadAt (by simp [metaReadCode]) rfl) ?_
intro k z hQ
have hk : k = 3 := hQ.1
exact ⟨by omega, hQ.2.trans (rankReadSlot_spec E pc m 111 fs.length hmeta hn hv.remaining)⟩
have hLoop := rootLevelLoop_spec b ι t N P E (pc + 3) R U D C TB ZB cap L BQ QB a fs m hLoopAt
hw hW hdet ht hL hcap hl hwords hBQ hQB hBQword hQBword hBQsep hQBsep hdisj hmeta hpos hmass hv
have hFull := Sem.seq_bound hRead (fun z _ hz => by subst z; exact hLoop)
obtain ⟨hpc, k, z, hrun, hreturn, hk, hregs, hvz, hf⟩ := hFull
refine ⟨hpc, k, z, hrun, hreturn, by omega, z.mem, ?_, hvz, hf⟩
apply ramState_eq_of
· exact hreturn
· rfl
· intro r; exact congrFun hregs r
theorem RootEnvironment.constants {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L : ℕ} {a : F} {m : ℕ → ℕ}
(h : RootEnvironment b R U D C TB ZB cap L a m) : RootConstants b R U D C TB ZB cap L m :=
⟨h.length, h.dimension, h.unit, h.capacity, h.fixedR, h.fixedD, h.fixedU, h.fixedC, h.fixedT, h.fixedZ, h.zero⟩
theorem RootConstants.environment {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L : ℕ} {m : ℕ → ℕ}
(h : RootConstants b R U D C TB ZB cap L m) (a : F) (ha : m 96 = enc b a) :
RootEnvironment b R U D C TB ZB cap L a m :=
⟨h.length, h.dimension, h.unit, h.capacity, ha, h.fixedR, h.fixedD, h.fixedU, h.fixedC, h.fixedT, h.fixedZ, h.zero⟩
theorem root_prepare_writable_le_basis (R U D C TB cap BQ QB T addr : ℕ) (h : rootPrepareMeta addr) :
rootBasisWritable R U D C TB cap BQ QB T addr := by
apply Or.inl
dsimp [rootPrepareMeta] at h
dsimp [rootBasisMeta, rootLevelMeta, rootNodeMeta]
omega
theorem root_tail_writable_le_basis (R U D C TB cap BQ QB T addr : ℕ)
(h : addr = 83 ∨ addr = 84 ∨ addr = 89 ∨ addr = 88 ∨ addr = 112) :
rootBasisWritable R U D C TB cap BQ QB T addr := by
apply Or.inl
dsimp [rootBasisMeta]
omega
theorem RootWorkspace.basis_meta_readonly {R U D C TB ZB cap Q0 Q1 T : ℕ}
(h : RootWorkspace R U D C TB ZB cap) (hQ0 : 128 ≤ Q0) (hQ1 : 128 ≤ Q1)
(slot : ℕ) (hs : slot < 128) (hn : ¬ rootBasisMeta slot) :
¬ rootBasisWritable R U D C TB cap Q0 Q1 T slot := by
intro hbad
rcases hbad with hm | hw | h0 | h1
· exact hn hm
· apply h.compute_meta_readonly slot hs ?_ hw
intro hc
apply hn
dsimp [rootBasisMeta, rootLevelMeta, rootNodeMeta]
first | omega | tauto
· omega
· omega
theorem RootWorkspace.basis_zero_readonly {R U D C TB ZB cap Q0 Q1 T : ℕ}
(h : RootWorkspace R U D C TB ZB cap)
(hQ0 : Q0 + T * cap ≤ ZB ∨ ZB + cap ≤ Q0) (hQ1 : Q1 + T * cap ≤ ZB ∨ ZB + cap ≤ Q1)
(i : ℕ) (hi : i < cap) : ¬ rootBasisWritable R U D C TB cap Q0 Q1 T (ZB + i) := by
have hz := h.Zlow
intro hbad
rcases hbad with hm | hw | h0 | h1
· dsimp [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta] at hm
omega
· exact h.zero_readonly i hi hw
· omega
· omega
theorem RootConstants.of_basis_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L Q0 Q1 T : ℕ} {m m' : ℕ → ℕ}
(h : RootConstants b R U D C TB ZB cap L m) (hl : RootWorkspace R U D C TB ZB cap)
(hQ0 : 128 ≤ Q0) (hQ1 : 128 ≤ Q1)
(hQ0Z : Q0 + T * cap ≤ ZB ∨ ZB + cap ≤ Q0) (hQ1Z : Q1 + T * cap ≤ ZB ∨ ZB + cap ≤ Q1)
(hf : MemoryFrame (rootBasisWritable R U D C TB cap Q0 Q1 T) m m') :
RootConstants b R U D C TB ZB cap L m' := by
have hmeta (slot : ℕ) (hs : slot < 128) (hn : ¬ rootBasisMeta slot) : m' slot = m slot :=
hf slot (hl.basis_meta_readonly hQ0 hQ1 slot hs hn)
refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, h.zero.of_frame hf (hl.basis_zero_readonly hQ0Z hQ1Z)⟩
· exact (hmeta 76 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.length
· exact (hmeta 77 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.dimension
· exact (hmeta 78 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.unit
· exact (hmeta 81 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.capacity
· exact (hmeta 102 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedR
· exact (hmeta 103 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedD
· exact (hmeta 104 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedU
· exact (hmeta 105 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedC
· exact (hmeta 106 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedT
· exact (hmeta 108 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])).trans h.fixedZ
theorem root_level_writable_le_basis (R U D C TB cap BQ QB T addr : ℕ)
(h : rootLevelWritable R U D C TB cap QB T addr) : rootBasisWritable R U D C TB cap BQ QB T addr := by
dsimp [rootLevelWritable, rootNodeWritable] at h
dsimp [rootBasisWritable, rootBasisMeta, rootLevelMeta, rootNodeMeta]
first | omega | tauto
theorem root_basis_writable_swap (R U D C TB cap BQ QB T addr : ℕ) :
rootBasisWritable R U D C TB cap BQ QB T addr ↔ rootBasisWritable R U D C TB cap QB BQ T addr := by
simp only [rootBasisWritable, or_assoc, or_comm, or_left_comm]
theorem rootBasisPrepare_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (E : RAMEnv) (s : RAMState) (j : Fin w) (count : ℕ)
(hmeta : (111 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W) (hc : count < 2 ^ E.W)
(hm88 : s.mem 88 = (j : ℕ)) (hm89 : s.mem 89 = count) :
runBlock rootBasisPrepareCode E s = boundaryState (s.pc + 86) (rootBasisPrepareMemory b s.mem j count) := by
have hcopy : (boundaryState (s.pc + 24) (Function.update s.mem 96 (enc b (b j)))).mem 89 = count := by
simpa [boundaryState] using hm89
rw [rootBasisPrepareCode, runBlock_append, runBlock_append, runBlock_append,
basisScalar_spec b E s j (by omega) hwe hm88,
copyMeta_spec E _ 89 111 count (by omega) hmeta hc hcopy,
setMeta_spec E _ 90 0 (by omega) (by omega),
setMeta_spec E _ 91 0 (by omega) (by omega)] <;> rfl
theorem rootBasisPrepare_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (m : ℕ → ℕ) (j : Fin w) (count : ℕ) :
MemoryFrame rootPrepareMeta m (rootBasisPrepareMemory b m j count) := by
intro addr ha
simp only [rootPrepareMeta] at ha
simp [rootBasisPrepareMemory, Function.update_of_ne (show addr ≠ 91 by omega),
Function.update_of_ne (show addr ≠ 90 by omega), Function.update_of_ne (show addr ≠ 111 by omega),
Function.update_of_ne (show addr ≠ 96 by omega)]
theorem swapMeta_spec (E : RAMEnv) (s : RAMState) (left right x y : ℕ)
(hl : left < 2 ^ E.W) (hr : right < 2 ^ E.W) (hx : x < 2 ^ E.W) (hy : y < 2 ^ E.W)
(hml : s.mem left = x) (hmr : s.mem right = y) :
runBlock (swapMetaCode left right) E s = boundaryState (s.pc + 28)
(Function.update (Function.update s.mem right x) left y) := by
rw [swapMetaCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc (swapMetaCode left right) E s (by
simp [swapMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [swapMetaCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 28 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, Nat.mod_eq_of_lt hl,
Nat.mod_eq_of_lt hr, Nat.mod_eq_of_lt hx, Nat.mod_eq_of_lt hy, hml, hmr, boundaryState]
· intro _; rfl
theorem rootBasisTail_spec (E : RAMEnv) (s : RAMState) (BQ QB count j n : ℕ)
(hmeta : (112 : ℕ) < 2 ^ E.W) (hBQ : BQ < 2 ^ E.W) (hQB : QB < 2 ^ E.W)
(hc : count < 2 ^ E.W) (hj : j + 1 < 2 ^ E.W) (hn : n + 1 < 2 ^ E.W)
(hm83 : s.mem 83 = BQ) (hm84 : s.mem 84 = QB) (hm90 : s.mem 90 = count)
(hm88 : s.mem 88 = j) (hm112 : s.mem 112 = n + 1) :
runBlock rootBasisTailCode E s = rankState (s.pc + 101)
(rootBasisTailMemory s.mem BQ QB count j n) n := by
have hcopy : (boundaryState (s.pc + 28) (Function.update (Function.update s.mem 84 BQ) 83 QB)).mem 90 = count := by
simpa [boundaryState] using hm90
have hinc : (boundaryState (s.pc + 28 + 22)
(Function.update (Function.update (Function.update s.mem 84 BQ) 83 QB) 89 count)).mem 88 = j := by
simpa [boundaryState] using hm88
have hcount : (boundaryState (s.pc + 28 + 22 + 24)
(Function.update (Function.update (Function.update (Function.update s.mem 84 BQ) 83 QB) 89 count) 88 (j + 1))).mem 112 = n + 1 := by
simpa [boundaryState] using hm112
rw [rootBasisTailCode, runBlock_append, runBlock_append, runBlock_append,
swapMeta_spec E s 83 84 BQ QB (by omega) (by omega) hBQ hQB hm83 hm84,
copyMeta_spec E _ 90 89 count (by omega) (by omega) hc hcopy]
change runBlock (countdownCode 112) E
(runBlock (incrementMetaCode 88) E (boundaryState (s.pc + 28 + 22)
(Function.update (Function.update (Function.update s.mem 84 BQ) 83 QB) 89 count))) = _
rw [incrementMeta_spec E _ 88 j (by omega) hj hinc]
change runBlock (countdownCode 112) E (boundaryState (s.pc + 28 + 22 + 24)
(Function.update (Function.update (Function.update (Function.update s.mem 84 BQ) 83 QB) 89 count) 88 (j + 1))) = _
rw [countdown_spec E _ 112 n hmeta hn hcount] <;> rfl
theorem rootBasisTail_frame (m : ℕ → ℕ) (BQ QB count j n : ℕ) :
MemoryFrame (fun addr => addr = 83 ∨ addr = 84 ∨ addr = 89 ∨ addr = 88 ∨ addr = 112)
m (rootBasisTailMemory m BQ QB count j n) := by
intro addr ha
dsimp [rootBasisTailMemory]
simp only [Function.update_of_ne (show addr ≠ 112 by omega), Function.update_of_ne (show addr ≠ 88 by omega),
Function.update_of_ne (show addr ≠ 89 by omega), Function.update_of_ne (show addr ≠ 83 by omega),
Function.update_of_ne (show addr ≠ 84 by omega)]
theorem RootBasisView.prepared {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L BQ QB t j0 n : ℕ}
{fs : List F[X]} {m : ℕ → ℕ} (hv : RootBasisView b R U D C TB ZB cap L BQ QB fs j0 n m)
(j : Fin w) (hl : RootWorkspace R U D C TB ZB cap) (hBQ : 128 ≤ BQ) (hQB : 128 ≤ QB)
(hBQsep : QueueWorkspaceSeparated R U D C TB ZB cap BQ t)
(hQBsep : QueueWorkspaceSeparated R U D C TB ZB cap QB t) :
RootLevelView b R U D C TB ZB cap L BQ QB (b j) fs [] fs (rootBasisPrepareMemory b m j fs.length) := by
let m1 := rootBasisPrepareMemory b m j fs.length
have hf01 : MemoryFrame (rootBasisWritable R U D C TB cap BQ QB t) m m1 :=
(rootBasisPrepare_frame b m j fs.length).mono (root_prepare_writable_le_basis R U D C TB cap BQ QB t)
have hc1 := hv.constants.of_basis_frame hl hBQ hQB hBQsep.QZ hQBsep.QZ hf01
have henv1 := hc1.environment (b j) (by simp [m1, rootBasisPrepareMemory])
have hq1 : FrontierStored b m1 BQ cap fs :=
(((hv.queue.meta_update hBQ 96 (enc b (b j)) (by norm_num)).meta_update hBQ 111 fs.length (by norm_num)).meta_update
hBQ 90 0 (by norm_num)).meta_update hBQ 91 0 (by norm_num)
have hv1 : RootLevelView b R U D C TB ZB cap L BQ QB (b j) fs [] fs m1 := by
refine ⟨henv1, hq1, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· intro k hk; simp [splitFrontier] at hk
· simpa [m1, rootBasisPrepareMemory] using hv.oldBase
· simpa [m1, rootBasisPrepareMemory] using hv.newBase
· simpa [m1, rootBasisPrepareMemory] using hv.count
· simp [m1, rootBasisPrepareMemory, splitFrontier]
· simp [m1, rootBasisPrepareMemory]
· simp [m1, rootBasisPrepareMemory]
exact hv1
theorem RootLevelView.basis_completed {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {R U D C TB ZB cap L BQ QB t : ℕ}
{fs : List F[X]} {m2 : ℕ → ℕ} (j : Fin w) (n : ℕ)
(hv2 : RootLevelView b R U D C TB ZB cap L BQ QB (b j) fs fs [] m2)
(hl : RootWorkspace R U D C TB ZB cap) (hBQ : 128 ≤ BQ) (hQB : 128 ≤ QB)
(hBQsep : QueueWorkspaceSeparated R U D C TB ZB cap BQ t)
(hQBsep : QueueWorkspaceSeparated R U D C TB ZB cap QB t) :
RootBasisView b R U D C TB ZB cap L QB BQ (splitFrontier w (b j) fs) ((j : ℕ) + 1) n
(rootBasisTailMemory m2 BQ QB (splitFrontier w (b j) fs).length (j : ℕ) n) := by
let m3 := rootBasisTailMemory m2 BQ QB (splitFrontier w (b j) fs).length (j : ℕ) n
have hf23 : MemoryFrame (rootBasisWritable R U D C TB cap BQ QB t) m2 m3 :=
(rootBasisTail_frame m2 BQ QB (splitFrontier w (b j) fs).length (j : ℕ) n).mono (root_tail_writable_le_basis R U D C TB cap BQ QB t)
have hq3 : FrontierStored b m3 QB cap (splitFrontier w (b j) fs) :=
((((hv2.newQueue.meta_update hQB 84 BQ (by norm_num)).meta_update hQB 83 QB (by norm_num)).meta_update
hQB 89 (splitFrontier w (b j) fs).length (by norm_num)).meta_update hQB 88 ((j : ℕ) + 1) (by norm_num)).meta_update
hQB 112 n (by norm_num)
have hv3 : RootBasisView b R U D C TB ZB cap L QB BQ (splitFrontier w (b j) fs) ((j : ℕ) + 1) n m3 := by
refine ⟨hv2.environment.constants.of_basis_frame hl hBQ hQB hBQsep.QZ hQBsep.QZ hf23, hq3, ?_, ?_, ?_, ?_, ?_⟩
all_goals simp [m3, rootBasisTailMemory]
exact hv3
theorem rootBasisBody_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L BQ QB n : ℕ) (j : Fin w) (fs : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootBasisBody pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hBQ : 128 ≤ BQ) (hQB : 128 ≤ QB)
(hBQword : BQ + t * cap ≤ 2 ^ E.W) (hQBword : QB + t * cap ≤ 2 ^ E.W)
(hBQsep : QueueWorkspaceSeparated R U D C TB ZB cap BQ t)
(hQBsep : QueueWorkspaceSeparated R U D C TB ZB cap QB t)
(hdisj : BQ + t * cap ≤ QB ∨ QB + t * cap ≤ BQ) (hmeta : (112 : ℕ) < 2 ^ E.W)
(hn : n + 1 < 2 ^ E.W) (hpos : ∀ f ∈ fs, 0 < f.natDegree) (hmass : frontierMass fs ≤ t)
(hv : RootBasisView b R U D C TB ZB cap L BQ QB fs (j : ℕ) (n + 1) m) :
Sem P E pc (pc + 3333) (rankState pc m (n + 1))
(fun k z => k ≤ (rootNodeBudget cap L w + 83) * fs.length + 191 ∧ ∃ m',
z = rankState (pc + 3333) m' n ∧
RootBasisView b R U D C TB ZB cap L QB BQ (splitFrontier w (b j) fs) ((j : ℕ) + 1) n m' ∧
MemoryFrame (rootBasisWritable R U D C TB cap BQ QB t) m m') := by
have hlen := frontier_length_le_mass fs hpos
have hc : 1 ≤ cap := by omega
have hmul : t ≤ t * cap := by simpa only [Nat.mul_one] using Nat.mul_le_mul_left t hc
have hcountWord : fs.length < 2 ^ E.W := by omega
have hBQWord : BQ < 2 ^ E.W := by omega
have hQBWord : QB < 2 ^ E.W := by omega
have hjWord : (j : ℕ) + 1 < 2 ^ E.W := by
have he : E.W < 2 ^ E.W := Nat.lt_two_pow_self
omega
let m1 := rootBasisPrepareMemory b m j fs.length
have hf01 : MemoryFrame (rootBasisWritable R U D C TB cap BQ QB t) m m1 :=
(rootBasisPrepare_frame b m j fs.length).mono (root_prepare_writable_le_basis R U D C TB cap BQ QB t)
have hv1 := hv.prepared j hl hBQ hQB hBQsep hQBsep
obtain ⟨hPrepareAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hLevelAt, hTailAt⟩ := At.seqStmt hRestAt
have hPrepare : Sem P E pc (pc + 86) (rankState pc m (n + 1))
(fun k z => k ≤ 86 ∧ z = boundaryState (pc + 86) m1) := by
refine Sem.mono (Sem.block P E pc rootBasisPrepareCode _ hPrepareAt
(by simp [rootBasisPrepareCode, basisScalarCode, copyMetaCode, setMetaCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl) ?_
intro k z hQ
have hk : k = 86 := hQ.1
exact ⟨by omega, hQ.2.trans (rootBasisPrepare_spec b E _ j fs.length (by omega) (by omega) hcountWord hv.index hv.count)⟩
have hLevel := rootLevelProcedure_spec b ι t N P E (pc + 86) R U D C TB ZB cap L BQ QB (b j) fs m1 hLevelAt
hw hW hdet ht hL hcap hl hwords hBQ hQB hBQword hQBword hBQsep hQBsep hdisj (by omega) hpos hmass hv1
obtain ⟨_, k2, z2, hRun2, hPc2, hCost2, m2, hz2, hv2, hf12raw⟩ := hLevel
have hf12 : MemoryFrame (rootBasisWritable R U D C TB cap BQ QB t) m1 m2 :=
hf12raw.mono (root_level_writable_le_basis R U D C TB cap BQ QB t)
have hf02 := MemoryFrame.trans hf01 hf12
have h88 : m2 88 = (j : ℕ) := by
rw [hf12raw 88 (hl.level_meta_readonly hQB 88 (by norm_num)
(by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta]))]
simpa [m1, rootBasisPrepareMemory] using hv.index
have h112 : m2 112 = n + 1 := by
rw [hf12raw 112 (hl.level_meta_readonly hQB 112 (by norm_num)
(by norm_num [rootLevelMeta, rootNodeMeta, rootComputeMeta]))]
simpa [m1, rootBasisPrepareMemory] using hv.remaining
have hnewPos := splitFrontier_positive w (b j) fs
have hnewMass : frontierMass (splitFrontier w (b j) fs) ≤ t :=
le_trans (splitFrontier_mass_le w (b j) fs (by
intro f hf hz
have hp := hpos f hf
simp [hz] at hp)) hmass
have hnewLen := frontier_length_le_mass (splitFrontier w (b j) fs) hnewPos
have hnewWord : (splitFrontier w (b j) fs).length < 2 ^ E.W := by omega
let m3 := rootBasisTailMemory m2 BQ QB (splitFrontier w (b j) fs).length (j : ℕ) n
have hf23 : MemoryFrame (rootBasisWritable R U D C TB cap BQ QB t) m2 m3 :=
(rootBasisTail_frame m2 BQ QB (splitFrontier w (b j) fs).length (j : ℕ) n).mono (root_tail_writable_le_basis R U D C TB cap BQ QB t)
have hf03 := MemoryFrame.trans hf02 hf23
have hv3 := hv2.basis_completed j n hl hBQ hQB hBQsep hQBsep
have hLevelExact : Sem P E (pc + 86) (pc + 3232) (boundaryState (pc + 86) m1)
(fun k z => k ≤ (rootNodeBudget cap L w + 83) * fs.length + 4 ∧ z = boundaryState (pc + 3232) m2) :=
⟨rfl, k2, z2, hRun2, hPc2, hCost2, hz2⟩
have hTail : Sem P E (pc + 3232) (pc + 3333) (boundaryState (pc + 3232) m2)
(fun k z => k ≤ 101 ∧ z = rankState (pc + 3333) m3 n) := by
refine Sem.mono (Sem.block P E _ rootBasisTailCode _ hTailAt
(by simp [rootBasisTailCode, swapMetaCode, copyMetaCode, incrementMetaCode, countdownCode,
metaReadCode, metaStoreCode, zeroRegsCode]) rfl) ?_
intro k z hQ
have hk : k = 101 := hQ.1
exact ⟨by omega, hQ.2.trans (rootBasisTail_spec E _ BQ QB (splitFrontier w (b j) fs).length (j : ℕ) n
hmeta hBQWord hQBWord hnewWord hjWord hn hv2.oldBase hv2.newBase hv2.newCount h88 h112)⟩
have hFull := Sem.seq_bound hPrepare (fun z _ hz => by
subst z
exact Sem.seq_bound hLevelExact (fun z _ hz => by subst z; exact hTail))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, m3, hQ.2, hv3, hf03⟩)
theorem basis_suffix_eq {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (j : ℕ) (hj : j < w) :
(List.ofFn b).drop j = b ⟨j, hj⟩ :: (List.ofFn b).drop (j + 1) := by
have h : j < (List.ofFn b).length := by simpa using hj
rw [List.drop_eq_getElem_cons h, List.getElem_ofFn]
theorem rootBasisLoop_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L Q0 Q1 : ℕ) (fs0 : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootBasisLoop pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hQ0 : 128 ≤ Q0) (hQ1 : 128 ≤ Q1)
(hQ0word : Q0 + t * cap ≤ 2 ^ E.W) (hQ1word : Q1 + t * cap ≤ 2 ^ E.W)
(hQ0sep : QueueWorkspaceSeparated R U D C TB ZB cap Q0 t)
(hQ1sep : QueueWorkspaceSeparated R U D C TB ZB cap Q1 t)
(hdisj : Q0 + t * cap ≤ Q1 ∨ Q1 + t * cap ≤ Q0) (hmeta : (112 : ℕ) < 2 ^ E.W)
(hpos : ∀ f ∈ fs0, 0 < f.natDegree) (hmass : frontierMass fs0 ≤ t)
(hv : RootBasisView b R U D C TB ZB cap L Q0 Q1 fs0 0 w m) :
Sem P E pc (pc + 3335) (rankState pc m w)
(fun k z => k ≤ ((rootNodeBudget cap L w + 83) * t + 193) * w + 1 ∧ z.regs = (fun _ => 0) ∧
∃ BQ QB fs, ((BQ = Q0 ∧ QB = Q1) ∨ (BQ = Q1 ∧ QB = Q0)) ∧
RootBasisView b R U D C TB ZB cap L BQ QB fs w 0 z.mem ∧
(∀ f ∈ fs, 0 < f.natDegree) ∧ frontierMass fs ≤ t ∧
rootForest w [] fs = rootForest w (List.ofFn b) fs0 ∧
MemoryFrame (rootBasisWritable R U D C TB cap Q0 Q1 t) m z.mem) := by
let I := fun (n : ℕ) (z : RAMState) => n ≤ w ∧ z.regs = Function.update (fun _ => 0) r9 n ∧
∃ BQ QB fs, ((BQ = Q0 ∧ QB = Q1) ∨ (BQ = Q1 ∧ QB = Q0)) ∧
RootBasisView b R U D C TB ZB cap L BQ QB fs (w - n) n z.mem ∧
(∀ f ∈ fs, 0 < f.natDegree) ∧ frontierMass fs ≤ t ∧
rootForest w ((List.ofFn b).drop (w - n)) fs = rootForest w (List.ofFn b) fs0 ∧
MemoryFrame (rootBasisWritable R U D C TB cap Q0 Q1 t) m z.mem
have hframe : ∀ n z pc', I n z → I n { z with pc := pc' } := by
intro n z pc' h
simpa only [I] using h
have hcounter : ∀ n z, I n z → z.regs r9 = n := by
intro n z h
rw [h.2.1, Function.update_self]
have hwWord : w < 2 ^ E.W := by
have he : E.W < 2 ^ E.W := Nat.lt_two_pow_self
omega
obtain ⟨_, _, hBodyAt, hJumpAt⟩ := at_loop hAt
have hbody : ∀ n z, I (n + 1) z → z.pc = pc →
Sem P E (pc + 1) pc { z with pc := pc + 1 }
(fun k z' => k ≤ (rootNodeBudget cap L w + 83) * t + 192 ∧ I n z') := by
intro n z hI hpc
obtain ⟨hn, hregs, BQ, QB, fs, horder, hvz, hposz, hmassz, hforest, hf⟩ := hI
let j : Fin w := ⟨w - (n + 1), by omega⟩
have hgeom : 128 ≤ BQ ∧ 128 ≤ QB ∧ BQ + t * cap ≤ 2 ^ E.W ∧ QB + t * cap ≤ 2 ^ E.W ∧
QueueWorkspaceSeparated R U D C TB ZB cap BQ t ∧ QueueWorkspaceSeparated R U D C TB ZB cap QB t ∧
(BQ + t * cap ≤ QB ∨ QB + t * cap ≤ BQ) := by
rcases horder with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩
· exact ⟨hQ0, hQ1, hQ0word, hQ1word, hQ0sep, hQ1sep, hdisj⟩
· exact ⟨hQ1, hQ0, hQ1word, hQ0word, hQ1sep, hQ0sep, hdisj.elim Or.inr Or.inl⟩
have hz : { z with pc := pc + 1 } = rankState (pc + 1) z.mem (n + 1) := by
apply ramState_eq_of
· rfl
· rfl
· intro r; exact congrFun hregs r
rw [hz]
have hrun := rootBasisBody_spec b ι t N P E (pc + 1) R U D C TB ZB cap L BQ QB n j fs z.mem hBodyAt
hw hW hdet ht hL hcap hl hwords hgeom.1 hgeom.2.1 hgeom.2.2.1 hgeom.2.2.2.1 hgeom.2.2.2.2.1
hgeom.2.2.2.2.2.1 hgeom.2.2.2.2.2.2 hmeta (by omega) hposz hmassz hvz
refine Sem.jmp_append (hAt := hJumpAt) (Sem.mono hrun ?_)
intro k z' hQ
obtain ⟨hk, m', hz', hv', hf'⟩ := hQ
have hlen := frontier_length_le_mass fs hposz
have hmul := Nat.mul_le_mul_left (rootNodeBudget cap L w + 83) (le_trans hlen hmassz)
refine ⟨by omega, by omega, ?_⟩
rw [hz']
have hjnext : (j : ℕ) + 1 = w - n := by dsimp [j]; omega
have hnewMass : frontierMass (splitFrontier w (b j) fs) ≤ t :=
le_trans (splitFrontier_mass_le w (b j) fs (by
intro f hf hz
have hp := hposz f hf
simp [hz] at hp)) hmassz
have hnewForest : rootForest w ((List.ofFn b).drop (w - n)) (splitFrontier w (b j) fs) =
rootForest w (List.ofFn b) fs0 := by
rw [← hjnext, rootForest_split]
have he := basis_suffix_eq b (j : ℕ) j.isLt
rw [← he]
exact hforest
have hnewFrame : MemoryFrame (rootBasisWritable R U D C TB cap Q0 Q1 t) z.mem m' := hf'.mono (by
intro addr ha
rcases horder with horder | horder
· simpa only [horder.1, horder.2] using ha
· have hh := (root_basis_writable_swap R U D C TB cap BQ QB t addr).mp ha
simpa only [horder.1, horder.2] using hh)
refine ⟨rfl, QB, BQ, splitFrontier w (b j) fs, ?_, ?_, splitFrontier_positive w (b j) fs,
hnewMass, hnewForest, MemoryFrame.trans hf hnewFrame⟩
· rcases horder with ⟨rfl, rfl⟩ | ⟨rfl, rfl⟩
· exact Or.inr ⟨rfl, rfl⟩
· exact Or.inl ⟨rfl, rfl⟩
· simpa only [hjnext, rankState, boundaryState] using hv'
have hinit : I w (rankState pc m w) := by
refine ⟨le_rfl, rfl, Q0, Q1, fs0, Or.inl ⟨rfl, rfl⟩, ?_, hpos, hmass, ?_, ?_⟩
· simpa only [Nat.sub_self, rankState, boundaryState] using hv
· simp only [Nat.sub_self, List.drop_zero]
· intro addr _; rfl
have hloop := Sem.loop_invariant P E pc rootBasisBody hAt (by omega) I
((rootNodeBudget cap L w + 83) * t + 192) hframe hcounter hbody w (rankState pc m w) hinit rfl
refine Sem.mono hloop ?_
intro k z hQ
obtain ⟨hk, _, hregs, BQ, QB, fs, horder, hvz, hposz, hmassz, hforest, hf⟩ := hQ
refine ⟨hk, ?_, BQ, QB, fs, horder, ?_, hposz, hmassz, ?_, hf⟩
· rw [hregs]
funext r
simp [Function.update_apply]
· simpa only [Nat.sub_zero] using hvz
· have he : (List.ofFn b).drop w = [] := by
simpa only [List.length_ofFn] using (List.drop_length (l := List.ofFn b))
simpa only [Nat.sub_zero, he] using hforest
theorem rootBasisProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L Q0 Q1 : ℕ) (fs0 : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootBasisProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hQ0 : 128 ≤ Q0) (hQ1 : 128 ≤ Q1)
(hQ0word : Q0 + t * cap ≤ 2 ^ E.W) (hQ1word : Q1 + t * cap ≤ 2 ^ E.W)
(hQ0sep : QueueWorkspaceSeparated R U D C TB ZB cap Q0 t)
(hQ1sep : QueueWorkspaceSeparated R U D C TB ZB cap Q1 t)
(hdisj : Q0 + t * cap ≤ Q1 ∨ Q1 + t * cap ≤ Q0) (hmeta : (112 : ℕ) < 2 ^ E.W)
(hpos : ∀ f ∈ fs0, 0 < f.natDegree) (hmass : frontierMass fs0 ≤ t)
(hv : RootBasisView b R U D C TB ZB cap L Q0 Q1 fs0 0 w m) :
Sem P E pc (pc + 3338) (boundaryState pc m)
(fun k z => k ≤ ((rootNodeBudget cap L w + 83) * t + 193) * w + 4 ∧ ∃ m',
z = boundaryState (pc + 3338) m' ∧ ∃ BQ QB fs,
((BQ = Q0 ∧ QB = Q1) ∨ (BQ = Q1 ∧ QB = Q0)) ∧
RootBasisView b R U D C TB ZB cap L BQ QB fs w 0 m' ∧
(∀ f ∈ fs, 0 < f.natDegree) ∧ frontierMass fs ≤ t ∧
rootForest w [] fs = rootForest w (List.ofFn b) fs0 ∧
MemoryFrame (rootBasisWritable R U D C TB cap Q0 Q1 t) m m') := by
have hn : w < 2 ^ E.W := by
have he : E.W < 2 ^ E.W := Nat.lt_two_pow_self
omega
obtain ⟨hReadAt, hLoopAt⟩ := At.seqStmt hAt
have hRead : Sem P E pc (pc + 3) (boundaryState pc m)
(fun k z => k ≤ 3 ∧ z = rankState (pc + 3) m w) := by
refine Sem.mono (Sem.block P E pc (metaReadCode r9 112) _ hReadAt (by simp [metaReadCode]) rfl) ?_
intro k z hQ
have hk : k = 3 := hQ.1
exact ⟨by omega, hQ.2.trans (rankReadSlot_spec E pc m 112 w hmeta hn hv.remaining)⟩
have hLoop := rootBasisLoop_spec b ι t N P E (pc + 3) R U D C TB ZB cap L Q0 Q1 fs0 m hLoopAt
hw hW hdet ht hL hcap hl hwords hQ0 hQ1 hQ0word hQ1word hQ0sep hQ1sep hdisj hmeta hpos hmass hv
have hFull := Sem.seq_bound hRead (fun z _ hz => by subst z; exact hLoop)
obtain ⟨hpc, k, z, hrun, hreturn, hk, hregs, BQ, QB, fs, horder, hvz, hposz, hmassz, hforest, hf⟩ := hFull
refine ⟨hpc, k, z, hrun, hreturn, by omega, z.mem, ?_, BQ, QB, fs, horder, hvz, hposz, hmassz, hforest, hf⟩
apply ramState_eq_of
· exact hreturn
· rfl
· intro r; exact congrFun hregs r
theorem fieldPosition_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (E : RAMEnv) (s : RAMState) (v : F)
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hN : N < 2 ^ E.W) (hv : s.regs r10 = enc b v) :
runBlock fieldPositionCode E s =
{ s with pc := s.pc + 4, regs := Function.update (Function.update (Function.update s.regs r15 (detPosBase w)) r14 (detPosBase w + enc b v)) r10 (posTab N ι v) } := by
have hend : detEnd w < 2 ^ E.W := by rw [hW]; exact detEnd_lt hw
have hbase : detPosBase w < 2 ^ E.W := by
have hpos := Nat.two_pow_pos w
unfold detEnd detImgBase at hend
omega
have haddr : detPosBase w + enc b v < 2 ^ E.W := by
have hvlt := enc_lt b v
unfold detEnd detImgBase at hend
omega
have h9 : (9 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (9 : ℕ) < 2 ^ 8) hp
have hh : E.det 9 = detPosBase w := by
rw [hdet.1 9 (by decide), detStd_hdr t N w b ι (by decide : 9 < 13)]
rfl
have ht : E.det (detPosBase w + enc b v) = posTab N ι v := by
rw [hdet.2 _ (by have h := detMulBase_le_detPosBase w; omega), detStd_pos t N b ι (enc_lt b v), dec_enc]
have hpWord : posTab N ι v < 2 ^ E.W := lt_of_le_of_lt (posTab_le N ι v) hN
apply ramState_eq_of
· simp [fieldPositionCode, runBlock_cons, runBlock_nil, execInstr] <;> omega
· rfl
· intro r
fin_cases r <;> simp [fieldPositionCode, runBlock_cons, runBlock_nil, execInstr, hv, hh, ht,
Nat.mod_eq_of_lt h9, Nat.mod_eq_of_lt hbase, Nat.mod_eq_of_lt haddr, Nat.mod_eq_of_lt hpWord]
theorem leafPosition_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (E : RAMEnv) (s : RAMState)
(src cap : ℕ) (f : F[X]) (hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (99 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ E.W) (hsrc : src + cap ≤ 2 ^ E.W) (hcap : 2 ≤ cap)
(hf : PolynomialStored b s.mem src cap f) (hm99 : s.mem 99 = src) (hm77 : s.mem 77 = w) :
∃ z, runBlock leafPositionCode E s = z ∧ z.pc = s.pc + 33 ∧ z.mem = s.mem ∧
z.regs r10 = posTab N ι ((linearRoot f)⁻¹) := by
have hwe : w ≤ E.W := by omega
have hsmall (i : ℕ) (hi : i ≤ 99) : i % 2 ^ E.W = i := Nat.mod_eq_of_lt (by omega)
have hEnc (v : F) : enc b v % 2 ^ E.W = enc b v :=
Nat.mod_eq_of_lt (lt_of_lt_of_le (enc_lt b v) (Nat.pow_le_pow_right (by norm_num) hwe))
have hSrc : src % 2 ^ E.W = src := Nat.mod_eq_of_lt (by omega)
have hSrc1 : (src + 1) % 2 ^ E.W = src + 1 := Nat.mod_eq_of_lt (by omega)
have hdim : w % 2 ^ E.W = w := Nat.mod_eq_of_lt (by have he : E.W < 2 ^ E.W := Nat.lt_two_pow_self; omega)
have hm0 : s.mem src = enc b (f.coeff 0) := by simpa only [Nat.add_zero] using hf 0 (by omega)
have hm1 : s.mem (src + 1) = enc b (f.coeff 1) := hf 1 (by omega)
let sA := runBlock leafCoefficientOneCode E s
have hA3 : sA.regs r3 = w := by
simp [sA, leafCoefficientOneCode, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil,
execInstr, hsmall, hm99, hm77, hSrc, hSrc1, hm1, hEnc, hdim]
have hA10 : sA.regs r10 = enc b (f.coeff 1) := by
simp [sA, leafCoefficientOneCode, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil,
execInstr, hsmall, hm99, hm77, hSrc, hSrc1, hm1, hEnc, hdim]
let sB := runBlock fieldInvCode E sA
have hB := fieldInvCode_spec b ι t N E sA (f.coeff 1) hw hW hdet hA10
have hB3 : sB.regs r3 = w := by dsimp only [sB]; rw [hB]; simpa using hA3
have hB10 : sB.regs r10 = enc b ((f.coeff 1)⁻¹) := by dsimp only [sB]; rw [hB]; simp
let sC := runBlock [iBor r11 r10 r10] E sB
have hC3 : sC.regs r3 = w := by simp [sC, runBlock_cons, runBlock_nil, execInstr, hB3]
have hC11 : sC.regs r11 = enc b ((f.coeff 1)⁻¹) := by
simp [sC, runBlock_cons, runBlock_nil, execInstr, hB10, hEnc]
have hCmem : sC.mem = s.mem := rfl
let sD := runBlock leafCoefficientZeroCode E sC
have hD3 : sD.regs r3 = w := by
simp [sD, leafCoefficientZeroCode, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr, hC3]
have hD11 : sD.regs r11 = enc b ((f.coeff 1)⁻¹) := by
simp [sD, leafCoefficientZeroCode, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr, hC11]
have hD10 : sD.regs r10 = enc b (f.coeff 0) := by
simp [sD, leafCoefficientZeroCode, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil,
execInstr, hsmall, hCmem, hm99, hSrc, hm0, hEnc]
let sE := runBlock fieldMulCode E sD
have hE := fieldMulCode_spec b ι t N E sD (f.coeff 0) (f.coeff 1)⁻¹ hw hW hdet hD3 hD10 hD11
have hroot : f.coeff 0 * (f.coeff 1)⁻¹ = linearRoot f := by
haveI : CharP F 2 := pinsketch_charP
simp [linearRoot, div_eq_mul_inv, CharTwo.neg_eq]
have hE10 : sE.regs r10 = enc b (linearRoot f) := by dsimp only [sE]; rw [hE]; simp [hroot]
let sF := runBlock fieldInvCode E sE
have hF := fieldInvCode_spec b ι t N E sE (linearRoot f) hw hW hdet hE10
have hF10 : sF.regs r10 = enc b ((linearRoot f)⁻¹) := by dsimp only [sF]; rw [hF]; simp
let sG := runBlock fieldPositionCode E sF
have hG := fieldPosition_spec b ι t N E sF (linearRoot f)⁻¹ hw hW hdet hN hF10
have hG10 : sG.regs r10 = posTab N ι ((linearRoot f)⁻¹) := by dsimp only [sG]; rw [hG]; simp
have hFull : runBlock leafPositionCode E s = sG := by
simp only [leafPositionCode, runBlock_append]
rfl
refine ⟨sG, hFull, ?_, rfl, hG10⟩
have hp := runBlock_pc leafPositionCode E s (by
simp [leafPositionCode, leafCoefficientOneCode, leafCoefficientZeroCode, metaReadCode,
fieldInvCode, fieldMulCode, fieldPositionCode])
rw [hFull] at hp
exact hp
theorem OutputStored.meta_update {m : ℕ → ℕ} {B : ℕ} {xs : List ℕ}
(h : OutputStored m B xs) (hB : 128 ≤ B) (slot value : ℕ) (hs : slot < 128) :
OutputStored (Function.update m slot value) B xs := by
intro j hj
rw [Function.update_of_ne (by omega : B + j ≠ slot)]
exact h j hj
theorem OutputStored.append_update {m : ℕ → ℕ} {B v : ℕ} {xs : List ℕ} (h : OutputStored m B xs) :
OutputStored (Function.update m (B + xs.length) v) B (xs ++ [v]) := by
intro j hj
by_cases hlt : j < xs.length
· rw [List.getD_append xs [v] 0 j hlt, Function.update_of_ne (by omega : B + j ≠ B + xs.length)]
exact h j hlt
· have heq : j = xs.length := by simp only [List.length_append, List.length_singleton] at hj; omega
subst j
rw [List.getD_append_right xs [v] 0 xs.length le_rfl, Nat.sub_self, Function.update_self]
rfl
theorem positionValidBit_le (p : ℕ) : positionValidBit p ≤ 1 := by
by_cases hp : 0 < p <;> simp [positionValidBit, hp]
/-- One legal-position test updates the flag and saturates the missing-position
sentinel to output index zero. Missing positions cannot be accepted later. -/
theorem positionFlag_spec (E : RAMEnv) (s : RAMState) (p flag : ℕ)
(hmeta : (100 : ℕ) < 2 ^ E.W) (hp : p < 2 ^ E.W) (hf : flag ≤ 1)
(h10 : s.regs r10 = p) (hm100 : s.mem 100 = flag) :
∃ z, runBlock positionFlagCode E s = z ∧ z.pc = s.pc + 10 ∧
z.mem = Function.update s.mem 100 (flag * positionValidBit p) ∧ z.regs r10 = p - 1 := by
have hbit := positionValidBit_le p
have hprod : flag * positionValidBit p ≤ 1 := by
exact le_trans (Nat.mul_le_mul hf hbit) (by norm_num)
have h100 : (100 : ℕ) % 2 ^ E.W = 100 := Nat.mod_eq_of_lt hmeta
have hflag : flag % 2 ^ E.W = flag := Nat.mod_eq_of_lt (by omega)
have hb : positionValidBit p % 2 ^ E.W = positionValidBit p := Nat.mod_eq_of_lt (by omega)
have hprodWord : (flag * positionValidBit p) % 2 ^ E.W = flag * positionValidBit p := Nat.mod_eq_of_lt (by omega)
let z0 := runBlock ([iImm r0 0, iLt r11 r0 r10] ++ metaReadCode r1 100 ++ [iMul r1 r1 r11]) E s
have h011 : z0.regs r11 = positionValidBit p := by
by_cases hp0 : 0 < p <;>
simp [z0, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
h10, positionValidBit, hp0, h100, hm100, Nat.mod_eq_of_lt (show 1 < 2 ^ E.W by omega)]
have h01 : z0.regs r1 = flag * positionValidBit p := by
by_cases hp0 : 0 < p <;>
simp [z0, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
h10, positionValidBit, hp0, h100, hm100, hflag, Nat.mod_eq_of_lt (show 1 < 2 ^ E.W by omega)]
have h010 : z0.regs r10 = p := by
simp [z0, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr, h10]
let z1 := runBlock (metaStoreCode r1 100 ++ [iSub r10 r10 r11]) E z0
have hm : z1.mem = Function.update s.mem 100 (flag * positionValidBit p) := by
simp [z1, runBlock_append, metaStore_spec, runBlock_cons, runBlock_nil, execInstr, h100, h01] <;> rfl
have hv : z1.regs r10 = p - 1 := by
simp only [z1, runBlock_append, metaStore_spec E _ r1 100 (by decide), runBlock_cons, runBlock_nil,
execInstr, Function.update_self, Function.update_of_ne (by decide : r10 ≠ r15), Function.update_of_ne (by decide : r11 ≠ r15)]
rw [h010, h011]
exact position_index_word p (2 ^ E.W) (by omega) hp
have he : runBlock positionFlagCode E s = z1 := by simp only [positionFlagCode, runBlock_append]; rfl
refine ⟨z1, he, ?_, hm, hv⟩
have hpc := runBlock_pc positionFlagCode E s (by simp [positionFlagCode, metaReadCode, metaStoreCode])
rw [he] at hpc
exact hpc
/-- Append the index in register 10 and advance the output count. -/
theorem positionAppend_spec (E : RAMEnv) (s : RAMState) (B n idx : ℕ)
(hmeta : (101 : ℕ) < 2 ^ E.W) (hB : B < 2 ^ E.W) (hn : n + 1 < 2 ^ E.W)
(haddr : B + n < 2 ^ E.W) (hidx : idx < 2 ^ E.W)
(h10 : s.regs r10 = idx) (hm85 : s.mem 85 = B) (hm101 : s.mem 101 = n) :
runBlock positionAppendCode E s = boundaryState (s.pc + 29)
(Function.update (Function.update s.mem (B + n) idx) 101 (n + 1)) := by
have hsmall (i : ℕ) (hi : i ≤ 101) : i % 2 ^ E.W = i := Nat.mod_eq_of_lt (by omega)
have hBmod := Nat.mod_eq_of_lt hB
have hnmod : n % 2 ^ E.W = n := Nat.mod_eq_of_lt (by omega)
let sA := runBlock (metaReadCode r2 85 ++ metaReadCode r9 101) E s
have hA2 : sA.regs r2 = B := by
simp [sA, runBlock_append, metaRead_spec, hsmall, hm85, hm101, hBmod, hnmod]
have hA9 : sA.regs r9 = n := by
simp [sA, runBlock_append, metaRead_spec, hsmall, hm85, hm101, hBmod, hnmod]
have hA10 : sA.regs r10 = idx := by
simp [sA, runBlock_append, metaRead_spec, h10]
let sB := runBlock [iAdd r2 r2 r9, iSt r2 r10, iImm r6 1, iAdd r9 r9 r6] E sA
have hB9 : sB.regs r9 = n + 1 := by
simp [sB, runBlock_cons, runBlock_nil, execInstr, hA9,
Nat.mod_eq_of_lt (show 1 < 2 ^ E.W by omega), Nat.mod_eq_of_lt hn]
have hBmem : sB.mem = Function.update s.mem (B + n) idx := by
simp [sB, runBlock_cons, runBlock_nil, execInstr, hA2, hA9, hA10, Nat.mod_eq_of_lt haddr] <;> rfl
let sC := runBlock (metaStoreCode r9 101) E sB
have hCmem : sC.mem = Function.update (Function.update s.mem (B + n) idx) 101 (n + 1) := by
dsimp only [sC]
rw [metaStore_spec E _ r9 101 (by decide)]
change Function.update sB.mem (101 % 2 ^ E.W) (sB.regs r9) = _
rw [hsmall 101 le_rfl, hB9, hBmem]
have hFull : runBlock positionAppendCode E s = boundaryState (sC.pc + 16) sC.mem := by
have he : runBlock positionAppendCode E s = runBlock zeroRegsCode E sC := by
simp only [positionAppendCode, runBlock_append]
rfl
rw [he, zeroRegs_spec]
have hpc : sC.pc + 16 = s.pc + 29 := by
have hp := runBlock_pc positionAppendCode E s (by
simp [positionAppendCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [hFull] at hp
exact hp
rw [hFull, hpc, hCmem]
theorem emitPosition_spec (E : RAMEnv) (s : RAMState) (B n p flag : ℕ)
(hmeta : (101 : ℕ) < 2 ^ E.W) (hB : 128 ≤ B) (hn : n + 1 < 2 ^ E.W)
(haddr : B + n < 2 ^ E.W) (hp : p < 2 ^ E.W) (hf : flag ≤ 1)
(h10 : s.regs r10 = p) (hm85 : s.mem 85 = B) (hm101 : s.mem 101 = n) (hm100 : s.mem 100 = flag) :
runBlock emitPositionCode E s = boundaryState (s.pc + 39) (emitPositionMemory s.mem B n p flag) := by
obtain ⟨z, hz, hpc, hmem, hidx⟩ := positionFlag_spec E s p flag (by omega) hp hf h10 hm100
have hz85 : z.mem 85 = B := by rw [hmem]; simpa using hm85
have hz101 : z.mem 101 = n := by rw [hmem]; simpa using hm101
rw [emitPositionCode, runBlock_append, hz,
positionAppend_spec E z B n (p - 1) hmeta (by omega) hn haddr (by omega) hidx hz85 hz101]
rw [hpc, hmem]
rfl
theorem emitPosition_stored {m : ℕ → ℕ} {B p flag : ℕ} {xs : List ℕ}
(h : OutputStored m B xs) (hB : 128 ≤ B) :
OutputStored (emitPositionMemory m B xs.length p flag) B (xs ++ [p - 1]) :=
((h.meta_update hB 100 (flag * positionValidBit p) (by norm_num)).append_update).meta_update
hB 101 (xs.length + 1) (by norm_num)
theorem emitPosition_frame (m : ℕ → ℕ) (B n p flag : ℕ) :
MemoryFrame (fun addr => addr = 100 ∨ addr = 101 ∨ addr = B + n) m (emitPositionMemory m B n p flag) :=
MemoryFrame.trans
(MemoryFrame.trans (MemoryFrame.update_allowed _ m 100 (flag * positionValidBit p) (Or.inl rfl))
(MemoryFrame.update_allowed _ _ (B + n) (p - 1) (Or.inr (Or.inr rfl))))
(MemoryFrame.update_allowed _ _ 101 (n + 1) (Or.inr (Or.inl rfl)))
theorem degreeBelowLoad_spec (E : RAMEnv) (pc : ℕ) (m : ℕ → ℕ) (threshold d : ℕ)
(hmeta : (95 : ℕ) < 2 ^ E.W) (ht : threshold < 2 ^ E.W)
(hd : d < 2 ^ E.W) (hm95 : m 95 = d) :
runBlock (degreeBelowLoadCode threshold) E (boundaryState pc m) = padeTestState (pc + 4) m threshold d := by
rw [degreeBelowLoadCode, runBlock_append, metaRead_spec E _ r1 95 (by decide)]
have h95 : (95 : ℕ) % 2 ^ E.W = 95 := Nat.mod_eq_of_lt hmeta
apply ramState_eq_of
· rfl
· rfl
· intro r
fin_cases r <;> simp [runBlock_cons, runBlock_nil, execInstr, boundaryState, padeTestState,
h95, Nat.mod_eq_of_lt ht, Nat.mod_eq_of_lt hd, hm95]
theorem degreeBelowBranch_spec (P : Program) (E : RAMEnv) (pc threshold : ℕ) (body : Stmt)
(m : ℕ → ℕ) (d B : ℕ) (Q : (ℕ → ℕ) → Prop)
(hAt : At P pc (Stmt.compile (degreeBelowBranch threshold body) pc))
(hmeta : (95 : ℕ) < 2 ^ E.W) (hthreshold : threshold < 2 ^ E.W) (hd : d < 2 ^ E.W) (hm95 : m 95 = d)
(hcall : d < threshold → ∀ base, At P base (Stmt.compile body base) →
Sem P E base (base + body.len) (boundaryState base m)
(fun k z => k ≤ B ∧ z.regs = (fun _ => 0) ∧ Q z.mem))
(hstop : ¬ d < threshold → Q m) :
Sem P E pc (pc + (degreeBelowBranch threshold body).len) (boundaryState pc m)
(fun k z => k ≤ B + 23 ∧ z.regs = (fun _ => 0) ∧ Q z.mem) := by
obtain ⟨hLoadAt, hIfAt⟩ := At.seqStmt hAt
obtain ⟨_, _, hTrueAt, _, hFalseAt, _⟩ := at_ite hIfAt
obtain ⟨hZeroAt, hBodyAt⟩ := At.seqStmt hTrueAt
have hLoad : Sem P E pc (pc + 4) (boundaryState pc m)
(fun k z => k ≤ 4 ∧ z = padeTestState (pc + 4) m threshold d) := by
refine Sem.mono (Sem.block P E pc (degreeBelowLoadCode threshold) _ hLoadAt
(by simp [degreeBelowLoadCode, metaReadCode]) rfl) ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
exact ⟨by change k = 4 at hk; omega, hz.trans (degreeBelowLoad_spec E pc m threshold d hmeta hthreshold hd hm95)⟩
let c : Cond := .lt r15 r1 r0
let a := pc + 4
let z0 := padeTestState a m threshold d
let endpc := a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + (Stmt.code zeroRegsCode).len + 3
have hIf : Sem P E a endpc z0
(fun k z => k ≤ B + 19 ∧ z.regs = (fun _ => 0) ∧ Q z.mem) := by
apply Sem.ite P E a c (Stmt.seq (Stmt.code zeroRegsCode) body) (Stmt.code zeroRegsCode) z0 _ hIfAt (by omega) rfl
· intro hgo
have hg : d < threshold := hgo
have hZero := Sem.zero_block P E (a + 2) { runBlock c.code E z0 with pc := a + 2 } hZeroAt rfl
have hBody := hcall hg (a + 18) hBodyAt
have hTrue := Sem.seq_bound hZero (fun z _ hz => by subst z; exact hBody)
have htend : a + c.code.length + 1 + (Stmt.seq (Stmt.code zeroRegsCode) body).len = a + 18 + body.len := by
simp only [c, Cond.code, Stmt.len, zeroRegsCode, List.length_cons, List.length_nil]
omega
rw [htend]
refine Sem.mono hTrue ?_
intro k z hQ
exact ⟨by change 1 + 1 + k + 1 ≤ B + 19; omega, hQ.2.1, hQ.2.2⟩
· intro hno
have hng : ¬ d < threshold := hno
have hFalseAt' : At P (a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2) zeroRegsCode := by
have hh : At P (a + c.code.length + 1 + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 1) zeroRegsCode := hFalseAt
have heq : a + c.code.length + 1 + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 1 =
a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2 := by omega
rw [heq] at hh
exact hh
have hZero := Sem.zero_block P E (a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2)
{ runBlock c.code E z0 with pc := a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2 } hFalseAt' rfl
have hfend : a + c.code.length + 1 + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 1 + (Stmt.code zeroRegsCode).len =
(a + c.code.length + (Stmt.seq (Stmt.code zeroRegsCode) body).len + 2) + 16 := by
simp only [Stmt.len, zeroRegsCode, List.length_cons, List.length_nil]
omega
rw [hfend]
refine Sem.mono hZero ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
refine ⟨by change 1 + 1 + k + 1 ≤ B + 19; omega, ?_, ?_⟩
· rw [hz]; rfl
· rw [hz]
exact hstop hng
have hFull := Sem.seq_bound hLoad (fun z _ hz => by subst z; exact hIf)
have hpc : endpc = pc + (degreeBelowBranch threshold body).len := by
simp only [endpc, a, c, degreeBelowBranch, Stmt.len, Cond.code, List.length_singleton, degreeBelowLoadCode,
metaReadCode, List.length_append, List.length_cons, List.length_nil]
omega
rw [hpc] at hFull
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem rootPositionList_append {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (us vs : List F) :
rootPositionList N ι (us ++ vs) = rootPositionList N ι us ++ rootPositionList N ι vs := by
simp [rootPositionList]
theorem rootPositionFlag_append {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (us vs : List F) :
rootPositionFlag N ι (us ++ vs) = rootPositionFlag N ι us * rootPositionFlag N ι vs := by
simp [rootPositionFlag, List.prod_append]
theorem rootPositionFlag_le_one {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (us : List F) :
rootPositionFlag N ι us ≤ 1 := by
induction us with
| nil => simp [rootPositionFlag]
| cons u us ih =>
change positionValidBit (posTab N ι u⁻¹) * rootPositionFlag N ι us ≤ 1
exact le_trans (Nat.mul_le_mul (positionValidBit_le _) ih) (by norm_num)
theorem leafEmissionProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc src cap B : ℕ) (f : F[X]) (xs : List ℕ) (flag : ℕ) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile leafEmissionProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (101 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ E.W) (hsrc : src + cap ≤ 2 ^ E.W) (hcap : 2 ≤ cap)
(hB : 128 ≤ B) (hn : xs.length + 1 < 2 ^ E.W) (haddr : B + xs.length < 2 ^ E.W) (hflag : flag ≤ 1)
(hf : PolynomialStored b m src cap f) (hout : OutputStored m B xs)
(hm99 : m 99 = src) (hm77 : m 77 = w) (hm85 : m 85 = B) (hm101 : m 101 = xs.length) (hm100 : m 100 = flag) :
Sem P E pc (pc + 72) (boundaryState pc m)
(fun k z => k ≤ 72 ∧ ∃ m', z = boundaryState (pc + 72) m' ∧
m' 100 = flag * positionValidBit (posTab N ι ((linearRoot f)⁻¹)) ∧ m' 101 = xs.length + 1 ∧
OutputStored m' B (xs ++ [posTab N ι ((linearRoot f)⁻¹) - 1]) ∧
MemoryFrame (fun addr => addr = 100 ∨ addr = 101 ∨ addr = B + xs.length) m m') := by
let p := posTab N ι ((linearRoot f)⁻¹)
let m' := emitPositionMemory m B xs.length p flag
obtain ⟨z, hz, hzpc, hzmem, hz10⟩ := leafPosition_spec b ι t N E (boundaryState pc m) src cap f hw hW hdet
(by omega) hN hsrc hcap hf hm99 hm77
have hp : p < 2 ^ E.W := lt_of_le_of_lt (posTab_le N ι _) hN
have hz85 : z.mem 85 = B := by rw [hzmem]; exact hm85
have hz101 : z.mem 101 = xs.length := by rw [hzmem]; exact hm101
have hz100 : z.mem 100 = flag := by rw [hzmem]; exact hm100
have hrun : runBlock (leafPositionCode ++ emitPositionCode) E (boundaryState pc m) = boundaryState (pc + 72) m' := by
rw [runBlock_append, hz, emitPosition_spec E z B xs.length p flag hmeta hB hn haddr hp hflag hz10 hz85 hz101 hz100,
hzpc, hzmem]
rfl
have hblock := Sem.boundary_block P E pc (leafPositionCode ++ emitPositionCode) m m' hAt
(by simp [leafPositionCode, leafCoefficientOneCode, leafCoefficientZeroCode, fieldPositionCode, fieldInvCode,
fieldMulCode, emitPositionCode, positionFlagCode, positionAppendCode, metaReadCode, metaStoreCode, zeroRegsCode]) hrun
change Sem P E pc (pc + 72) (boundaryState pc m)
(fun k z => k ≤ 72 ∧ z = boundaryState (pc + 72) m') at hblock
refine Sem.mono hblock ?_
intro k z hQ
refine ⟨by omega, m', hQ.2, ?_, ?_, emitPosition_stored hout hB, emitPosition_frame m B xs.length p flag⟩
· simp [m', emitPositionMemory, p, show 100 ≠ B + xs.length by omega]
· simp [m', emitPositionMemory]
theorem leafKeepProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc src cap B T : ℕ) (f : F[X]) (us : List F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile leafKeepProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (101 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ E.W)
(hsrc : 128 ≤ src) (hSword : src + cap ≤ 2 ^ E.W) (hcap : 2 ≤ cap)
(hB : 128 ≤ B) (hBword : B + T ≤ 2 ^ E.W) (hroom : f.natDegree = 1 → us.length < T)
(hFpos : 0 < f.natDegree) (hdeg : f.natDegree < cap)
(hf : PolynomialStored b m src cap f) (hout : OutputStored m B (rootPositionList N ι us))
(hm99 : m 99 = src) (hm77 : m 77 = w) (hm81 : m 81 = cap) (hm85 : m 85 = B)
(hm101 : m 101 = us.length) (hm100 : m 100 = rootPositionFlag N ι us) :
Sem P E pc (pc + 182) (boundaryState pc m)
(fun k z => k ≤ 17 * cap + 150 ∧ z.regs = (fun _ => 0) ∧
z.mem 100 = rootPositionFlag N ι (us ++ traceRootSearch w [] f) ∧
z.mem 101 = (us ++ traceRootSearch w [] f).length ∧
OutputStored z.mem B (rootPositionList N ι (us ++ traceRootSearch w [] f)) ∧
MemoryFrame (leafKeepWritable B us.length f.natDegree) m z.mem) := by
let m1 := Function.update (Function.update m 64 src) 66 cap
let m2 := Function.update m1 95 (degreeScan f cap)
have hcapWord : cap < 2 ^ E.W := by omega
have hsrcWord : src < 2 ^ E.W := by omega
have hwe : w ≤ E.W := by omega
have hfne : f ≠ 0 := by intro hz; simp [hz] at hFpos
have hscan := degreeScan_eq f hfne cap hdeg
have hmarker : degreeScan f cap < 3 ↔ f.natDegree = 1 := by rw [hscan]; omega
have hm2meta (slot : ℕ) (hlo : 72 ≤ slot) (hne : slot ≠ 95) : m2 slot = m slot := by
simp [m2, m1, hne, show slot ≠ 64 by omega, show slot ≠ 66 by omega]
have hout2 : OutputStored m2 B (rootPositionList N ι us) :=
((hout.meta_update hB 64 src (by norm_num)).meta_update hB 66 cap (by norm_num)).meta_update
hB 95 (degreeScan f cap) (by norm_num)
have hf1 := (hf.meta_update hsrc 64 src (by norm_num)).meta_update hsrc 66 cap (by norm_num)
have hf2 := hf1.meta_update hsrc 95 (degreeScan f cap) (by norm_num)
let Q := fun m' => m' 100 = rootPositionFlag N ι (us ++ traceRootSearch w [] f) ∧
m' 101 = (us ++ traceRootSearch w [] f).length ∧
OutputStored m' B (rootPositionList N ι (us ++ traceRootSearch w [] f)) ∧
MemoryFrame (leafKeepWritable B us.length f.natDegree) m m'
have hf01 : MemoryFrame (leafKeepWritable B us.length f.natDegree) m m1 :=
MemoryFrame.trans (MemoryFrame.update_allowed _ m 64 src (Or.inl rfl))
(MemoryFrame.update_allowed _ _ 66 cap (Or.inr (Or.inl rfl)))
have hf02 : MemoryFrame (leafKeepWritable B us.length f.natDegree) m m2 :=
MemoryFrame.trans hf01 (MemoryFrame.update_allowed _ _ 95 _ (Or.inr (Or.inr (Or.inl rfl))))
obtain ⟨hSetupAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hScanAt, hKeepAt⟩ := At.seqStmt hRestAt
have hSetup : Sem P E pc (pc + 28) (boundaryState pc m)
(fun k z => k ≤ 28 ∧ z = boundaryState (pc + 28) m1) := by
exact Sem.boundary_block P E _ (scanSetupCode 99) m m1 hSetupAt
(by simp [scanSetupCode, metaReadCode, metaStoreCode, zeroRegsCode])
(scanSetup_spec E _ 99 src cap (by omega) (by omega) hsrcWord hcapWord hm99 hm81)
have hScan := scanProcedure_spec b P E (pc + 28) src cap f m1 hScanAt (by omega) hwe
hsrcWord hcapWord hSword hf1 (by simp [m1]) (by simp [m1])
have hBranch := degreeBelowBranch_spec P E (pc + 70) 3 leafEmissionProcedure m2 (degreeScan f cap) 72 Q
hKeepAt (by omega) (by omega) (lt_of_le_of_lt (degreeScan_le _ _) hcapWord) (by simp [m2])
(by
intro hgo base hBodyAt
have hlinear := hmarker.mp hgo
have hroom' := hroom hlinear
have hnWord : (rootPositionList N ι us).length + 1 < 2 ^ E.W := by
simp only [rootPositionList, List.length_map]
omega
have hEmission := leafEmissionProcedure_spec b ι t N P E base src cap B f (rootPositionList N ι us)
(rootPositionFlag N ι us) m2 hBodyAt hw hW hdet hmeta hN hSword hcap hB hnWord
(by simp only [rootPositionList, List.length_map]; omega) (rootPositionFlag_le_one N ι us) hf2 hout2
((hm2meta 99 (by norm_num) (by norm_num)).trans hm99)
((hm2meta 77 (by norm_num) (by norm_num)).trans hm77)
((hm2meta 85 (by norm_num) (by norm_num)).trans hm85)
(by simpa only [rootPositionList, List.length_map] using (hm2meta 101 (by norm_num) (by norm_num)).trans hm101)
((hm2meta 100 (by norm_num) (by norm_num)).trans hm100)
refine Sem.mono hEmission ?_
intro k z hPost
obtain ⟨hk, m3, hz, h100, h101, hstore, hf23⟩ := hPost
refine ⟨hk, ?_, ?_⟩
· rw [hz]; rfl
· change Q z.mem
rw [hz]
dsimp only [Q]
have hr : traceRootSearch w [] f = [linearRoot f] := by simp [traceRootSearch, hlinear]
rw [hr]
refine ⟨?_, ?_, ?_, MemoryFrame.trans hf02 (hf23.mono (by
intro addr ha
simp only [rootPositionList, List.length_map] at ha
dsimp [leafKeepWritable]
omega))⟩
· simpa [boundaryState, rootPositionFlag_append, rootPositionFlag] using h100
· simpa [boundaryState, rootPositionList] using h101
· simpa [boundaryState, rootPositionList_append, rootPositionList] using hstore)
(by
intro hstop
have hnonlinear : f.natDegree ≠ 1 := fun h => hstop (hmarker.mpr h)
have hr : traceRootSearch w [] f = [] := by simp [traceRootSearch, hnonlinear]
dsimp only [Q]
rw [hr, List.append_nil]
exact ⟨(hm2meta 100 (by norm_num) (by norm_num)).trans hm100,
(hm2meta 101 (by norm_num) (by norm_num)).trans hm101, hout2, hf02⟩)
have hFull := Sem.seq_bound hSetup (fun z _ hz => by
subst z
exact Sem.seq_bound hScan (fun z _ hz => by subst z; exact hBranch))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2.1, hQ.2.2⟩)
theorem rootForest_leaf_length_le_mass {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (fs : List F[X]) : (rootForest w [] fs).length ≤ frontierMass fs := by
induction fs with
| nil => simp [rootForest, frontierMass]
| cons f fs ih =>
rw [rootForest_cons, List.length_append]
by_cases h : f.natDegree = 1
· simp only [traceRootSearch, if_pos h, List.length_singleton, frontierMass]
omega
· simp only [traceRootSearch, if_neg h, List.length_nil, zero_add, frontierMass]
omega
theorem rootForest_leaf_snoc {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (fs : List F[X]) (f : F[X]) :
rootForest w [] (fs ++ [f]) = rootForest w [] fs ++ traceRootSearch w [] f := by
rw [rootForest_append]
simp [rootForest]
theorem rootForest_prefix_budget {F : Type} [Field F] [DecidableEq F]
(w : ℕ) (fs done pending : List F[X]) (f : F[X]) (T : ℕ)
(heq : fs = done ++ (f :: pending)) (hmass : frontierMass fs ≤ T) :
(rootForest w [] done).length + f.natDegree + frontierMass pending ≤ T := by
have h := rootForest_leaf_length_le_mass w done
rw [heq, frontierMass_append] at hmass
change frontierMass done + (f.natDegree + frontierMass pending) ≤ T at hmass
omega
theorem emission_meta_readonly (B T slot : ℕ) (hB : 128 ≤ B) (hs : slot < 128) (hn : ¬ rootEmissionMeta slot) :
¬ rootEmissionWritable B T slot := by
intro h
rcases h with h | h
· exact hn h
· omega
theorem leaf_keep_writable_le_emission (B T n degree addr : ℕ)
(hroom : degree = 1 → n < T) (ha : leafKeepWritable B n degree addr) : rootEmissionWritable B T addr := by
rcases ha with h64 | h66 | h95 | h100 | h101 | ⟨hdeg, hout⟩
· exact Or.inl (Or.inl h64)
· exact Or.inl (Or.inr (Or.inl h66))
· exact Or.inl (Or.inr (Or.inr (Or.inl h95)))
· apply Or.inl
dsimp [rootEmissionMeta]
omega
· apply Or.inl
dsimp [rootEmissionMeta]
omega
· have hn := hroom hdeg
exact Or.inr ⟨by omega, by omega⟩
theorem FrontierStored.of_emission_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m m' : ℕ → ℕ} {BQ cap B T : ℕ} {fs : List F[X]}
(h : FrontierStored b m BQ cap fs) (hBQ : 128 ≤ BQ) (hlen : fs.length ≤ T)
(hdisj : BQ + T * cap ≤ B ∨ B + T ≤ BQ) (hf : MemoryFrame (rootEmissionWritable B T) m m') :
FrontierStored b m' BQ cap fs := by
intro j hj
apply (h j hj).of_frame hf
intro i hi
have hlo : BQ ≤ BQ + j * cap + i := by omega
have hhi := queue_slot_before_next BQ cap T j i (by omega) hi
dsimp [rootEmissionWritable, rootEmissionMeta]
omega
theorem RootEmissionView.source_update {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {N : ℕ} {ι : ℕ → F} {BQ cap B : ℕ}
{fs done pending : List F[X]} {m : ℕ → ℕ}
(h : RootEmissionView b N ι BQ cap B fs done pending m) (hBQ : 128 ≤ BQ) (hB : 128 ≤ B) (src : ℕ) :
RootEmissionView b N ι BQ cap B fs done pending (Function.update m 99 src) := by
refine ⟨h.queue.meta_update hBQ 99 src (by norm_num), h.output.meta_update hB 99 src (by norm_num), ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· simpa using h.queueBase
· simpa using h.outputBase
· simpa using h.dimension
· simpa using h.capacity
· simpa using h.queueCount
· simpa using h.index
· simpa using h.remaining
· simpa using h.flag
· simpa using h.count
theorem rootEmissionBody_spec {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc BQ cap B T : ℕ) (fs done pending : List F[X]) (f : F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootEmissionBody pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (111 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ E.W) (hcap : 2 ≤ cap) (hTcap : T < cap)
(hBQ : 128 ≤ BQ) (hBQword : BQ + T * cap ≤ 2 ^ E.W)
(hB : 128 ≤ B) (hBword : B + T ≤ 2 ^ E.W) (hdisj : BQ + T * cap ≤ B ∨ B + T ≤ BQ)
(heq : fs = done ++ (f :: pending)) (hpos : ∀ g ∈ fs, 0 < g.natDegree) (hmass : frontierMass fs ≤ T)
(hv : RootEmissionView b N ι BQ cap B fs done (f :: pending) m) :
Sem P E pc (pc + 263) (rankState pc m (pending.length + 1))
(fun k z => k ≤ 17 * cap + 231 ∧ ∃ m', z = rankState (pc + 263) m' pending.length ∧
RootEmissionView b N ι BQ cap B fs (done ++ [f]) pending m' ∧
MemoryFrame (rootEmissionWritable B T) m m') := by
have hlen := frontier_length_le_mass fs hpos
have hfmem : f ∈ fs := by rw [heq]; simp
have hfpos := hpos f hfmem
have hfdeg := le_trans (frontier_degree_le_mass fs f hfmem) hmass
have hbudget := rootForest_prefix_budget w fs done pending f T heq hmass
have hroom : f.natDegree = 1 → (rootForest w [] done).length < T := by intro hf; omega
have hlenEq : fs.length = done.length + (pending.length + 1) := by simp [heq]
have hj : done.length < T := by omega
have hslot := queue_slot_word_bounds BQ cap T done.length E.W hBQ (by omega) hj hBQword
have hTword : T < 2 ^ E.W := by
have hm : T ≤ T * cap := by simpa only [Nat.mul_one] using Nat.mul_le_mul_left T (show 1 ≤ cap by omega)
omega
have hnWord : pending.length + 1 < 2 ^ E.W := by omega
have hjWord : done.length + 1 < 2 ^ E.W := by omega
let src := BQ + done.length * cap
let m1 := Function.update m 99 src
have hv1 := hv.source_update hBQ hB src
have hfactor : PolynomialStored b m1 src cap f := by
have hjfs : done.length < fs.length := by omega
have hg := hv1.queue done.length hjfs
have he : fs.getD done.length 0 = f := by
rw [heq, List.getD_append_right done (f :: pending) 0 done.length le_rfl, Nat.sub_self]
rfl
rw [he] at hg
exact hg
have hf01 : MemoryFrame (rootEmissionWritable B T) m m1 :=
MemoryFrame.update_allowed _ m 99 src (by left; dsimp [rootEmissionMeta]; omega)
obtain ⟨hPointerAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hKeepAt, hTailAt⟩ := At.seqStmt hRestAt
have hPointer : Sem P E pc (pc + 30) (rankState pc m (pending.length + 1))
(fun k z => k ≤ 30 ∧ z = boundaryState (pc + 30) m1) := by
refine Sem.mono (Sem.block P E pc queueReadPointerCode _ hPointerAt
(by simp [queueReadPointerCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl) ?_
intro k z hQ
have hk : k = 30 := hQ.1
exact ⟨by omega, hQ.2.trans (queueReadPointer_spec E _ BQ done.length cap (by omega) (by omega)
hslot.2.2.2.1 hslot.2.2.2.2 hslot.2.2.1 hslot.2.1 hv.queueBase hv.index hv.capacity)⟩
have hKeep := leafKeepProcedure_spec b ι t N P E (pc + 30) src cap B T f (rootForest w [] done) m1 hKeepAt
hw hW hdet (by omega) hN (by dsimp [src]; omega) hslot.1 hcap hB hBword hroom hfpos (by omega)
hfactor hv1.output (by simp [m1]) hv1.dimension hv1.capacity hv1.outputBase hv1.count hv1.flag
obtain ⟨_, k2, z2, hRun2, hPc2, hCost2, hRegs2, hFlag2, hCount2, hOutput2, hf12raw⟩ := hKeep
let m2 := z2.mem
have hz2 : z2 = boundaryState (pc + 212) m2 := by
apply ramState_eq_of
· exact hPc2
· rfl
· intro r; exact congrFun hRegs2 r
have hf12 : MemoryFrame (rootEmissionWritable B T) m1 m2 :=
hf12raw.mono (fun addr ha => leaf_keep_writable_le_emission B T (rootForest w [] done).length f.natDegree addr hroom ha)
have hf02 := MemoryFrame.trans hf01 hf12
have h91 : m2 91 = done.length := by
have he : m2 91 = m1 91 := hf12raw 91 (by dsimp [leafKeepWritable]; omega)
exact he.trans hv1.index
have h111 : m2 111 = pending.length + 1 := by
have he : m2 111 = m1 111 := hf12raw 111 (by dsimp [leafKeepWritable]; omega)
exact he.trans hv1.remaining
let m3 := Function.update (Function.update m2 91 (done.length + 1)) 111 pending.length
have hf23 : MemoryFrame (rootEmissionWritable B T) m2 m3 :=
MemoryFrame.trans (MemoryFrame.update_allowed _ m2 91 (done.length + 1) (by left; dsimp [rootEmissionMeta]; omega))
(MemoryFrame.update_allowed _ _ 111 pending.length (by left; dsimp [rootEmissionMeta]; omega))
have hf03 := MemoryFrame.trans hf02 hf23
have hfixed (slot : ℕ) (hs : slot < 128) (hn : ¬ rootEmissionMeta slot) : m3 slot = m slot :=
hf03 slot (emission_meta_readonly B T slot hB hs hn)
have hv3 : RootEmissionView b N ι BQ cap B fs (done ++ [f]) pending m3 := by
refine ⟨hv.queue.of_emission_frame hBQ (by omega) hdisj hf03, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· rw [rootForest_leaf_snoc]
exact (hOutput2.meta_update hB 91 (done.length + 1) (by norm_num)).meta_update hB 111 pending.length (by norm_num)
· exact (hfixed 83 (by norm_num) (by norm_num [rootEmissionMeta])).trans hv.queueBase
· exact (hfixed 85 (by norm_num) (by norm_num [rootEmissionMeta])).trans hv.outputBase
· exact (hfixed 77 (by norm_num) (by norm_num [rootEmissionMeta])).trans hv.dimension
· exact (hfixed 81 (by norm_num) (by norm_num [rootEmissionMeta])).trans hv.capacity
· exact (hfixed 89 (by norm_num) (by norm_num [rootEmissionMeta])).trans hv.queueCount
· simp [m3]
· simp [m3]
· simpa [m3, rootForest_leaf_snoc] using hFlag2
· simpa [m3, rootForest_leaf_snoc] using hCount2
have hKeepExact : Sem P E (pc + 30) (pc + 212) (boundaryState (pc + 30) m1)
(fun k z => k ≤ 17 * cap + 150 ∧ z = boundaryState (pc + 212) m2) :=
⟨rfl, k2, z2, hRun2, hPc2, hCost2, hz2⟩
have hTail : Sem P E (pc + 212) (pc + 263) (boundaryState (pc + 212) m2)
(fun k z => k ≤ 51 ∧ z = rankState (pc + 263) m3 pending.length) := by
refine Sem.mono (Sem.block P E _ rootLevelTailCode _ hTailAt
(by simp [rootLevelTailCode, incrementMetaCode, countdownCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl) ?_
intro k z hQ
have hk : k = 51 := hQ.1
exact ⟨by omega, hQ.2.trans (rootLevelTail_spec E _ done.length pending.length hmeta hjWord hnWord h91 h111)⟩
have hFull := Sem.seq_bound hPointer (fun z _ hz => by
subst z
exact Sem.seq_bound hKeepExact (fun z _ hz => by subst z; exact hTail))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, m3, hQ.2, hv3, hf03⟩)
theorem rootEmissionLoop_spec {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc BQ cap B T : ℕ) (fs : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootEmissionLoop pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (111 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ E.W) (hcap : 2 ≤ cap) (hTcap : T < cap)
(hBQ : 128 ≤ BQ) (hBQword : BQ + T * cap ≤ 2 ^ E.W)
(hB : 128 ≤ B) (hBword : B + T ≤ 2 ^ E.W) (hdisj : BQ + T * cap ≤ B ∨ B + T ≤ BQ)
(hpos : ∀ f ∈ fs, 0 < f.natDegree) (hmass : frontierMass fs ≤ T)
(hv : RootEmissionView b N ι BQ cap B fs [] fs m) :
Sem P E pc (pc + 265) (rankState pc m fs.length)
(fun k z => k ≤ (17 * cap + 233) * fs.length + 1 ∧ z.regs = (fun _ => 0) ∧
RootEmissionView b N ι BQ cap B fs fs [] z.mem ∧ MemoryFrame (rootEmissionWritable B T) m z.mem) := by
let I := fun (n : ℕ) (z : RAMState) => n ≤ fs.length ∧ z.regs = Function.update (fun _ => 0) r9 n ∧
∃ done pending, fs = done ++ pending ∧ pending.length = n ∧
RootEmissionView b N ι BQ cap B fs done pending z.mem ∧ MemoryFrame (rootEmissionWritable B T) m z.mem
have hframe : ∀ n z pc', I n z → I n { z with pc := pc' } := by
intro n z pc' h
simpa only [I] using h
have hcounter : ∀ n z, I n z → z.regs r9 = n := by
intro n z h
rw [h.2.1, Function.update_self]
obtain ⟨_, _, hBodyAt, hJumpAt⟩ := at_loop hAt
have hbody : ∀ n z, I (n + 1) z → z.pc = pc →
Sem P E (pc + 1) pc { z with pc := pc + 1 } (fun k z' => k ≤ 17 * cap + 232 ∧ I n z') := by
intro n z hI hpc
obtain ⟨hn, hregs, done, pending, heq, hrem, hvz, hf⟩ := hI
cases pending with
| nil => simp at hrem
| cons f pending =>
have heN : n = pending.length := by simp only [List.length_cons] at hrem; omega
subst n
have hz : { z with pc := pc + 1 } = rankState (pc + 1) z.mem (pending.length + 1) := by
apply ramState_eq_of
· rfl
· rfl
· intro r; exact congrFun hregs r
rw [hz]
have hrun := rootEmissionBody_spec b ι t N P E (pc + 1) BQ cap B T fs done pending f z.mem hBodyAt
hw hW hdet hmeta hN hcap hTcap hBQ hBQword hB hBword hdisj heq hpos hmass hvz
refine Sem.jmp_append (hAt := hJumpAt) (Sem.mono hrun ?_)
intro k z' hQ
obtain ⟨hk, m', hz', hv', hf'⟩ := hQ
refine ⟨by omega, by omega, ?_⟩
rw [hz']
refine ⟨rfl, done ++ [f], pending, ?_, rfl, hv', MemoryFrame.trans hf hf'⟩
simpa only [List.append_assoc, List.singleton_append] using heq
have hinit : I fs.length (rankState pc m fs.length) := by
refine ⟨le_rfl, rfl, [], fs, by simp, rfl, hv, ?_⟩
intro addr _; rfl
have hloop := Sem.loop_invariant P E pc rootEmissionBody hAt (by omega) I (17 * cap + 232)
hframe hcounter hbody fs.length (rankState pc m fs.length) hinit rfl
refine Sem.mono hloop ?_
intro k z hQ
obtain ⟨hk, _, hregs, done, pending, heq, hrem, hvz, hf⟩ := hQ
have hp : pending = [] := by
cases pending with
| nil => rfl
| cons f pending => simp at hrem
subst pending
have hd : done = fs := by simpa using heq.symm
subst done
refine ⟨hk, ?_, hvz, hf⟩
rw [hregs]
funext r
simp [Function.update_apply]
theorem rootEmissionProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc BQ cap B T : ℕ) (fs : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootEmissionProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (111 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ E.W) (hcap : 2 ≤ cap) (hTcap : T < cap)
(hBQ : 128 ≤ BQ) (hBQword : BQ + T * cap ≤ 2 ^ E.W)
(hB : 128 ≤ B) (hBword : B + T ≤ 2 ^ E.W) (hdisj : BQ + T * cap ≤ B ∨ B + T ≤ BQ)
(hpos : ∀ f ∈ fs, 0 < f.natDegree) (hmass : frontierMass fs ≤ T)
(hv : RootEmissionView b N ι BQ cap B fs [] fs m) :
Sem P E pc (pc + 268) (boundaryState pc m)
(fun k z => k ≤ (17 * cap + 233) * fs.length + 4 ∧ ∃ m', z = boundaryState (pc + 268) m' ∧
RootEmissionView b N ι BQ cap B fs fs [] m' ∧ MemoryFrame (rootEmissionWritable B T) m m') := by
have hlen := frontier_length_le_mass fs hpos
have hmul : T ≤ T * cap := by simpa only [Nat.mul_one] using Nat.mul_le_mul_left T (show 1 ≤ cap by omega)
have hn : fs.length < 2 ^ E.W := by omega
obtain ⟨hReadAt, hLoopAt⟩ := At.seqStmt hAt
have hRead : Sem P E pc (pc + 3) (boundaryState pc m)
(fun k z => k ≤ 3 ∧ z = rankState (pc + 3) m fs.length) := by
refine Sem.mono (Sem.block P E pc (metaReadCode r9 111) _ hReadAt (by simp [metaReadCode]) rfl) ?_
intro k z hQ
have hk : k = 3 := hQ.1
exact ⟨by omega, hQ.2.trans (rankReadSlot_spec E pc m 111 fs.length hmeta hn hv.remaining)⟩
have hLoop := rootEmissionLoop_spec b ι t N P E (pc + 3) BQ cap B T fs m hLoopAt
hw hW hdet hmeta hN hcap hTcap hBQ hBQword hB hBword hdisj hpos hmass hv
have hFull := Sem.seq_bound hRead (fun z _ hz => by subst z; exact hLoop)
obtain ⟨hpc, k, z, hrun, hreturn, hk, hregs, hvz, hf⟩ := hFull
refine ⟨hpc, k, z, hrun, hreturn, by omega, z.mem, ?_, hvz, hf⟩
apply ramState_eq_of
· exact hreturn
· rfl
· intro r; exact congrFun hregs r
theorem initializeLoop_spec (E : RAMEnv) (s : RAMState) (index counter source len : ℕ)
(hi : index < 2 ^ E.W) (hc : counter < 2 ^ E.W) (hs : source < 2 ^ E.W)
(hne : source ≠ index) (hlen : len < 2 ^ E.W) (hm : s.mem source = len) :
runBlock (initializeLoopCode index counter source) E s = boundaryState (s.pc + 42)
(Function.update (Function.update s.mem index 0) counter len) := by
rw [initializeLoopCode, runBlock_append, setMeta_spec E s index 0 hi (by omega)]
have hsrc : (boundaryState (s.pc + 20) (Function.update s.mem index 0)).mem source = len := by
simpa [boundaryState, hne] using hm
rw [copyMeta_spec E _ source counter len hs hc hlen hsrc] <;> rfl
theorem initializeLoop_frame (m : ℕ → ℕ) (index counter len : ℕ) :
MemoryFrame (fun addr => addr = index ∨ addr = counter) m (Function.update (Function.update m index 0) counter len) :=
MemoryFrame.trans (MemoryFrame.update_allowed _ m index 0 (Or.inl rfl))
(MemoryFrame.update_allowed _ _ counter len (Or.inr rfl))
theorem rootFactorProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L Q0 Q1 : ℕ) (fs0 : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootFactorProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hQ0 : 128 ≤ Q0) (hQ1 : 128 ≤ Q1)
(hQ0word : Q0 + t * cap ≤ 2 ^ E.W) (hQ1word : Q1 + t * cap ≤ 2 ^ E.W)
(hQ0sep : QueueWorkspaceSeparated R U D C TB ZB cap Q0 t)
(hQ1sep : QueueWorkspaceSeparated R U D C TB ZB cap Q1 t)
(hdisj : Q0 + t * cap ≤ Q1 ∨ Q1 + t * cap ≤ Q0) (hmeta : (112 : ℕ) < 2 ^ E.W)
(hpos : ∀ f ∈ fs0, 0 < f.natDegree) (hmass : frontierMass fs0 ≤ t)
(hc : RootConstants b R U D C TB ZB cap L m) (hq : FrontierStored b m Q0 cap fs0)
(hm83 : m 83 = Q0) (hm84 : m 84 = Q1) (hm89 : m 89 = fs0.length) :
Sem P E pc (pc + 3380) (boundaryState pc m)
(fun k z => k ≤ ((rootNodeBudget cap L w + 83) * t + 193) * w + 46 ∧ ∃ m',
z = boundaryState (pc + 3380) m' ∧ ∃ BQ QB fs,
((BQ = Q0 ∧ QB = Q1) ∨ (BQ = Q1 ∧ QB = Q0)) ∧
RootBasisView b R U D C TB ZB cap L BQ QB fs w 0 m' ∧
(∀ f ∈ fs, 0 < f.natDegree) ∧ frontierMass fs ≤ t ∧
rootForest w [] fs = rootForest w (List.ofFn b) fs0 ∧
MemoryFrame (rootBasisWritable R U D C TB cap Q0 Q1 t) m m') := by
let m1 := Function.update (Function.update m 88 0) 112 w
have hf01 : MemoryFrame (rootBasisWritable R U D C TB cap Q0 Q1 t) m m1 :=
(initializeLoop_frame m 88 112 w).mono (by
intro addr ha
left
dsimp [rootBasisMeta]
omega)
have hc1 := hc.of_basis_frame hl hQ0 hQ1 hQ0sep.QZ hQ1sep.QZ hf01
have hv1 : RootBasisView b R U D C TB ZB cap L Q0 Q1 fs0 0 w m1 := by
refine ⟨hc1, (hq.meta_update hQ0 88 0 (by norm_num)).meta_update hQ0 112 w (by norm_num), ?_, ?_, ?_, ?_, ?_⟩
· simpa [m1] using hm83
· simpa [m1] using hm84
· simpa [m1] using hm89
· simp [m1]
· simp [m1]
have hwWord : w < 2 ^ E.W := by have he : E.W < 2 ^ E.W := Nat.lt_two_pow_self; omega
obtain ⟨hInitAt, hRootAt⟩ := At.seqStmt hAt
have hInit : Sem P E pc (pc + 42) (boundaryState pc m)
(fun k z => k ≤ 42 ∧ z = boundaryState (pc + 42) m1) :=
Sem.boundary_block P E pc (initializeLoopCode 88 112 77) m m1 hInitAt
(by simp [initializeLoopCode, setMetaCode, copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(initializeLoop_spec E _ 88 112 77 w (by omega) hmeta (by omega) (by decide) hwWord hc.dimension)
have hRoot := rootBasisProcedure_spec b ι t N P E (pc + 42) R U D C TB ZB cap L Q0 Q1 fs0 m1 hRootAt
hw hW hdet ht hL hcap hl hwords hQ0 hQ1 hQ0word hQ1word hQ0sep hQ1sep hdisj hmeta hpos hmass hv1
have hFull := Sem.seq_bound hInit (fun z _ hz => by subst z; exact hRoot)
refine Sem.mono hFull ?_
intro k z hQ
obtain ⟨hk, m2, hz2, BQ, QB, fs, horder, hv2, hpos2, hmass2, hforest, hf12⟩ := hQ
exact ⟨by omega, m2, hz2, BQ, QB, fs, horder, hv2, hpos2, hmass2, hforest, MemoryFrame.trans hf01 hf12⟩
theorem rootEmitInitialize_spec (E : RAMEnv) (s : RAMState) (count : ℕ)
(hmeta : (111 : ℕ) < 2 ^ E.W) (hc : count < 2 ^ E.W) (hm89 : s.mem 89 = count) :
runBlock rootEmitInitializeCode E s = boundaryState (s.pc + 82) (rootEmitInitializeMemory s.mem count) := by
rw [rootEmitInitializeCode, runBlock_append, runBlock_append,
initializeLoop_spec E s 91 111 89 count (by omega) hmeta (by omega) (by decide) hc hm89,
setMeta_spec E _ 100 1 (by omega) (by omega), setMeta_spec E _ 101 0 (by omega) (by omega)] <;> rfl
theorem rootOutputProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc BQ cap B T : ℕ) (fs : List F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootOutputProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (111 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ E.W) (hcap : 2 ≤ cap) (hTcap : T < cap)
(hBQ : 128 ≤ BQ) (hBQword : BQ + T * cap ≤ 2 ^ E.W)
(hB : 128 ≤ B) (hBword : B + T ≤ 2 ^ E.W) (hdisj : BQ + T * cap ≤ B ∨ B + T ≤ BQ)
(hpos : ∀ f ∈ fs, 0 < f.natDegree) (hmass : frontierMass fs ≤ T)
(hq : FrontierStored b m BQ cap fs) (hm83 : m 83 = BQ) (hm85 : m 85 = B) (hm77 : m 77 = w)
(hm81 : m 81 = cap) (hm89 : m 89 = fs.length) :
Sem P E pc (pc + 350) (boundaryState pc m)
(fun k z => k ≤ (17 * cap + 233) * fs.length + 86 ∧ ∃ m', z = boundaryState (pc + 350) m' ∧
RootEmissionView b N ι BQ cap B fs fs [] m' ∧ MemoryFrame (rootEmissionWritable B T) m m') := by
have hlen := frontier_length_le_mass fs hpos
have hmul : T ≤ T * cap := by simpa only [Nat.mul_one] using Nat.mul_le_mul_left T (show 1 ≤ cap by omega)
have hnWord : fs.length < 2 ^ E.W := by omega
let m1 := rootEmitInitializeMemory m fs.length
have hf01 : MemoryFrame (rootEmissionWritable B T) m m1 :=
MemoryFrame.trans
(MemoryFrame.trans
(MemoryFrame.trans (MemoryFrame.update_allowed _ m 91 0 (by left; dsimp [rootEmissionMeta]; omega))
(MemoryFrame.update_allowed _ _ 111 fs.length (by left; dsimp [rootEmissionMeta]; omega)))
(MemoryFrame.update_allowed _ _ 100 1 (by left; dsimp [rootEmissionMeta]; omega)))
(MemoryFrame.update_allowed _ _ 101 0 (by left; dsimp [rootEmissionMeta]; omega))
have hv1 : RootEmissionView b N ι BQ cap B fs [] fs m1 := by
refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· exact (((hq.meta_update hBQ 91 0 (by norm_num)).meta_update hBQ 111 fs.length (by norm_num)).meta_update
hBQ 100 1 (by norm_num)).meta_update hBQ 101 0 (by norm_num)
· intro j hj; simp [rootPositionList, rootForest] at hj
· simpa [m1, rootEmitInitializeMemory] using hm83
· simpa [m1, rootEmitInitializeMemory] using hm85
· simpa [m1, rootEmitInitializeMemory] using hm77
· simpa [m1, rootEmitInitializeMemory] using hm81
· simpa [m1, rootEmitInitializeMemory] using hm89
· simp [m1, rootEmitInitializeMemory]
· simp [m1, rootEmitInitializeMemory]
· simp [m1, rootEmitInitializeMemory, rootPositionFlag, rootForest]
· simp [m1, rootEmitInitializeMemory, rootForest]
obtain ⟨hInitAt, hEmitAt⟩ := At.seqStmt hAt
have hInit : Sem P E pc (pc + 82) (boundaryState pc m)
(fun k z => k ≤ 82 ∧ z = boundaryState (pc + 82) m1) :=
Sem.boundary_block P E pc rootEmitInitializeCode m m1 hInitAt
(by simp [rootEmitInitializeCode, initializeLoopCode, setMetaCode, copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(rootEmitInitialize_spec E _ fs.length hmeta hnWord hm89)
have hEmit := rootEmissionProcedure_spec b ι t N P E (pc + 82) BQ cap B T fs m1 hEmitAt
hw hW hdet hmeta hN hcap hTcap hBQ hBQword hB hBword hdisj hpos hmass hv1
have hFull := Sem.seq_bound hInit (fun z _ hz => by subst z; exact hEmit)
refine Sem.mono hFull ?_
intro k z hQ
obtain ⟨hk, m2, hz2, hv2, hf12⟩ := hQ
exact ⟨by omega, m2, hz2, hv2, MemoryFrame.trans hf01 hf12⟩
theorem root_seed_meta_readonly (Q0 cap t slot : ℕ) (hQ0 : 128 ≤ Q0) (hs : slot < 128) (hn : ¬ rootSeedMeta slot) :
¬ rootSeedWritable Q0 cap t slot := by
intro h
rcases h with h | h
· exact hn h
· omega
theorem root_seed_writable_le_basis (R U D C TB cap Q0 Q1 t addr : ℕ) (ha : rootSeedWritable Q0 cap t addr) :
rootBasisWritable R U D C TB cap Q0 Q1 t addr := by
rcases ha with hmeta | hqueue
· left
dsimp [rootSeedMeta] at hmeta
dsimp [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta]
omega
· exact Or.inr (Or.inr (Or.inl hqueue))
theorem rootSeedProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv)
(pc Q0 Q1 src cap t : ℕ) (σ : F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootSeedProcedure pc))
(hmeta : (107 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W) (ht : 1 ≤ t) (hcap : 1 ≤ cap)
(hQ0 : 128 ≤ Q0) (hQ1 : Q1 < 2 ^ E.W) (hsrc : 128 ≤ src)
(hQword : Q0 + t * cap ≤ 2 ^ E.W) (hSword : src + cap ≤ 2 ^ E.W)
(hdisj : src + cap ≤ Q0 ∨ Q0 + t * cap ≤ src) (hdeg : σ.natDegree < cap)
(hf : PolynomialStored b m src cap σ) (hm75 : m 75 = src) (hm83 : m 83 = Q0)
(hm107 : m 107 = Q1) (hm81 : m 81 = cap) :
Sem P E pc (pc + 317) (boundaryState pc m)
(fun k z => k ≤ 29 * cap + 275 ∧ ∃ m', z = boundaryState (pc + 317) m' ∧
FrontierStored b m' Q0 cap (keepFactor σ) ∧ m' 83 = Q0 ∧ m' 84 = Q1 ∧ m' 89 = (keepFactor σ).length ∧
MemoryFrame (rootSeedWritable Q0 cap t) m m') := by
have hmul : cap ≤ t * cap := by simpa only [Nat.one_mul] using Nat.mul_le_mul_right cap ht
have hQ0Word : Q0 < 2 ^ E.W := by omega
have hSrcWord : src < 2 ^ E.W := by omega
let m1 := Function.update m 97 src
let m2 := Function.update m1 84 Q0
let m3 := Function.update m2 90 0
have hf03 : MemoryFrame (rootSeedWritable Q0 cap t) m m3 :=
MemoryFrame.trans
(MemoryFrame.trans (MemoryFrame.update_allowed _ m 97 src (by left; dsimp [rootSeedMeta]; omega))
(MemoryFrame.update_allowed _ _ 84 Q0 (by left; dsimp [rootSeedMeta]; omega)))
(MemoryFrame.update_allowed _ _ 90 0 (by left; dsimp [rootSeedMeta]; omega))
obtain ⟨hCopySourceAt, hRest1⟩ := At.seqStmt hAt
obtain ⟨hCopyBaseAt, hRest2⟩ := At.seqStmt hRest1
obtain ⟨hZeroAt, hRest3⟩ := At.seqStmt hRest2
obtain ⟨hKeepAt, hRest4⟩ := At.seqStmt hRest3
obtain ⟨hCountAt, hRestoreAt⟩ := At.seqStmt hRest4
have hCopySource : Sem P E pc (pc + 22) (boundaryState pc m)
(fun k z => k ≤ 22 ∧ z = boundaryState (pc + 22) m1) :=
Sem.boundary_block P E _ (copyMetaCode 75 97) m m1 hCopySourceAt
(by simp [copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(copyMeta_spec E _ 75 97 src (by omega) (by omega) hSrcWord hm75)
have hCopyBase : Sem P E (pc + 22) (pc + 44) (boundaryState (pc + 22) m1)
(fun k z => k ≤ 22 ∧ z = boundaryState (pc + 44) m2) :=
Sem.boundary_block P E _ (copyMetaCode 83 84) m1 m2 hCopyBaseAt
(by simp [copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(copyMeta_spec E _ 83 84 Q0 (by omega) (by omega) hQ0Word (by simpa [boundaryState, m1] using hm83))
have hZero : Sem P E (pc + 44) (pc + 64) (boundaryState (pc + 44) m2)
(fun k z => k ≤ 20 ∧ z = boundaryState (pc + 64) m3) :=
Sem.boundary_block P E _ (setMetaCode 90 0) m2 m3 hZeroAt
(by simp [setMetaCode, metaStoreCode, zeroRegsCode]) (setMeta_spec E _ 90 0 (by omega) (by omega))
have hfactor3 := ((hf.meta_update hsrc 97 src (by norm_num)).meta_update hsrc 84 Q0 (by norm_num)).meta_update hsrc 90 0 (by norm_num)
have hKeep := queueKeepProcedure_spec b P E (pc + 64) Q0 src cap t [] σ m3 hKeepAt
(by omega) hwe hcap hQ0 hsrc hQword hSword (by intro _; simp only [List.length_nil]; omega) hdisj
(by intro j hj; simp at hj) hfactor3 hdeg (by simp [m3, m2]) (by simp [m3])
(by simpa [m3, m2, m1] using hm81) (by simp [m3, m2, m1])
obtain ⟨_, k4, z4, hRun4, hPc4, hCost4, hRegs4, hCount4, hQueue4, hf34raw⟩ := hKeep
let m4 := z4.mem
have hz4 : z4 = boundaryState (pc + 273) m4 := by
apply ramState_eq_of
· exact hPc4
· rfl
· intro r; exact congrFun hRegs4 r
have hf34 : MemoryFrame (rootSeedWritable Q0 cap t) m3 m4 := hf34raw.mono (by
intro addr ha
have hh := queue_keep_writable_le_whole Q0 t cap 0 σ.natDegree addr (by intro _; omega) ha
dsimp [wholeQueueWritable] at hh
dsimp [rootSeedWritable, rootSeedMeta]
omega)
have hf04 := MemoryFrame.trans hf03 hf34
have hfixed4 (slot : ℕ) (hs : slot < 128) (hn : ¬ rootSeedMeta slot) : m4 slot = m slot :=
hf04 slot (root_seed_meta_readonly Q0 cap t slot hQ0 hs hn)
have hcountWord : (keepFactor σ).length < 2 ^ E.W := by
have hh : (keepFactor σ).length ≤ 1 := by by_cases h : σ.natDegree = 0 <;> simp [keepFactor, h]
omega
let m5 := Function.update m4 89 (keepFactor σ).length
let m6 := Function.update m5 84 Q1
have hCount : Sem P E (pc + 273) (pc + 295) (boundaryState (pc + 273) m4)
(fun k z => k ≤ 22 ∧ z = boundaryState (pc + 295) m5) :=
Sem.boundary_block P E _ (copyMetaCode 90 89) m4 m5 hCountAt
(by simp [copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(copyMeta_spec E _ 90 89 (keepFactor σ).length (by omega) (by omega) hcountWord (by simpa [boundaryState, m4] using hCount4))
have hRestore : Sem P E (pc + 295) (pc + 317) (boundaryState (pc + 295) m5)
(fun k z => k ≤ 22 ∧ z = boundaryState (pc + 317) m6) :=
Sem.boundary_block P E _ (copyMetaCode 107 84) m5 m6 hRestoreAt
(by simp [copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(copyMeta_spec E _ 107 84 Q1 hmeta (by omega) hQ1 (by
change m5 107 = Q1
simpa [m5] using (hfixed4 107 (by norm_num) (by norm_num [rootSeedMeta])).trans hm107))
have hKeepExact : Sem P E (pc + 64) (pc + 273) (boundaryState (pc + 64) m3)
(fun k z => k ≤ 29 * cap + 167 ∧ z = boundaryState (pc + 273) m4) :=
⟨rfl, k4, z4, hRun4, hPc4, hCost4, hz4⟩
have hFull := Sem.seq_bound hCopySource (fun z _ hz => by
subst z
exact Sem.seq_bound hCopyBase (fun z _ hz => by
subst z
exact Sem.seq_bound hZero (fun z _ hz => by
subst z
exact Sem.seq_bound hKeepExact (fun z _ hz => by
subst z
exact Sem.seq_bound hCount (fun z _ hz => by subst z; exact hRestore)))))
refine Sem.mono hFull ?_
intro k z hQ
refine ⟨by omega, m6, hQ.2, ?_, ?_, by simp [m6], by simp [m6, m5], ?_⟩
· simpa only [List.nil_append] using (hQueue4.meta_update hQ0 89 (keepFactor σ).length (by norm_num)).meta_update hQ0 84 Q1 (by norm_num)
· simpa [m6, m5] using (hfixed4 83 (by norm_num) (by norm_num [rootSeedMeta])).trans hm83
· exact MemoryFrame.trans
(MemoryFrame.trans hf04 (MemoryFrame.update_allowed _ m4 89 (keepFactor σ).length (by left; dsimp [rootSeedMeta]; omega)))
(MemoryFrame.update_allowed _ _ 84 Q1 (by left; dsimp [rootSeedMeta]; omega))
theorem rootSearchProcedure_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc R U D C TB ZB cap L Q0 Q1 B src : ℕ) (σ : F[X]) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile rootSearchProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(ht : 1 ≤ t) (hL : L = 2 * t + 1) (hcap : cap = 2 * L)
(hl : RootWorkspace R U D C TB ZB cap) (hwords : RootWords E R U D C TB ZB cap)
(hQ0 : 128 ≤ Q0) (hQ1 : 128 ≤ Q1) (hB : 128 ≤ B)
(hQ0word : Q0 + t * cap ≤ 2 ^ E.W) (hQ1word : Q1 + t * cap ≤ 2 ^ E.W) (hBword : B + t ≤ 2 ^ E.W)
(hQ0sep : QueueWorkspaceSeparated R U D C TB ZB cap Q0 t)
(hQ1sep : QueueWorkspaceSeparated R U D C TB ZB cap Q1 t)
(hdisj : Q0 + t * cap ≤ Q1 ∨ Q1 + t * cap ≤ Q0)
(hQ0out : Q0 + t * cap ≤ B ∨ B + t ≤ Q0) (hQ1out : Q1 + t * cap ≤ B ∨ B + t ≤ Q1)
(hmeta : (112 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ E.W)
(hsrc : 128 ≤ src) (hSword : src + cap ≤ 2 ^ E.W) (hSrcQ0 : src + cap ≤ Q0 ∨ Q0 + t * cap ≤ src)
(hσ : σ ≠ 0) (hdeg : σ.natDegree ≤ t)
(hc : RootConstants b R U D C TB ZB cap L m) (hσStored : PolynomialStored b m src cap σ)
(hm75 : m 75 = src) (hm83 : m 83 = Q0) (hm107 : m 107 = Q1) (hm85 : m 85 = B) :
Sem P E pc (pc + 4047) (boundaryState pc m)
(fun k z => k ≤ ((rootNodeBudget cap L w + 83) * t + 193) * w +
(17 * cap + 233) * t + 29 * cap + 407 ∧ ∃ m',
z = boundaryState (pc + 4047) m' ∧ m' 100 = rootPositionFlag N ι (rootsByBasis b σ) ∧
m' 101 = (rootsByBasis b σ).length ∧ m' 85 = B ∧
OutputStored m' B (rootPositionList N ι (rootsByBasis b σ)) ∧
(rootsByBasis b σ).length ≤ t ∧
MemoryFrame (rootSearchWritable R U D C TB cap Q0 Q1 B t) m m') := by
have hcapPos : 1 ≤ cap := by omega
have htcap : t < cap := by omega
have hm : cap ≤ t * cap := by simpa only [Nat.one_mul] using Nat.mul_le_mul_right cap ht
have hQ1fit : Q1 < 2 ^ E.W := by omega
have hkeepPos : ∀ f ∈ keepFactor σ, 0 < f.natDegree := by
intro f hf
obtain ⟨rfl, hne⟩ := (mem_keepFactor f σ).mp hf
omega
have hkeepMass : frontierMass (keepFactor σ) ≤ t := by rw [frontierMass_keep]; exact hdeg
obtain ⟨hSeedAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hFactorAt, hOutputAt⟩ := At.seqStmt hRestAt
have hSeed := rootSeedProcedure_spec b P E pc Q0 Q1 src cap t σ m hSeedAt (by omega) (by omega) ht hcapPos
hQ0 hQ1fit hsrc hQ0word hSword hSrcQ0 (by omega) hσStored hm75 hm83 hm107 hc.capacity
obtain ⟨_, k1, z1, hRun1, hPc1, hCost1, m1, hz1, hQueue1, h831, h841, h891, hf01raw⟩ := hSeed
have hf01 : MemoryFrame (rootBasisWritable R U D C TB cap Q0 Q1 t) m m1 :=
hf01raw.mono (root_seed_writable_le_basis R U D C TB cap Q0 Q1 t)
have hc1 := hc.of_basis_frame hl hQ0 hQ1 hQ0sep.QZ hQ1sep.QZ hf01
have hSeedExact : Sem P E pc (pc + 317) (boundaryState pc m)
(fun k z => k ≤ 29 * cap + 275 ∧ z = boundaryState (pc + 317) m1) :=
⟨rfl, k1, z1, hRun1, hPc1, hCost1, hz1⟩
have hFactor := rootFactorProcedure_spec b ι t N P E (pc + 317) R U D C TB ZB cap L Q0 Q1 (keepFactor σ) m1 hFactorAt
hw hW hdet ht hL hcap hl hwords hQ0 hQ1 hQ0word hQ1word hQ0sep hQ1sep hdisj hmeta hkeepPos hkeepMass hc1 hQueue1 h831 h841 h891
obtain ⟨_, k2, z2, hRun2, hPc2, hCost2, m2, hz2, BQ, QB, fs, horder, hv2, hpos2, hmass2, hforest, hf12⟩ := hFactor
have hf02 := MemoryFrame.trans hf01 hf12
have hgeometry : 128 ≤ BQ ∧ BQ + t * cap ≤ 2 ^ E.W ∧ (BQ + t * cap ≤ B ∨ B + t ≤ BQ) := by
rcases horder with horder | horder
· simpa only [horder.1] using And.intro hQ0 (And.intro hQ0word hQ0out)
· simpa only [horder.1] using And.intro hQ1 (And.intro hQ1word hQ1out)
have hm285 : m2 85 = B :=
(hf02 85 (hl.basis_meta_readonly hQ0 hQ1 85 (by norm_num)
(by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta]))).trans hm85
have hOutput := rootOutputProcedure_spec b ι t N P E (pc + 3697) BQ cap B t fs m2 hOutputAt hw hW hdet (by omega) hN
(by omega) htcap hgeometry.1 hgeometry.2.1 hB hBword hgeometry.2.2 hpos2 hmass2 hv2.queue hv2.oldBase hm285
hv2.constants.dimension hv2.constants.capacity hv2.count
have hFactorExact : Sem P E (pc + 317) (pc + 3697) (boundaryState (pc + 317) m1)
(fun k z => k ≤ ((rootNodeBudget cap L w + 83) * t + 193) * w + 46 ∧ z = boundaryState (pc + 3697) m2) :=
⟨rfl, k2, z2, hRun2, hPc2, hCost2, hz2⟩
have hForest : rootForest w [] fs = rootsByBasis b σ := by
rw [hforest, rootForest_keep]
rfl
have hlen := frontier_length_le_mass fs hpos2
have hlenBound : fs.length ≤ t := le_trans hlen hmass2
have hCostBound := Nat.mul_le_mul_left (17 * cap + 233) hlenBound
have hFull := Sem.seq_bound hSeedExact (fun z _ hz => by
subst z
exact Sem.seq_bound hFactorExact (fun z _ hz => by subst z; exact hOutput))
refine Sem.mono hFull ?_
intro k z hQ
obtain ⟨hk, m3, hz3, hv3, hf23⟩ := hQ
refine ⟨by omega, m3, hz3, ?_, ?_, hv3.outputBase, ?_, le_trans (rootsByBasis_sound b σ hσ).2.2 hdeg, ?_⟩
· simpa only [hForest] using hv3.flag
· simpa only [hForest] using hv3.count
· simpa only [hForest] using hv3.output
· exact MemoryFrame.trans (hf02.mono (fun _ ha => Or.inl ha)) (hf23.mono (fun _ ha => Or.inr ha))
theorem decoderRows_root (t : ℕ) :
RootWorkspace (decoderRowBase t 0) (decoderRowBase t 6) (decoderRowBase t 1) (decoderRowBase t 7)
(decoderRowBase t 4) (decoderRowBase t 5) (decoderCapacity t) := by
have hc := decoderCapacity_pos t
constructor
· constructor <;> dsimp [decoderRowBase, decoderSavedBase] <;> omega
all_goals dsimp [decoderRowBase, decoderSavedBase] <;> omega
theorem decoderRows_root_words (E : RAMEnv) (t : ℕ) (hword : decoderAllocEnd t ≤ 2 ^ E.W) :
RootWords E (decoderRowBase t 0) (decoderRowBase t 6) (decoderRowBase t 1) (decoderRowBase t 7)
(decoderRowBase t 4) (decoderRowBase t 5) (decoderCapacity t) :=
⟨decoderRow_word E t 0 (by norm_num) hword, decoderRow_word E t 6 (by norm_num) hword,
decoderRow_word E t 1 (by norm_num) hword, decoderRow_word E t 7 (by norm_num) hword,
decoderRow_word E t 4 (by norm_num) hword, decoderRow_word E t 5 (by norm_num) hword⟩
theorem decoderQueue0_root_separated (t : ℕ) :
QueueWorkspaceSeparated (decoderRowBase t 0) (decoderRowBase t 6) (decoderRowBase t 1) (decoderRowBase t 7)
(decoderRowBase t 4) (decoderRowBase t 5) (decoderCapacity t) (decoderQueue0 t) t :=
⟨Or.inr (decoderRow_end_le_queue t 0 (by norm_num)), Or.inr (decoderRow_end_le_queue t 6 (by norm_num)),
Or.inr (decoderRow_end_le_queue t 1 (by norm_num)), Or.inr (decoderRow_end_le_queue t 7 (by norm_num)),
Or.inr (decoderRow_end_le_queue t 4 (by norm_num)), Or.inr (decoderRow_end_le_queue t 5 (by norm_num))⟩
theorem decoderQueue1_root_separated (t : ℕ) :
QueueWorkspaceSeparated (decoderRowBase t 0) (decoderRowBase t 6) (decoderRowBase t 1) (decoderRowBase t 7)
(decoderRowBase t 4) (decoderRowBase t 5) (decoderCapacity t) (decoderQueue1 t) t := by
have hQ : decoderQueue0 t ≤ decoderQueue1 t := by unfold decoderQueue1; omega
have hr (k : ℕ) (hk : k < 8) : decoderRowBase t k + decoderCapacity t ≤ decoderQueue1 t :=
le_trans (decoderRow_end_le_queue t k hk) hQ
exact ⟨Or.inr (hr 0 (by norm_num)), Or.inr (hr 6 (by norm_num)), Or.inr (hr 1 (by norm_num)),
Or.inr (hr 7 (by norm_num)), Or.inr (hr 4 (by norm_num)), Or.inr (hr 5 (by norm_num))⟩
theorem decoderGeometry_spec (E : RAMEnv) (t : ℕ) (hEnd : decoderAllocEnd t < 2 ^ E.W) : DecoderGeometry E t := by
have hEnd' := hEnd
dsimp [decoderAllocEnd, decoderVerifyBase, decoderOutputBase, decoderQueue1, decoderQueue0, decoderRowBase, decoderSavedBase] at hEnd'
constructor <;>
(try dsimp [decoderSavedBase, decoderQueue0, decoderQueue1, decoderOutputBase, decoderVerifyBase, decoderRowBase]) <;> omega
theorem rootSearch_saved_readonly (t j : ℕ) (hj : j < 2 * t) :
¬ rootSearchWritable (decoderRowBase t 0) (decoderRowBase t 6) (decoderRowBase t 1) (decoderRowBase t 7)
(decoderRowBase t 4) (decoderCapacity t) (decoderQueue0 t) (decoderQueue1 t) (decoderOutputBase t) t (decoderSavedBase t + j) := by
dsimp [rootSearchWritable, rootBasisWritable, rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta,
rootComputeWritable, rootEmissionWritable, rootEmissionMeta, decoderRowBase, decoderSavedBase, decoderQueue0, decoderQueue1, decoderOutputBase]
omega
theorem rootSearch_preserved_meta {t : ℕ} {m m' : ℕ → ℕ}
(hf : MemoryFrame (rootSearchWritable (decoderRowBase t 0) (decoderRowBase t 6) (decoderRowBase t 1) (decoderRowBase t 7)
(decoderRowBase t 4) (decoderCapacity t) (decoderQueue0 t) (decoderQueue1 t) (decoderOutputBase t) t) m m')
(slot : ℕ) (hs : slot < 128) (hBasis : ¬ rootBasisMeta slot) (hEmission : ¬ rootEmissionMeta slot) : m' slot = m slot := by
apply hf
intro ha
rcases ha with hb | he
· exact (decoderRows_root t).basis_meta_readonly (decoderRow_low t 8)
(by have hq := decoderRow_low t 8; unfold decoderQueue1 decoderQueue0; omega) slot hs hBasis hb
· exact emission_meta_readonly (decoderOutputBase t) t slot (by
have hq := decoderRow_low t 8
unfold decoderOutputBase decoderQueue1 decoderQueue0
omega) hs hEmission he
section PinBits
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end PinBits
section Uniqueness
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end Uniqueness
section Slp
variable {F : Type} [Field F]
end Slp
open LinearSetReconciliation327.Main in
theorem LinearSetReconciliation327.Main.pinsketch_decoder_root_search
{F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv) (pc : ℕ)
(e : ℕ → F) (m : ℕ → ℕ) (hAt : At P pc (Stmt.compile rootSearchProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι) (ht : 1 ≤ t)
(hEnd : decoderAllocEnd t < 2 ^ E.W) (hN : N < 2 ^ w) (hReady : KeyReady b E t N e m) :
Sem P E pc (pc + 4047) (boundaryState pc m)
(fun k z => k ≤ rootPhaseBudget t w ∧ ∃ m', z = boundaryState (pc + 4047) m' ∧
CandidateReady b ι t N e m' ∧ MemoryFrame
(rootSearchWritable (decoderRowBase t 0) (decoderRowBase t 6) (decoderRowBase t 1) (decoderRowBase t 7)
(decoderRowBase t 4) (decoderCapacity t) (decoderQueue0 t) (decoderQueue1 t) (decoderOutputBase t) t) m m') := by
have hg := decoderGeometry_spec E t hEnd
have hmin := padeSolve_minimal e t ht
obtain ⟨src, h75, hlo, hword, hstored, hdisj⟩ := hReady.sigma
have hRoot := rootSearchProcedure_spec b ι t N P E pc (decoderRowBase t 0) (decoderRowBase t 6)
(decoderRowBase t 1) (decoderRowBase t 7) (decoderRowBase t 4) (decoderRowBase t 5) (decoderCapacity t)
(decoderLength t) (decoderQueue0 t) (decoderQueue1 t) (decoderOutputBase t) src (padeSolve e t).curC m hAt
hw hW hdet ht rfl rfl (decoderRows_root t) (decoderRows_root_words E t (le_of_lt hEnd)) hg.firstLow hg.secondLow hg.outputLow
hg.firstWord hg.secondWord hg.outputWord (decoderQueue0_root_separated t) (decoderQueue1_root_separated t)
(Or.inl hg.queues) (Or.inl hg.firstOutput) (Or.inl hg.secondOutput) (by have hh := hg.metadata; omega)
(lt_of_lt_of_le hN (Nat.pow_le_pow_right (by norm_num) (by omega : w ≤ E.W)))
hlo hword hdisj hmin.1.1 hmin.1.2.1 hReady.root hstored h75 hReady.firstQueue hReady.fixedQ1 hReady.output
refine Sem.mono hRoot ?_
intro k z hQ
obtain ⟨hk, m2, hz2, h100, h101, h85, hout, hlen, hf⟩ := hQ
have hm (slot : ℕ) (hs : slot < 128) (hb : ¬ rootBasisMeta slot) (he : ¬ rootEmissionMeta slot) :=
rootSearch_preserved_meta hf slot hs hb he
have hCandidate : CandidateReady b ι t N e m2 := by
refine ⟨hReady.saved.of_frame hf (rootSearch_saved_readonly t), hout, ?_, ?_, ?_, h85, ?_, h100, h101⟩
· exact (hm 79 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])
(by norm_num [rootEmissionMeta])).trans hReady.savedBase
· exact (hm 77 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])
(by norm_num [rootEmissionMeta])).trans hReady.root.dimension
· exact (hm 80 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])
(by norm_num [rootEmissionMeta])).trans hReady.tValue
· exact (hm 86 (by norm_num) (by norm_num [rootBasisMeta, rootLevelMeta, rootNodeMeta, rootComputeMeta])
(by norm_num [rootEmissionMeta])).trans hReady.verification
exact ⟨hk, m2, hz2, hCandidate, hf⟩
/-! Child C5: `LinearSetReconciliation327.Main.pinsketch_decoder_verifier`.
Generated by `p21opt/gen/emit.py` by skeleton subtraction from
`Solutions/_p21_opt3.lean` (Stage-2 declaration spans). -/
set_option autoImplicit false
open scoped ENNReal
open Finset Polynomial
section FieldFacts
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end FieldFacts
section PowerSums
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
variable {N : ℕ}
theorem mem_binSupp {x : Fin N → ZMod 2} {i : Fin N} : i ∈ binSupp x ↔ x i = 1 := by
simp [binSupp]
end PowerSums
/-- A polynomial of degree `< #s` that vanishes on `s` is zero (over a domain). -/
theorem pdec_eq_zero_of_card {A : Type} [CommRing A] [IsDomain A] [DecidableEq A]
{p : A[X]} {s : Finset A} (hdeg : p.natDegree < s.card) (h : ∀ x ∈ s, p.eval x = 0) : p = 0 := by
by_contra hp
have hsub : s ⊆ p.roots.toFinset := by
intro x hx
rw [Multiset.mem_toFinset, mem_roots hp, IsRoot.def]
exact h x hx
have h1 : s.card ≤ p.roots.toFinset.card := Finset.card_le_card hsub
have h2 : p.roots.toFinset.card ≤ p.roots.card := Multiset.toFinset_card_le p.roots
have h3 : p.roots.card ≤ p.natDegree := Polynomial.card_roots' p
omega
/-- `(Σ_{a<N} v^a X^a)(1 − vX) = 1 − v^N X^N`: the geometric series telescopes in `F[X]`. -/
theorem pdec_geom_C {F : Type} [CommRing F] (v : F) (N : ℕ) :
(∑ a ∈ Finset.range N, C (v ^ a) * X ^ a) * (1 - C v * X) = 1 - C (v ^ N) * X ^ N := by
induction N with
| zero => simp
| succ N ih =>
rw [Finset.sum_range_succ, add_mul, ih, pow_succ, pow_succ, map_mul]
ring
/-- The syndrome form: `(Σ_{j<N} v^{j+1} X^j)(1 − vX) = v − v^{N+1} X^N`. -/
theorem pdec_geom_shift {F : Type} [CommRing F] (v : F) (N : ℕ) :
(∑ j ∈ Finset.range N, C (v ^ (j + 1)) * X ^ j) * (1 - C v * X)
= C v - C (v ^ (N + 1)) * X ^ N := by
have h : (∑ j ∈ Finset.range N, C (v ^ (j + 1)) * X ^ j)
= C v * ∑ j ∈ Finset.range N, C (v ^ j) * X ^ j := by
rw [Finset.mul_sum]
refine Finset.sum_congr rfl (fun j _ => ?_)
rw [← mul_assoc, ← map_mul, ← pow_succ']
rw [h, mul_assoc, pdec_geom_C, mul_sub, mul_one, ← mul_assoc, ← map_mul, ← pow_succ']
/-- Splitting the syndrome polynomial into one geometric series per support point. -/
theorem synP_eq_sum_geom {F : Type} [Field F] [DecidableEq F] (D : Finset F) (N : ℕ) :
synP D N = ∑ v ∈ D, ∑ j ∈ Finset.range N, C (v ^ (j + 1)) * X ^ j := by
classical
unfold synP
rw [Finset.sum_congr rfl (fun j (_ : j ∈ Finset.range N) => by
rw [map_sum, Finset.sum_mul] :
∀ j ∈ Finset.range N, C (∑ v ∈ D, v ^ (j + 1)) * X ^ j
= ∑ v ∈ D, C (v ^ (j + 1)) * X ^ j)]
rw [Finset.sum_comm]
/-- **The key-equation identity**: `σ S = ω − X^N K` with `K = Σ_{v∈D} v^{N+1} ∏_{w≠v}(1 − wX)`. -/
theorem locDual_mul_synP {F : Type} [Field F] [DecidableEq F] (D : Finset F) (N : ℕ) :
locDual D * synP D N =
omegaD D - X ^ N * ∑ v ∈ D, C (v ^ (N + 1)) * ∏ w ∈ D.erase v, (1 - C w * X) := by
classical
rw [synP_eq_sum_geom, Finset.mul_sum]
have hterm : ∀ v ∈ D,
locDual D * (∑ j ∈ Finset.range N, C (v ^ (j + 1)) * X ^ j)
= (∑ j ∈ Finset.range N, C (v ^ (j + 1)) * X ^ j) * (1 - C v * X)
* ∏ w ∈ D.erase v, (1 - C w * X) := by
intro v hv
rw [locDual, ← Finset.prod_erase_mul D (fun w => (1 - C w * X)) hv]
ring
rw [Finset.sum_congr rfl hterm]
rw [Finset.sum_congr rfl (fun v (_ : v ∈ D) => by rw [pdec_geom_shift] :
∀ v ∈ D, (∑ j ∈ Finset.range N, C (v ^ (j + 1)) * X ^ j) * (1 - C v * X)
* ∏ w ∈ D.erase v, (1 - C w * X)
= (C v - C (v ^ (N + 1)) * X ^ N) * ∏ w ∈ D.erase v, (1 - C w * X))]
have hfin : (∑ v ∈ D, (C v - C (v ^ (N + 1)) * X ^ N) * ∏ w ∈ D.erase v, (1 - C w * X))
= (∑ v ∈ D, C v * ∏ w ∈ D.erase v, (1 - C w * X))
- X ^ N * ∑ v ∈ D, C (v ^ (N + 1)) * ∏ w ∈ D.erase v, (1 - C w * X) := by
have hstep : ∀ v ∈ D, (C v - C (v ^ (N + 1)) * X ^ N) * ∏ w ∈ D.erase v, (1 - C w * X)
= C v * ∏ w ∈ D.erase v, (1 - C w * X)
- X ^ N * (C (v ^ (N + 1)) * ∏ w ∈ D.erase v, (1 - C w * X)) := by
intro v _
ring
rw [Finset.sum_congr rfl hstep, Finset.sum_sub_distrib, Finset.mul_sum]
rw [hfin]
unfold omegaD
rfl
/-- **The locator satisfies the key equation** (stage C): `X^N ∣ σ S − ω`. With `N = 2t` this is
`X^(2t) ∣ σ S − ω`, the key equation of the decoder. -/
theorem locator_key_equation {F : Type} [Field F] [DecidableEq F] (D : Finset F) (N : ℕ) :
X ^ N ∣ locDual D * synP D N - omegaD D :=
⟨-∑ v ∈ D, C (v ^ (N + 1)) * ∏ w ∈ D.erase v, (1 - C w * X), by
rw [locDual_mul_synP]
ring⟩
theorem pdec_natDegree_finset_prod_le {α F : Type} [Field F] [DecidableEq F] (s : Finset α)
(f : α → F[X]) (h : ∀ i ∈ s, (f i).natDegree ≤ 1) : (∏ i ∈ s, f i).natDegree ≤ s.card := by
refine le_trans (Polynomial.natDegree_prod_le s f) ?_
refine le_trans (Finset.sum_le_sum (fun i hi => h i hi)) ?_
simp
/-- Every factor `1 − vX` has degree at most one. -/
theorem pdec_one_sub_C_mul_X_natDegree_le {F : Type} [Field F] (v : F) :
(1 - C v * X : F[X]).natDegree ≤ 1 := by
have h1 : (C v * X : F[X]).natDegree ≤ 1 := by
refine le_trans (Polynomial.natDegree_mul_le) ?_
rw [Polynomial.natDegree_C, Polynomial.natDegree_X]
have h2 : (1 : F[X]).natDegree ≤ 1 := by
rw [Polynomial.natDegree_one]
omega
refine le_trans (Polynomial.natDegree_sub_le (1 : F[X]) (C v * X)) (max_le h2 h1)
/-- `1 − vX` is nonzero when `v ≠ 0`. -/
theorem pdec_one_sub_C_mul_X_ne_zero {F : Type} [Field F] {v : F} (hv : v ≠ 0) :
(1 - C v * X : F[X]) ≠ 0 := by
intro h
have h1 : (1 - C v * X : F[X]).coeff 1 = -v := by
rw [Polynomial.coeff_sub, Polynomial.coeff_one, Polynomial.coeff_C_mul, Polynomial.coeff_X]
simp
rw [h] at h1
simp at h1
exact hv (by simpa using h1)
theorem locDual_ne_zero {F : Type} [Field F] [DecidableEq F] (D : Finset F)
(h0 : ∀ v ∈ D, v ≠ 0) : locDual D ≠ 0 := by
classical
rw [locDual]
intro h
obtain ⟨v, hv, hz⟩ := Finset.prod_eq_zero_iff.mp h
exact pdec_one_sub_C_mul_X_ne_zero (h0 v hv) hz
/-- `deg σ ≤ #D`: the dual locator has at most `#D` factors of degree one. -/
theorem locDual_natDegree_le {F : Type} [Field F] [DecidableEq F] (D : Finset F) :
(locDual D).natDegree ≤ D.card :=
pdec_natDegree_finset_prod_le D (fun v => 1 - C v * X)
(fun v _ => pdec_one_sub_C_mul_X_natDegree_le v)
/-- Each summand of `ω` spans `D.erase v`. -/
theorem pdec_omegaD_term_le {F : Type} [Field F] [DecidableEq F] (D : Finset F) (v : F) :
(C v * ∏ w ∈ D.erase v, (1 - C w * X) : F[X]).natDegree ≤ (D.erase v).card := by
have h1 : (C v * ∏ w ∈ D.erase v, (1 - C w * X) : F[X]).natDegree
≤ (C v : F[X]).natDegree + (∏ w ∈ D.erase v, (1 - C w * X)).natDegree :=
Polynomial.natDegree_mul_le
have h2 : (C v : F[X]).natDegree = 0 := Polynomial.natDegree_C v
have h3 : (∏ w ∈ D.erase v, (1 - C w * X)).natDegree ≤ (D.erase v).card :=
pdec_natDegree_finset_prod_le _ _ (fun w _ => pdec_one_sub_C_mul_X_natDegree_le w)
omega
/-- **`deg ω < #D`** for a nonempty support: each cofactor spans `D.erase v`. -/
theorem omegaD_natDegree_lt {F : Type} [Field F] [DecidableEq F] (D : Finset F)
(hne : D.Nonempty) : (omegaD D).natDegree < D.card := by
have hcard : 0 < D.card := Finset.card_pos.mpr hne
have hle : (omegaD D).natDegree ≤ D.card - 1 := by
refine pdec_natDegree_finset_sum_le D
(fun v => C v * ∏ w ∈ D.erase v, (1 - C w * X)) (D.card - 1) (fun v hv => ?_)
have hlt : (D.erase v).card < D.card := Finset.card_erase_lt_of_mem hv
have := pdec_omegaD_term_le D v
omega
omega
/-- `deg ω < t` as soon as `#D ≤ t` --- the empty support included (`ω = 0`, `deg 0 = 0 < t`). -/
theorem omegaD_natDegree_lt_of_card {F : Type} [Field F] [DecidableEq F] (D : Finset F) (t : ℕ)
(ht : 1 ≤ t) (hcard : D.card ≤ t) : (omegaD D).natDegree < t := by
by_cases h : D = ∅
· subst h
have : omegaD (∅ : Finset F) = 0 := by simp [omegaD]
rw [this, Polynomial.natDegree_zero]
omega
· have hne : D.Nonempty := Finset.nonempty_iff_ne_empty.mpr h
have := omegaD_natDegree_lt D hne
omega
theorem locDual_eval {F : Type} [Field F] [DecidableEq F] (D : Finset F) (u : F) :
(locDual D).eval u = ∏ v ∈ D, (1 - v * u) := by
rw [locDual, eval_prod]
exact Finset.prod_congr rfl (fun v _ => by simp)
/-- The dual locator vanishes at the inverse of every support point. -/
theorem locDual_eval_inv {F : Type} [Field F] [DecidableEq F] (D : Finset F) {v : F} (hv : v ≠ 0)
(hmem : v ∈ D) : (locDual D).eval v⁻¹ = 0 := by
rw [locDual_eval, Finset.prod_eq_zero_iff]
exact ⟨v, hmem, by simp [hv]⟩
theorem omegaD_eval {F : Type} [Field F] [DecidableEq F] (D : Finset F) (u : F) :
(omegaD D).eval u = ∑ v ∈ D, v * ∏ w ∈ D.erase v, (1 - w * u) := by
classical
have hsum : (omegaD D).eval u
= ∑ v ∈ D, (C v * ∏ w ∈ D.erase v, (1 - C w * X) : F[X]).eval u := by
unfold omegaD
rw [show (∑ v ∈ D, C v * ∏ w ∈ D.erase v, (1 - C w * X) : F[X]).eval u
= Polynomial.evalRingHom u (∑ v ∈ D, C v * ∏ w ∈ D.erase v, (1 - C w * X)) from rfl,
map_sum]
exact Finset.sum_congr rfl (fun v _ => rfl)
rw [hsum]
refine Finset.sum_congr rfl (fun v _ => ?_)
rw [eval_mul, eval_C, eval_prod]
congr 1
exact Finset.prod_congr rfl (fun w _ => by simp)
/-- **`ω` does not vanish at the inverse of a support point.** Every term of the sum except the
`v`-th contains the factor `1 − v v⁻¹ = 0`; the `v`-th term is a product of nonzero factors. -/
theorem omegaD_eval_inv_ne {F : Type} [Field F] [DecidableEq F] (D : Finset F) {v : F} (hv : v ≠ 0)
(hmem : v ∈ D) : (omegaD D).eval v⁻¹ ≠ 0 := by
classical
have hsingle : (∑ v' ∈ D, v' * ∏ w ∈ D.erase v', (1 - w * v⁻¹))
= v * ∏ w ∈ D.erase v, (1 - w * v⁻¹) := by
refine Finset.sum_eq_single v ?_ ?_
· intro w _ hwv
refine mul_eq_zero.mpr (Or.inr ?_)
refine Finset.prod_eq_zero_iff.mpr ⟨v, ?_, ?_⟩
· rw [Finset.mem_erase]
exact ⟨Ne.symm hwv, hmem⟩
· rw [mul_inv_cancel₀ hv]
ring
· intro hnot
exact absurd hmem hnot
rw [omegaD_eval, hsingle]
have hprod : (∏ w ∈ D.erase v, (1 - w * v⁻¹)) ≠ 0 := by
intro hz
obtain ⟨w, hw, hwz⟩ := Finset.prod_eq_zero_iff.mp hz
rw [Finset.mem_erase] at hw
exact hw.1 (by
have h1 : w * v⁻¹ = 1 := (sub_eq_zero.mp hwz).symm
calc w = w * v⁻¹ * v := by rw [mul_assoc, inv_mul_cancel₀ hv, mul_one]
_ = 1 * v := by rw [h1]
_ = v := one_mul v)
intro hzero
rcases mul_eq_zero.mp hzero with h | h
· exact hv h
· exact hprod h
/-- A solution of the key equation for the stored power sums is one for the support they come from. -/
theorem keySol_of_keySolE {F : Type} [Field F] [DecidableEq F] {D : Finset F} {e : ℕ → F} {t : ℕ}
{σ ω : F[X]} (he : ∀ j < 2 * t, e j = ∑ v ∈ D, v ^ (j + 1)) (h : KeySolE e t σ ω) :
KeySol D t σ ω := by
obtain ⟨h1, h2, h3, h4⟩ := h
refine ⟨h1, h2, h3, ?_⟩
have hs : synP D (2 * t) = ∑ j ∈ Finset.range (2 * t), C (e j) * X ^ j := by
unfold synP
exact Finset.sum_congr rfl (fun j hj => by rw [← he j (Finset.mem_range.mp hj)])
rw [hs]
exact h4
/-- The locator pair of a support of size `≤ t` **is** a key solution. -/
theorem locator_isKeySol {F : Type} [Field F] [DecidableEq F] (D : Finset F) (t : ℕ)
(h0 : ∀ v ∈ D, v ≠ 0) (ht : 1 ≤ t) (hcard : D.card ≤ t) :
KeySol D t (locDual D) (omegaD D) :=
⟨locDual_ne_zero D h0, le_trans (locDual_natDegree_le D) hcard,
omegaD_natDegree_lt_of_card D t ht hcard, locator_key_equation D (2 * t)⟩
/-- **Root containment**: for *any* key solution and any support point `v`, `v⁻¹` is a root of
`σ`. The cross-multiplied uniqueness of the key equation gives `σ ω₀ = σ₀ ω`; at `v⁻¹` the right
side vanishes (the locator has a root there) while `ω₀(v⁻¹) ≠ 0`. -/
theorem keySol_root_containment {F : Type} [Field F] [DecidableEq F] (D : Finset F) (t : ℕ)
(h0 : ∀ v ∈ D, v ≠ 0) (ht : 1 ≤ t) (hcard : D.card ≤ t)
{σ ω : F[X]} (hσ : KeySol D t σ ω) :
∀ v ∈ D, σ.eval v⁻¹ = 0 := by
intro v hv
have hσ₀ : KeySol D t (locDual D) (omegaD D) := locator_isKeySol D t h0 ht hcard
have huniq : σ * omegaD D = locDual D * ω :=
key_equation_unique (synP D (2 * t)) t hσ.1 hσ₀.1 hσ.2.1 hσ₀.2.1 hσ.2.2.1 hσ₀.2.2.1
hσ.2.2.2 hσ₀.2.2.2
have hev : σ.eval v⁻¹ * (omegaD D).eval v⁻¹ = (locDual D).eval v⁻¹ * ω.eval v⁻¹ := by
rw [← eval_mul, huniq, eval_mul]
rw [locDual_eval_inv D (h0 v hv) hv, zero_mul] at hev
rcases mul_eq_zero.mp hev with h | h
· exact h
· exact absurd h (omegaD_eval_inv_ne D (h0 v hv) hv)
theorem pdec_finProdFinEquiv_val {t w : ℕ} (j : Fin t) (k : Fin w) :
(finProdFinEquiv (j, k)).val = j.val * w + k.val := by
simp [finProdFinEquiv, Nat.mul_comm, Nat.add_comm]
theorem pdec_finProdFinEquiv_mk {t w : ℕ} (j : Fin t) (k : Fin w)
(h : j.val * w + k.val < t * w) :
finProdFinEquiv (j, k) = (⟨j.val * w + k.val, h⟩ : Fin (t * w)) := by
refine Fin.ext ?_
rw [pdec_finProdFinEquiv_val]
theorem pdec_finProdFinEquiv_symm {t w : ℕ} (j : Fin t) (k : Fin w)
(h : j.val * w + k.val < t * w) :
finProdFinEquiv.symm (⟨j.val * w + k.val, h⟩ : Fin (t * w)) = (j, k) := by
have hp := pdec_finProdFinEquiv_mk j k h
rw [← hp, Equiv.symm_apply_apply]
/-- The bit of the payload at position `j·w + k` is the `k`-th coordinate of the `j`-th field. -/
theorem payloadField_apply_bits {F : Type} [Field F] [Algebra (ZMod 2) F] {w t : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (y : Fin (t * w) → ZMod 2) (j : Fin t) (k : Fin w)
(h : j.val * w + k.val < t * w) :
y (⟨j.val * w + k.val, h⟩ : Fin (t * w)) = b.repr (payloadField b y j) k := by
rw [payloadField_apply]
unfold payloadAt
rw [dif_pos h]
/-- **Stage B, finished**: the `j`-th field of the packed payload is the `j`-th syndrome
coordinate. -/
theorem payloadField_pinBits {F : Type} [Field F] [Algebra (ZMod 2) F] {w t : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (s : Fin t → F) (j : Fin t) :
payloadField b (pinBits b s) j = s j := by
apply b.repr.injective
refine Finsupp.ext (fun k => ?_)
rw [payloadField_apply]
have hlt : j.val * w + k.val < t * w := by
have h1 : j.val < t := j.isLt
have h2 : k.val < w := k.isLt
have hstep : j.val * w + k.val < j.val * w + w := Nat.add_lt_add_left h2 _
have hstep2 : j.val * w + w = (j.val + 1) * w := by rw [Nat.add_mul, Nat.one_mul]
have hstep3 : (j.val + 1) * w ≤ t * w := Nat.mul_le_mul_right _ h1
calc j.val * w + k.val < j.val * w + w := hstep
_ = (j.val + 1) * w := hstep2
_ ≤ t * w := hstep3
unfold payloadAt
rw [dif_pos hlt]
show b.repr (s (finProdFinEquiv.symm ⟨j.val * w + k.val, hlt⟩).1)
(finProdFinEquiv.symm ⟨j.val * w + k.val, hlt⟩).2 = b.repr (s j) k
rw [pdec_finProdFinEquiv_symm j k hlt]
/-- The converse bridge: a syndrome whose payload fields are `payloadField b y` has payload `y`. -/
theorem pinBits_payloadField {F : Type} [Field F] [Algebra (ZMod 2) F] {w t : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) {y : Fin (t * w) → ZMod 2} {s : Fin t → F}
(h : ∀ j : Fin t, s j = payloadField b y j) : pinBits b s = y := by
funext p
set q : Fin t × Fin w := finProdFinEquiv.symm p with hq
have hp : finProdFinEquiv q = p := Equiv.apply_symm_apply _ _
obtain ⟨j, k⟩ := q
have hval : j.val * w + k.val = p.val := by
have := congrArg Fin.val hp
rwa [pdec_finProdFinEquiv_val] at this
have hlt : j.val * w + k.val < t * w := by rw [hval]; exact p.isLt
have hp' : p = (⟨j.val * w + k.val, hlt⟩ : Fin (t * w)) := by
rw [← hp, pdec_finProdFinEquiv_mk j k hlt]
show b.repr (s (finProdFinEquiv.symm p).1) (finProdFinEquiv.symm p).2 = y p
have hsymm : finProdFinEquiv.symm p = (j, k) := by
rw [hp', pdec_finProdFinEquiv_symm j k hlt]
rw [hsymm, h j, ← payloadField_apply_bits b y j k hlt, hp']
/-- **The numbers the verifier compares against are the true power sums.** The machine stores
`s_j = e j` for `j < 2t`: odd-indexed power sums `s_{2k} = P_{2k+1}` are read out of the packed
payload (`hodd`), and the even-indexed ones are squares, `s_{2a-1} = s_{a-1}²` (`heven`, the paper's
`P_{2a} = P_a²`). Then `e (a-1)` is the true power sum `P_a` for every `a ∈ [1, 2t]`. -/
theorem expected_eq_pinPower {F : Type} [Field F] [Algebra (ZMod 2) F] {N t : ℕ}
(ι : ℕ → F) (x : Fin N → ZMod 2) (e : ℕ → F)
(hodd : ∀ k : Fin t, e (2 * k.val) = pin ι t x k)
(heven : ∀ a : ℕ, 0 < a → e (2 * a - 1) = e (a - 1) ^ 2) :
∀ a : ℕ, 1 ≤ a → a ≤ 2 * t → e (a - 1) = pinPower ι a x := by
intro a
induction a using Nat.strong_induction_on with
| _ a ih =>
intro ha1 ha2
rcases Nat.even_or_odd a with ⟨k, rfl⟩ | ⟨k, rfl⟩
· -- even: `e (2k-1) = e (k-1)² = P_k² = P_{2k}`
have hkpos : 0 < k := by omega
have hklt : k < k + k := by omega
have hk1 : 1 ≤ k := hkpos
have hk2 : k ≤ 2 * t := by omega
have hidx : k + k - 1 = 2 * k - 1 := by omega
rw [hidx, heven k hkpos, ih k hklt hk1 hk2]
rw [show k + k = 2 * k by omega, pinPower_frobenius]
· -- odd: read out of the payload
have hkt : k < t := by omega
have hidx : 2 * k + 1 - 1 = 2 * k := by omega
rw [hidx, hodd ⟨k, hkt⟩]
rfl
theorem mem_binSupp_vecOf {F : Type} [Field F] [DecidableEq F] (N : ℕ) (ι : ℕ → F)
(D : Finset F) (i : Fin N) : i ∈ binSupp (vecOf N ι D) ↔ ι i.val ∈ D := by
rw [mem_binSupp]
by_cases h : ι i.val ∈ D <;> simp [vecOf, h]
/-- **The power sums of a support**, read off a vector whose support is that set. -/
theorem pinPower_eq_sum_support {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F]
{N : ℕ} (ι : ℕ → F) (x : Fin N → ZMod 2) (D : Finset F)
(hD : ∀ v, v ∈ D ↔ ∃ i : Fin N, ι i.val = v ∧ x i = 1)
(hinj : Set.InjOn ι (Set.Iio N)) (a : ℕ) :
pinPower ι a x = ∑ v ∈ D, v ^ a := by
rw [pinPower_eq_sum_supp]
have himg : (binSupp x).image (fun i => ι i.val) = D := by
ext v
rw [hD v, Finset.mem_image]
constructor
· rintro ⟨i, hi, hv⟩
exact ⟨i, hv, mem_binSupp.mp hi⟩
· rintro ⟨i, hv, hi⟩
exact ⟨i, mem_binSupp.mpr hi, hv⟩
have hinj' : ∀ i ∈ binSupp x, ∀ j ∈ binSupp x, ι i.val = ι j.val → i = j := by
intro i _ j _ h
exact Fin.ext (hinj i.isLt j.isLt h)
rw [← himg, Finset.sum_image hinj']
/-- The power sums of the answer vector are the power sums of the candidate set. -/
theorem pinPower_vecOf {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {N : ℕ}
(ι : ℕ → F) (D : Finset F) (hinj : Set.InjOn ι (Set.Iio N))
(hD : ∀ v ∈ D, ∃ i : Fin N, ι i.val = v) (a : ℕ) :
pinPower ι a (vecOf N ι D) = ∑ v ∈ D, v ^ a := by
refine pinPower_eq_sum_support ι _ D ?_ hinj a
intro v
constructor
· intro hv
obtain ⟨i, hi⟩ := hD v hv
have hmem : ι i.val ∈ D := by rw [hi]; exact hv
exact ⟨i, hi, mem_binSupp.mp ((mem_binSupp_vecOf N ι D i).mpr hmem)⟩
· rintro ⟨i, hi, hx⟩
have hmem : ι i.val ∈ D := (mem_binSupp_vecOf N ι D i).mp (mem_binSupp.mpr hx)
exact hi ▸ hmem
/-- The answer vector has exactly `#D` support points. -/
theorem card_binSupp_vecOf {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {N : ℕ}
(ι : ℕ → F) (D : Finset F) (hinj : Set.InjOn ι (Set.Iio N))
(hD : ∀ v ∈ D, ∃ i : Fin N, ι i.val = v) :
(binSupp (vecOf N ι D)).card = D.card := by
have himg : (binSupp (vecOf N ι D)).image (fun i => ι i.val) = D := by
ext v
rw [Finset.mem_image]
constructor
· rintro ⟨i, hi, rfl⟩
exact (mem_binSupp_vecOf N ι D i).mp hi
· intro hv
obtain ⟨i, hi⟩ := hD v hv
have hmem : i ∈ binSupp (vecOf N ι D) := by
rw [mem_binSupp_vecOf]
rw [hi]
exact hv
exact ⟨i, hmem, hi⟩
have hinj' : ∀ i ∈ binSupp (vecOf N ι D), ∀ j ∈ binSupp (vecOf N ι D),
ι i.val = ι j.val → i = j := by
intro i _ j _ h
exact Fin.ext (hinj i.isLt j.isLt h)
conv_rhs => rw [← himg]
rw [Finset.card_image_of_injOn hinj']
/-- A solution of the key equation for a support is one for the power sums it stores. -/
theorem keySolE_of_keySol {F : Type} [Field F] [DecidableEq F] {D : Finset F} {e : ℕ → F} {t : ℕ}
{σ ω : F[X]} (he : ∀ j < 2 * t, e j = ∑ v ∈ D, v ^ (j + 1)) (h : KeySol D t σ ω) :
KeySolE e t σ ω := by
obtain ⟨h1, h2, h3, h4⟩ := h
refine ⟨h1, h2, h3, ?_⟩
have hs : synP D (2 * t) = ∑ j ∈ Finset.range (2 * t), C (e j) * X ^ j := by
unfold synP
exact Finset.sum_congr rfl (fun j hj => by rw [← he j (Finset.mem_range.mp hj)])
rwa [hs] at h4
/-- **Accept**: if the verification test passes on the candidate `D'`, then the answer vector has
weight `≤ t` and exactly the right sketch --- so it *is* the light vector, and `OutputsSupport`
follows from the list of positions (`outputsSupport_of_mem` in the calculus). -/
theorem decoder_accept {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {N t w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (y : Fin (t * w) → ZMod 2) (e : ℕ → F)
(hinj : Set.InjOn ι (Set.Iio N))
(hodd : ∀ k : Fin t, e (2 * k.val) = payloadField b y k)
(D' : Finset F) (hD' : ∀ v ∈ D', ∃ i : Fin N, ι i.val = v) (hcard : D'.card ≤ t)
(hver : ∀ a ∈ Finset.Icc 1 (2 * t), ∑ v ∈ D', v ^ a = e (a - 1)) :
∃ x : Fin N → ZMod 2, (binSupp x).card ≤ t ∧ pinBits b (pin ι t x) = y ∧
∀ i : Fin N, x i = 1 ↔ ι i.val ∈ D' := by
refine ⟨vecOf N ι D', ?_, ?_, ?_⟩
· rw [card_binSupp_vecOf ι D' hinj hD']
exact hcard
· refine pinBits_payloadField b (s := pin ι t (vecOf N ι D')) (fun k => ?_)
have h1 : pin ι t (vecOf N ι D') k = pinPower ι (2 * k.val + 1) (vecOf N ι D') := rfl
rw [h1, pinPower_vecOf ι D' hinj hD']
rw [← hodd k]
have h2 := hver (2 * k.val + 1) (by
rw [Finset.mem_Icc]
have := k.isLt
omega)
have h3 : 2 * k.val + 1 - 1 = 2 * k.val := by omega
rw [h3] at h2
exact h2
· intro i
by_cases h : ι i.val ∈ D' <;> simp [vecOf, h]
@[simp] theorem traceValue_zero {F : Type} [Field F] (n : ℕ) :
traceValue n (0 : F) = 0 := by
induction n with
| zero => rfl
| succ n ih => simp [traceValue, ih]
theorem traceValue_add {F : Type} [Field F] [Algebra (ZMod 2) F]
(n : ℕ) (x y : F) : traceValue n (x + y) = traceValue n x + traceValue n y := by
haveI : CharP F 2 := pinsketch_charP
induction n with
| zero => simp [traceValue]
| succ n ih =>
simp only [traceValue, ih, CharTwo.add_sq]
ring
/-- Trace is an `F₂`-linear map. -/
def traceLinear {F : Type} [Field F] [Algebra (ZMod 2) F] (n : ℕ) : F →ₗ[ZMod 2] F where
toFun := traceValue n
map_add' := traceValue_add n
map_smul' := by
intro c x
rcases zmod2_eq_zero_or_one c with hc | hc <;> simp [hc]
theorem tracePolynomial_eval {F : Type} [Field F] (a x : F) (n : ℕ) :
(tracePolynomial a n).eval x = traceValue n (a * x) := by
induction n with
| zero => simp [tracePolynomial, traceValue]
| succ n ih => simp [tracePolynomial, traceValue, ih]
/-- The sparse trace polynomial has degree strictly below the field size.
The implementation evaluates it modulo the current factor by `n` squarings. -/
theorem tracePolynomial_natDegree_lt {F : Type} [Field F] (a : F) (n : ℕ) :
(tracePolynomial a n).natDegree < 2 ^ n := by
induction n with
| zero => simp [tracePolynomial]
| succ n ih =>
have hsq : ((tracePolynomial a n) ^ 2).natDegree ≤
2 * (tracePolynomial a n).natDegree := by
simpa only [pow_two, two_mul] using
(Polynomial.natDegree_mul_le (p := tracePolynomial a n) (q := tracePolynomial a n))
have hlin : (C a * X : F[X]).natDegree ≤ 1 := by
simpa only [pow_one] using Polynomial.natDegree_C_mul_X_pow_le a 1
have hsum := Polynomial.natDegree_add_le ((tracePolynomial a n) ^ 2) (C a * X)
change (((tracePolynomial a n) ^ 2) + C a * X).natDegree < 2 ^ (n + 1)
rw [Nat.pow_succ]
have hp := Nat.two_pow_pos n
omega
/-- Its derivative is nonzero whenever at least one term is present. -/
theorem tracePolynomial_derivative {F : Type} [Field F] [Algebra (ZMod 2) F] (n : ℕ) :
Polynomial.derivative (tracePolynomial (1 : F) (n + 1)) = 1 := by
simp [tracePolynomial, Polynomial.derivative_sq, pinsketch_two_eq_zero (F := F)]
theorem traceValue_square_add {F : Type} [Field F] [Algebra (ZMod 2) F]
(n : ℕ) (z : F) : traceValue n z ^ 2 + traceValue n z = z ^ (2 ^ n) + z := by
haveI : CharP F 2 := pinsketch_charP
induction n with
| zero => simp [traceValue, CharTwo.add_self_eq_zero]
| succ n ih =>
have hs := congrArg (fun a : F => a ^ 2) ih
rw [CharTwo.add_sq, CharTwo.add_sq] at hs
have hp : z ^ (2 ^ (n + 1)) = (z ^ (2 ^ n)) ^ 2 := by
rw [Nat.pow_succ, pow_mul]
calc
traceValue (n + 1) z ^ 2 + traceValue (n + 1) z
= ((traceValue n z ^ 2) ^ 2 + traceValue n z ^ 2) + z ^ 2 + z := by
simp only [traceValue, CharTwo.add_sq]
ring
_ = ((z ^ (2 ^ n)) ^ 2 + z ^ 2) + z ^ 2 + z := by rw [hs]
_ = (z ^ (2 ^ n)) ^ 2 + ((z ^ 2 + z ^ 2) + z) := by ring
_ = z ^ (2 ^ (n + 1)) + z := by rw [CharTwo.add_self_eq_zero, zero_add, ← hp]
/-- Cardinality and Frobenius follow from the supplied basis, independent of
which concrete finite field represents the coordinates. -/
theorem field_pow_two_dim {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (z : F) : z ^ (2 ^ w) = z := by
letI : Fintype F := Fintype.ofEquiv (Fin w → ZMod 2) b.equivFun.toEquiv.symm
have hcard : Fintype.card F = 2 ^ w := by
calc
Fintype.card F = Fintype.card (Fin w → ZMod 2) :=
Fintype.card_congr b.equivFun.toEquiv
_ = 2 ^ w := by simp
rw [← hcard]
exact FiniteField.pow_card z
/-- Every trace value is a bit. -/
theorem traceValue_bit {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (z : F) :
traceValue w z = 0 ∨ traceValue w z = 1 := by
haveI : CharP F 2 := pinsketch_charP
have h := traceValue_square_add w z
rw [field_pow_two_dim b z, CharTwo.add_self_eq_zero] at h
have hs : traceValue w z ^ 2 = traceValue w z := pinsketch_eq_of_add_eq_zero h
have hp : traceValue w z * (traceValue w z - 1) = 0 := by
calc
traceValue w z * (traceValue w z - 1) = traceValue w z ^ 2 - traceValue w z := by ring
_ = 0 := by rw [hs, sub_self]
rcases mul_eq_zero.mp hp with h0 | h1
· exact Or.inl h0
· exact Or.inr (sub_eq_zero.mp h1)
/-- Trace is a nonzero functional. The proof uses a degree bound; the
algorithm itself never enumerates the field. -/
theorem traceValue_nonzero {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (hw : 0 < w) :
∃ z : F, traceValue w z ≠ 0 := by
classical
letI : Fintype F := Fintype.ofEquiv (Fin w → ZMod 2) b.equivFun.toEquiv.symm
have hcard : Fintype.card F = 2 ^ w := by
calc
Fintype.card F = Fintype.card (Fin w → ZMod 2) :=
Fintype.card_congr b.equivFun.toEquiv
_ = 2 ^ w := by simp
by_contra h
push_neg at h
have hp : tracePolynomial (1 : F) w = 0 := by
apply pdec_eq_zero_of_card (s := Finset.univ)
· rw [Finset.card_univ, hcard]
exact tracePolynomial_natDegree_lt 1 w
· intro z _
simpa only [tracePolynomial_eval, one_mul] using h z
obtain ⟨n, hn⟩ := Nat.exists_eq_succ_of_ne_zero hw.ne'
rw [hn] at hp
have hd := tracePolynomial_derivative (F := F) n
rw [hp, Polynomial.derivative_zero] at hd
exact zero_ne_one hd
/-- Traces against basis vectors detect every nonzero element. -/
theorem basis_trace_detects {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (hw : 0 < w) {z : F} (hz : z ≠ 0) :
∃ j : Fin w, traceValue w (b j * z) ≠ 0 := by
classical
obtain ⟨c, hc⟩ := traceValue_nonzero b hw
by_contra h
push_neg at h
let L : F →ₗ[ZMod 2] F :=
{ toFun := fun a => traceValue w (a * z)
map_add' := fun a d => by rw [add_mul, traceValue_add]
map_smul' := by
intro a d
rcases zmod2_eq_zero_or_one a with ha | ha <;> simp [ha] }
have hL : L = 0 := b.ext (fun j => by
change traceValue w (b j * z) = 0
exact h j)
have hcz := congrArg (fun f : F →ₗ[ZMod 2] F => f (c / z)) hL
change traceValue w (c / z * z) = 0 at hcz
rw [div_mul_cancel₀ c hz] at hcz
exact hc hcz
/-- The `w` trace splitters separate all field elements. -/
theorem basis_trace_separates {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (hw : 0 < w) {u v : F} (h : u ≠ v) :
∃ j : Fin w, (tracePolynomial (b j) w).eval u ≠ (tracePolynomial (b j) w).eval v := by
obtain ⟨j, hj⟩ := basis_trace_detects b hw (sub_ne_zero.mpr h)
refine ⟨j, ?_⟩
rw [tracePolynomial_eval, tracePolynomial_eval]
intro heq
apply hj
rw [mul_sub]
change traceLinear w (b j * u - b j * v) = 0
rw [map_sub]
change traceValue w (b j * u) - traceValue w (b j * v) = 0
rw [heq, sub_self]
/-- Evaluation form of membership in the finite root set. -/
theorem rootSet_mem_iff {F : Type} [Field F] [DecidableEq F]
{f : F[X]} (hf : f ≠ 0) (u : F) :
u ∈ f.roots.toFinset ↔ f.eval u = 0 := by
rw [Multiset.mem_toFinset, Polynomial.mem_roots hf, Polynomial.IsRoot.def]
theorem constant_eval_ne_zero {F : Type} [Field F] {f : F[X]}
(hf : f ≠ 0) (hdeg : f.natDegree = 0) (u : F) : f.eval u ≠ 0 := by
obtain ⟨a, ha⟩ := Polynomial.natDegree_eq_zero.mp hdeg
intro hu
rw [← ha, Polynomial.eval_C] at hu
exact hf (by rw [← ha, hu, Polynomial.C_0])
/-- Splitting is correct on a square-free split input. The condition is only
needed for completeness; the later syndrome verifier certifies every accepted
answer independently. -/
theorem rootSearch_spec {F : Type} [Field F] [DecidableEq F]
(ps : List F[X]) (f : F[X]) (hf : f ≠ 0) (hsplit : f.Splits) (hsep : f.Separable)
(hbit : ∀ p ∈ ps, ∀ u : F, p.eval u = 0 ∨ p.eval u = 1)
(hsepar : SeparatesRoots ps f) :
(rootSearch ps f).Nodup ∧ ∀ u : F, u ∈ rootSearch ps f ↔ f.eval u = 0 := by
induction ps generalizing f with
| nil =>
have hcard : f.roots.toFinset.card ≤ 1 := by
apply Finset.card_le_one.mpr
intro u hu v hv
by_contra hne
obtain ⟨p, hp, _⟩ := hsepar u v ((rootSet_mem_iff hf u).mp hu)
((rootSet_mem_iff hf v).mp hv) hne
simp at hp
rw [Multiset.toFinset_card_of_nodup (Polynomial.nodup_roots hsep)] at hcard
have hdeg : f.natDegree ≤ 1 := by
rw [hsplit.natDegree_eq_card_roots]
exact hcard
by_cases hone : f.natDegree = 1
· rw [rootSearch, if_pos hone]
refine ⟨by simp, ?_⟩
intro u
simpa only [List.mem_singleton] using (linearRoot_eval_iff hf hone u).symm
· have hzero : f.natDegree = 0 := by omega
rw [rootSearch, if_neg hone]
refine ⟨by simp, ?_⟩
intro u
simp [constant_eval_ne_zero hf hzero u]
| cons p ps ih =>
by_cases hzero : f.natDegree = 0
· rw [rootSearch, if_pos hzero]
refine ⟨by simp, ?_⟩
intro u
simp [constant_eval_ne_zero hf hzero u]
· let g0 := EuclideanDomain.gcd f p
let g1 := EuclideanDomain.gcd f (p - 1)
have h0ne : g0 ≠ 0 := gcd_ne_zero_left hf p
have h1ne : g1 ≠ 0 := gcd_ne_zero_left hf (p - 1)
have h0dvd : g0 ∣ f := EuclideanDomain.gcd_dvd_left f p
have h1dvd : g1 ∣ f := EuclideanDomain.gcd_dvd_left f (p - 1)
have h0root (u : F) : g0.eval u = 0 ↔ f.eval u = 0 ∧ p.eval u = 0 :=
gcd_eval_iff f p u
have h1root (u : F) : g1.eval u = 0 ↔ f.eval u = 0 ∧ p.eval u = 1 := by
change (EuclideanDomain.gcd f (p - 1)).eval u = 0 ↔ f.eval u = 0 ∧ p.eval u = 1
rw [gcd_eval_iff]
simp only [Polynomial.eval_sub, Polynomial.eval_one, sub_eq_zero]
have htailbit : ∀ q ∈ ps, ∀ u : F, q.eval u = 0 ∨ q.eval u = 1 := by
intro q hq u
exact hbit q (List.mem_cons_of_mem p hq) u
have htail (g : F[X]) (hsub : ∀ u, g.eval u = 0 → f.eval u = 0)
(hsame : ∀ u v, g.eval u = 0 → g.eval v = 0 → p.eval u = p.eval v) :
SeparatesRoots ps g := by
intro u v hu hv huv
obtain ⟨q, hq, hne⟩ := hsepar u v (hsub u hu) (hsub v hv) huv
rcases List.mem_cons.mp hq with hq | hq
· subst q
exact False.elim (hne (hsame u v hu hv))
· exact ⟨q, hq, hne⟩
have hsep0 : SeparatesRoots ps g0 := htail g0
(fun u hu => ((h0root u).mp hu).1)
(fun u v hu hv => (((h0root u).mp hu).2).trans ((((h0root v).mp hv).2).symm))
have hsep1 : SeparatesRoots ps g1 := htail g1
(fun u hu => ((h1root u).mp hu).1)
(fun u v hu hv => (((h1root u).mp hu).2).trans ((((h1root v).mp hv).2).symm))
obtain ⟨hnd0, hmem0⟩ := ih g0 h0ne (hsplit.of_dvd hf h0dvd)
(hsep.of_dvd h0dvd) htailbit hsep0
obtain ⟨hnd1, hmem1⟩ := ih g1 h1ne (hsplit.of_dvd hf h1dvd)
(hsep.of_dvd h1dvd) htailbit hsep1
have hdisj : List.Disjoint (rootSearch ps g0) (rootSearch ps g1) := by
apply List.disjoint_left.mpr
intro u hu0 hu1
have h0 := ((h0root u).mp ((hmem0 u).mp hu0)).2
have h1 := ((h1root u).mp ((hmem1 u).mp hu1)).2
exact zero_ne_one (h0.symm.trans h1)
rw [rootSearch, if_neg hzero]
refine ⟨List.nodup_append'.mpr ⟨hnd0, hnd1, hdisj⟩, ?_⟩
intro u
change (u ∈ rootSearch ps g0 ++ rootSearch ps g1) ↔ f.eval u = 0
rw [List.mem_append, hmem0, hmem1, h0root, h1root]
constructor
· rintro (h | h) <;> exact h.1
· intro hu
rcases hbit p (List.mem_cons_self) u with h0 | h1
· exact Or.inl ⟨hu, h0⟩
· exact Or.inr ⟨hu, h1⟩
/-- The output list fits in the degree budget. -/
theorem rootSearch_length_le {F : Type} [Field F] [DecidableEq F]
(ps : List F[X]) (f : F[X]) (hf : f ≠ 0) (hsplit : f.Splits) (hsep : f.Separable)
(hbit : ∀ p ∈ ps, ∀ u : F, p.eval u = 0 ∨ p.eval u = 1)
(hsepar : SeparatesRoots ps f) : (rootSearch ps f).length ≤ f.natDegree := by
obtain ⟨hnd, hmem⟩ := rootSearch_spec ps f hf hsplit hsep hbit hsepar
have heq : (rootSearch ps f).toFinset = f.roots.toFinset := by
ext u
rw [List.mem_toFinset, hmem, rootSet_mem_iff hf]
calc
(rootSearch ps f).length = (rootSearch ps f).toFinset.card :=
(List.toFinset_card_of_nodup hnd).symm
_ = f.roots.toFinset.card := congrArg Finset.card heq
_ ≤ f.roots.card := Multiset.toFinset_card_le _
_ ≤ f.natDegree := Polynomial.card_roots' f
theorem traceSplitters_bit {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) :
∀ p ∈ traceSplitters b, ∀ u : F, p.eval u = 0 ∨ p.eval u = 1 := by
intro p hp u
obtain ⟨j, rfl⟩ := List.mem_ofFn.mp hp
rw [tracePolynomial_eval]
exact traceValue_bit b (b j * u)
theorem traceSplitters_separates {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (hw : 0 < w) (f : F[X]) :
SeparatesRoots (traceSplitters b) f := by
intro u v _ _ huv
obtain ⟨j, hj⟩ := basis_trace_separates b hw huv
exact ⟨tracePolynomial (b j) w, List.mem_ofFn.mpr ⟨j, rfl⟩, hj⟩
theorem rootsByBasis_spec {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (hw : 0 < w) (f : F[X])
(hf : f ≠ 0) (hsplit : f.Splits) (hsep : f.Separable) :
(rootsByBasis b f).Nodup ∧
(∀ u : F, u ∈ rootsByBasis b f ↔ f.eval u = 0) ∧
(rootsByBasis b f).length ≤ f.natDegree := by
have heq : rootsByBasis b f = rootSearch (traceSplitters b) f := by
rw [rootsByBasis, traceRootSearch_eq]
congr 1
simp [traceSplitters, List.map_ofFn, Function.comp_def]
rw [heq]
have h := rootSearch_spec (traceSplitters b) f hf hsplit hsep
(traceSplitters_bit b) (traceSplitters_separates b hw f)
exact ⟨h.1, h.2, rootSearch_length_le (traceSplitters b) f hf hsplit hsep
(traceSplitters_bit b) (traceSplitters_separates b hw f)⟩
/-- On a decodable sequence, a minimum key solution has exactly the inverse
support roots, with neither missing roots nor multiplicities. -/
theorem minimum_key_roots {F : Type} [Field F] [DecidableEq F]
(D : Finset F) (e : ℕ → F) (t : ℕ) (ht : 1 ≤ t)
(h0 : ∀ v ∈ D, v ≠ 0) (hcard : D.card ≤ t)
(he : ∀ j < 2 * t, e j = ∑ v ∈ D, v ^ (j + 1))
{σ ω : F[X]} (hmin : KeySolEMin e t σ ω) :
σ.Splits ∧ σ.Separable ∧ ∀ u : F, σ.eval u = 0 ↔ u⁻¹ ∈ D := by
let R := D.image (fun v => v⁻¹)
have hRcard : R.card = D.card := Finset.card_image_of_injOn (fun a _ b _ hab => by
rw [← inv_inv a, hab, inv_inv])
have hsub : R ⊆ σ.roots.toFinset := by
intro u hu
obtain ⟨v, hv, rfl⟩ := Finset.mem_image.mp hu
rw [rootSet_mem_iff hmin.1.1]
exact keySol_root_containment D t h0 ht hcard (keySol_of_keySolE he hmin.1) v hv
have htrue : KeySolE e t (locDual D) (omegaD D) :=
keySolE_of_keySol he (locator_isKeySol D t h0 ht hcard)
have hdeg : σ.natDegree ≤ D.card :=
le_trans (hmin.2 _ _ htrue) (locDual_natDegree_le D)
have hcard0 := Finset.card_le_card hsub
have hcard1 := Multiset.toFinset_card_le σ.roots
have hcard2 := Polynomial.card_roots' σ
have hsplit : σ.Splits := Polynomial.splits_iff_card_roots.mpr (by omega)
have hnodup : σ.roots.Nodup :=
Multiset.toFinset_card_eq_card_iff_nodup.mp (by omega)
have hsep : σ.Separable :=
(Polynomial.nodup_roots_iff_of_splits hmin.1.1 hsplit).mp hnodup
have hset : R = σ.roots.toFinset := Finset.eq_of_subset_of_card_le hsub (by omega)
refine ⟨hsplit, hsep, ?_⟩
intro u
rw [← rootSet_mem_iff hmin.1.1, ← hset]
constructor
· intro hu
obtain ⟨v, hv, hvi⟩ := Finset.mem_image.mp hu
have hvu : v = u⁻¹ := by rw [← hvi, inv_inv]
rw [← hvu]
exact hv
· intro hu
exact Finset.mem_image.mpr ⟨u⁻¹, hu, inv_inv u⟩
theorem supportCandidate_eq {F : Type} [Field F] [DecidableEq F]
[Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (hw : 0 < w)
(D : Finset F) (e : ℕ → F) (t : ℕ) (ht : 1 ≤ t)
(h0 : ∀ v ∈ D, v ≠ 0) (hcard : D.card ≤ t)
(he : ∀ j < 2 * t, e j = ∑ v ∈ D, v ^ (j + 1)) :
supportCandidate b (padeSolve e t).curC = D := by
have hmin := padeSolve_minimal e t ht
obtain ⟨hsplit, hsep, hroots⟩ := minimum_key_roots D e t ht h0 hcard he hmin
obtain ⟨_, hmem, _⟩ := rootsByBasis_spec b hw (padeSolve e t).curC hmin.1.1 hsplit hsep
ext v
simp only [supportCandidate, List.mem_toFinset, List.mem_map]
constructor
· rintro ⟨u, hu, huv⟩
have hv := (hroots u).mp ((hmem u).mp hu)
rwa [huv] at hv
· intro hv
refine ⟨v⁻¹, ?_, inv_inv v⟩
exact (hmem v⁻¹).mpr ((hroots v⁻¹).mpr (by simpa using hv))
/-- A successful verifier supplies a valid light-vector answer. -/
theorem verified_candidate_accept {F : Type} [Field F] [DecidableEq F]
[Algebra (ZMod 2) F] {N t w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F)
(y : Fin (t * w) → ZMod 2) (e : ℕ → F) (D : Finset F)
(hinj : Set.InjOn ι (Set.Iio N))
(hodd : ∀ k : Fin t, e (2 * k.val) = payloadField b y k)
(hverified : CandidateVerified N t ι e D) :
∃ x : Fin N → ZMod 2, (binSupp x).card ≤ t ∧ pinBits b (pin ι t x) = y ∧
∀ i : Fin N, x i = 1 ↔ ι i.val ∈ D :=
decoder_accept b ι y e hinj hodd D hverified.2.1 hverified.1 hverified.2.2
/-- Rejection of the computed candidate is complete. Splitting and
separability are derived only under the hypothetical existence of a valid
answer; arbitrary input polynomials do not need to split. -/
theorem computed_candidate_reject {F : Type} [Field F] [DecidableEq F]
[Algebra (ZMod 2) F] {N t w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F)
(y : Fin (t * w) → ZMod 2) (e : ℕ → F) (ht : 1 ≤ t) (hw : 0 < w)
(h0 : ∀ v < N, ι v ≠ 0) (hinj : Set.InjOn ι (Set.Iio N))
(hodd : ∀ k : Fin t, e (2 * k.val) = payloadField b y k)
(heven : ∀ a : ℕ, 0 < a → e (2 * a - 1) = e (a - 1) ^ 2)
(hfail : ¬ CandidateVerified N t ι e (supportCandidate b (padeSolve e t).curC)) :
¬ ∃ x : Fin N → ZMod 2, (binSupp x).card ≤ t ∧ pinBits b (pin ι t x) = y := by
rintro ⟨x, hx, hxy⟩
let D := (binSupp x).image (fun i => ι i.val)
have hDmem : ∀ v, v ∈ D ↔ ∃ i : Fin N, ι i.val = v ∧ x i = 1 := by
intro v
simp only [D, Finset.mem_image, mem_binSupp]
constructor
· rintro ⟨i, hi, hv⟩
exact ⟨i, hv, hi⟩
· rintro ⟨i, hv, hi⟩
exact ⟨i, hi, hv⟩
have hDcard : D.card ≤ t := le_trans (Finset.card_image_le) hx
have hD0 : ∀ v ∈ D, v ≠ 0 := by
intro v hv
obtain ⟨i, hi, _⟩ := (hDmem v).mp hv
rw [← hi]
exact h0 i.val i.isLt
have he : ∀ a : ℕ, 1 ≤ a → a ≤ 2 * t → e (a - 1) = pinPower ι a x := by
refine expected_eq_pinPower ι x e (fun k => ?_) heven
rw [hodd k, ← hxy]
exact payloadField_pinBits b (pin ι t x) k
have hsum : ∀ a : ℕ, 1 ≤ a → a ≤ 2 * t → ∑ v ∈ D, v ^ a = e (a - 1) := by
intro a ha1 ha2
rw [he a ha1 ha2, pinPower_eq_sum_support ι x D hDmem hinj a]
have heD : ∀ j < 2 * t, e j = ∑ v ∈ D, v ^ (j + 1) := by
intro j hj
simpa only [Nat.add_sub_cancel] using (hsum (j + 1) (by omega) (by omega)).symm
have hcandidate := supportCandidate_eq b hw D e t ht hD0 hDcard heD
apply hfail
rw [hcandidate]
refine ⟨hDcard, ?_, ?_⟩
· intro v hv
obtain ⟨i, hi, _⟩ := (hDmem v).mp hv
exact ⟨i, hi⟩
· intro a ha
rw [Finset.mem_Icc] at ha
exact hsum a ha.1 ha.2
section Enc
variable {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
end Enc
section Tables
variable {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
end Tables
section ReadInt
end ReadInt
section ReadLoop
end ReadLoop
section ProgramAt
end ProgramAt
section ReadSpec
end ReadSpec
section ReadStmt
end ReadStmt
section Bounds
end Bounds
section Prologue
end Prologue
section ReadAssembly
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end ReadAssembly
section Expand
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end Expand
section ExpandStd
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end ExpandStd
theorem clearMem_get (B : ℕ) (m : ℕ → ℕ) (n i : ℕ) (hi : i < n) :
clearMem B m n (B + i) = 0 := by
induction n with
| zero => omega
| succ n ih =>
by_cases h : i = n
· subst i
simp [clearMem]
· rw [clearMem, Function.update_of_ne (by omega : B + i ≠ B + n)]
exact ih (by omega)
theorem clearMem_frame (B : ℕ) (m : ℕ → ℕ) (n a : ℕ)
(ha : a < B ∨ B + n ≤ a) : clearMem B m n a = m a := by
induction n with
| zero => rfl
| succ n ih =>
rw [clearMem, Function.update_of_ne (by omega : a ≠ B + n)]
exact ih (by omega)
theorem clearCond_eval (pc B L : ℕ) (m : ℕ → ℕ) (r : Fin 16 → ℕ) (j : ℕ) :
clearCond.eval (clearState pc B L m r j) ↔ j < L := by
simp [clearCond, Cond.eval, clearState]
theorem clearBody_spec (E : RAMEnv) (pc B L : ℕ) (m : ℕ → ℕ) (r : Fin 16 → ℕ)
(j : ℕ) (hj : j < L) (hW : 1 < 2 ^ E.W) (hL : L < 2 ^ E.W)
(hB : B + L ≤ 2 ^ E.W) :
runBlock clearBody E
{ runBlock clearCond.code E (clearState pc B L m r j) with pc := pc + 2 } =
{ clearState pc B L m r (j + 1) with pc := pc + 7 } := by
have haddr : (B + j) % 2 ^ E.W = B + j := Nat.mod_eq_of_lt (by omega)
have hnext : (j + 1) % 2 ^ E.W = j + 1 := Nat.mod_eq_of_lt (by omega)
have h1 : (1 : ℕ) % 2 ^ E.W = 1 := Nat.mod_eq_of_lt hW
apply ramState_eq_of
· simp only [clearBody, Fin.isValue, Cond.code, clearCond, clearState, runBlock_cons, execInstr,
↓reduceIte, one_ne_zero, runBlock_nil, ne_eq, Fin.reduceEq, not_false_eq_true, Function.update_of_ne,
Function.update_self, Nat.zero_mod, Nat.add_right_cancel_iff, Nat.add_left_cancel_iff] <;> omega
· simp only [clearBody, Fin.isValue, Cond.code, clearCond, clearState, runBlock_cons, execInstr,
↓reduceIte, one_ne_zero, hj, h1, runBlock_nil, ne_eq, Fin.reduceEq, not_false_eq_true,
Function.update_of_ne, haddr, Function.update_self, hnext, Nat.zero_mod, clearMem]
· intro d
fin_cases d <;>
simp only [clearBody, Fin.isValue, Cond.code, clearCond, clearState, runBlock_cons, execInstr,
↓reduceIte, one_ne_zero, hj, h1, runBlock_nil, ne_eq, Fin.reduceEq, not_false_eq_true,
Function.update_of_ne, haddr, Function.update_self, hnext, Nat.zero_mod, Fin.zero_eta,
Nat.add_left_cancel_iff, Fin.mk_one, Fin.reduceFinMk]
theorem clearBodyIter (P : Program) (E : RAMEnv) (pc B L : ℕ)
(m : ℕ → ℕ) (r : Fin 16 → ℕ) (j : ℕ) (hj : j < L)
(hAt : At P pc (Stmt.compile clearStmt pc))
(hW : 1 < 2 ^ E.W) (hL : L < 2 ^ E.W) (hB : B + L ≤ 2 ^ E.W) :
Sem P E (pc + clearCond.code.length + 1) pc
{ runBlock clearCond.code E (clearState pc B L m r j) with pc := pc + clearCond.code.length + 1 }
(fun k s' => k = 6 ∧ s' = clearState pc B L m r (j + 1)) := by
obtain ⟨_, _, hbody, hjmp⟩ := at_loop hAt
have hbodyAt : At P (pc + 2) clearBody := hbody
have hjmpAt : P[pc + 7]? = some (iJmp pc) := hjmp
have hrun : Sem P E (pc + 2) (pc + 7)
{ runBlock clearCond.code E (clearState pc B L m r j) with pc := pc + 2 }
(fun k s' => k = 5 ∧ s' = { clearState pc B L m r (j + 1) with pc := pc + 7 }) := by
refine Sem.mono (Sem.block P E (pc + 2) clearBody _ hbodyAt
(by simp [clearBody]) rfl) ?_
intro k s' h
obtain ⟨hk, hs⟩ := h
refine ⟨hk, ?_⟩
rw [hs]
exact clearBody_spec E pc B L m r j hj hW hL hB
refine Sem.jmp_append (hAt := hjmpAt) (Sem.mono hrun ?_)
intro k s' h
obtain ⟨hk, hs⟩ := h
refine ⟨by omega, ?_⟩
rw [hs]
rfl
theorem clearCond_exit (E : RAMEnv) (pc B L : ℕ) (m : ℕ → ℕ) (r : Fin 16 → ℕ) :
({ runBlock clearCond.code E (clearState pc B L m r L) with pc := pc + 8 } : RAMState) =
{ clearState pc B L m r L with pc := pc + 8 } := by
apply ramState_eq_of
· rfl
· rfl
· intro d
fin_cases d <;> simp [clearCond, Cond.code, runBlock_cons, runBlock_nil, execInstr, clearState]
/-- An actual counted RAM loop clears the array and preserves all memory
outside it, with at most `8L+2` steps. -/
theorem clearArray_spec (P : Program) (E : RAMEnv) (pc B L : ℕ)
(m : ℕ → ℕ) (r : Fin 16 → ℕ)
(hAt : At P pc (Stmt.compile clearStmt pc))
(hW : 1 < 2 ^ E.W) (hL : L < 2 ^ E.W) (hB : B + L ≤ 2 ^ E.W) :
Sem P E pc (pc + 8) (clearState pc B L m r 0)
(fun k s' => k ≤ 8 * L + 2 ∧ s' = { clearState pc B L m r L with pc := pc + 8 }) := by
have h := Sem.loop P E pc clearCond (.code clearBody) hAt hW L
(fun j => clearState pc B L m r j) (fun _ => 6)
(fun _ => rfl)
(fun j hj => (clearCond_eval pc B L m r j).mpr hj)
(fun hf => (Nat.lt_irrefl L) ((clearCond_eval pc B L m r L).mp hf))
(fun j hj => clearBodyIter P E pc B L m r j hj hAt hW hL hB)
refine Sem.mono h ?_
intro k s' hQ
obtain ⟨hcost, hs⟩ := hQ
refine ⟨?_, ?_⟩
· have hsum : (∑ j ∈ Finset.range L, (clearCond.code.length + 1 + 6)) = 8 * L := by
change (∑ j ∈ Finset.range L, (8 : ℕ)) = 8 * L
exact sum_range_const_mul L 8
rw [hsum] at hcost
change k ≤ 2 + 8 * L at hcost
omega
· rw [hs]
exact clearCond_exit E pc B L m r
theorem posTab_zero_iff {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (v : F) :
posTab N ι v = 0 ↔ ¬ ∃ i, i < N ∧ ι i = v := by
classical
by_cases h : ∃ i, i < N ∧ ι i = v <;> simp [posTab, h]
theorem posTab_positive_spec {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (v : F)
(hpos : 0 < posTab N ι v) : ∃ i, i < N ∧ posTab N ι v = i + 1 ∧ ι i = v := by
classical
by_cases h : ∃ i, i < N ∧ ι i = v
· exact ⟨Classical.choose h, (Classical.choose_spec h).1, by simp [posTab, h], (Classical.choose_spec h).2⟩
· simp [posTab, h] at hpos
theorem posTab_iota {F : Type} [Field F] (N : ℕ) (ι : ℕ → F)
(hinj : Set.InjOn ι (Set.Iio N)) (i : ℕ) (hi : i < N) : posTab N ι (ι i) = i + 1 := by
classical
have h : ∃ j, j < N ∧ ι j = ι i := ⟨i, hi, rfl⟩
have hc := Classical.choose_spec h
have heq : Classical.choose h = i := hinj hc.1 hi hc.2
simp [posTab, h, heq]
theorem OutputStored.of_frame {A : ℕ → Prop} {m m' : ℕ → ℕ} {B : ℕ} {xs : List ℕ}
(h : OutputStored m B xs) (hf : MemoryFrame A m m') (hr : ∀ j < xs.length, ¬ A (B + j)) :
OutputStored m' B xs := by
intro j hj
rw [hf (B + j) (hr j hj)]
exact h j hj
theorem positionValidBit_eq_one (p : ℕ) : positionValidBit p = 1 ↔ 0 < p := by
by_cases hp : 0 < p <;> simp [positionValidBit, hp]
theorem bit_mul_eq_one (a b : ℕ) (ha : a ≤ 1) (hb : b ≤ 1) : a * b = 1 ↔ a = 1 ∧ b = 1 := by
interval_cases a <;> interval_cases b <;> norm_num
theorem rootPositionFlag_valid {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (us : List F) :
rootPositionFlag N ι us = 1 ↔ ∀ u ∈ us, 0 < posTab N ι u⁻¹ := by
induction us with
| nil => simp [rootPositionFlag]
| cons u us ih =>
change positionValidBit (posTab N ι u⁻¹) * rootPositionFlag N ι us = 1 ↔ _
rw [bit_mul_eq_one _ _ (positionValidBit_le _) (rootPositionFlag_le_one N ι us)]
simp [positionValidBit_eq_one, ih]
theorem rootPositionIndex_inj {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (u v : F)
(hu : 0 < posTab N ι u⁻¹) (hv : 0 < posTab N ι v⁻¹)
(heq : posTab N ι u⁻¹ - 1 = posTab N ι v⁻¹ - 1) : u = v := by
obtain ⟨i, hi, hpi, hvi⟩ := posTab_positive_spec N ι u⁻¹ hu
obtain ⟨j, hj, hpj, hvj⟩ := posTab_positive_spec N ι v⁻¹ hv
have hij : i = j := by rw [hpi, hpj] at heq; simpa using heq
have he : u⁻¹ = v⁻¹ := by rw [← hvi, ← hvj, hij]
calc
u = (u⁻¹)⁻¹ := (inv_inv u).symm
_ = (v⁻¹)⁻¹ := congrArg (fun x : F => x⁻¹) he
_ = v := inv_inv v
theorem rootPositionList_nodup {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (us : List F)
(hnd : us.Nodup) (hvalid : rootPositionFlag N ι us = 1) : (rootPositionList N ι us).Nodup := by
suffices hh : ∀ xs : List F, xs.Nodup → (∀ u ∈ xs, 0 < posTab N ι u⁻¹) →
(rootPositionList N ι xs).Nodup from hh us hnd ((rootPositionFlag_valid N ι us).mp hvalid)
intro xs
induction xs with
| nil => intro _ _; simp [rootPositionList]
| cons u xs ih =>
intro hnd hv
have hnd' := List.nodup_cons.mp hnd
have hvu := hv u (by simp)
have hvt : ∀ v ∈ xs, 0 < posTab N ι v⁻¹ := fun v hv' => hv v (by simp [hv'])
rw [rootPositionList, List.map_cons, List.nodup_cons]
refine ⟨?_, ih hnd'.2 hvt⟩
intro hbad
obtain ⟨v, hv', hveq⟩ := List.mem_map.mp hbad
have he := rootPositionIndex_inj N ι v u (hvt v hv') hvu hveq
exact hnd'.1 (he ▸ hv')
theorem rootPositionList_range {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (us : List F)
(hN : 1 ≤ N) : ∀ i ∈ rootPositionList N ι us, i < N := by
intro i hi
obtain ⟨u, hu, rfl⟩ := List.mem_map.mp hi
have hp := posTab_le N ι u⁻¹
omega
theorem rootPositionList_iota {F : Type} [Field F] (N : ℕ) (ι : ℕ → F) (us : List F)
(hvalid : rootPositionFlag N ι us = 1) (u : F) (hu : u ∈ us) :
ι (posTab N ι u⁻¹ - 1) = u⁻¹ := by
have hp := (rootPositionFlag_valid N ι us).mp hvalid u hu
obtain ⟨i, hi, hpi, hvi⟩ := posTab_positive_spec N ι u⁻¹ hp
simpa [hpi] using hvi
theorem FieldArrayStored.meta_update {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m : ℕ → ℕ} {B len : ℕ} {v : ℕ → F}
(h : FieldArrayStored b m B len v) (hB : 128 ≤ B) (slot value : ℕ) (hs : slot < 128) :
FieldArrayStored b (Function.update m slot value) B len v := by
intro j hj
rw [Function.update_of_ne (by omega : B + j ≠ slot)]
exact h j hj
theorem FieldArrayStored.congr_values {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m : ℕ → ℕ} {B len : ℕ} {v v' : ℕ → F}
(h : FieldArrayStored b m B len v) (hv : ∀ j < len, v j = v' j) : FieldArrayStored b m B len v' := by
intro j hj
rw [← hv j hj]
exact h j hj
theorem listPowerSums_nil {F : Type} [Field F] (ι : ℕ → F) (j : ℕ) : listPowerSums ι [] j = 0 := by
simp [listPowerSums]
theorem listPowerSums_append_one {F : Type} [Field F] (ι : ℕ → F) (xs : List ℕ) (i j : ℕ) :
listPowerSums ι (xs ++ [i]) j = listPowerSums ι xs j + ι i ^ (j + 1) := by
simp [listPowerSums, List.sum_append]
theorem powerPrefix_zero {F : Type} [Field F] (v : ℕ → F) (a : F) : powerPrefix v a 0 = v := by
funext j
simp [powerPrefix]
theorem powerPrefix_complete {F : Type} [Field F] (v : ℕ → F) (a : F) (len j : ℕ) (hj : j < len) :
powerPrefix v a len j = v j + a ^ (j + 1) := by simp [powerPrefix, hj]
theorem powerPrefix_succ_stored {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (m : ℕ → ℕ) (B len k : ℕ) (v : ℕ → F) (a : F)
(hk : k < len) (h : FieldArrayStored b m B len (powerPrefix v a k)) :
FieldArrayStored b (Function.update m (B + k) (enc b (v k + a ^ (k + 1)))) B len (powerPrefix v a (k + 1)) := by
intro j hj
by_cases heq : j = k
· subst j
rw [Function.update_self]
simp [powerPrefix]
· rw [Function.update_of_ne (by omega : B + j ≠ B + k), h j hj]
congr 1
dsimp [powerPrefix]
have hiff : (j < k + 1) = (j < k) := propext (by omega)
simp only [hiff]
theorem fieldImage_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (E : RAMEnv) (s : RAMState) (i : ℕ)
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hi : i < 2 ^ w) (h10 : s.regs r10 = i) :
runBlock fieldImageCode E s =
{ s with pc := s.pc + 4, regs := Function.update (Function.update (Function.update s.regs r15 (detImgBase w)) r14 (detImgBase w + i)) r10 (enc b (ι i)) } := by
have hwe : w ≤ E.W := by omega
have hend : detEnd w < 2 ^ E.W := by rw [hW]; exact detEnd_lt hw
have hbase : detImgBase w < 2 ^ E.W := by
have hpos := Nat.two_pow_pos w
unfold detEnd at hend
omega
have haddr : detImgBase w + i < 2 ^ E.W := by unfold detEnd at hend; omega
have h10Word : (10 : ℕ) < 2 ^ E.W := by
have hp : (2 : ℕ) ^ 8 ≤ 2 ^ E.W := by
rw [hW]; exact Nat.pow_le_pow_right (by norm_num) (by omega)
exact lt_of_lt_of_le (by norm_num : (10 : ℕ) < 2 ^ 8) hp
have hh : E.det 10 = detImgBase w := by
rw [hdet.1 10 (by decide), detStd_hdr t N w b ι (by decide : 10 < 13)]
rfl
have ht : E.det (detImgBase w + i) = enc b (ι i) := by
rw [hdet.2 _ (by have h := detMulBase_le_detImgBase w; omega), detStd_img t N b ι hi]
have hv : enc b (ι i) < 2 ^ E.W := lt_of_lt_of_le (enc_lt b _) (Nat.pow_le_pow_right (by norm_num) hwe)
apply ramState_eq_of
· simp [fieldImageCode, runBlock_cons, runBlock_nil, execInstr] <;> omega
· rfl
· intro r
fin_cases r <;> simp [fieldImageCode, runBlock_cons, runBlock_nil, execInstr, h10, hh, ht,
Nat.mod_eq_of_lt h10Word, Nat.mod_eq_of_lt hbase, Nat.mod_eq_of_lt haddr, Nat.mod_eq_of_lt hv]
theorem advanceCounter_spec (E : RAMEnv) (s : RAMState) (index counter j n : ℕ)
(hi : index < 2 ^ E.W) (hc : counter < 2 ^ E.W) (hne : index ≠ counter)
(hj : j + 1 < 2 ^ E.W) (hn : n + 1 < 2 ^ E.W)
(hmi : s.mem index = j) (hmc : s.mem counter = n + 1) :
runBlock (advanceCounterCode index counter) E s = rankState (s.pc + 51)
(Function.update (Function.update s.mem index (j + 1)) counter n) n := by
rw [advanceCounterCode, runBlock_append, incrementMeta_spec E s index j hi hj hmi]
have hcounter : (boundaryState (s.pc + 24) (Function.update s.mem index (j + 1))).mem counter = n + 1 := by
simpa [boundaryState, Ne.symm hne] using hmc
rw [countdown_spec E _ counter n hc hn hcounter] <;> rfl
theorem powerAccumulate_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (E : RAMEnv) (s : RAMState) (B j : ℕ) (x y : F)
(hmeta : (115 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W)
(hB : B < 2 ^ E.W) (hj : j < 2 ^ E.W) (haddr : B + j < 2 ^ E.W)
(hm86 : s.mem 86 = B) (hm113 : s.mem 113 = j) (hm115 : s.mem 115 = enc b y) (hmV : s.mem (B + j) = enc b x) :
∃ z, runBlock powerAccumulateCode E s = z ∧ z.pc = s.pc + 13 ∧
z.mem = Function.update s.mem (B + j) (enc b (x + y)) := by
have hsmall (i : ℕ) (hi : i ≤ 115) : i % 2 ^ E.W = i := Nat.mod_eq_of_lt (by omega)
have hEnc (a : F) : enc b a % 2 ^ E.W = enc b a :=
Nat.mod_eq_of_lt (lt_of_lt_of_le (enc_lt b a) (Nat.pow_le_pow_right (by norm_num) hwe))
let sA := runBlock (metaReadCode r2 86 ++ metaReadCode r0 113 ++ [iAdd r2 r2 r0, iLd r10 r2]) E s
have hA2 : sA.regs r2 = B + j := by
simp [sA, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
hsmall, hm86, hm113, Nat.mod_eq_of_lt hB, Nat.mod_eq_of_lt hj, Nat.mod_eq_of_lt haddr]
have hA10 : sA.regs r10 = enc b x := by
simp [sA, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
hsmall, hm86, hm113, Nat.mod_eq_of_lt hB, Nat.mod_eq_of_lt hj, Nat.mod_eq_of_lt haddr, hmV, hEnc]
let sB := runBlock (metaReadCode r11 115) E sA
have hB2 : sB.regs r2 = B + j := by simp [sB, metaRead_spec, hA2]
have hB10 : sB.regs r10 = enc b x := by simp [sB, metaRead_spec, hA10]
have hB11 : sB.regs r11 = enc b y := by
have hmA : sA.mem = s.mem := rfl
simp [sB, metaRead_spec, hsmall, hmA, hm115, hEnc]
let sC := runBlock [iBxor r10 r10 r11, iSt r2 r10] E sB
have hCmem : sC.mem = Function.update s.mem (B + j) (enc b (x + y)) := by
simp [sC, runBlock_cons, runBlock_nil, execInstr, hB2, hB10, hB11, ← enc_add_xor, hEnc] <;> rfl
have he : runBlock powerAccumulateCode E s = sC := by
simp only [powerAccumulateCode, runBlock_append]
rfl
refine ⟨sC, he, ?_, hCmem⟩
have hp := runBlock_pc powerAccumulateCode E s (by simp [powerAccumulateCode, metaReadCode])
rw [he] at hp
exact hp
theorem powerMultiply_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (E : RAMEnv) (s : RAMState) (y a : F)
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (116 : ℕ) < 2 ^ E.W)
(hm115 : s.mem 115 = enc b y) (hm116 : s.mem 116 = enc b a) (hm77 : s.mem 77 = w) :
∃ z, runBlock powerMultiplyCode E s = z ∧ z.pc = s.pc + 19 ∧
z.mem = Function.update s.mem 115 (enc b (y * a)) := by
have hwe : w ≤ E.W := by omega
have hsmall (i : ℕ) (hi : i ≤ 116) : i % 2 ^ E.W = i := Nat.mod_eq_of_lt (by omega)
have hEnc (v : F) : enc b v % 2 ^ E.W = enc b v :=
Nat.mod_eq_of_lt (lt_of_lt_of_le (enc_lt b v) (Nat.pow_le_pow_right (by norm_num) hwe))
have hdim : w % 2 ^ E.W = w := Nat.mod_eq_of_lt (by have he : E.W < 2 ^ E.W := Nat.lt_two_pow_self; omega)
let sA := runBlock (metaReadCode r10 115 ++ metaReadCode r11 116 ++ metaReadCode r3 77) E s
have hA3 : sA.regs r3 = w := by simp [sA, runBlock_append, metaRead_spec, hsmall, hm115, hm116, hm77, hEnc, hdim]
have hA10 : sA.regs r10 = enc b y := by simp [sA, runBlock_append, metaRead_spec, hsmall, hm115, hm116, hm77, hEnc, hdim]
have hA11 : sA.regs r11 = enc b a := by simp [sA, runBlock_append, metaRead_spec, hsmall, hm115, hm116, hm77, hEnc, hdim]
let sB := runBlock fieldMulCode E sA
have hB := fieldMulCode_spec b ι t N E sA y a hw hW hdet hA3 hA10 hA11
have hB10 : sB.regs r10 = enc b (y * a) := by dsimp only [sB]; rw [hB]; simp
let sC := runBlock (metaStoreCode r10 115) E sB
have hCmem : sC.mem = Function.update s.mem 115 (enc b (y * a)) := by
dsimp only [sC]
rw [metaStore_spec E _ r10 115 (by decide)]
change Function.update sB.mem (115 % 2 ^ E.W) (sB.regs r10) = _
rw [hsmall 115 (by norm_num), hB10]
rfl
have he : runBlock powerMultiplyCode E s = sC := by simp only [powerMultiplyCode, runBlock_append]; rfl
refine ⟨sC, he, ?_, hCmem⟩
have hp := runBlock_pc powerMultiplyCode E s (by simp [powerMultiplyCode, fieldMulCode, metaReadCode, metaStoreCode])
rw [he] at hp
exact hp
theorem powerStep_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (E : RAMEnv) (s : RAMState)
(B j : ℕ) (x y a : F) (hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (116 : ℕ) < 2 ^ E.W) (hB : 128 ≤ B) (haddr : B + j < 2 ^ E.W)
(hm86 : s.mem 86 = B) (hm113 : s.mem 113 = j) (hm115 : s.mem 115 = enc b y)
(hm116 : s.mem 116 = enc b a) (hm77 : s.mem 77 = w) (hmV : s.mem (B + j) = enc b x) :
∃ z, runBlock powerStepCode E s = z ∧ z.pc = s.pc + 32 ∧
z.mem = Function.update (Function.update s.mem (B + j) (enc b (x + y))) 115 (enc b (y * a)) := by
obtain ⟨z1, hz1, hpc1, hmem1⟩ := powerAccumulate_spec b E s B j x y (by omega) (by omega) (by omega) (by omega)
haddr hm86 hm113 hm115 hmV
have hm115' : z1.mem 115 = enc b y := by rw [hmem1, Function.update_of_ne (by omega : 115 ≠ B + j)]; exact hm115
have hm116' : z1.mem 116 = enc b a := by rw [hmem1, Function.update_of_ne (by omega : 116 ≠ B + j)]; exact hm116
have hm77' : z1.mem 77 = w := by rw [hmem1, Function.update_of_ne (by omega : 77 ≠ B + j)]; exact hm77
obtain ⟨z2, hz2, hpc2, hmem2⟩ := powerMultiply_spec b ι t N E z1 y a hw hW hdet hmeta hm115' hm116' hm77'
refine ⟨z2, ?_, by rw [hpc2, hpc1] <;> omega, by rw [hmem2, hmem1]⟩
rw [powerStepCode, runBlock_append, hz1, hz2]
theorem powerLoopBody_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc B len j n : ℕ) (v : ℕ → F) (a : F) (m : ℕ → ℕ)
(hAt : At P pc powerLoopBodyCode)
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (116 : ℕ) < 2 ^ E.W) (hB : 128 ≤ B) (hword : B + len ≤ 2 ^ E.W)
(hj : j < len) (hn : n + 1 < 2 ^ E.W)
(hstored : FieldArrayStored b m B len (powerPrefix v a j))
(hm86 : m 86 = B) (hm113 : m 113 = j) (hm114 : m 114 = n + 1)
(hm115 : m 115 = enc b (a ^ (j + 1))) (hm116 : m 116 = enc b a) (hm77 : m 77 = w) :
Sem P E pc (pc + 83) (rankState pc m (n + 1))
(fun k z => k ≤ 83 ∧ ∃ m', z = rankState (pc + 83) m' n ∧
FieldArrayStored b m' B len (powerPrefix v a (j + 1)) ∧
m' 86 = B ∧ m' 113 = j + 1 ∧ m' 114 = n ∧ m' 115 = enc b (a ^ (j + 2)) ∧
m' 116 = enc b a ∧ m' 77 = w ∧ MemoryFrame (powerLoopWritable B len) m m') := by
have hvalue : m (B + j) = enc b (v j) := by simpa [powerPrefix] using hstored j hj
obtain ⟨z1, hz1, hpc1, hmem1⟩ := powerStep_spec b ι t N E (rankState pc m (n + 1)) B j (v j) (a ^ (j + 1)) a
hw hW hdet hmeta hB (by omega) hm86 hm113 hm115 hm116 hm77 hvalue
let mA := Function.update (Function.update m (B + j) (enc b (v j + a ^ (j + 1)))) 115 (enc b (a ^ (j + 1) * a))
let m' := Function.update (Function.update mA 113 (j + 1)) 114 n
have hmA114 : z1.mem 114 = n + 1 := by
rw [hmem1]
simpa [rankState, boundaryState, show 114 ≠ B + j by omega] using hm114
have hmA113 : z1.mem 113 = j := by
rw [hmem1]
simpa [rankState, boundaryState, show 113 ≠ B + j by omega] using hm113
have hrun : runBlock powerLoopBodyCode E (rankState pc m (n + 1)) = rankState (pc + 83) m' n := by
rw [powerLoopBodyCode, runBlock_append, hz1, advanceCounter_spec E z1 113 114 j n
(by omega) (by omega) (by decide) (by omega) hn hmA113 hmA114, hpc1, hmem1]
rfl
have hbody := Sem.block P E pc powerLoopBodyCode (rankState pc m (n + 1)) hAt
(by simp [powerLoopBodyCode, powerStepCode, powerAccumulateCode, powerMultiplyCode, fieldMulCode,
advanceCounterCode, incrementMetaCode, countdownCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl
have hstoreA : FieldArrayStored b mA B len (powerPrefix v a (j + 1)) :=
(powerPrefix_succ_stored b m B len j v a hj hstored).meta_update hB 115 (enc b (a ^ (j + 1) * a)) (by norm_num)
have hstore' : FieldArrayStored b m' B len (powerPrefix v a (j + 1)) :=
(hstoreA.meta_update hB 113 (j + 1) (by norm_num)).meta_update hB 114 n (by norm_num)
have hfixed (slot : ℕ) (hs : slot < 128) (hne113 : slot ≠ 113) (hne114 : slot ≠ 114) (hne115 : slot ≠ 115) :
m' slot = m slot := by
simp [m', mA, hne113, hne114, hne115, show slot ≠ B + j by omega]
have hframe : MemoryFrame (powerLoopWritable B len) m m' :=
MemoryFrame.trans
(MemoryFrame.trans
(MemoryFrame.trans (MemoryFrame.update_allowed _ m (B + j) _ (Or.inr (Or.inr (Or.inr ⟨by omega, by omega⟩))))
(MemoryFrame.update_allowed _ _ 115 _ (Or.inr (Or.inr (Or.inl rfl)))))
(MemoryFrame.update_allowed _ _ 113 _ (Or.inl rfl)))
(MemoryFrame.update_allowed _ _ 114 _ (Or.inr (Or.inl rfl)))
refine Sem.mono hbody ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
change k = 83 at hk
refine ⟨by omega, m', hz.trans hrun, hstore', ?_, by simp [m'], by simp [m'], ?_, ?_, ?_, hframe⟩
· exact (hfixed 86 (by norm_num) (by norm_num) (by norm_num) (by norm_num)).trans hm86
· simp [m', mA, pow_succ]
· exact (hfixed 116 (by norm_num) (by norm_num) (by norm_num) (by norm_num)).trans hm116
· exact (hfixed 77 (by norm_num) (by norm_num) (by norm_num) (by norm_num)).trans hm77
theorem powerLoop_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc B len : ℕ) (v : ℕ → F) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile powerLoopStmt pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (116 : ℕ) < 2 ^ E.W) (hB : 128 ≤ B) (hword : B + len ≤ 2 ^ E.W)
(hstored : FieldArrayStored b m B len v)
(hm86 : m 86 = B) (hm113 : m 113 = 0) (hm114 : m 114 = len)
(hm115 : m 115 = enc b a) (hm116 : m 116 = enc b a) (hm77 : m 77 = w) :
Sem P E pc (pc + 85) (rankState pc m len)
(fun k z => k ≤ 85 * len + 1 ∧ z.regs = (fun _ => 0) ∧
FieldArrayStored b z.mem B len (fun j => v j + a ^ (j + 1)) ∧
z.mem 86 = B ∧ z.mem 113 = len ∧ z.mem 114 = 0 ∧ z.mem 115 = enc b (a ^ (len + 1)) ∧
z.mem 116 = enc b a ∧ z.mem 77 = w ∧ MemoryFrame (powerLoopWritable B len) m z.mem) := by
let I := fun (n : ℕ) (z : RAMState) => n ≤ len ∧ z.regs = Function.update (fun _ => 0) r9 n ∧
z.mem 86 = B ∧ z.mem 113 = len - n ∧ z.mem 114 = n ∧ z.mem 115 = enc b (a ^ (len - n + 1)) ∧
z.mem 116 = enc b a ∧ z.mem 77 = w ∧ FieldArrayStored b z.mem B len (powerPrefix v a (len - n)) ∧
MemoryFrame (powerLoopWritable B len) m z.mem
have hframe : ∀ n z pc', I n z → I n { z with pc := pc' } := by intro n z pc' h; simpa only [I] using h
have hcounter : ∀ n z, I n z → z.regs r9 = n := by intro n z h; rw [h.2.1, Function.update_self]
obtain ⟨_, _, hBodyAt, hJumpAt⟩ := at_loop hAt
have hbody : ∀ n z, I (n + 1) z → z.pc = pc →
Sem P E (pc + 1) pc { z with pc := pc + 1 } (fun k z' => k ≤ 84 ∧ I n z') := by
intro n z hI hpc
obtain ⟨hn, hregs, h86, h113, h114, h115, h116, h77, hstoredz, hf⟩ := hI
have hz : { z with pc := pc + 1 } = rankState (pc + 1) z.mem (n + 1) := by
apply ramState_eq_of
· rfl
· rfl
· intro r; exact congrFun hregs r
rw [hz]
have hrun := powerLoopBody_spec b ι t N P E (pc + 1) B len (len - (n + 1)) n v a z.mem hBodyAt
hw hW hdet hmeta hB hword (by omega) (by omega) hstoredz h86 h113 h114 h115 h116 h77
refine Sem.jmp_append (hAt := hJumpAt) (Sem.mono hrun ?_)
intro k z' hQ
obtain ⟨hk, m', hz', hs', h86', h113', h114', h115', h116', h77', hf'⟩ := hQ
have hidx : len - (n + 1) + 1 = len - n := by omega
have hexp : len - (n + 1) + 2 = len - n + 1 := by omega
refine ⟨by omega, by omega, ?_⟩
rw [hz']
refine ⟨rfl, h86', ?_, h114', ?_, h116', h77', ?_, MemoryFrame.trans hf hf'⟩
· simpa only [hidx, rankState, boundaryState] using h113'
· simpa only [hexp, rankState, boundaryState] using h115'
· simpa only [hidx, rankState, boundaryState] using hs'
have hinit : I len (rankState pc m len) := by
refine ⟨le_rfl, rfl, hm86, ?_, hm114, ?_, hm116, hm77, ?_, ?_⟩
· simpa only [Nat.sub_self, rankState, boundaryState] using hm113
· simpa only [Nat.sub_self, zero_add, pow_one, rankState, boundaryState] using hm115
· simpa only [Nat.sub_self, powerPrefix_zero, rankState, boundaryState] using hstored
· intro addr _; rfl
have hloop := Sem.loop_invariant P E pc (.code powerLoopBodyCode) hAt (by omega) I 84 hframe hcounter hbody
len (rankState pc m len) hinit rfl
refine Sem.mono hloop ?_
intro k z hQ
obtain ⟨hk, _, hregs, h86, h113, h114, h115, h116, h77, hstore, hf⟩ := hQ
refine ⟨hk, ?_, ?_, h86, ?_, h114, ?_, h116, h77, hf⟩
· rw [hregs]
funext r
simp [Function.update_apply]
· apply hstore.congr_values
intro j hj
exact powerPrefix_complete v a (len - 0) j (by omega)
· simpa only [Nat.sub_zero] using h113
· simpa only [Nat.sub_zero] using h115
theorem powerProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc B len : ℕ) (v : ℕ → F) (a : F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile powerProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (116 : ℕ) < 2 ^ E.W) (hB : 128 ≤ B) (hword : B + len ≤ 2 ^ E.W)
(hstored : FieldArrayStored b m B len v)
(hm86 : m 86 = B) (hm113 : m 113 = 0) (hm114 : m 114 = len)
(hm115 : m 115 = enc b a) (hm116 : m 116 = enc b a) (hm77 : m 77 = w) :
Sem P E pc (pc + 88) (boundaryState pc m)
(fun k z => k ≤ 85 * len + 4 ∧ ∃ m', z = boundaryState (pc + 88) m' ∧
FieldArrayStored b m' B len (fun j => v j + a ^ (j + 1)) ∧ m' 86 = B ∧ m' 113 = len ∧
m' 114 = 0 ∧ m' 115 = enc b (a ^ (len + 1)) ∧ m' 116 = enc b a ∧ m' 77 = w ∧
MemoryFrame (powerLoopWritable B len) m m') := by
have hn : len < 2 ^ E.W := by omega
obtain ⟨hReadAt, hLoopAt⟩ := At.seqStmt hAt
have hRead : Sem P E pc (pc + 3) (boundaryState pc m)
(fun k z => k ≤ 3 ∧ z = rankState (pc + 3) m len) := by
refine Sem.mono (Sem.block P E pc (metaReadCode r9 114) _ hReadAt (by simp [metaReadCode]) rfl) ?_
intro k z hQ
have hk : k = 3 := hQ.1
exact ⟨by omega, hQ.2.trans (rankReadSlot_spec E pc m 114 len (by omega) hn hm114)⟩
have hLoop := powerLoop_spec b ι t N P E (pc + 3) B len v a m hLoopAt hw hW hdet hmeta hB hword
hstored hm86 hm113 hm114 hm115 hm116 hm77
have hFull := Sem.seq_bound hRead (fun z _ hz => by subst z; exact hLoop)
obtain ⟨hpc, k, z, hrun, hreturn, hk, hregs, hs, h86, h113, h114, h115, h116, h77, hf⟩ := hFull
refine ⟨hpc, k, z, hrun, hreturn, by omega, z.mem, ?_, hs, h86, h113, h114, h115, h116, h77, hf⟩
apply ramState_eq_of
· exact hreturn
· rfl
· intro r; exact congrFun hregs r
theorem candidateRead_spec (E : RAMEnv) (s : RAMState) (B j idx : ℕ)
(hmeta : (117 : ℕ) < 2 ^ E.W) (hB : B < 2 ^ E.W) (hj : j < 2 ^ E.W)
(haddr : B + j < 2 ^ E.W) (hidx : idx < 2 ^ E.W)
(hm85 : s.mem 85 = B) (hm117 : s.mem 117 = j) (hm : s.mem (B + j) = idx) :
∃ z, runBlock candidateReadCode E s = z ∧ z.pc = s.pc + 8 ∧ z.mem = s.mem ∧ z.regs r10 = idx := by
have hsmall (i : ℕ) (hi : i ≤ 117) : i % 2 ^ E.W = i := Nat.mod_eq_of_lt (by omega)
let z := runBlock candidateReadCode E s
refine ⟨z, rfl, ?_, rfl, ?_⟩
· exact runBlock_pc candidateReadCode E s (by simp [candidateReadCode, metaReadCode])
· simp [z, candidateReadCode, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
hsmall, hm85, hm117, Nat.mod_eq_of_lt hB, Nat.mod_eq_of_lt hj, Nat.mod_eq_of_lt haddr, hm, Nat.mod_eq_of_lt hidx]
theorem powerPrepare_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (E : RAMEnv) (s : RAMState)
(B j idx len : ℕ) (hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (121 : ℕ) < 2 ^ E.W) (hB : B < 2 ^ E.W) (hj : j < 2 ^ E.W)
(haddr : B + j < 2 ^ E.W) (hidx : idx < 2 ^ w) (hlen : len < 2 ^ E.W)
(hm85 : s.mem 85 = B) (hm117 : s.mem 117 = j) (hm : s.mem (B + j) = idx) (hm121 : s.mem 121 = len) :
runBlock powerPrepareCode E s = boundaryState (s.pc + 60) (powerPrepareMemory b s.mem (ι idx) len) := by
have hwe : w ≤ E.W := by omega
have hidxWord : idx < 2 ^ E.W := lt_of_lt_of_le hidx (Nat.pow_le_pow_right (by norm_num) hwe)
obtain ⟨z1, hz1, hpc1, hmem1, h10⟩ := candidateRead_spec E s B j idx (by omega) hB hj haddr hidxWord hm85 hm117 hm
let z2 := runBlock fieldImageCode E z1
have hImage := fieldImage_spec b ι t N E z1 idx hw hW hdet hidx h10
have h210 : z2.regs r10 = enc b (ι idx) := by dsimp only [z2]; rw [hImage]; simp
have h2mem : z2.mem = s.mem := by dsimp only [z2]; rw [hImage]; exact hmem1
let z3 := runBlock (metaStoreCode r10 115 ++ metaStoreCode r10 116) E z2
have h3mem : z3.mem = Function.update (Function.update s.mem 115 (enc b (ι idx))) 116 (enc b (ι idx)) := by
simp [z3, runBlock_append, metaStore_spec, h210, h2mem, Nat.mod_eq_of_lt (show 115 < 2 ^ E.W by omega),
Nat.mod_eq_of_lt (show 116 < 2 ^ E.W by omega)]
generalize hz4 : runBlock (setMetaCode 113 0) E z3 = z4
have h4 : z4 = boundaryState (z3.pc + 20) (Function.update z3.mem 113 0) :=
hz4.symm.trans (setMeta_spec E z3 113 0 (by omega) (by omega))
have h4121 : z4.mem 121 = len := by rw [h4]; simpa [boundaryState, h3mem] using hm121
have he : runBlock powerPrepareCode E s = runBlock (copyMetaCode 121 114) E z4 := by
simp only [powerPrepareCode, runBlock_append]
rw [hz1]
change runBlock (copyMetaCode 121 114) E (runBlock (setMetaCode 113 0) E z3) = _
rw [hz4]
have hpc4 : z4.pc + 22 = s.pc + 60 := by
have hp := runBlock_pc powerPrepareCode E s (by
simp [powerPrepareCode, candidateReadCode, fieldImageCode, metaReadCode, metaStoreCode, setMetaCode, copyMetaCode, zeroRegsCode])
rw [he, copyMeta_spec E z4 121 114 len hmeta (by omega) hlen h4121] at hp
exact hp
rw [he, copyMeta_spec E z4 121 114 len hmeta (by omega) hlen h4121, hpc4]
have h4mem : z4.mem = Function.update (Function.update (Function.update s.mem 115 (enc b (ι idx))) 116 (enc b (ι idx))) 113 0 := by
rw [h4]
change Function.update z3.mem 113 0 = _
rw [h3mem]
rw [h4mem]
rfl
theorem powerPrepare_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (m : ℕ → ℕ) (a : F) (len : ℕ) :
MemoryFrame (fun addr => addr = 113 ∨ addr = 114 ∨ addr = 115 ∨ addr = 116) m (powerPrepareMemory b m a len) := by
intro addr ha
dsimp [powerPrepareMemory]
simp only [Function.update_of_ne (show addr ≠ 114 by omega), Function.update_of_ne (show addr ≠ 113 by omega),
Function.update_of_ne (show addr ≠ 116 by omega), Function.update_of_ne (show addr ≠ 115 by omega)]
theorem power_outer_meta_readonly (V len slot : ℕ) (hV : 128 ≤ V) (hs : slot < 128) (hn : ¬ powerOuterMeta slot) :
¬ powerOuterWritable V len slot := by
intro h
rcases h with h | h
· exact hn h
· omega
theorem power_prepare_le_outer (V len addr : ℕ) (ha : addr = 113 ∨ addr = 114 ∨ addr = 115 ∨ addr = 116) :
powerOuterWritable V len addr := by
left
dsimp [powerOuterMeta]
omega
theorem power_loop_le_outer (V len addr : ℕ) (ha : powerLoopWritable V len addr) :
powerOuterWritable V len addr := by
dsimp [powerLoopWritable] at ha
dsimp [powerOuterWritable, powerOuterMeta]
omega
theorem OutputStored.of_power_frame {m m' : ℕ → ℕ} {BP V len T : ℕ} {xs : List ℕ}
(h : OutputStored m BP xs) (hBP : 128 ≤ BP) (hlen : xs.length ≤ T)
(hdisj : BP + T ≤ V ∨ V + len ≤ BP) (hf : MemoryFrame (powerOuterWritable V len) m m') : OutputStored m' BP xs := by
apply h.of_frame hf
intro j hj
dsimp [powerOuterWritable, powerOuterMeta]
omega
theorem powerOuterBody_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc BP V len T : ℕ) (xs done pending : List ℕ) (i : ℕ) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile powerOuterBody pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (121 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ w)
(hBP : 128 ≤ BP) (hBPword : BP + T ≤ 2 ^ E.W) (hV : 128 ≤ V) (hVword : V + len ≤ 2 ^ E.W)
(hdisj : BP + T ≤ V ∨ V + len ≤ BP) (hcount : xs.length ≤ T) (hrange : ∀ i ∈ xs, i < N)
(heq : xs = done ++ (i :: pending)) (hv : PowerOuterView b ι BP V len xs done (i :: pending) m) :
Sem P E pc (pc + 199) (rankState pc m (pending.length + 1))
(fun k z => k ≤ 85 * len + 115 ∧ ∃ m', z = rankState (pc + 199) m' pending.length ∧
PowerOuterView b ι BP V len xs (done ++ [i]) pending m' ∧ MemoryFrame (powerOuterWritable V len) m m') := by
have hlenEq : xs.length = done.length + (pending.length + 1) := by simp [heq]
have hiMem : i ∈ xs := by rw [heq]; simp
have hi := hrange i hiMem
have hidx : i < 2 ^ w := lt_trans hi hN
have hnWord : pending.length + 1 < 2 ^ E.W := by omega
have hjWord : done.length + 1 < 2 ^ E.W := by omega
have hlenWord : len < 2 ^ E.W := by omega
have hpos : m (BP + done.length) = i := by
have hj : done.length < xs.length := by omega
have hh := hv.positions done.length hj
rw [heq, List.getD_append_right done (i :: pending) 0 done.length le_rfl, Nat.sub_self] at hh
exact hh
let m1 := powerPrepareMemory b m (ι i) len
have hf01 : MemoryFrame (powerOuterWritable V len) m m1 :=
(powerPrepare_frame b m (ι i) len).mono (power_prepare_le_outer V len)
have hstore1 : FieldArrayStored b m1 V len (listPowerSums ι done) :=
(((hv.powers.meta_update hV 115 (enc b (ι i)) (by norm_num)).meta_update hV 116 (enc b (ι i)) (by norm_num)).meta_update
hV 113 0 (by norm_num)).meta_update hV 114 len (by norm_num)
have hm1meta (slot : ℕ) (hne115 : slot ≠ 115) (hne116 : slot ≠ 116) (hne113 : slot ≠ 113) (hne114 : slot ≠ 114) :
m1 slot = m slot := by simp [m1, powerPrepareMemory, hne115, hne116, hne113, hne114]
obtain ⟨hPrepareAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hPowerAt, hTailAt⟩ := At.seqStmt hRestAt
have hPrepare : Sem P E pc (pc + 60) (rankState pc m (pending.length + 1))
(fun k z => k ≤ 60 ∧ z = boundaryState (pc + 60) m1) := by
refine Sem.mono (Sem.block P E pc powerPrepareCode _ hPrepareAt
(by simp [powerPrepareCode, candidateReadCode, fieldImageCode, metaReadCode, metaStoreCode, setMetaCode, copyMetaCode, zeroRegsCode]) rfl) ?_
intro k z hQ
have hk : k = 60 := hQ.1
exact ⟨by omega, hQ.2.trans (powerPrepare_spec b ι t N E _ BP done.length i len hw hW hdet hmeta (by omega) (by omega)
(by omega) hidx hlenWord hv.positionsBase hv.index hpos hv.length)⟩
have hPower := powerProcedure_spec b ι t N P E (pc + 60) V len (listPowerSums ι done) (ι i) m1 hPowerAt
hw hW hdet (by omega) hV hVword hstore1
((hm1meta 86 (by norm_num) (by norm_num) (by norm_num) (by norm_num)).trans hv.powersBase)
(by simp [m1, powerPrepareMemory]) (by simp [m1, powerPrepareMemory])
(by simp [m1, powerPrepareMemory]) (by simp [m1, powerPrepareMemory])
((hm1meta 77 (by norm_num) (by norm_num) (by norm_num) (by norm_num)).trans hv.dimension)
obtain ⟨_, k2, z2, hRun2, hPc2, hCost2, m2, hz2, hstore2, h86, h113, h114, h115, h116, h77, hf12raw⟩ := hPower
have hf12 : MemoryFrame (powerOuterWritable V len) m1 m2 := hf12raw.mono (power_loop_le_outer V len)
have hf02 := MemoryFrame.trans hf01 hf12
have h117 : m2 117 = done.length := by
rw [hf12raw 117 (by dsimp [powerLoopWritable]; omega), hm1meta 117 (by norm_num) (by norm_num) (by norm_num) (by norm_num)]
exact hv.index
have h118 : m2 118 = pending.length + 1 := by
rw [hf12raw 118 (by dsimp [powerLoopWritable]; omega), hm1meta 118 (by norm_num) (by norm_num) (by norm_num) (by norm_num)]
exact hv.remaining
let m3 := Function.update (Function.update m2 117 (done.length + 1)) 118 pending.length
have hf23 : MemoryFrame (powerOuterWritable V len) m2 m3 :=
MemoryFrame.trans (MemoryFrame.update_allowed _ m2 117 (done.length + 1) (by left; dsimp [powerOuterMeta]; omega))
(MemoryFrame.update_allowed _ _ 118 pending.length (by left; dsimp [powerOuterMeta]; omega))
have hf03 := MemoryFrame.trans hf02 hf23
have hfixed (slot : ℕ) (hs : slot < 128) (hn : ¬ powerOuterMeta slot) : m3 slot = m slot :=
hf03 slot (power_outer_meta_readonly V len slot hV hs hn)
have hs3 : FieldArrayStored b m3 V len (listPowerSums ι (done ++ [i])) := by
apply ((hstore2.meta_update hV 117 (done.length + 1) (by norm_num)).meta_update hV 118 pending.length (by norm_num)).congr_values
intro j _
exact (listPowerSums_append_one ι done i j).symm
have hv3 : PowerOuterView b ι BP V len xs (done ++ [i]) pending m3 := by
refine ⟨hv.positions.of_power_frame hBP hcount hdisj hf03, hs3, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· exact (hfixed 85 (by norm_num) (by norm_num [powerOuterMeta])).trans hv.positionsBase
· exact (hfixed 86 (by norm_num) (by norm_num [powerOuterMeta])).trans hv.powersBase
· exact (hfixed 77 (by norm_num) (by norm_num [powerOuterMeta])).trans hv.dimension
· exact (hfixed 121 (by norm_num) (by norm_num [powerOuterMeta])).trans hv.length
· exact (hfixed 101 (by norm_num) (by norm_num [powerOuterMeta])).trans hv.count
· simp [m3]
· simp [m3]
have hPowerExact : Sem P E (pc + 60) (pc + 148) (boundaryState (pc + 60) m1)
(fun k z => k ≤ 85 * len + 4 ∧ z = boundaryState (pc + 148) m2) :=
⟨rfl, k2, z2, hRun2, hPc2, hCost2, hz2⟩
have hTail : Sem P E (pc + 148) (pc + 199) (boundaryState (pc + 148) m2)
(fun k z => k ≤ 51 ∧ z = rankState (pc + 199) m3 pending.length) := by
refine Sem.mono (Sem.block P E _ (advanceCounterCode 117 118) _ hTailAt
(by simp [advanceCounterCode, incrementMetaCode, countdownCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl) ?_
intro k z hQ
have hk : k = 51 := hQ.1
exact ⟨by omega, hQ.2.trans (advanceCounter_spec E _ 117 118 done.length pending.length
(by omega) (by omega) (by decide) hjWord hnWord h117 h118)⟩
have hFull := Sem.seq_bound hPrepare (fun z _ hz => by
subst z
exact Sem.seq_bound hPowerExact (fun z _ hz => by subst z; exact hTail))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, m3, hQ.2, hv3, hf03⟩)
theorem powerOuterLoop_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc BP V len T : ℕ) (xs : List ℕ) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile powerOuterLoop pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (121 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ w)
(hBP : 128 ≤ BP) (hBPword : BP + T ≤ 2 ^ E.W) (hV : 128 ≤ V) (hVword : V + len ≤ 2 ^ E.W)
(hdisj : BP + T ≤ V ∨ V + len ≤ BP) (hcount : xs.length ≤ T) (hrange : ∀ i ∈ xs, i < N)
(hv : PowerOuterView b ι BP V len xs [] xs m) :
Sem P E pc (pc + 201) (rankState pc m xs.length)
(fun k z => k ≤ (85 * len + 117) * xs.length + 1 ∧ z.regs = (fun _ => 0) ∧
PowerOuterView b ι BP V len xs xs [] z.mem ∧ MemoryFrame (powerOuterWritable V len) m z.mem) := by
let I := fun (n : ℕ) (z : RAMState) => n ≤ xs.length ∧ z.regs = Function.update (fun _ => 0) r9 n ∧
∃ done pending, xs = done ++ pending ∧ pending.length = n ∧
PowerOuterView b ι BP V len xs done pending z.mem ∧ MemoryFrame (powerOuterWritable V len) m z.mem
have hframe : ∀ n z pc', I n z → I n { z with pc := pc' } := by intro n z pc' h; simpa only [I] using h
have hcounter : ∀ n z, I n z → z.regs r9 = n := by intro n z h; rw [h.2.1, Function.update_self]
obtain ⟨_, _, hBodyAt, hJumpAt⟩ := at_loop hAt
have hbody : ∀ n z, I (n + 1) z → z.pc = pc →
Sem P E (pc + 1) pc { z with pc := pc + 1 } (fun k z' => k ≤ 85 * len + 116 ∧ I n z') := by
intro n z hI hpc
obtain ⟨hn, hregs, done, pending, heq, hrem, hvz, hf⟩ := hI
cases pending with
| nil => simp at hrem
| cons i pending =>
have heN : n = pending.length := by simp only [List.length_cons] at hrem; omega
subst n
have hz : { z with pc := pc + 1 } = rankState (pc + 1) z.mem (pending.length + 1) := by
apply ramState_eq_of
· rfl
· rfl
· intro r; exact congrFun hregs r
rw [hz]
have hrun := powerOuterBody_spec b ι t N P E (pc + 1) BP V len T xs done pending i z.mem hBodyAt
hw hW hdet hmeta hN hBP hBPword hV hVword hdisj hcount hrange heq hvz
refine Sem.jmp_append (hAt := hJumpAt) (Sem.mono hrun ?_)
intro k z' hQ
obtain ⟨hk, m', hz', hv', hf'⟩ := hQ
refine ⟨by omega, by omega, ?_⟩
rw [hz']
refine ⟨rfl, done ++ [i], pending, ?_, rfl, hv', MemoryFrame.trans hf hf'⟩
simpa only [List.append_assoc, List.singleton_append] using heq
have hinit : I xs.length (rankState pc m xs.length) := by
refine ⟨le_rfl, rfl, [], xs, by simp, rfl, hv, ?_⟩
intro addr _; rfl
have hloop := Sem.loop_invariant P E pc powerOuterBody hAt (by omega) I (85 * len + 116)
hframe hcounter hbody xs.length (rankState pc m xs.length) hinit rfl
refine Sem.mono hloop ?_
intro k z hQ
obtain ⟨hk, _, hregs, done, pending, heq, hrem, hvz, hf⟩ := hQ
have hp : pending = [] := by
cases pending with
| nil => rfl
| cons i pending => simp at hrem
subst pending
have hd : done = xs := by simpa using heq.symm
subst done
refine ⟨hk, ?_, hvz, hf⟩
rw [hregs]
funext r
simp [Function.update_apply]
theorem powerOuterProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc BP V len T : ℕ) (xs : List ℕ) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile powerOuterProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (121 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ w)
(hBP : 128 ≤ BP) (hBPword : BP + T ≤ 2 ^ E.W) (hV : 128 ≤ V) (hVword : V + len ≤ 2 ^ E.W)
(hdisj : BP + T ≤ V ∨ V + len ≤ BP) (hcount : xs.length ≤ T) (hrange : ∀ i ∈ xs, i < N)
(hv : PowerOuterView b ι BP V len xs [] xs m) :
Sem P E pc (pc + 204) (boundaryState pc m)
(fun k z => k ≤ (85 * len + 117) * xs.length + 4 ∧ ∃ m', z = boundaryState (pc + 204) m' ∧
PowerOuterView b ι BP V len xs xs [] m' ∧ MemoryFrame (powerOuterWritable V len) m m') := by
have hn : xs.length < 2 ^ E.W := by omega
obtain ⟨hReadAt, hLoopAt⟩ := At.seqStmt hAt
have hRead : Sem P E pc (pc + 3) (boundaryState pc m)
(fun k z => k ≤ 3 ∧ z = rankState (pc + 3) m xs.length) := by
refine Sem.mono (Sem.block P E pc (metaReadCode r9 118) _ hReadAt (by simp [metaReadCode]) rfl) ?_
intro k z hQ
have hk : k = 3 := hQ.1
exact ⟨by omega, hQ.2.trans (rankReadSlot_spec E pc m 118 xs.length (by omega) hn hv.remaining)⟩
have hLoop := powerOuterLoop_spec b ι t N P E (pc + 3) BP V len T xs m hLoopAt
hw hW hdet hmeta hN hBP hBPword hV hVword hdisj hcount hrange hv
have hFull := Sem.seq_bound hRead (fun z _ hz => by subst z; exact hLoop)
obtain ⟨hpc, k, z, hrun, hreturn, hk, hregs, hvz, hf⟩ := hFull
refine ⟨hpc, k, z, hrun, hreturn, by omega, z.mem, ?_, hvz, hf⟩
apply ramState_eq_of
· exact hreturn
· rfl
· intro r; exact congrFun hregs r
theorem equalBit_le_one {α : Type} [DecidableEq α] (x y : α) : equalBit x y ≤ 1 := by
by_cases h : x = y <;> simp [equalBit, h]
theorem equalBit_eq_one {α : Type} [DecidableEq α] (x y : α) : equalBit x y = 1 ↔ x = y := by
by_cases h : x = y <;> simp [equalBit, h]
theorem equalBit_enc {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (x y : F) : equalBit (enc b x) (enc b y) = equalBit x y := by
have hh : enc b x = enc b y ↔ x = y := (enc_injective b).eq_iff
simp [equalBit, hh]
theorem equalPrefix_le_one {α : Type} [DecidableEq α] (u v : ℕ → α) (k : ℕ) : equalPrefix u v k ≤ 1 := by
induction k with
| zero => simp [equalPrefix]
| succ k ih => exact le_trans (Nat.mul_le_mul ih (equalBit_le_one _ _)) (by norm_num)
theorem equalPrefix_eq_one {α : Type} [DecidableEq α] (u v : ℕ → α) (k : ℕ) :
equalPrefix u v k = 1 ↔ ∀ j < k, u j = v j := by
induction k with
| zero => simp [equalPrefix]
| succ k ih =>
rw [equalPrefix, bit_mul_eq_one _ _ (equalPrefix_le_one u v k) (equalBit_le_one _ _), ih, equalBit_eq_one]
constructor
· rintro ⟨hp, hk⟩ j hj
by_cases he : j = k
· simpa [he] using hk
· exact hp j (by omega)
· intro hp
exact ⟨fun j hj => hp j (by omega), hp k (by omega)⟩
theorem compareFlag_succ {α : Type} [DecidableEq α] (u v : ℕ → α) (flag k : ℕ) :
(flag * equalPrefix u v k) * equalBit (u k) (v k) = flag * equalPrefix u v (k + 1) := by
simp [equalPrefix, Nat.mul_assoc]
theorem compareFlag_accept {α : Type} [DecidableEq α] (u v : ℕ → α) (flag len : ℕ) (hf : flag ≤ 1) :
flag * equalPrefix u v len = 1 ↔ flag = 1 ∧ ∀ j < len, u j = v j := by
rw [bit_mul_eq_one _ _ hf (equalPrefix_le_one u v len), equalPrefix_eq_one]
theorem equalityTest_spec (E : RAMEnv) (s : RAMState) (x y : ℕ)
(hword : 2 < 2 ^ E.W) (hx : s.regs r10 = x) (hy : s.regs r11 = y) :
∃ z, runBlock equalityTestCode E s = z ∧ z.pc = s.pc + 5 ∧ z.mem = s.mem ∧ z.regs r0 = equalBit x y := by
let z := runBlock equalityTestCode E s
refine ⟨z, rfl, runBlock_pc equalityTestCode E s (by simp [equalityTestCode]), rfl, ?_⟩
have h1 : (1 : ℕ) % 2 ^ E.W = 1 := Nat.mod_eq_of_lt (by omega)
rcases lt_trichotomy x y with h | h | h
· have hnot : ¬ y < x := by omega
have hne : x ≠ y := by omega
simp [z, equalityTestCode, runBlock_cons, runBlock_nil, execInstr, hx, hy, h, hnot, hne, equalBit, h1]
· have hy' : s.regs r11 = x := hy.trans h.symm
simp [z, equalityTestCode, runBlock_cons, runBlock_nil, execInstr, hx, hy', equalBit, h, h1, Nat.add_mod_right]
· have hnot : ¬ x < y := by omega
have hne : x ≠ y := by omega
simp [z, equalityTestCode, runBlock_cons, runBlock_nil, execInstr, hx, hy, h, hnot, hne, equalBit, h1]
theorem matchFlag_spec (E : RAMEnv) (s : RAMState) (x y flag : ℕ)
(hmeta : (100 : ℕ) < 2 ^ E.W) (hf : flag ≤ 1)
(hx : s.regs r10 = x) (hy : s.regs r11 = y) (hm100 : s.mem 100 = flag) :
∃ z, runBlock matchFlagCode E s = z ∧ z.pc = s.pc + 12 ∧
z.mem = Function.update s.mem 100 (flag * equalBit x y) := by
obtain ⟨z1, hz1, hpc1, hmem1, hbit⟩ := equalityTest_spec E s x y (by omega) hx hy
have h100 : (100 : ℕ) % 2 ^ E.W = 100 := Nat.mod_eq_of_lt hmeta
have hfmod : flag % 2 ^ E.W = flag := Nat.mod_eq_of_lt (by omega)
have hb := equalBit_le_one x y
have hm : flag * equalBit x y ≤ 1 := le_trans (Nat.mul_le_mul hf hb) (by norm_num)
have hmod : (flag * equalBit x y) % 2 ^ E.W = flag * equalBit x y := Nat.mod_eq_of_lt (by omega)
let z2 := runBlock (metaReadCode r1 100 ++ [iMul r1 r1 r0]) E z1
have h21 : z2.regs r1 = flag * equalBit x y := by
simp [z2, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
hmem1, h100, hm100, hfmod, hbit, hmod]
let z3 := runBlock (metaStoreCode r1 100) E z2
have h3mem : z3.mem = Function.update s.mem 100 (flag * equalBit x y) := by
dsimp only [z3]
rw [metaStore_spec E _ r1 100 (by decide)]
change Function.update z2.mem (100 % 2 ^ E.W) (z2.regs r1) = _
rw [h100, h21]
change Function.update z1.mem 100 _ = _
rw [hmem1]
have he : runBlock matchFlagCode E s = z3 := by
simp only [matchFlagCode, runBlock_append]
rw [hz1] <;> rfl
refine ⟨z3, he, ?_, h3mem⟩
have hp := runBlock_pc matchFlagCode E s (by simp [matchFlagCode, equalityTestCode, metaReadCode, metaStoreCode])
rw [he] at hp
exact hp
theorem comparisonRead_spec (E : RAMEnv) (s : RAMState) (EB V j x y : ℕ)
(hmeta : (119 : ℕ) < 2 ^ E.W) (hEB : EB < 2 ^ E.W) (hV : V < 2 ^ E.W) (hj : j < 2 ^ E.W)
(hEaddr : EB + j < 2 ^ E.W) (hVaddr : V + j < 2 ^ E.W) (hx : x < 2 ^ E.W) (hy : y < 2 ^ E.W)
(hm79 : s.mem 79 = EB) (hm86 : s.mem 86 = V) (hm119 : s.mem 119 = j)
(hmE : s.mem (EB + j) = x) (hmV : s.mem (V + j) = y) :
∃ z, runBlock comparisonReadCode E s = z ∧ z.pc = s.pc + 13 ∧ z.mem = s.mem ∧ z.regs r10 = x ∧ z.regs r11 = y := by
have hsmall (i : ℕ) (hi : i ≤ 119) : i % 2 ^ E.W = i := Nat.mod_eq_of_lt (by omega)
let z1 := runBlock (metaReadCode r2 79 ++ metaReadCode r0 119 ++ [iAdd r2 r2 r0, iLd r10 r2]) E s
have h10 : z1.regs r10 = x := by
simp [z1, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
hsmall, hm79, hm119, Nat.mod_eq_of_lt hEB, Nat.mod_eq_of_lt hj, Nat.mod_eq_of_lt hEaddr, hmE, Nat.mod_eq_of_lt hx]
have h0 : z1.regs r0 = j := by
simp [z1, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
hsmall, hm79, hm119, Nat.mod_eq_of_lt hj]
have hm1 : z1.mem = s.mem := rfl
let z2 := runBlock (metaReadCode r2 86 ++ [iAdd r2 r2 r0, iLd r11 r2]) E z1
have h210 : z2.regs r10 = x := by
simp [z2, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr, h10]
have h211 : z2.regs r11 = y := by
simp [z2, runBlock_append, metaRead_spec, runBlock_cons, runBlock_nil, execInstr,
hsmall, hm1, hm86, Nat.mod_eq_of_lt hV, h0, Nat.mod_eq_of_lt hVaddr, hmV, Nat.mod_eq_of_lt hy]
have he : runBlock comparisonReadCode E s = z2 := by simp only [comparisonReadCode, runBlock_append]; rfl
refine ⟨z2, he, ?_, rfl, h210, h211⟩
have hp := runBlock_pc comparisonReadCode E s (by simp [comparisonReadCode, metaReadCode])
rw [he] at hp
exact hp
theorem comparisonStep_spec {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (E : RAMEnv) (s : RAMState) (EB V j flag : ℕ) (x y : F)
(hmeta : (119 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W)
(hEB : EB < 2 ^ E.W) (hV : V < 2 ^ E.W) (hj : j < 2 ^ E.W)
(hEaddr : EB + j < 2 ^ E.W) (hVaddr : V + j < 2 ^ E.W) (hflag : flag ≤ 1)
(hm79 : s.mem 79 = EB) (hm86 : s.mem 86 = V) (hm119 : s.mem 119 = j)
(hmE : s.mem (EB + j) = enc b x) (hmV : s.mem (V + j) = enc b y) (hm100 : s.mem 100 = flag) :
∃ z, runBlock comparisonStepCode E s = z ∧ z.pc = s.pc + 25 ∧
z.mem = Function.update s.mem 100 (flag * equalBit x y) := by
have hEnc (v : F) : enc b v < 2 ^ E.W := lt_of_lt_of_le (enc_lt b v) (Nat.pow_le_pow_right (by norm_num) hwe)
obtain ⟨z1, hz1, hpc1, hmem1, h10, h11⟩ := comparisonRead_spec E s EB V j (enc b x) (enc b y) hmeta hEB hV hj
hEaddr hVaddr (hEnc x) (hEnc y) hm79 hm86 hm119 hmE hmV
obtain ⟨z2, hz2, hpc2, hmem2⟩ := matchFlag_spec E z1 (enc b x) (enc b y) flag (by omega) hflag h10 h11 (by rw [hmem1]; exact hm100)
refine ⟨z2, ?_, by rw [hpc2, hpc1] <;> omega, ?_⟩
· rw [comparisonStepCode, runBlock_append, hz1, hz2]
· rw [hmem2, hmem1, equalBit_enc]
theorem comparisonLoopBody_spec {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv)
(pc EB V len flag j n : ℕ) (e v : ℕ → F) (m : ℕ → ℕ)
(hAt : At P pc comparisonLoopBodyCode) (hmeta : (120 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W)
(hEB : 128 ≤ EB) (hV : 128 ≤ V) (hEword : EB + len ≤ 2 ^ E.W) (hVword : V + len ≤ 2 ^ E.W)
(hj : j < len) (hn : n + 1 < 2 ^ E.W) (hflag : flag ≤ 1)
(hv : ComparisonView b EB V len e v flag j (n + 1) m) :
Sem P E pc (pc + 76) (rankState pc m (n + 1))
(fun k z => k ≤ 76 ∧ ∃ m', z = rankState (pc + 76) m' n ∧
ComparisonView b EB V len e v flag (j + 1) n m' ∧ MemoryFrame comparisonWritable m m') := by
have hprod : flag * equalPrefix e v j ≤ 1 := le_trans (Nat.mul_le_mul hflag (equalPrefix_le_one e v j)) (by norm_num)
obtain ⟨z1, hz1, hpc1, hmem1⟩ := comparisonStep_spec b E (rankState pc m (n + 1)) EB V j (flag * equalPrefix e v j)
(e j) (v j) (by omega) hwe (by omega) (by omega) (by omega) (by omega) (by omega) hprod
hv.expectedBase hv.actualBase hv.index (hv.expected j hj) (hv.actual j hj) hv.flag
let m1 := Function.update m 100 ((flag * equalPrefix e v j) * equalBit (e j) (v j))
let m' := Function.update (Function.update m1 119 (j + 1)) 120 n
have h119 : z1.mem 119 = j := by rw [hmem1]; simpa [rankState, boundaryState] using hv.index
have h120 : z1.mem 120 = n + 1 := by rw [hmem1]; simpa [rankState, boundaryState] using hv.remaining
have hrun : runBlock comparisonLoopBodyCode E (rankState pc m (n + 1)) = rankState (pc + 76) m' n := by
rw [comparisonLoopBodyCode, runBlock_append, hz1, advanceCounter_spec E z1 119 120 j n
(by omega) hmeta (by decide) (by omega) hn h119 h120, hpc1, hmem1]
rfl
have hbody := Sem.block P E pc comparisonLoopBodyCode (rankState pc m (n + 1)) hAt
(by simp [comparisonLoopBodyCode, comparisonStepCode, comparisonReadCode, matchFlagCode, equalityTestCode,
advanceCounterCode, incrementMetaCode, countdownCode, metaReadCode, metaStoreCode, zeroRegsCode]) rfl
have hframe : MemoryFrame comparisonWritable m m' :=
MemoryFrame.trans
(MemoryFrame.trans (MemoryFrame.update_allowed _ m 100 _ (Or.inl rfl))
(MemoryFrame.update_allowed _ _ 119 _ (Or.inr (Or.inl rfl))))
(MemoryFrame.update_allowed _ _ 120 _ (Or.inr (Or.inr rfl)))
have hv' : ComparisonView b EB V len e v flag (j + 1) n m' := by
refine ⟨?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· exact ((hv.expected.meta_update hEB 100 _ (by norm_num)).meta_update hEB 119 (j + 1) (by norm_num)).meta_update hEB 120 n (by norm_num)
· exact ((hv.actual.meta_update hV 100 _ (by norm_num)).meta_update hV 119 (j + 1) (by norm_num)).meta_update hV 120 n (by norm_num)
· simpa [m', m1] using hv.expectedBase
· simpa [m', m1] using hv.actualBase
· simp [m']
· simp [m']
· simp [m', m1, compareFlag_succ]
refine Sem.mono hbody ?_
intro k z hQ
obtain ⟨hk, hz⟩ := hQ
change k = 76 at hk
exact ⟨by omega, m', hz.trans hrun, hv', hframe⟩
theorem comparisonLoop_spec {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv) (pc EB V len flag : ℕ) (e v : ℕ → F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile comparisonLoopStmt pc)) (hmeta : (120 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W)
(hEB : 128 ≤ EB) (hV : 128 ≤ V) (hEword : EB + len ≤ 2 ^ E.W) (hVword : V + len ≤ 2 ^ E.W)
(hflag : flag ≤ 1) (hv : ComparisonView b EB V len e v flag 0 len m) :
Sem P E pc (pc + 78) (rankState pc m len)
(fun k z => k ≤ 78 * len + 1 ∧ z.regs = (fun _ => 0) ∧
ComparisonView b EB V len e v flag len 0 z.mem ∧ MemoryFrame comparisonWritable m z.mem) := by
let I := fun (n : ℕ) (z : RAMState) => n ≤ len ∧ z.regs = Function.update (fun _ => 0) r9 n ∧
ComparisonView b EB V len e v flag (len - n) n z.mem ∧ MemoryFrame comparisonWritable m z.mem
have hframe : ∀ n z pc', I n z → I n { z with pc := pc' } := by intro n z pc' h; simpa only [I] using h
have hcounter : ∀ n z, I n z → z.regs r9 = n := by intro n z h; rw [h.2.1, Function.update_self]
obtain ⟨_, _, hBodyAt, hJumpAt⟩ := at_loop hAt
have hbody : ∀ n z, I (n + 1) z → z.pc = pc →
Sem P E (pc + 1) pc { z with pc := pc + 1 } (fun k z' => k ≤ 77 ∧ I n z') := by
intro n z hI hpc
obtain ⟨hn, hregs, hvz, hf⟩ := hI
have hz : { z with pc := pc + 1 } = rankState (pc + 1) z.mem (n + 1) := by
apply ramState_eq_of
· rfl
· rfl
· intro r; exact congrFun hregs r
rw [hz]
have hrun := comparisonLoopBody_spec b P E (pc + 1) EB V len flag (len - (n + 1)) n e v z.mem hBodyAt
hmeta hwe hEB hV hEword hVword (by omega) (by omega) hflag hvz
refine Sem.jmp_append (hAt := hJumpAt) (Sem.mono hrun ?_)
intro k z' hQ
obtain ⟨hk, m', hz', hv', hf'⟩ := hQ
have hidx : len - (n + 1) + 1 = len - n := by omega
refine ⟨by omega, by omega, ?_⟩
rw [hz']
refine ⟨rfl, ?_, MemoryFrame.trans hf hf'⟩
simpa only [hidx, rankState, boundaryState] using hv'
have hinit : I len (rankState pc m len) := by
refine ⟨le_rfl, rfl, ?_, ?_⟩
· simpa only [Nat.sub_self, rankState, boundaryState] using hv
· intro addr _; rfl
have hloop := Sem.loop_invariant P E pc (.code comparisonLoopBodyCode) hAt (by omega) I 77
hframe hcounter hbody len (rankState pc m len) hinit rfl
refine Sem.mono hloop ?_
intro k z hQ
obtain ⟨hk, _, hregs, hvz, hf⟩ := hQ
refine ⟨hk, ?_, ?_, hf⟩
· rw [hregs]
funext r
simp [Function.update_apply]
· simpa only [Nat.sub_zero] using hvz
theorem comparisonProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (P : Program) (E : RAMEnv) (pc EB V len flag : ℕ) (e v : ℕ → F) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile comparisonProcedure pc)) (hmeta : (120 : ℕ) < 2 ^ E.W) (hwe : w ≤ E.W)
(hEB : 128 ≤ EB) (hV : 128 ≤ V) (hEword : EB + len ≤ 2 ^ E.W) (hVword : V + len ≤ 2 ^ E.W)
(hflag : flag ≤ 1) (hv : ComparisonView b EB V len e v flag 0 len m) :
Sem P E pc (pc + 81) (boundaryState pc m)
(fun k z => k ≤ 78 * len + 4 ∧ ∃ m', z = boundaryState (pc + 81) m' ∧
ComparisonView b EB V len e v flag len 0 m' ∧ MemoryFrame comparisonWritable m m') := by
have hn : len < 2 ^ E.W := by omega
obtain ⟨hReadAt, hLoopAt⟩ := At.seqStmt hAt
have hRead : Sem P E pc (pc + 3) (boundaryState pc m)
(fun k z => k ≤ 3 ∧ z = rankState (pc + 3) m len) := by
refine Sem.mono (Sem.block P E pc (metaReadCode r9 120) _ hReadAt (by simp [metaReadCode]) rfl) ?_
intro k z hQ
have hk : k = 3 := hQ.1
exact ⟨by omega, hQ.2.trans (rankReadSlot_spec E pc m 120 len hmeta hn hv.remaining)⟩
have hLoop := comparisonLoop_spec b P E (pc + 3) EB V len flag e v m hLoopAt hmeta hwe hEB hV hEword hVword hflag hv
have hFull := Sem.seq_bound hRead (fun z _ hz => by subst z; exact hLoop)
obtain ⟨hpc, k, z, hrun, hreturn, hk, hregs, hvz, hf⟩ := hFull
refine ⟨hpc, k, z, hrun, hreturn, by omega, z.mem, ?_, hvz, hf⟩
apply ramState_eq_of
· exact hreturn
· rfl
· intro r; exact congrFun hregs r
theorem verifierClearArgs_spec (E : RAMEnv) (pc V len : ℕ) (m : ℕ → ℕ)
(hmeta : (121 : ℕ) < 2 ^ E.W) (hV : V < 2 ^ E.W) (hlen : len < 2 ^ E.W)
(hm86 : m 86 = V) (hm121 : m 121 = len) :
runBlock verifierClearArgsCode E (boundaryState pc m) = clearState (pc + 7) V len m (fun _ => 0) 0 := by
have hsmall (i : ℕ) (hi : i ≤ 121) : i % 2 ^ E.W = i := Nat.mod_eq_of_lt (by omega)
apply ramState_eq_of
· simp only [verifierClearArgsCode, Fin.isValue, List.append_assoc, boundaryState, runBlock_append, ne_eq,
Fin.reduceEq, not_false_eq_true, metaRead_spec, runBlock_cons, execInstr, runBlock_nil, clearState,
ite_self, Nat.add_right_cancel_iff, Nat.add_left_cancel_iff]
· rfl
· intro r
fin_cases r <;> simp only [verifierClearArgsCode, Fin.isValue, List.append_assoc, boundaryState,
runBlock_append, ne_eq, Fin.reduceEq, not_false_eq_true, metaRead_spec,
Nat.reduceLeDiff, hsmall, hm86, Nat.mod_eq_of_lt hV, Std.le_refl, hm121,
Nat.mod_eq_of_lt hlen, runBlock_cons, execInstr, Nat.one_le_ofNat, runBlock_nil,
Fin.zero_eta, Function.update_of_ne, zero_ne_one, clearState, ite_self, ↓reduceIte,
Fin.mk_one, Function.update_self, one_ne_zero, Fin.reduceFinMk]
theorem verifierClearProcedure_spec (P : Program) (E : RAMEnv) (pc V len : ℕ) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile verifierClearProcedure pc))
(hmeta : (121 : ℕ) < 2 ^ E.W) (hV : 128 ≤ V) (hVfit : V < 2 ^ E.W) (hword : V + len ≤ 2 ^ E.W)
(hm86 : m 86 = V) (hm121 : m 121 = len) :
Sem P E pc (pc + 31) (boundaryState pc m)
(fun k z => k ≤ 8 * len + 25 ∧ z = boundaryState (pc + 31) (clearMem V m len)) := by
obtain ⟨hArgsAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hClearAt, hZeroAt⟩ := At.seqStmt hRestAt
have hArgs : Sem P E pc (pc + 7) (boundaryState pc m)
(fun k z => k ≤ 7 ∧ z = clearState (pc + 7) V len m (fun _ => 0) 0) := by
refine Sem.mono (Sem.block P E pc verifierClearArgsCode _ hArgsAt (by simp [verifierClearArgsCode, metaReadCode]) rfl) ?_
intro k z hQ
have hk : k = 7 := hQ.1
exact ⟨by omega, hQ.2.trans (verifierClearArgs_spec E pc V len m hmeta hVfit (by omega) hm86 hm121)⟩
have hClear := clearArray_spec P E (pc + 7) V len m (fun _ => 0) hClearAt (by omega) (by omega) hword
have hZero := Sem.zero_block P E (pc + 15) { clearState (pc + 7) V len m (fun _ => 0) len with pc := pc + 15 } hZeroAt rfl
have hFull := Sem.seq_bound hArgs (fun z _ hz => by
subst z
exact Sem.seq_bound hClear (fun z _ hz => by subst z; exact hZero))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, hQ.2⟩)
theorem FieldArrayStored.cleared {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (m : ℕ → ℕ) (V len : ℕ) :
FieldArrayStored b (clearMem V m len) V len (fun _ => 0) := by
intro j hj
rw [clearMem_get V m len j hj, enc_zero]
theorem verifierLength_spec (E : RAMEnv) (s : RAMState) (t : ℕ)
(hmeta : (121 : ℕ) < 2 ^ E.W) (ht : 2 * t < 2 ^ E.W) (hm80 : s.mem 80 = t) :
runBlock verifierLengthCode E s = boundaryState (s.pc + 23) (Function.update s.mem 121 (2 * t)) := by
have hsmall (i : ℕ) (hi : i ≤ 121) : i % 2 ^ E.W = i := Nat.mod_eq_of_lt (by omega)
have ht0 : t % 2 ^ E.W = t := Nat.mod_eq_of_lt (by omega)
have ht1 : (t + t) % 2 ^ E.W = 2 * t := by rw [show t + t = 2 * t by omega, Nat.mod_eq_of_lt ht]
rw [verifierLengthCode, runBlock_append, zeroRegs_spec]
apply ramState_eq_of
· have hp := runBlock_pc verifierLengthCode E s (by simp [verifierLengthCode, metaReadCode, metaStoreCode, zeroRegsCode])
rw [verifierLengthCode, runBlock_append, zeroRegs_spec] at hp
change _ = s.pc + 23 at hp
exact hp
· simp [runBlock_append, metaRead_spec, metaStore_spec, runBlock_cons, runBlock_nil, execInstr, hsmall, hm80, ht0, ht1, boundaryState]
· intro _; rfl
theorem verifier_core_meta_readonly (V len slot : ℕ) (hV : 128 ≤ V) (hs : slot < 128) (hn : slot < 113 ∨ 121 < slot) :
¬ verifierCoreWritable V len slot := by dsimp [verifierCoreWritable]; omega
theorem verifier_meta_readonly (V len slot : ℕ) (hV : 128 ≤ V) (hs : slot < 128)
(hn : slot ≠ 100) (hr : slot < 113 ∨ 121 < slot) : ¬ verifierWritable V len slot := by
dsimp [verifierWritable, verifierCoreWritable]
omega
theorem power_outer_le_verifier_core (V len addr : ℕ) (ha : powerOuterWritable V len addr) : verifierCoreWritable V len addr := by
dsimp [powerOuterWritable, powerOuterMeta] at ha
dsimp [verifierCoreWritable]
omega
theorem comparison_le_verifier (V len addr : ℕ) (ha : comparisonWritable addr) : verifierWritable V len addr := by
dsimp [comparisonWritable] at ha
dsimp [verifierWritable, verifierCoreWritable]
omega
theorem FieldArrayStored.of_verifier_frame {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
{b : Module.Basis (Fin w) (ZMod 2) F} {m m' : ℕ → ℕ} {EB V len : ℕ} {e : ℕ → F}
(h : FieldArrayStored b m EB len e) (hEB : 128 ≤ EB)
(hdisj : EB + len ≤ V ∨ V + len ≤ EB) (hf : MemoryFrame (verifierWritable V len) m m') : FieldArrayStored b m' EB len e := by
apply h.of_frame hf
intro j hj
dsimp [verifierWritable, verifierCoreWritable]
omega
theorem OutputStored.of_verifier_frame {m m' : ℕ → ℕ} {BP V len T : ℕ} {xs : List ℕ}
(h : OutputStored m BP xs) (hBP : 128 ≤ BP) (hlen : xs.length ≤ T)
(hdisj : BP + T ≤ V ∨ V + len ≤ BP) (hf : MemoryFrame (verifierWritable V len) m m') : OutputStored m' BP xs := by
apply h.of_frame hf
intro j hj
dsimp [verifierWritable, verifierCoreWritable]
omega
theorem verifierPrepareProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (P : Program) (E : RAMEnv)
(pc BP V T t : ℕ) (xs : List ℕ) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile verifierPrepareProcedure pc))
(hmeta : (121 : ℕ) < 2 ^ E.W) (hBP : 128 ≤ BP) (hBPword : BP + T ≤ 2 ^ E.W)
(hV : 128 ≤ V) (hVfit : V < 2 ^ E.W) (hVword : V + 2 * t ≤ 2 ^ E.W) (hdisj : BP + T ≤ V ∨ V + 2 * t ≤ BP)
(hcount : xs.length ≤ T) (hout : OutputStored m BP xs)
(hm85 : m 85 = BP) (hm86 : m 86 = V) (hm77 : m 77 = w) (hm80 : m 80 = t) (hm101 : m 101 = xs.length) :
Sem P E pc (pc + 96) (boundaryState pc m)
(fun k z => k ≤ 8 * (2 * t) + 90 ∧ ∃ m', z = boundaryState (pc + 96) m' ∧
PowerOuterView b ι BP V (2 * t) xs [] xs m' ∧ MemoryFrame (verifierCoreWritable V (2 * t)) m m') := by
let len := 2 * t
let m1 := Function.update m 121 len
let m2 := clearMem V m1 len
let m3 := Function.update (Function.update m2 117 0) 118 xs.length
have hlenWord : len < 2 ^ E.W := by dsimp [len]; omega
have hcountWord : xs.length < 2 ^ E.W := by omega
have hf01 : MemoryFrame (verifierCoreWritable V len) m m1 :=
MemoryFrame.update_allowed _ m 121 len (Or.inl ⟨by norm_num, le_rfl⟩)
have hf12 : MemoryFrame (verifierCoreWritable V len) m1 m2 := by
intro addr ha
apply clearMem_frame V m1 len addr
dsimp [verifierCoreWritable] at ha
omega
have hf23 : MemoryFrame (verifierCoreWritable V len) m2 m3 :=
(initializeLoop_frame m2 117 118 xs.length).mono (by
intro addr ha
dsimp [verifierCoreWritable]
omega)
have hf02 := MemoryFrame.trans hf01 hf12
have hf03 := MemoryFrame.trans hf02 hf23
have hfixed (slot : ℕ) (hs : slot < 113) : m3 slot = m slot :=
hf03 slot (verifier_core_meta_readonly V len slot hV (by omega) (Or.inl hs))
have hm286 : m2 86 = V :=
(hf02 86 (verifier_core_meta_readonly V len 86 hV (by norm_num) (by omega))).trans hm86
have hm2121 : m2 121 = len := by
change clearMem V m1 len 121 = len
rw [clearMem_frame V m1 len 121 (Or.inl (by omega))]
simp [m1]
have hm2101 : m2 101 = xs.length :=
(hf02 101 (verifier_core_meta_readonly V len 101 hV (by norm_num) (by omega))).trans hm101
obtain ⟨hLengthAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hClearAt, hLoopInitAt⟩ := At.seqStmt hRestAt
have hLength : Sem P E pc (pc + 23) (boundaryState pc m)
(fun k z => k ≤ 23 ∧ z = boundaryState (pc + 23) m1) :=
Sem.boundary_block P E pc verifierLengthCode m m1 hLengthAt
(by simp [verifierLengthCode, metaReadCode, metaStoreCode, zeroRegsCode])
(verifierLength_spec E _ t hmeta hlenWord hm80)
have hClear := verifierClearProcedure_spec P E (pc + 23) V len m1 hClearAt hmeta hV hVfit hVword
(by simpa [m1] using hm86) (by simp [m1])
have hInit : Sem P E (pc + 54) (pc + 96) (boundaryState (pc + 54) m2)
(fun k z => k ≤ 42 ∧ z = boundaryState (pc + 96) m3) :=
Sem.boundary_block P E _ (initializeLoopCode 117 118 101) m2 m3 hLoopInitAt
(by simp [initializeLoopCode, setMetaCode, copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(initializeLoop_spec E _ 117 118 101 xs.length (by omega) (by omega) (by omega) (by decide) hcountWord hm2101)
have hview : PowerOuterView b ι BP V len xs [] xs m3 := by
refine ⟨hout.of_verifier_frame hBP hcount hdisj (hf03.mono (fun _ ha => Or.inr ha)), ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
· apply (((FieldArrayStored.cleared b m1 V len).meta_update hV 117 0 (by norm_num)).meta_update hV 118 xs.length (by norm_num)).congr_values
intro j _
exact (listPowerSums_nil ι j).symm
· exact (hfixed 85 (by norm_num)).trans hm85
· exact (hfixed 86 (by norm_num)).trans hm86
· exact (hfixed 77 (by norm_num)).trans hm77
· simpa [m3] using hm2121
· exact (hfixed 101 (by norm_num)).trans hm101
· simp [m3]
· simp [m3]
have hFull := Sem.seq_bound hLength (fun z _ hz => by
subst z
exact Sem.seq_bound hClear (fun z _ hz => by subst z; exact hInit))
exact Sem.mono hFull (fun k z hQ => ⟨by omega, m3, hQ.2, hview, hf03⟩)
theorem verifierPowerProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc BP V T : ℕ) (xs : List ℕ) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile verifierPowerProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (121 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ w)
(hBP : 128 ≤ BP) (hBPword : BP + T ≤ 2 ^ E.W) (hV : 128 ≤ V) (hVfit : V < 2 ^ E.W) (hVword : V + 2 * t ≤ 2 ^ E.W)
(hdisj : BP + T ≤ V ∨ V + 2 * t ≤ BP) (hcount : xs.length ≤ T) (hrange : ∀ i ∈ xs, i < N)
(hout : OutputStored m BP xs) (hm85 : m 85 = BP) (hm86 : m 86 = V) (hm77 : m 77 = w)
(hm80 : m 80 = t) (hm101 : m 101 = xs.length) :
Sem P E pc (pc + 300) (boundaryState pc m)
(fun k z => k ≤ (85 * (2 * t) + 117) * xs.length + 8 * (2 * t) + 94 ∧ ∃ m',
z = boundaryState (pc + 300) m' ∧ PowerOuterView b ι BP V (2 * t) xs xs [] m' ∧
MemoryFrame (verifierCoreWritable V (2 * t)) m m') := by
obtain ⟨hPrepareAt, hPowerAt⟩ := At.seqStmt hAt
have hPrepare := verifierPrepareProcedure_spec b ι P E pc BP V T t xs m hPrepareAt hmeta hBP hBPword hV hVfit hVword
hdisj hcount hout hm85 hm86 hm77 hm80 hm101
obtain ⟨_, k1, z1, hRun1, hPc1, hCost1, m1, hz1, hv1, hf01⟩ := hPrepare
have hPrepareExact : Sem P E pc (pc + 96) (boundaryState pc m)
(fun k z => k ≤ 8 * (2 * t) + 90 ∧ z = boundaryState (pc + 96) m1) :=
⟨rfl, k1, z1, hRun1, hPc1, hCost1, hz1⟩
have hPower := powerOuterProcedure_spec b ι t N P E (pc + 96) BP V (2 * t) T xs m1 hPowerAt
hw hW hdet hmeta hN hBP hBPword hV hVword hdisj hcount hrange hv1
have hFull := Sem.seq_bound hPrepareExact (fun z _ hz => by subst z; exact hPower)
refine Sem.mono hFull ?_
intro k z hQ
obtain ⟨hk, m2, hz2, hv2, hf12⟩ := hQ
exact ⟨by omega, m2, hz2, hv2, MemoryFrame.trans hf01 (hf12.mono (power_outer_le_verifier_core V (2 * t)))⟩
/-- The complete RAM verifier: recompute all 2t sums from the bounded
candidate list, compare them with the saved input, and accumulate the flag. -/
theorem verifierProcedure_spec {F : Type} [Field F] [Algebra (ZMod 2) F] [DecidableEq F] {w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (t N : ℕ) (P : Program) (E : RAMEnv)
(pc EB BP V T flag : ℕ) (e : ℕ → F) (xs : List ℕ) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile verifierProcedure pc))
(hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hmeta : (121 : ℕ) < 2 ^ E.W) (hN : N < 2 ^ w) (hflag : flag ≤ 1)
(hBP : 128 ≤ BP) (hBPword : BP + T ≤ 2 ^ E.W) (hV : 128 ≤ V) (hVfit : V < 2 ^ E.W) (hVword : V + 2 * t ≤ 2 ^ E.W)
(hEB : 128 ≤ EB) (hEBword : EB + 2 * t ≤ 2 ^ E.W)
(hdisj : BP + T ≤ V ∨ V + 2 * t ≤ BP) (hEdisj : EB + 2 * t ≤ V ∨ V + 2 * t ≤ EB)
(hcount : xs.length ≤ T) (hrange : ∀ i ∈ xs, i < N)
(hout : OutputStored m BP xs) (hExpected : FieldArrayStored b m EB (2 * t) e)
(hm79 : m 79 = EB) (hm85 : m 85 = BP) (hm86 : m 86 = V) (hm77 : m 77 = w)
(hm80 : m 80 = t) (hm101 : m 101 = xs.length) (hm100 : m 100 = flag) :
Sem P E pc (pc + 423) (boundaryState pc m)
(fun k z => k ≤ (85 * (2 * t) + 117) * xs.length + 86 * (2 * t) + 140 ∧ ∃ m',
z = boundaryState (pc + 423) m' ∧ m' 100 = flag * equalPrefix e (listPowerSums ι xs) (2 * t) ∧
m' 100 ≤ 1 ∧ (m' 100 = 1 ↔ flag = 1 ∧ ∀ j < 2 * t, e j = listPowerSums ι xs j) ∧
m' 85 = BP ∧ m' 101 = xs.length ∧ OutputStored m' BP xs ∧
MemoryFrame (verifierWritable V (2 * t)) m m') := by
obtain ⟨hPowerAt, hRestAt⟩ := At.seqStmt hAt
obtain ⟨hInitAt, hCompareAt⟩ := At.seqStmt hRestAt
have hPower := verifierPowerProcedure_spec b ι t N P E pc BP V T xs m hPowerAt hw hW hdet hmeta hN
hBP hBPword hV hVfit hVword hdisj hcount hrange hout hm85 hm86 hm77 hm80 hm101
obtain ⟨_, k1, z1, hRun1, hPc1, hCost1, m1, hz1, hv1, hf01⟩ := hPower
have hPowerExact : Sem P E pc (pc + 300) (boundaryState pc m)
(fun k z => k ≤ (85 * (2 * t) + 117) * xs.length + 8 * (2 * t) + 94 ∧ z = boundaryState (pc + 300) m1) :=
⟨rfl, k1, z1, hRun1, hPc1, hCost1, hz1⟩
let m2 := Function.update (Function.update m1 119 0) 120 (2 * t)
have hf12 : MemoryFrame (verifierCoreWritable V (2 * t)) m1 m2 :=
(initializeLoop_frame m1 119 120 (2 * t)).mono (by
intro addr ha
dsimp [verifierCoreWritable]
omega)
have hf02 := MemoryFrame.trans hf01 hf12
have hfixed2 (slot : ℕ) (hs : slot < 113) : m2 slot = m slot :=
hf02 slot (verifier_core_meta_readonly V (2 * t) slot hV (by omega) (Or.inl hs))
have hExpected2 := hExpected.of_verifier_frame hEB hEdisj (hf02.mono (fun _ ha => Or.inr ha))
have hActual2 := (hv1.powers.meta_update hV 119 0 (by norm_num)).meta_update hV 120 (2 * t) (by norm_num)
have hv2 : ComparisonView b EB V (2 * t) e (listPowerSums ι xs) flag 0 (2 * t) m2 := by
refine ⟨hExpected2, hActual2, ?_, ?_, by simp [m2], by simp [m2], ?_⟩
· exact (hfixed2 79 (by norm_num)).trans hm79
· exact (hfixed2 86 (by norm_num)).trans hm86
· simpa only [equalPrefix, Nat.mul_one] using (hfixed2 100 (by norm_num)).trans hm100
have hInit : Sem P E (pc + 300) (pc + 342) (boundaryState (pc + 300) m1)
(fun k z => k ≤ 42 ∧ z = boundaryState (pc + 342) m2) :=
Sem.boundary_block P E _ (initializeLoopCode 119 120 121) m1 m2 hInitAt
(by simp [initializeLoopCode, setMetaCode, copyMetaCode, metaReadCode, metaStoreCode, zeroRegsCode])
(initializeLoop_spec E _ 119 120 121 (2 * t) (by omega) (by omega) hmeta (by decide) (by omega) hv1.length)
have hCompare := comparisonProcedure_spec b P E (pc + 342) EB V (2 * t) flag e (listPowerSums ι xs) m2 hCompareAt
(by omega) (by omega) hEB hV hEBword hVword hflag hv2
have hFull := Sem.seq_bound hPowerExact (fun z _ hz => by
subst z
exact Sem.seq_bound hInit (fun z _ hz => by subst z; exact hCompare))
refine Sem.mono hFull ?_
intro k z hQ
obtain ⟨hk, m3, hz3, hv3, hf23⟩ := hQ
have hf03 : MemoryFrame (verifierWritable V (2 * t)) m m3 :=
MemoryFrame.trans (hf02.mono (fun _ ha => Or.inr ha)) (hf23.mono (comparison_le_verifier V (2 * t)))
have hfixed3 (slot : ℕ) (hs : slot < 113) (hn : slot ≠ 100) : m3 slot = m slot :=
hf03 slot (verifier_meta_readonly V (2 * t) slot hV (by omega) hn (Or.inl hs))
refine ⟨by omega, m3, hz3, hv3.flag, ?_, ?_, ?_, ?_, hout.of_verifier_frame hBP hcount hdisj hf03, hf03⟩
· rw [hv3.flag]
exact le_trans (Nat.mul_le_mul hflag (equalPrefix_le_one e (listPowerSums ι xs) (2 * t))) (by norm_num)
· rw [hv3.flag]
exact compareFlag_accept e (listPowerSums ι xs) flag (2 * t) hflag
· exact (hfixed3 85 (by norm_num) (by norm_num)).trans hm85
· exact (hfixed3 101 (by norm_num) (by norm_num)).trans hm101
theorem rootCandidate_card_le {F : Type} [Field F] [DecidableEq F] (us : List F) :
(rootCandidate us).card ≤ us.length := by
simpa only [rootCandidate, List.length_map] using List.toFinset_card_le (us.map (fun u => u⁻¹))
theorem rootCandidate_legal {F : Type} [Field F] [DecidableEq F] (N : ℕ) (ι : ℕ → F) (us : List F)
(hvalid : rootPositionFlag N ι us = 1) : ∀ v ∈ rootCandidate us, ∃ i : Fin N, ι i.val = v := by
intro v hv
obtain ⟨u, hu, rfl⟩ := List.mem_map.mp (List.mem_toFinset.mp hv)
have hp := (rootPositionFlag_valid N ι us).mp hvalid u hu
obtain ⟨i, hi, hpi, hvi⟩ := posTab_positive_spec N ι u⁻¹ hp
exact ⟨⟨i, hi⟩, hvi⟩
theorem rootPositions_powerSum {F : Type} [Field F] [DecidableEq F] (N : ℕ) (ι : ℕ → F) (us : List F) (j : ℕ)
(hnd : us.Nodup) (hvalid : rootPositionFlag N ι us = 1) :
listPowerSums ι (rootPositionList N ι us) j = ∑ v ∈ rootCandidate us, v ^ (j + 1) := by
have hinv : Function.Injective (fun u : F => u⁻¹) := by
intro u v h
have hh := congrArg (fun a : F => a⁻¹) h
simpa only [inv_inv] using hh
have hnd' := List.Nodup.map hinv hnd
rw [rootCandidate, List.sum_toFinset (fun v : F => v ^ (j + 1)) hnd']
simp only [listPowerSums, rootPositionList, List.map_map]
apply congrArg List.sum
apply List.map_congr_left
intro u hu
change ι (posTab N ι u⁻¹ - 1) ^ (j + 1) = (u⁻¹) ^ (j + 1)
rw [rootPositionList_iota N ι us hvalid u hu]
theorem rootCandidate_verified {F : Type} [Field F] [DecidableEq F]
(N t : ℕ) (ι : ℕ → F) (e : ℕ → F) (us : List F)
(hlen : us.length ≤ t) (hnd : us.Nodup) (hvalid : rootPositionFlag N ι us = 1)
(hsums : ∀ j < 2 * t, e j = listPowerSums ι (rootPositionList N ι us) j) :
CandidateVerified N t ι e (rootCandidate us) := by
refine ⟨le_trans (rootCandidate_card_le us) hlen, rootCandidate_legal N ι us hvalid, ?_⟩
intro a ha
have hbounds := Finset.mem_Icc.mp ha
have hj : a - 1 < 2 * t := by omega
have he := hsums (a - 1) hj
rw [rootPositions_powerSum N ι us (a - 1) hnd hvalid] at he
have hex : a - 1 + 1 = a := by omega
simpa only [hex] using he.symm
/-- The word-level checks are equivalent to the already verified algebraic
candidate predicate; this also supplies the rejection implication. -/
theorem rootCandidate_checks_iff {F : Type} [Field F] [DecidableEq F]
(N t : ℕ) (ι : ℕ → F) (e : ℕ → F) (us : List F) (hlen : us.length ≤ t) (hnd : us.Nodup) :
CandidateVerified N t ι e (rootCandidate us) ↔
rootPositionFlag N ι us = 1 ∧ ∀ j < 2 * t, e j = listPowerSums ι (rootPositionList N ι us) j := by
constructor
· intro hv
have hvalid : rootPositionFlag N ι us = 1 := by
apply (rootPositionFlag_valid N ι us).mpr
intro u hu
have hm : u⁻¹ ∈ rootCandidate us := List.mem_toFinset.mpr (List.mem_map.mpr ⟨u, hu, rfl⟩)
obtain ⟨i, hi⟩ := hv.2.1 u⁻¹ hm
by_contra hc
have hz : posTab N ι u⁻¹ = 0 := by omega
exact (posTab_zero_iff N ι u⁻¹).mp hz ⟨i.val, i.isLt, hi⟩
refine ⟨hvalid, ?_⟩
intro j hj
rw [rootPositions_powerSum N ι us j hnd hvalid]
have hs := hv.2.2 (j + 1) (Finset.mem_Icc.mpr ⟨by omega, by omega⟩)
simpa only [Nat.add_sub_cancel] using hs.symm
· rintro ⟨hvalid, hsums⟩
exact rootCandidate_verified N t ι e us hlen hnd hvalid hsums
theorem rootPositionList_support {F : Type} [Field F] [DecidableEq F]
(N : ℕ) (ι : ℕ → F) (us : List F) (hinj : Set.InjOn ι (Set.Iio N))
(hvalid : rootPositionFlag N ι us = 1) (i : Fin N) :
i.val ∈ rootPositionList N ι us ↔ ι i.val ∈ rootCandidate us := by
constructor
· intro hi
obtain ⟨u, hu, hui⟩ := List.mem_map.mp hi
have he := rootPositionList_iota N ι us hvalid u hu
rw [hui] at he
exact List.mem_toFinset.mpr (List.mem_map.mpr ⟨u, hu, he.symm⟩)
· intro hi
obtain ⟨u, hu, hui⟩ := List.mem_map.mp (List.mem_toFinset.mp hi)
have hp : posTab N ι u⁻¹ = i.val + 1 := by rw [hui]; exact posTab_iota N ι hinj i.val i.isLt
exact List.mem_map.mpr ⟨u, hu, by simp [hp]⟩
theorem outputsSupport_of_mem {n : ℕ} (s : RAMState) (x : Fin n → ZMod 2) (base L : ℕ)
(l : List ℕ) (hbase : s.regs 0 = base) (hlen : s.regs 1 = L) (hlen' : l.length = L)
(hmem : ∀ k, k < L → s.mem (base + k) = l.getD k 0)
(hnd : l.Nodup) (hls : ∀ v : ℕ, v ∈ l ↔ ∃ i : Fin n, i.val = v ∧ x i = 1) :
OutputsSupport s x := by
have hout : outList s = l := by
unfold outList
rw [hlen, hbase]
apply List.ext_getElem
· simp [hlen']
· intro k h₁ h₂
have hk : k < L := by simpa using h₁
simp only [List.getElem_map, List.getElem_range]
rw [hmem k hk]
exact List.getD_eq_getElem l 0 (by omega)
refine ⟨?_, ?_⟩
· rw [hout]
exact hnd
· intro v
rw [hout]
exact hls v
/-- Finish the already verified accept/reject algebra from the exact checks
performed by the actual RAM verifier and its stored output list. -/
theorem decoder_correct_of_candidate_checks {F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F]
{N t w : ℕ} (b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F)
(y : Fin (t * w) → ZMod 2) (e : ℕ → F) (s : RAMState) (B : ℕ)
(hN : 1 ≤ N) (ht : 1 ≤ t) (hw : 0 < w) (h0 : ∀ i < N, ι i ≠ 0) (hinj : Set.InjOn ι (Set.Iio N))
(hodd : ∀ k : Fin t, e (2 * k.val) = payloadField b y k)
(heven : ∀ a : ℕ, 0 < a → e (2 * a - 1) = e (a - 1) ^ 2)
(hflag : s.regs r2 ≤ 1) (hbase : s.regs r0 = B) (hcount : s.regs r1 = (rootsByBasis b (padeSolve e t).curC).length)
(hout : OutputStored s.mem B (rootPositionList N ι (rootsByBasis b (padeSolve e t).curC)))
(hchecks : s.regs r2 = 1 ↔ rootPositionFlag N ι (rootsByBasis b (padeSolve e t).curC) = 1 ∧
∀ j < 2 * t, e j = listPowerSums ι (rootPositionList N ι (rootsByBasis b (padeSolve e t).curC)) j) :
(s.regs r2 ≠ 0 → ∃ x : Fin N → ZMod 2, (binSupp x).card ≤ t ∧ pinBits b (pin ι t x) = y ∧ OutputsSupport s x) ∧
(s.regs r2 = 0 → ¬ ∃ x : Fin N → ZMod 2, (binSupp x).card ≤ t ∧ pinBits b (pin ι t x) = y) := by
let σ := (padeSolve e t).curC
let us := rootsByBasis b σ
let xs := rootPositionList N ι us
have hmin := padeSolve_minimal e t ht
have hSound := rootsByBasis_sound b σ hmin.1.1
have hlen : us.length ≤ t := le_trans hSound.2.2 hmin.1.2.1
have hVerified : s.regs r2 = 1 ↔ CandidateVerified N t ι e (rootCandidate us) :=
hchecks.trans (rootCandidate_checks_iff N t ι e us hlen hSound.1).symm
constructor
· intro hgo
have hOne : s.regs r2 = 1 := by omega
have hv := hVerified.mp hOne
have hvalid := (hchecks.mp hOne).1
obtain ⟨x, hx, hxy, hsupport⟩ := verified_candidate_accept b ι y e (rootCandidate us) hinj hodd hv
refine ⟨x, hx, hxy, ?_⟩
apply outputsSupport_of_mem s x B us.length xs hbase hcount
· simp [xs, rootPositionList]
· intro k hk
exact hout k (by simpa only [rootPositionList, List.length_map] using hk)
· exact rootPositionList_nodup N ι us hSound.1 hvalid
· intro v
constructor
· intro hvx
have hvN := rootPositionList_range N ι us hN v hvx
let i : Fin N := ⟨v, hvN⟩
refine ⟨i, rfl, (hsupport i).mpr ?_⟩
exact (rootPositionList_support N ι us hinj hvalid i).mp hvx
· rintro ⟨i, rfl, hxi⟩
exact (rootPositionList_support N ι us hinj hvalid i).mpr ((hsupport i).mp hxi)
· intro hstop
apply computed_candidate_reject b ι y e ht hw h0 hinj hodd heven
intro hv
have hv' : CandidateVerified N t ι e (rootCandidate us) := hv
have hh := hVerified.mpr hv'
omega
theorem finishOutput_spec (E : RAMEnv) (pc : ℕ) (m : ℕ → ℕ)
(hmeta : (128 : ℕ) < 2 ^ E.W) (h85 : m 85 < 2 ^ E.W) (h101 : m 101 < 2 ^ E.W) (h100 : m 100 < 2 ^ E.W) :
∃ z, runBlock finishOutputCode E (boundaryState pc m) = z ∧ z.pc = pc + 9 ∧ z.mem = m ∧
z.regs r0 = m 85 ∧ z.regs r1 = m 101 ∧ z.regs r2 = m 100 := by
unfold finishOutputCode
rw [runBlock_append, runBlock_append]
rw [metaRead_spec E _ r0 85 (by decide), metaRead_spec E _ r1 101 (by decide), metaRead_spec E _ r2 100 (by decide)]
refine ⟨_, rfl, ?_, rfl, ?_, ?_, ?_⟩ <;>
simp [boundaryState, Nat.mod_eq_of_lt (show 85 < 2 ^ E.W by omega),
Nat.mod_eq_of_lt (show 100 < 2 ^ E.W by omega), Nat.mod_eq_of_lt (show 101 < 2 ^ E.W by omega),
Nat.mod_eq_of_lt h85, Nat.mod_eq_of_lt h101, Nat.mod_eq_of_lt h100] <;> omega
section PinBits
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end PinBits
section Uniqueness
variable {F : Type} [Field F] [Algebra (ZMod 2) F]
end Uniqueness
section Slp
variable {F : Type} [Field F]
end Slp
open LinearSetReconciliation327.Main in
theorem LinearSetReconciliation327.Main.pinsketch_decoder_verifier
{F : Type} [Field F] [DecidableEq F] [Algebra (ZMod 2) F] {N t w : ℕ}
(b : Module.Basis (Fin w) (ZMod 2) F) (ι : ℕ → F) (y : Fin (t * w) → ZMod 2) (e : ℕ → F)
(P : Program) (E : RAMEnv) (pc : ℕ) (m : ℕ → ℕ)
(hAt : At P pc (Stmt.compile verificationFinalProcedure pc))
(hN : 1 ≤ N) (ht : 1 ≤ t) (hw : 1 ≤ w) (hW : E.W = 8 * w) (hdet : DetAgrees E t N b ι)
(hEnd : decoderAllocEnd t < 2 ^ E.W) (hNw : N < 2 ^ w)
(h0 : ∀ i < N, ι i ≠ 0) (hinj : Set.InjOn ι (Set.Iio N))
(hodd : ∀ k : Fin t, e (2 * k.val) = payloadField b y k)
(heven : ∀ a : ℕ, 0 < a → e (2 * a - 1) = e (a - 1) ^ 2)
(hReady : CandidateReady b ι t N e m) :
Sem P E pc (pc + 432) (boundaryState pc m)
(fun k z => k ≤ (170 * t + 117) * t + 172 * t + 149 ∧ decoderPost (N := N) b ι y z) := by
let us := rootsByBasis b (padeSolve e t).curC
let xs := rootPositionList N ι us
have hmin := padeSolve_minimal e t ht
have hsound := rootsByBasis_sound b (padeSolve e t).curC hmin.1.1
have hlen : us.length ≤ t := le_trans hsound.2.2 hmin.1.2.1
have hxslen : xs.length = us.length := by simp [xs, rootPositionList]
have hg := decoderGeometry_spec E t hEnd
obtain ⟨hVerAt, hFinishAt⟩ := At.seqStmt hAt
have hVer := verifierProcedure_spec b ι t N P E pc (decoderSavedBase t) (decoderOutputBase t)
(decoderVerifyBase t) t (rootPositionFlag N ι us) e xs m hVerAt hw hW hdet (by have hh := hg.metadata; omega)
hNw (rootPositionFlag_le_one N ι us) hg.outputLow hg.outputWord hg.verifyLow hg.verifyFits hg.verifyWord
hg.savedLow hg.savedWord (Or.inl hg.outputVerify) (Or.inl hg.savedVerify)
(by rw [hxslen]; exact hlen) (rootPositionList_range N ι us hN) hReady.positions hReady.saved
hReady.savedBase hReady.output hReady.verification hReady.dimension hReady.tValue
(by simpa only [hxslen] using hReady.count) hReady.flag
obtain ⟨_, k1, z1, hrun1, hpc1, hk1, m1, hz1, h100, hbit, hchecks, h85, h101, hout, hf⟩ := hVer
have hVerExact : Sem P E pc (pc + 423) (boundaryState pc m)
(fun k z => k ≤ (85 * (2 * t) + 117) * xs.length + 86 * (2 * t) + 140 ∧ z = boundaryState (pc + 423) m1) :=
⟨rfl, k1, z1, hrun1, hpc1, hk1, hz1⟩
have hc : m1 101 ≤ t := h101.trans_le (hxslen.trans_le hlen)
obtain ⟨z2, hz2, hpc2, hmem2, hr0, hr1, hr2⟩ := finishOutput_spec E (pc + 423) m1 hg.metadata
(by rw [h85]; have hh := hg.outputWord; omega)
(by have hh := hg.outputWord; have hl := hg.outputLow; omega) (by have hh := hg.metadata; omega)
have hFinish : Sem P E (pc + 423) (pc + 432) (boundaryState (pc + 423) m1)
(fun k z => k ≤ 9 ∧ z = z2) := by
have hh := Sem.block P E (pc + 423) finishOutputCode (boundaryState (pc + 423) m1) hFinishAt
(by simp [finishOutputCode, metaReadCode]) rfl
exact Sem.mono hh (fun k z hq => ⟨by simpa [finishOutputCode, metaReadCode] using hq.1.le, hq.2.trans hz2⟩)
have hFull := Sem.seq_bound hVerExact (fun z _ hz => by subst z; exact hFinish)
refine Sem.mono hFull ?_
intro k z hQ
obtain ⟨hk, rfl⟩ := hQ
refine ⟨?_, ?_⟩
· have hh : (85 * (2 * t) + 117) * xs.length ≤ (170 * t + 117) * t := by
calc
_ = (170 * t + 117) * xs.length := by ring
_ ≤ _ := Nat.mul_le_mul_left (170 * t + 117) (hxslen.trans_le hlen)
omega
· apply decoder_correct_of_candidate_checks b ι y e z (decoderOutputBase t) hN ht (by omega) h0 hinj hodd heven
· rw [hr2]; exact hbit
· exact hr0.trans h85
· exact hr1.trans (h101.trans hxslen)
· rw [hmem2]; exact hout
· rw [hr2]; exact hchecks
end LinearSetReconciliation327.Main
Source
arXiv:2611.11409, §2.1–2.2, Proposition 2.1; the four published stage contracts re-derived with the `det` hypothesis weakened to the slots the decoder reads.