| import Mathlib |
| import OAI.Computability.DeterministicSum.Expressions |
|
|
| namespace OAI |
|
|
| /-! Indexed kernels and memory-preserving iteration. -/ |
|
|
| namespace DeterministicThreeSum.Structured |
| open Command |
|
|
| def written (initial : Data) (base : ℕ) (f : ℕ → ℕ) (k a : ℕ) : Option ℕ := |
| if base≤a ∧ a<base+k then some (f (a-base)) else initial.memory a |
|
|
| lemma written_next (initial : Data) (base : ℕ) (f : ℕ → ℕ) (k : ℕ) : |
| Function.update (written initial base f k) (base+k) (some (f k))= |
| written initial base f (k+1) := by |
| funext a |
| by_cases ha : a=base+k |
| · subst a; simp [written] |
| · rw [Function.update_of_ne ha] |
| unfold written |
| have hh : (base≤a ∧ a<base+k) ↔ (base≤a ∧ a<base+(k+1)) := by omega |
| simp only [hh] |
|
|
| lemma written_zero (initial : Data) (base : ℕ) (f : ℕ → ℕ) : |
| written initial base f 0=initial.memory := by |
| funext a |
| simp [written] |
|
|
| lemma written_outside {initial : Data} {base k a : ℕ} {f : ℕ → ℕ} |
| (ha : a<base ∨ base+k≤a) : written initial base f k a=initial.memory a := by |
| simp only [written,ite_eq_right (by omega : ¬(base≤a ∧ a<base+k))] |
|
|
| def indexedLoop (index bound : ℕ) (body : Command) : Command := |
| .loop .lt (.register index) (.register bound) |
| (.seq body (.atom (.binary index .add (.register index) (.literal 1)))) |
|
|
| theorem indexedLoop_correct {w n index bound base K : ℕ} |
| (hnw : n+1<wordModulus w) (_hne : index≠bound) |
| (body : Command) (initial s : Data) (f : ℕ → ℕ) (keep : ℕ → Prop) |
| (hkeep : keep bound) (hindex : ¬keep index) |
| (hbound : s.registers bound=n) (hstart : s.registers index=0) |
| (hm : s.memory=initial.memory) |
| (stepProof : ∀ k t, k<n → |
| (∀ r, keep r → t.registers r=s.registers r) → t.registers index=k → |
| t.memory=written initial base f k → |
| ∃ cost u, Eval w body t cost u ∧ cost≤K ∧ |
| (∀ r, keep r ∨ r=index → u.registers r=t.registers r) ∧ |
| u.memory=Function.update t.memory (base+k) (some (f k))) : |
| ∃ cost t, Eval w (indexedLoop index bound body) s cost t ∧ cost≤(K+3)*n+1 ∧ |
| (∀ r, keep r → t.registers r=s.registers r) ∧ t.registers index=n ∧ |
| t.memory=written initial base f n := by |
| let Inv : ℕ → Data → Prop := fun k t => |
| (∀ r, keep r → t.registers r=s.registers r) ∧ t.registers index=k ∧ |
| t.memory=written initial base f k |
| have hyes : ∀ k t, k<n → Inv k t → test w t .lt (.register index) (.register bound)=true := by |
| intro k t hk ht |
| simp [test,operand_register,evalTest,ht.1 bound hkeep,hbound,ht.2.1, |
| Nat.mod_eq_of_lt (by omega : n<wordModulus w),Nat.mod_eq_of_lt (by omega : k<wordModulus w),hk] |
| have hno : ∀ t, Inv n t → test w t .lt (.register index) (.register bound)=false := by |
| intro t ht |
| simp [test,operand_register,evalTest,ht.1 bound hkeep,hbound,ht.2.1] |
| have hb : ∀ k t, k<n → Inv k t → ∃ cost u, |
| Eval w (.seq body (.atom (.binary index .add (.register index) (.literal 1)))) t cost u ∧ |
| cost≤K+1 ∧ Inv (k+1) u := by |
| intro k t hk ht |
| obtain ⟨cost,u,he,hc,hr,hu⟩ := stepProof k t hk ht.1 ht.2.1 ht.2.2 |
| have hi : u.registers index=k := (hr index (Or.inr rfl)).trans ht.2.1 |
| have einc:=eval_increment (w:=w) (s:=u) (r:=index) (by rw [hi]; omega) |
| rw [hi] at einc |
| refine ⟨cost+1,put u index (k+1),Eval.seq he einc,by omega,?_,?_,?_⟩ |
| · intro r hr' |
| have hri : r≠index := by intro hh; subst r; exact hindex hr' |
| simp only [put,Function.update_of_ne hri] |
| exact (hr r (Or.inl hr')).trans (ht.1 r hr') |
| · simp only [put,Function.update_self] |
| · change u.memory=_ |
| rw [hu,ht.2.2,written_next] |
| have hs : Inv 0 s := ⟨fun _ _ => rfl,hstart,by rwa [written_zero]⟩ |
| obtain ⟨cost,t,he,hc,ht⟩ := bounded_loop Inv hyes hno hb (i:=0) (by omega) hs |
| exact ⟨cost,t,he,by simpa [Nat.add_assoc] using hc,ht⟩ |
|
|
| end DeterministicThreeSum.Structured |
| namespace DeterministicThreeSum.Structured.Indexed |
| open Command |
|
|
| def Scalar.reads {m : ℕ} (env : Fin m → ℕ) : Scalar m → Finset ℕ |
| | .literal _ => ∅ |
| | .input a => {a.value env} |
| | .binary _ a b => a.reads env ∪ b.reads env |
| | .branch x y a b => if x.value env<y.value env then a.reads env else b.reads env |
|
|
| lemma Scalar.memory_congr {m w T : ℕ} (e : Scalar m) (env : Fin m → ℕ) |
| (mem mem' : ℕ → Option ℕ) |
| (h : ∀ a∈e.reads env, mem a=mem' a) : |
| (e.Valid w T env mem ↔ e.Valid w T env mem') ∧ e.value T env mem=e.value T env mem' := by |
| induction e with |
| | literal k => exact ⟨Iff.rfl,rfl⟩ |
| | input a => |
| have hh:=h (a.value env) (by simp [Scalar.reads]) |
| simp [Scalar.Valid,Scalar.value,hh] |
| | binary op a b iha ihb => |
| obtain ⟨ha,ha'⟩:=iha (fun k hk => h k (by simp only [Scalar.reads,Finset.mem_union];exact Or.inl hk)) |
| obtain ⟨hb,hb'⟩:=ihb (fun k hk => h k (by simp only [Scalar.reads,Finset.mem_union];exact Or.inr hk)) |
| exact ⟨and_congr ha hb,by simp only [Scalar.value,ha',hb']⟩ |
| | branch x y a b iha ihb => |
| by_cases hh : x.value env<y.value env |
| · have ih:=iha (by simpa only [Scalar.reads,ite_eq_left hh] using h) |
| simpa only [Scalar.Valid,Scalar.value,ite_eq_left hh] using |
| And.intro (and_congr Iff.rfl (and_congr Iff.rfl ih.1)) ih.2 |
| · have ih:=ihb (by simpa only [Scalar.reads,ite_eq_right hh] using h) |
| simpa only [Scalar.Valid,Scalar.value,ite_eq_right hh] using |
| And.intro (and_congr Iff.rfl (and_congr Iff.rfl ih.1)) ih.2 |
|
|
| def kernelBody {m : ℕ} (index base : Fin m) (e : Scalar m) : Command := |
| .seq (e.compile m) (straight [.binary (m+1) .add (.register base.val) (.register index.val), |
| .store (.register (m+1)) (.register m)]) |
|
|
| def kernel {m : ℕ} (index bound base : Fin m) (e : Scalar m) : Command := |
| indexedLoop index.val bound.val (kernelBody index base e) |
|
|
| theorem kernel_correct {m w T N P : ℕ} (index bound base : Fin m) (e : Scalar m) |
| (s : Data) (hm3 : 3 ≤ m) (hT : 0<T) (hadd : 2*T<wordModulus w) |
| (hmul : T*T<wordModulus w) (hnw : N+1<wordModulus w) |
| (hP : P+N<wordModulus w) (hib : index≠bound) (hip : index≠base) |
| (hi2 : index.val≠2) (hbound : s.registers bound.val=N) |
| (hbase : s.registers base.val=P) (hmod : s.registers 2=T) |
| (hstart : s.registers index.val=0) |
| (hv : ∀ i, i<N → e.Valid w T (Function.update (fun a : Fin m => s.registers a.val) index i) s.memory) |
| (hdis : ∀ i, i<N → ∀ a∈e.reads (Function.update (fun a : Fin m => s.registers a.val) index i), |
| a<P ∨ P+N≤a) : |
| ∃ c t, Eval w (kernel index bound base e) s c t ∧ c≤(e.cost+5)*N+1 ∧ |
| (∀ r, r< m → r≠index.val → t.registers r=s.registers r) ∧ |
| t.registers index.val=N ∧ |
| t.memory=written s P |
| (fun i => e.value T (Function.update (fun a : Fin m => s.registers a.val) index i) s.memory) N := by |
| let env : ℕ → Fin m → ℕ := fun i => Function.update (fun a : Fin m => s.registers a.val) index i |
| let f : ℕ → ℕ := fun i => e.value T (env i) s.memory |
| let keep : ℕ → Prop := fun r => r< m ∧ r≠index.val |
| have hkeep : keep bound.val := ⟨bound.isLt,fun h => hib (Fin.ext h.symm)⟩ |
| have hnot : ¬keep index.val := by simp [keep] |
| have stepProof : ∀ i u, i<N → |
| (∀ r, keep r → u.registers r=s.registers r) → u.registers index.val=i → |
| u.memory=written s P f i → |
| ∃ c v, Eval w (kernelBody index base e) u c v ∧ c≤e.cost+2 ∧ |
| (∀ r, keep r ∨ r=index.val → v.registers r=u.registers r) ∧ |
| v.memory=Function.update u.memory (P+i) (some (f i)) := by |
| intro i u hi hu hindex hmem |
| have hparams : ∀ a : Fin m, u.registers a.val=env i a := by |
| intro a |
| by_cases h : a=index |
| · subst a; simpa [env] using hindex |
| · simpa [env,h] using hu a.val ⟨a.isLt,fun hh => h (Fin.ext hh)⟩ |
| have hmod' : u.registers 2=T := (hu 2 ⟨by omega,Ne.symm hi2⟩).trans hmod |
| have heq : ∀ a∈e.reads (env i), u.memory a=s.memory a := by |
| intro a ha |
| rw [hmem] |
| exact written_outside (by have hh:=hdis i hi a ha;omega) |
| obtain ⟨heqValid,heqVal⟩:=e.memory_congr (w:=w) (T:=T) (env i) u.memory s.memory heq |
| obtain ⟨c,v,he,hc,hvm,hvr,hvf⟩:=e.compile_correct (env i) u.memory u le_rfl hm3 hT hadd hmul |
| hparams hmod' rfl (heqValid.mpr (hv i hi)) |
| have hval : v.registers m=f i := hvr.trans heqVal |
| have hidx : v.registers index.val=i := (hvf _ index.isLt).trans hindex |
| have hbas : v.registers base.val=P := (hvf _ base.isLt).trans |
| ((hu _ ⟨base.isLt,fun h => hip (Fin.ext h.symm)⟩).trans hbase) |
| have hfv : f i<wordModulus w := lt_trans (e.value_lt (env i) s.memory hT (hv i hi)) (by omega) |
| let z : Data := {put v (m+1) (P+i) with memory:=Function.update v.memory (P+i) (some (f i))} |
| have hz : Eval w (straight [.binary (m+1) .add (.register base.val) (.register index.val), |
| .store (.register (m+1)) (.register m)]) v 2 z := by |
| apply straight_correct |
| simp [execStraight,Atom.eval,evalBinOp,operand_register,put,z,hidx,hbas,hval, |
| Nat.mod_eq_of_lt (show P<wordModulus w by omega),Nat.mod_eq_of_lt (show i<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show P+i<wordModulus w by omega),Nat.mod_eq_of_lt hfv] |
| refine ⟨c+2,z,Eval.seq he hz,by omega,?_,?_⟩ |
| · intro r hr |
| have hr' : r< m := by rcases hr with hr|rfl;exact hr.1;exact index.isLt |
| simp only [z,put,Function.update_of_ne (show r≠m+1 by omega)] |
| exact hvf r hr' |
| · change Function.update v.memory (P+i) (some (f i))=_ |
| rw [hvm] |
| obtain ⟨c,t,he,hc,hr,ht,hm⟩:=indexedLoop_correct (w:=w) (n:=N) (base:=P) (K:=e.cost+2) |
| hnw (fun h => hib (Fin.ext h)) (kernelBody index base e) s s f keep hkeep hnot |
| hbound hstart rfl stepProof |
| exact ⟨c,t,he,by simpa only [Nat.add_assoc] using hc,fun r hr' hi => hr r ⟨hr',hi⟩,ht,hm⟩ |
|
|
| end DeterministicThreeSum.Structured.Indexed |
|
|
| end OAI |
|
|
