| import Mathlib |
| import OAI.Computability.DeterministicSum.Structured |
|
|
| namespace OAI |
|
|
| /-! Signed word encoding, no-wrap bounds and modular arithmetic commands. -/ |
|
|
| namespace DeterministicThreeSum |
|
|
| lemma wordModulus_pos (w : ℕ) : 0<wordModulus w := by unfold wordModulus; positivity |
|
|
| lemma encodeWord_lt (w : ℕ) (a : ℤ) : encodeWord w a<wordModulus w := by |
| have hp : (0:ℤ)<wordModulus w := by exact_mod_cast wordModulus_pos w |
| have hn := Int.emod_nonneg a hp.ne' |
| have hl := Int.emod_lt_of_pos a hp |
| unfold encodeWord |
| omega |
| |
| lemma encodeWord_add (w : ℕ) (a b : ℤ) : |
| encodeWord w (a+b)=(encodeWord w a+encodeWord w b)%wordModulus w := by |
| have hp : (0:ℤ)<wordModulus w := by exact_mod_cast wordModulus_pos w |
| have hn := Int.emod_nonneg a hp.ne' |
| have hn' := Int.emod_nonneg b hp.ne' |
| unfold encodeWord |
| rw [Int.add_emod] |
| rw [Int.toNat_emod (add_nonneg hn hn') hp.le, Int.toNat_add hn hn'] |
| simp |
|
|
| lemma encodeWord_eq_zero_iff {w : ℕ} {a : ℤ} (ha : |a|<(wordModulus w:ℤ)) : |
| encodeWord w a=0 ↔ a=0 := by |
| have hp : (0:ℤ)<wordModulus w := by exact_mod_cast wordModulus_pos w |
| constructor |
| · intro he |
| have he' : a%(wordModulus w:ℤ)=0 := by |
| have hn := Int.emod_nonneg a hp.ne' |
| unfold encodeWord at he |
| omega |
| apply Int.eq_zero_of_dvd_of_natAbs_lt_natAbs (Int.dvd_of_emod_eq_zero he') |
| have hh : (Int.natAbs a:ℤ)<Int.natAbs (wordModulus w:ℤ) := by |
| simpa only [Int.natCast_natAbs,abs_of_pos hp] using ha |
| exact_mod_cast hh |
| · rintro rfl; simp [encodeWord] |
| |
| lemma wordWidth_lower (factor n : ℕ) (_hn : 1≤n+2) : |
| (n+2)^factor≤wordModulus (wordWidth factor n) := by |
| have hx : (0:ℝ)<n+2 := by positivity |
| have hb : (1:ℝ)<2 := by norm_num |
| have hceil := Nat.le_ceil ((factor:ℝ)*Real.logb 2 (n+2)) |
| have he := Real.rpow_le_rpow_of_exponent_le hb.le hceil |
| have hid : (2:ℝ)^((factor:ℝ)*Real.logb 2 (n+2))=(n+2:ℝ)^factor := by |
| rw [mul_comm,Real.rpow_mul (by norm_num),Real.rpow_logb (by norm_num) (by norm_num) hx] |
| rw [Real.rpow_natCast] |
| rw [hid,Real.rpow_natCast] at he |
| unfold wordWidth wordModulus |
| exact_mod_cast he |
| |
| lemma cubic_sum_no_wrap {n w : ℕ} (hn : 3≤n) (hw : (n+2)^4≤wordModulus w) |
| (a b c : ℤ) (ha : |a|≤(n:ℤ)^3) (hb : |b|≤(n:ℤ)^3) (hc : |c|≤(n:ℤ)^3) : |
| |a+b+c|<(wordModulus w:ℤ) := by |
| have hn' : (3:ℤ)≤n := by exact_mod_cast hn |
| have hw' : ((n:ℤ)+2)^4≤wordModulus w := by exact_mod_cast hw |
| have ht : 3*(n:ℤ)^3<((n:ℤ)+2)^4 := by nlinarith [sq_nonneg (n:ℤ),sq_nonneg ((n:ℤ)^2)] |
| have htri := abs_add_le (a+b) c |
| have htri' := abs_add_le a b |
| linarith |
|
|
| lemma polynomial_sum_no_wrap {n C w : ℕ} (hn : 3≤n) (_hC : 0<C) |
| (hw : (n+2)^(C+4)≤wordModulus w) |
| (a b c : ℤ) (ha : |a|≤(n:ℤ)^C) (hb : |b|≤(n:ℤ)^C) (hc : |c|≤(n:ℤ)^C) : |
| |a+b+c|<(wordModulus w:ℤ) := by |
| have hn' : (3:ℤ)≤n := by exact_mod_cast hn |
| have hw' : ((n:ℤ)+2)^(C+4)≤wordModulus w := by exact_mod_cast hw |
| have hpow : (n:ℤ)^C≤((n:ℤ)+2)^C := pow_le_pow_left₀ (by omega) (by omega) C |
| have hp : (0:ℤ)<((n:ℤ)+2)^C := pow_pos (by omega) _ |
| have hfour : (3:ℤ)<((n:ℤ)+2)^4 := by |
| have hbound : (5:ℤ)^4≤((n:ℤ)+2)^4 := pow_le_pow_left₀ (by norm_num) (by omega) 4 |
| norm_num at hbound ⊢ |
| omega |
| have ht : 3*(n:ℤ)^C<((n:ℤ)+2)^(C+4) := by rw [pow_add]; nlinarith |
| have htri := abs_add_le (a+b) c |
| have htri' := abs_add_le a b |
| linarith |
| |
| end DeterministicThreeSum |
| namespace DeterministicThreeSum.Structured |
| open Command |
| |
| def straight : List Atom → Command |
| | [] => .skip |
| | a::as => .seq (.atom a) (straight as) |
| |
| def execStraight (w : ℕ) : List Atom → Data → Option Data |
| | [],s => some s |
| | a::as,s => (a.eval w s).bind (execStraight w as) |
| |
| lemma straight_correct {w : ℕ} {as : List Atom} {s t : Data} |
| (he : execStraight w as s=some t) : Eval w (straight as) s as.length t := by |
| induction as generalizing s with |
| | nil => simp only [execStraight,Option.some.injEq] at he; subst t; exact Eval.skip s |
| | cons a as ih => |
| obtain ⟨u,ha,hu⟩ := Option.bind_eq_some_iff.mp he |
| simpa only [straight,List.length_cons,Nat.add_comm] using Eval.seq (Eval.atom ha) (ih hu) |
| |
| lemma straight_writes (as : List Atom) : (straight as).writes=as.foldr (fun a S => a.writes∪S) ∅ := by |
| induction as with |
| | nil => rfl |
| | cons a as ih => simp only [straight,Command.writes,List.foldr_cons,ih] |
| |
| lemma eval_add {w r a b : ℕ} (s : Data) |
| (_ha : a<wordModulus w) (_hb : b<wordModulus w) (hsum : a+b<wordModulus w) |
| (u v : Operand) (hu : operand w s u=a) (hv : operand w s v=b) : |
| Eval w (.atom (.binary r .add u v)) s 1 (put s r (a+b)) := by |
| apply Eval.atom |
| simp [Atom.eval,hu,hv,evalBinOp,Nat.mod_eq_of_lt hsum] |
| |
| lemma eval_remainder {w r a b : ℕ} (s : Data) (hb : 0<b) |
| (u v : Operand) (hu : operand w s u=a) (hv : operand w s v=b) : |
| Eval w (.atom (.binary r .rem u v)) s 1 (put s r (a%b)) := by |
| apply Eval.atom |
| simp [Atom.eval,hu,hv,evalBinOp,hb.ne'] |
|
|
| lemma eval_indirect_load {w r a v : ℕ} (s : Data) (u : Operand) |
| (hu : operand w s u=a) (hv : s.memory a=some v) : |
| Eval w (.atom (.load r u)) s 1 (put s r v) := by |
| apply Eval.atom |
| simp [Atom.eval,hu,hv] |
|
|
| lemma eval_indirect_store {w a v : ℕ} (s : Data) (u z : Operand) |
| (hu : operand w s u=a) (hz : operand w s z=v) : |
| Eval w (.atom (.store u z)) s 1 {s with memory:=Function.update s.memory a (some v)} := by |
| apply Eval.atom |
| simp [Atom.eval,hu,hz] |
|
|
| end DeterministicThreeSum.Structured |
| namespace DeterministicThreeSum.Structured.Modular |
| open Command |
|
|
| def add : Command := straight [.binary 0 .add (.register 0) (.register 1), |
| .binary 0 .rem (.register 0) (.register 2)] |
| def mul : Command := straight [.binary 0 .mul (.register 0) (.register 1), |
| .binary 0 .rem (.register 0) (.register 2)] |
| def sub : Command := straight [.binary 0 .add (.register 0) (.register 2), |
| .binary 0 .sub (.register 0) (.register 1), |
| .binary 0 .rem (.register 0) (.register 2)] |
|
|
| lemma add_correct {w T a b : ℕ} (s : Data) (hT : 0<T) |
| (hw : 2*T<wordModulus w) (ha : a<T) (hb : b<T) |
| (h0 : s.registers 0=a) (h1 : s.registers 1=b) (h2 : s.registers 2=T) : |
| Eval w add s 2 (put s 0 ((a+b)%T)) := by |
| apply straight_correct |
| simp [execStraight,Atom.eval,evalBinOp,operand_register,put,h0,h1,h2, |
| Nat.mod_eq_of_lt (show a<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show b<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show a+b<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show T<wordModulus w by omega),hT.ne',Function.update_idem] |
| |
| lemma mul_correct {w T a b : ℕ} (s : Data) (hT : 0<T) |
| (hw : T*T<wordModulus w) (ha : a<T) (hb : b<T) |
| (h0 : s.registers 0=a) (h1 : s.registers 1=b) (h2 : s.registers 2=T) : |
| Eval w mul s 2 (put s 0 ((a*b)%T)) := by |
| have hT' : T<wordModulus w := by nlinarith |
| have hp : a*b<wordModulus w := lt_of_le_of_lt (Nat.mul_le_mul ha.le hb.le) hw |
| apply straight_correct |
| simp [execStraight,Atom.eval,evalBinOp,operand_register,put,h0,h1,h2, |
| Nat.mod_eq_of_lt (show a<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show b<wordModulus w by omega), |
| Nat.mod_eq_of_lt hp,Nat.mod_eq_of_lt hT',hT.ne',Function.update_idem] |
|
|
| lemma sub_correct {w T a b : ℕ} (s : Data) (hT : 0<T) |
| (hw : 2*T<wordModulus w) (ha : a<T) (hb : b<T) |
| (h0 : s.registers 0=a) (h1 : s.registers 1=b) (h2 : s.registers 2=T) : |
| Eval w sub s 3 (put s 0 ((a+T-b)%T)) := by |
| have hs : (a+T+wordModulus w-b)%wordModulus w=a+T-b := by |
| rw [show a+T+wordModulus w-b=(a+T-b)+wordModulus w by omega] |
| simp [Nat.mod_eq_of_lt (show a+T-b<wordModulus w by omega)] |
| apply straight_correct |
| simp [execStraight,Atom.eval,evalBinOp,operand_register,put,h0,h1,h2, |
| Nat.mod_eq_of_lt (show a<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show b<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show a+T<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show T<wordModulus w by omega),hT.ne',hs,Function.update_idem] |
| |
| lemma cast_add (T a b : ℕ) : (((a+b)%T:ℕ):ZMod T)=(a:ZMod T)+(b:ZMod T) := by |
| simp |
| lemma cast_mul (T a b : ℕ) : (((a*b)%T:ℕ):ZMod T)=(a:ZMod T)*(b:ZMod T) := by |
| simp |
| lemma cast_sub {T a b : ℕ} (hb : b<T) : |
| (((a+T-b)%T:ℕ):ZMod T)=(a:ZMod T)-(b:ZMod T) := by |
| rw [ZMod.natCast_mod,Nat.cast_sub (by omega : b≤a+T)] |
| simp |
| |
| def mac : Command := .seq mul (.seq (.atom (.assign 1 (.register 3))) |
| (.seq add (.atom (.assign 3 (.register 0))))) |
| |
| lemma mac_correct {w T a b acc : ℕ} (s : Data) (hT : 0<T) |
| (hadd : 2*T<wordModulus w) (hmul : T*T<wordModulus w) |
| (ha : a<T) (hb : b<T) (hc : acc<T) |
| (h0 : s.registers 0=a) (h1 : s.registers 1=b) |
| (h2 : s.registers 2=T) (h3 : s.registers 3=acc) : |
| ∃ t, Eval w mac s 6 t ∧ t.memory=s.memory ∧ |
| t.registers 3=(acc+a*b)%T ∧ |
| (∀ r, r≠0 → r≠1 → r≠3 → t.registers r=s.registers r) := by |
| let u:=put s 0 ((a*b)%T) |
| let v:=put u 1 acc |
| let z:=put v 0 (((a*b)%T+acc)%T) |
| let t:=put z 3 (((a*b)%T+acc)%T) |
| have hu : Eval w mul s 2 u := mul_correct s hT hmul ha hb h0 h1 h2 |
| have hv : Eval w (.atom (.assign 1 (.register 3))) u 1 v := by |
| apply Eval.atom |
| simp [Atom.eval,operand_register,put,u,v,h3,Nat.mod_eq_of_lt (show acc<wordModulus w by omega)] |
| have hz : Eval w add v 2 z := add_correct v hT hadd (Nat.mod_lt _ hT) hc |
| (by simp [v,u,put]) (by simp [v,put]) (by simp [v,u,put,h2]) |
| have ht : Eval w (.atom (.assign 3 (.register 0))) z 1 t := by |
| apply Eval.atom |
| simp [Atom.eval,operand_register,put,z,t,Nat.mod_eq_of_lt |
| (show (a*b+acc)%T<wordModulus w by have:=Nat.mod_lt (a*b+acc) hT;omega)] |
| refine ⟨t,?_,rfl,?_,?_⟩ |
| · exact Eval.seq hu (Eval.seq hv (Eval.seq hz ht)) |
| · simp [t,put,Nat.add_mod,Nat.add_comm] |
| · intro r hr0 hr1 hr3 |
| simp [t,z,v,u,put,hr0,hr1,hr3] |
| |
| end DeterministicThreeSum.Structured.Modular |
| |
| end OAI |
| |
