| import Mathlib |
| import OAI.Computability.DeterministicSum.ModularInverses |
|
|
| namespace OAI |
|
|
| /-! Prime-power coefficient tables and their paid Newton transforms. -/ |
|
|
| namespace DeterministicThreeSum.Newton |
| open Finset |
| open scoped BigOperators |
| noncomputable section |
| variable {R : Type*} [CommRing R] {q : ℕ} |
|
|
| lemma entry_map (node : Fin q → ℤ) : |
| (Int.castRingHom R).mapMatrix (entry node)=entry (fun i => (node i:R)) := by |
| ext i j |
| simp [entry] |
|
|
| lemma cast_natAbs_unit {a : ℤ} (h : IsUnit (a:R)) : IsUnit ((a.natAbs:ℕ):R) := by |
| have he : ((a.natAbs:ℕ):R)=((|a|:ℤ):R) := by |
| rw [show ((a.natAbs:ℕ):R)=((a.natAbs:ℤ):R) by simp,Int.natCast_natAbs] |
| rw [he] |
| rcases abs_choice a with hpos|hneg |
| · rwa [hpos] |
| · simpa only [hneg,Int.cast_neg] using h.neg |
|
|
| def inverseDenominator (order : Equiv.Perm (Fin q)) : ℕ := |
| (entry (fun i => ((order i).val:ℤ))).det.natAbs |
|
|
| def inverseNumerator (order : Equiv.Perm (Fin q)) (i j : Fin q) : ℤ := |
| (entry (fun k => ((order k).val:ℤ))).det.sign * |
| (entry (fun k => ((order k).val:ℤ))).adjugate i j |
|
|
| lemma inverseDenominator_unit {p e : ℕ} (hp : p.Prime) (he : 0 < e) (hq : q < p) |
| (order : Equiv.Perm (Fin q)) : IsUnit (inverseDenominator order:ZMod (p^e)) := by |
| apply cast_natAbs_unit |
| have h:=entry_det_unit (fun i => ((order i).val:ZMod (p^e))) (primePower_node_units hp he hq order) |
| have hmap : (Int.castRingHom (ZMod (p^e))).mapMatrix (entry (fun i => ((order i).val:ℤ)))= |
| entry (fun i => ((order i).val:ZMod (p^e))) := by |
| simpa only [Int.cast_natCast] using entry_map (R:=ZMod (p^e)) (fun i => ((order i).val:ℤ)) |
| have hd:=RingHom.map_det (Int.castRingHom (ZMod (p^e))) (entry (fun i => ((order i).val:ℤ))) |
| rw [hmap] at hd |
| change IsUnit ((Int.castRingHom (ZMod (p^e))) (entry (fun i => ((order i).val:ℤ))).det) |
| rwa [hd] |
|
|
| lemma inverseDenominator_prime {p : ℕ} (hp : p.Prime) (hq : q < p) (order : Equiv.Perm (Fin q)) : |
| ¬p∣inverseDenominator order := by |
| have h:=inverseDenominator_unit (e:=1) hp (by omega) hq order |
| exact (ZMod.isUnit_natCast_iff_not_dvd_pow hp (by omega : 0<1)).mp h |
|
|
| lemma inverseInteger_eq (M : Matrix (Fin q) (Fin q) ℤ) (s : R) |
| (hs : s*(M.det.natAbs:R)=1) : |
| ((Int.castRingHom R).mapMatrix M)⁻¹= |
| (s*(M.det.sign:R)) • (Int.castRingHom R).mapMatrix M.adjugate := by |
| apply Matrix.inv_eq_left_inv |
| rw [Matrix.smul_mul,RingHom.map_adjugate,Matrix.adjugate_mul,← RingHom.map_det,smul_smul] |
| have hz : (M.det.sign:R)*(M.det:R)=(M.det.natAbs:R) := by |
| rw [← Int.cast_mul,Int.sign_mul_self,Int.cast_natCast] |
| change ((s*(M.det.sign:R))*(M.det:R)) • (1:Matrix (Fin q) (Fin q) R)=1 |
| rw [mul_assoc,hz,hs,one_smul] |
|
|
| lemma inverse_entry_integer (order : Equiv.Perm (Fin q)) (s : R) |
| (hs : s*(inverseDenominator order:R)=1) (i j : Fin q) : |
| ((entry (fun k => ((order k).val:R)))⁻¹) i j=s*(inverseNumerator order i j:R) := by |
| have hm:=inverseInteger_eq (entry (fun k => ((order k).val:ℤ))) s hs |
| rw [entry_map] at hm |
| have hv:=congrArg (fun A : Matrix (Fin q) (Fin q) R => A i j) hm |
| simpa [inverseNumerator,Int.cast_mul,mul_assoc] using hv |
|
|
| end |
| end DeterministicThreeSum.Newton |
| namespace DeterministicThreeSum.Structured.Indexed.NewtonTable |
| open Command DeterministicThreeSum.Newton |
| noncomputable section |
|
|
| def numeratorAt {q : ℕ} (order : Equiv.Perm (Fin q)) (z : ℕ) : ℤ := |
| if h : z<q*q then |
| inverseNumerator order |
| ⟨z/q,(Nat.div_lt_iff_lt_mul (by nlinarith : 0<q)).mpr h⟩ |
| ⟨z%q,Nat.mod_lt _ (by nlinarith : 0<q)⟩ |
| else 0 |
|
|
| def numerators {q : ℕ} (order : Equiv.Perm (Fin q)) : List ℤ := |
| List.ofFn (fun z : Fin (q*q) => numeratorAt order z.val) |
|
|
| def command {q : ℕ} (p : ℕ) (order : Equiv.Perm (Fin q)) : Command := |
| commonTable p (inverseDenominator order) (numerators order) |
|
|
| lemma numeratorAt_entry {q : ℕ} (order : Equiv.Perm (Fin q)) (i j : Fin q) : |
| numeratorAt order (i.val*q+j.val)=inverseNumerator order i j := by |
| have hq : 0<q := Nat.zero_lt_of_lt i.isLt |
| have hi : i.val*q+j.val<q*q := by nlinarith [i.isLt,j.isLt] |
| unfold numeratorAt |
| rw [dite_eq_left hi] |
| congr 1 <;> apply Fin.ext |
| · change (i.val*q+j.val)/q=i.val |
| rw [Nat.mul_comm i.val q,Nat.mul_add_div hq,Nat.div_eq_of_lt j.isLt,Nat.add_zero] |
| · simp [Nat.add_mod,Nat.mod_eq_of_lt j.isLt] |
|
|
| theorem command_correct {w p e q base : ℕ} (order : Equiv.Perm (Fin q)) (s : Data) |
| (hp : p.Prime) (hq : q<p) |
| (hmul : (p^(e+1))*(p^(e+1))<wordModulus w) |
| (hD : inverseDenominator order<wordModulus w) |
| (hbase : base+q*q<wordModulus w) |
| (hints : ∀ a∈numerators order, a.natAbs<wordModulus w) |
| (h2 : s.registers 2=p^(e+1)) (h3 : s.registers 3=base) : |
| ∃ cost z, Eval w (command p order) s cost z ∧ cost≤10*w+13+9*(q*q) ∧ |
| (∀ i j : Fin q, ∃ v, z.memory (base+i.val*q+j.val)=some v ∧ v<p^(e+1) ∧ |
| (v:ZMod (p^(e+1)))=((entry (fun k => ((order k).val:ZMod (p^(e+1)))))⁻¹) i j) ∧ |
| (∀ a, a<base ∨ base+q*q≤a → z.memory a=s.memory a) ∧ |
| (∀ r, r=2 ∨ r=3 ∨ 7≤r → z.registers r=s.registers r) := by |
| have hl : (numerators order).length=q*q := by simp [numerators] |
| obtain ⟨c,z,he,hc,hm,houtside,hframe⟩:=commonTable_correct s (numerators order) hp hmul hD |
| (inverseDenominator_prime hp hq order) (by simpa only [hl] using hbase) hints h2 h3 |
| refine ⟨c,z,he,by simpa only [hl] using hc,?_,by simpa only [hl] using houtside,hframe⟩ |
| intro i j |
| have hi : i.val*q+j.val<q*q := by nlinarith [i.isLt,j.isLt] |
| obtain ⟨v,hv,hvT,hvalue⟩:=hm (i.val*q+j.val) (by simpa only [hl] using hi) |
| refine ⟨v,by simpa only [Nat.add_assoc] using hv,hvT,?_⟩ |
| have hu:=inverseDenominator_unit hp (by omega : 0<e+1) hq order |
| obtain ⟨a,ha⟩:=hu.exists_left_inv |
| rw [inverse_entry_integer order a ha] |
| have hnum : (numerators order)[i.val*q+j.val]=inverseNumerator order i j := by |
| simpa only [numerators,List.getElem_ofFn] using numeratorAt_entry order i j |
| rw [hnum] at hvalue |
| calc |
| (v:ZMod (p^(e+1))) = a*((v:ZMod (p^(e+1)))*(inverseDenominator order:ZMod (p^(e+1)))) := by calc |
| _ = (v:ZMod (p^(e+1)))*(a*(inverseDenominator order:ZMod (p^(e+1)))) := by rw [ha,mul_one] |
| _ = _ := by ring |
| _ = _ := by rw [hvalue] |
| end |
| end DeterministicThreeSum.Structured.Indexed.NewtonTable |
| namespace DeterministicThreeSum.Newton |
| open Finset |
| open scoped BigOperators |
| noncomputable section |
| variable {R : Type*} [CommRing R] {q : ℕ} |
|
|
| lemma univariate_integer (node : Fin q → ℤ) (j : Fin q) : |
| Polynomial.map (Int.castRingHom R) (univariate node j)=univariate (fun k => (node k:R)) j := by |
| simp [univariate,Polynomial.map_prod] |
|
|
| lemma conversion_integer (node : Fin q → ℤ) (j v : Fin q) : |
| ((conversion node j v:ℤ):R)=conversion (fun k => (node k:R)) j v := by |
| change (Int.castRingHom R) ((univariate node j).coeff v.val)=_ |
| rw [← Polynomial.coeff_map,univariate_integer] |
| rfl |
| end |
| end DeterministicThreeSum.Newton |
| namespace DeterministicThreeSum.Structured.Indexed.NewtonConversionTable |
| open Command DeterministicThreeSum.Newton |
| noncomputable section |
|
|
| def integerAt {q : ℕ} (order : Equiv.Perm (Fin q)) (z : ℕ) : ℤ := |
| if h : z<q*q then |
| conversion (fun k => ((order k).val:ℤ)) |
| ⟨z%q,Nat.mod_lt _ (by nlinarith : 0<q)⟩ |
| ⟨z/q,(Nat.div_lt_iff_lt_mul (by nlinarith : 0<q)).mpr h⟩ |
| else 0 |
|
|
| def integers {q : ℕ} (order : Equiv.Perm (Fin q)) : List ℤ := |
| List.ofFn (fun z : Fin (q*q) => integerAt order z.val) |
|
|
| def command {q : ℕ} (p : ℕ) (order : Equiv.Perm (Fin q)) : Command := |
| commonTable p 1 (integers order) |
|
|
| lemma integerAt_entry {q : ℕ} (order : Equiv.Perm (Fin q)) (i j : Fin q) : |
| integerAt order (i.val*q+j.val)=conversion (fun k => ((order k).val:ℤ)) j i := by |
| have hq : 0<q := Nat.zero_lt_of_lt i.isLt |
| have hi : i.val*q+j.val<q*q := by nlinarith [i.isLt,j.isLt] |
| unfold integerAt |
| rw [dite_eq_left hi] |
| congr 1 <;> apply Fin.ext |
| · simp [Nat.add_mod,Nat.mod_eq_of_lt j.isLt] |
| · change (i.val*q+j.val)/q=i.val |
| rw [Nat.mul_comm i.val q,Nat.mul_add_div hq,Nat.div_eq_of_lt j.isLt,Nat.add_zero] |
|
|
| theorem command_correct {w p e q base : ℕ} (order : Equiv.Perm (Fin q)) (s : Data) |
| (hp : p.Prime) (hmul : (p^(e+1))*(p^(e+1))<wordModulus w) |
| (hbase : base+q*q<wordModulus w) |
| (hints : ∀ a∈integers order, a.natAbs<wordModulus w) |
| (h2 : s.registers 2=p^(e+1)) (h3 : s.registers 3=base) : |
| ∃ cost z, Eval w (command p order) s cost z ∧ cost≤10*w+13+9*(q*q) ∧ |
| (∀ i j : Fin q, ∃ v, z.memory (base+i.val*q+j.val)=some v ∧ v<p^(e+1) ∧ |
| (v:ZMod (p^(e+1)))=conversion (fun k => ((order k).val:ZMod (p^(e+1)))) j i) ∧ |
| (∀ a, a<base ∨ base+q*q≤a → z.memory a=s.memory a) ∧ |
| (∀ r, r=2 ∨ r=3 ∨ 7≤r → z.registers r=s.registers r) := by |
| have hT : 1≤p^(e+1) := Nat.one_le_pow _ _ hp.pos |
| have h1 : 1<wordModulus w := by nlinarith |
| have hl : (integers order).length=q*q := by simp [integers] |
| obtain ⟨c,z,he,hc,hm,houtside,hframe⟩:=commonTable_correct s (integers order) hp hmul h1 |
| (by exact hp.not_dvd_one) (by simpa only [hl] using hbase) hints h2 h3 |
| refine ⟨c,z,he,by simpa only [hl] using hc,?_,by simpa only [hl] using houtside,hframe⟩ |
| intro i j |
| have hi : i.val*q+j.val<q*q := by nlinarith [i.isLt,j.isLt] |
| obtain ⟨v,hv,hvT,hvalue⟩:=hm (i.val*q+j.val) (by simpa only [hl] using hi) |
| refine ⟨v,by simpa only [Nat.add_assoc] using hv,hvT,?_⟩ |
| have hnum : (integers order)[i.val*q+j.val]=conversion (fun k => ((order k).val:ℤ)) j i := by |
| simpa only [integers,List.getElem_ofFn] using integerAt_entry order i j |
| rw [hnum] at hvalue |
| have hi':=((conversion_integer (R:=ZMod (p^(e+1))) (fun k => ((order k).val:ℤ)) j i)) |
| simpa only [Nat.cast_one,mul_one,hi',Int.cast_natCast] using hvalue |
| end |
| end DeterministicThreeSum.Structured.Indexed.NewtonConversionTable |
| namespace DeterministicThreeSum.Structured.Indexed.NewtonPass |
| open Command Axis DeterministicThreeSum.Newton |
| noncomputable section |
|
|
| lemma inverseTable_lt {T q : ℕ} (hT : 0<T) (node : Fin q → ZMod T) (z : ℕ) : |
| inverseTable T q node z<T := by |
| let : NeZero T := ⟨by omega⟩ |
| unfold inverseTable |
| split_ifs <;> simp only [ZMod.val_lt, hT] |
|
|
| lemma conversionTable_lt {T q : ℕ} (hT : 0<T) (node : Fin q → ZMod T) (z : ℕ) : |
| conversionTable T q node z<T := by |
| let : NeZero T := ⟨by omega⟩ |
| unfold conversionTable |
| split_ifs <;> simp only [ZMod.val_lt,hT] |
|
|
| lemma memory_inverse {T q base : ℕ} (hT : 0<T) (hq : 0<q) (node : Fin q → ZMod T) (s : Data) |
| (h : ∀ i j : Fin q, ∃ v, s.memory (base+i.val*q+j.val)=some v ∧ v<T ∧ |
| (v:ZMod T)=((entry node)⁻¹) i j) : |
| ∀ z, z<q*q → s.memory (base+z)=some (inverseTable T q node z) ∧ inverseTable T q node z<T := by |
| let : NeZero T := ⟨by omega⟩ |
| intro z hz |
| let i : Fin q := ⟨z/q,(Nat.div_lt_iff_lt_mul hq).mpr hz⟩ |
| let j : Fin q := ⟨z%q,Nat.mod_lt _ hq⟩ |
| have he : i.val*q+j.val=z := by dsimp [i,j]; nlinarith only [Nat.mod_add_div z q] |
| obtain ⟨v,hv,hvT,hvc⟩:=h i j |
| have hc : (v:ZMod T)=(inverseTable T q node z:ZMod T) := by |
| rw [← he,inverseTable_entry hT] |
| exact hvc |
| apply_fun ZMod.val at hc |
| simp only [ZMod.val_natCast,Nat.mod_eq_of_lt hvT, |
| Nat.mod_eq_of_lt (inverseTable_lt hT node z)] at hc |
| refine ⟨?_,inverseTable_lt hT node z⟩ |
| simpa only [Nat.add_assoc,he,hc] using hv |
|
|
| lemma memory_conversion {T q base : ℕ} (hT : 0<T) (hq : 0<q) (node : Fin q → ZMod T) (s : Data) |
| (h : ∀ i j : Fin q, ∃ v, s.memory (base+i.val*q+j.val)=some v ∧ v<T ∧ |
| (v:ZMod T)=conversion node j i) : |
| ∀ z, z<q*q → s.memory (base+z)=some (conversionTable T q node z) ∧ conversionTable T q node z<T := by |
| let : NeZero T := ⟨by omega⟩ |
| intro z hz |
| let i : Fin q := ⟨z/q,(Nat.div_lt_iff_lt_mul hq).mpr hz⟩ |
| let j : Fin q := ⟨z%q,Nat.mod_lt _ hq⟩ |
| have he : i.val*q+j.val=z := by dsimp [i,j]; nlinarith only [Nat.mod_add_div z q] |
| obtain ⟨v,hv,hvT,hvc⟩:=h i j |
| have hc : (v:ZMod T)=(conversionTable T q node z:ZMod T) := by |
| rw [← he,conversionTable_entry hT] |
| exact hvc |
| apply_fun ZMod.val at hc |
| simp only [ZMod.val_natCast,Nat.mod_eq_of_lt hvT, |
| Nat.mod_eq_of_lt (conversionTable_lt hT node z)] at hc |
| refine ⟨?_,conversionTable_lt hT node z⟩ |
| simpa only [Nat.add_assoc,he,hc] using hv |
|
|
| def tableSources (k b i : ℕ) : Operand := match i with |
| | 2 => .register (k+6) | 3 => .register (k+b) | _ => .literal 0 |
|
|
| def tableValues (T B i : ℕ) : ℕ := match i with |
| | 2 => T | 3 => B | _ => 0 |
|
|
| lemma tableSetup_correct {w k T B b : ℕ} (s : Data) (hk : 16≤k) |
| (hT : T<wordModulus w) (hB : B<wordModulus w) |
| (h6 : s.registers (k+6)=T) (hb : s.registers (k+b)=B) : |
| Eval w (copyPrefix (tableSources k b) 4) s 4 (patched s 4 (tableValues T B)) := by |
| apply copyPrefix_correct |
| · intro i hi r hr |
| interval_cases i <;> simp only [tableSources] at hr <;> cases hr <;> omega |
| · intro i hi |
| interval_cases i <;> simp [tableSources,tableValues,operand_register,operand_literal, |
| h6,hb,Nat.mod_eq_of_lt hT,Nat.mod_eq_of_lt hB] |
|
|
| def initialSources (k i : ℕ) : Operand := match i with |
| | 3 => .register (k+10) | 4 => .register (k+11) | 5 => .register (k+12) |
| | _ => tensorSources k i |
|
|
| lemma initialSetup_correct {w k T N P S C B A : ℕ} (s : Data) (hk : 16≤k) |
| (hT : T<wordModulus w) (hN : N<wordModulus w) (hP : P<wordModulus w) |
| (hS : S<wordModulus w) (hC : C<wordModulus w) (hB : B<wordModulus w) (hA : A<wordModulus w) |
| (h0 : s.registers k=A) (h1 : s.registers (k+1)=B) (h2 : s.registers (k+2)=N) |
| (h12 : s.registers (k+12)=C) (h6 : s.registers (k+6)=T) |
| (h10 : s.registers (k+10)=P) (h11 : s.registers (k+11)=S) : |
| Eval w (copyPrefix (initialSources k) 8) s 8 |
| (patched s 8 (tensorValues T N P S C B A)) := by |
| apply copyPrefix_correct |
| · intro i hi r hr |
| interval_cases i <;> simp only [initialSources,tensorSources] at hr <;> cases hr <;> omega |
| · intro i hi |
| interval_cases i <;> simp [initialSources,tensorSources,tensorValues,operand_register,operand_literal, |
| h0,h1,h2,h12,h6,h10,h11,Nat.mod_eq_of_lt hT,Nat.mod_eq_of_lt hN,Nat.mod_eq_of_lt hP, |
| Nat.mod_eq_of_lt hS,Nat.mod_eq_of_lt hC,Nat.mod_eq_of_lt hB,Nat.mod_eq_of_lt hA] |
|
|
| def paidCommand {q : ℕ} (p k : ℕ) (order : Equiv.Perm (Fin q)) : Command := |
| .seq (copyPrefix (tableSources k 12) 4) (.seq (NewtonTable.command p order) |
| (.seq (copyPrefix (tableSources k 5) 4) (.seq (NewtonConversionTable.command p order) |
| (.seq (copyPrefix (initialSources k) 8) (command q k))))) |
| end |
| end DeterministicThreeSum.Structured.Indexed.NewtonPass |
| namespace DeterministicThreeSum.Structured.Indexed.NewtonPass |
| open Command Axis DeterministicThreeSum.Newton |
| noncomputable section |
|
|
| theorem paidCommand_correct {w p e q L d A P S C E D k : ℕ} |
| (order : Equiv.Perm (Fin q)) (s : Data) (x : ℕ → ℕ) |
| (hk : 16≤k) (hkw : (tensorCommand q q).writes.sup id<k) |
| (hp : p.Prime) (hq : 1<q) (hqp : q<p) (hA : 0<A) |
| (hadd : 2*(p^(e+1))<wordModulus w) (hmul : (p^(e+1))*(p^(e+1))<wordModulus w) |
| (hL : A*q^d≤L) (hLw : L*q+L+3<wordModulus w) |
| (hP : P+L+1<wordModulus w) (hS : S+L+1<wordModulus w) |
| (hC : C+q*q<wordModulus w) (hE : E+q*q<wordModulus w) (hD : D<wordModulus w) |
| (hPS : S+L≤P ∨ P+L≤S) |
| (hCP : C+q*q≤P ∨ P+L≤C) (hCS : C+q*q≤S ∨ S+L≤C) |
| (hEP : E+q*q≤P ∨ P+L≤E) (hES : E+q*q≤S ∨ S+L≤E) |
| (hCE : E+q*q≤C ∨ C+q*q≤E) |
| (hden : inverseDenominator order<wordModulus w) |
| (hints : ∀ a∈NewtonTable.numerators order, a.natAbs<wordModulus w) |
| (hconv : ∀ a∈NewtonConversionTable.integers order, a.natAbs<wordModulus w) |
| (hctx : ∀ i, i<8 → s.registers (k+i)=context A (tensorStride q d) (A*q*tensorStride q d) (q^d) D E (p^(e+1)) i) |
| (h10 : s.registers (k+10)=P) (h11 : s.registers (k+11)=S) (h12 : s.registers (k+12)=C) |
| (hx : ∀ i, i<A*q^d → s.memory (S+i)=some (x i) ∧ x i<p^(e+1)) : |
| ∃ cost z, Eval w (paidCommand p k order) s cost z ∧ |
| cost≤2*(((row q q).cost+5)*L+11)*d+(5*d+10)*(A*q^d)+20*w+18*(q*q)+61 ∧ |
| (∀ a : Fin 8, z.registers a.val=environment (p^(e+1)) 0 P S E 0 (A*q^d) 0 a) ∧ |
| (∀ i, i<A*q^d → z.memory (S+i)=some |
| (tensorValue (p^(e+1)) q q (conversionTable (p^(e+1)) q (fun j => ((order j).val:ZMod (p^(e+1))))) d |
| (filtered q d D (tensorValue (p^(e+1)) q q |
| (inverseTable (p^(e+1)) q (fun j => ((order j).val:ZMod (p^(e+1))))) d x)) i)) ∧ |
| (∀ a, (a<P ∨ P+L≤a) → (a<S ∨ S+L≤a) → |
| (a<C ∨ C+q*q≤a) → (a<E ∨ E+q*q≤a) → z.memory a=s.memory a) := by |
| have hT : 0<p^(e+1) := pow_pos hp.pos _ |
| have hTw : p^(e+1)<wordModulus w := by omega |
| have h6 : s.registers (k+6)=p^(e+1) := by simpa [context] using hctx 6 (by omega) |
| have h5 : s.registers (k+5)=E := by simpa [context] using hctx 5 (by omega) |
| let u := patched s 4 (tableValues (p^(e+1)) C) |
| have eu := tableSetup_correct (w:=w) (k:=k) (T:=p^(e+1)) (B:=C) (b:=12) s hk hTw (by omega) h6 h12 |
| obtain ⟨c1,t1,et1,hc1,ht1m,ht1f,ht1r⟩:=NewtonTable.command_correct (w:=w) (p:=p) (e:=e) (base:=C) |
| order u hp hqp hmul hden hC hints (by simp [u,patched,tableValues]) (by simp [u,patched,tableValues]) |
| have hr1 : ∀ i, t1.registers (k+i)=s.registers (k+i) := by |
| intro i |
| rw [ht1r _ (by omega)] |
| simp [u,patched,show ¬k+i<4 by omega] |
| let u1 := patched t1 4 (tableValues (p^(e+1)) E) |
| have eu1 := tableSetup_correct (w:=w) (k:=k) (T:=p^(e+1)) (B:=E) (b:=5) t1 hk hTw (by omega) |
| ((hr1 6).trans h6) ((hr1 5).trans h5) |
| obtain ⟨c2,t2,et2,hc2,ht2m,ht2f,ht2r⟩:=NewtonConversionTable.command_correct (w:=w) (p:=p) (e:=e) (base:=E) |
| order u1 hp hmul hE hconv (by simp [u1,patched,tableValues]) (by simp [u1,patched,tableValues]) |
| have hr2 : ∀ i, t2.registers (k+i)=s.registers (k+i) := by |
| intro i |
| rw [ht2r _ (by omega)] |
| change (if k+i<4 then _ else t1.registers (k+i))=_ |
| rw [ite_eq_right (by omega),hr1] |
| have hQpos : 0<q^d := pow_pos (by omega : 0<q) _ |
| have hQL : q^d≤L := (by simpa using Nat.mul_le_mul_right (q^d) hA : q^d≤A*q^d) |>.trans hL |
| have hAw : A<wordModulus w := by |
| have hh : A≤A*q^d := by simpa using Nat.mul_le_mul_left A hQpos |
| omega |
| have hBw : tensorStride q d<wordModulus w := (tensorStride_le hq d).trans_lt (by omega) |
| have hNw : A*q*tensorStride q d<wordModulus w := (initialCount_le hq d).trans_lt (by omega) |
| let u2 := patched t2 8 (tensorValues (p^(e+1)) (A*q*tensorStride q d) P S C (tensorStride q d) A) |
| have eu2 := initialSetup_correct (w:=w) (k:=k) (T:=p^(e+1)) (N:=A*q*tensorStride q d) |
| (P:=P) (S:=S) (C:=C) (B:=tensorStride q d) (A:=A) t2 hk hTw hNw (by omega) (by omega) (by omega) hBw hAw |
| (by simpa only [Nat.add_zero] using (hr2 0).trans (by simpa [context] using hctx 0 (by omega))) |
| ((hr2 1).trans (by simpa [context] using hctx 1 (by omega))) |
| ((hr2 2).trans (by simpa [context] using hctx 2 (by omega))) |
| ((hr2 12).trans h12) ((hr2 6).trans h6) ((hr2 10).trans h10) ((hr2 11).trans h11) |
| have hu2r : ∀ a : Fin 8, u2.registers a.val= |
| environment (p^(e+1)) (A*q*tensorStride q d) P S C (tensorStride q d) A 0 a := by |
| intro a; simp only [u2,patched,a.isLt,ite_eq_left,tensorValues_environment] |
| have hu2ctx : ∀ i, i<8 → u2.registers (k+i)=context A (tensorStride q d) (A*q*tensorStride q d) (q^d) D E (p^(e+1)) i := by |
| intro i hi |
| simp only [u2,patched,ite_eq_right (show ¬k+i<8 by omega),hr2,hctx i hi] |
| let node : Fin q → ZMod (p^(e+1)) := fun j => ((order j).val:ZMod (p^(e+1))) |
| have hu2c : ∀ i, i<q*q → u2.memory (C+i)=some (inverseTable (p^(e+1)) q node i) ∧ inverseTable (p^(e+1)) q node i<p^(e+1) := by |
| intro i hi |
| change t2.memory _=_ ∧ _ |
| rw [ht2f _ (by omega)] |
| exact memory_inverse hT (by omega) node t1 ht1m i hi |
| have hu2e : ∀ i, i<q*q → u2.memory (E+i)=some (conversionTable (p^(e+1)) q node i) ∧ conversionTable (p^(e+1)) q node i<p^(e+1) := |
| memory_conversion hT (by omega) node t2 ht2m |
| have hu2x : ∀ i, i<A*q^d → u2.memory (S+i)=some (x i) ∧ x i<p^(e+1) := by |
| intro i hi |
| change t2.memory _=_ ∧ _ |
| rw [ht2f _ (by omega)] |
| change t1.memory _=_ ∧ _ |
| rw [ht1f _ (by omega)] |
| exact hx i hi |
| obtain ⟨c3,z,ez,hc3,hzr,hzm,hzf⟩:=command_correct u2 x (inverseTable (p^(e+1)) q node) (conversionTable (p^(e+1)) q node) |
| hk hkw hq hA hT hadd hmul hL hLw hP hS hC hE hD hPS hCP hCS hEP hES hu2r hu2ctx hu2x hu2c hu2e |
| refine ⟨4+(c1+(4+(c2+(8+c3)))),z,Eval.seq eu (Eval.seq et1 (Eval.seq eu1 (Eval.seq et2 (Eval.seq eu2 ez)))),by omega,hzr,?_,?_⟩ |
| · intro i hi |
| exact (hzm i hi).1 |
| · intro a haP haS haC haE |
| rw [hzf a haP haS] |
| change t2.memory a=s.memory a |
| rw [ht2f a haE] |
| exact ht1f a haC |
| end |
| end DeterministicThreeSum.Structured.Indexed.NewtonPass |
|
|
| end OAI |
|
|
