| import Mathlib |
| import OAI.Computability.DeterministicSum.WordArithmetic |
| import OAI.Computability.DeterministicSum.PrunedTree |
|
|
| namespace OAI |
|
|
| /-! Instruction-level prefix enumeration and bounded level traversal. -/ |
|
|
| namespace DeterministicThreeSum.Structured.Pruned |
| open Command DeterministicThreeSum.Pruned |
|
|
| def Stored (s : Data) (P : ℕ) (l : List Node) : Prop := |
| ∀ i (hi : i<l.length), s.memory (P+2*i)=some l[i].1 ∧ s.memory (P+2*i+1)=some l[i].2 |
|
|
| def storePair (s : Data) (P j : ℕ) (p : Node) : Data := |
| {s with memory:=Function.update (Function.update s.memory (P+2*j) (some p.1)) (P+2*j+1) (some p.2)} |
|
|
| lemma storePair_outside (s : Data) (P j : ℕ) (p : Node) (a : ℕ) |
| (ha : a<P+2*j ∨ P+2*j+2≤a) : (storePair s P j p).memory a=s.memory a := by |
| simp only [storePair,Function.update_of_ne (by omega : a≠P+2*j+1),Function.update_of_ne (by omega : a≠P+2*j)] |
|
|
| lemma storePair_stored (s : Data) (P : ℕ) (l : List Node) (p : Node) (hs : Stored s P l) : |
| Stored (storePair s P l.length p) P (l++[p]) := by |
| intro i hi |
| by_cases h : i<l.length |
| · rw [List.getElem_append_left h] |
| have h0:=storePair_outside s P l.length p (P+2*i) (by omega) |
| have h1:=storePair_outside s P l.length p (P+2*i+1) (by omega) |
| simpa only [h0,h1] using hs i h |
| · have he : i=l.length := by simp only [List.length_append,List.length_singleton] at hi; omega |
| subst i |
| simp [storePair,List.getElem_append_right (by omega : l.length≤l.length)] |
|
|
| lemma stored_nil (s : Data) (P : ℕ) : Stored s P [] := by intro i hi; simp at hi |
|
|
| def pushDigit (r v : ℕ) : Command := straight [ |
| .binary 11 .mul (.register 8) (.literal r), |
| .binary 11 .add (.register 11) (.literal v), |
| .binary 12 .mul (.register 6) (.literal 2), |
| .binary 12 .add (.register 3) (.register 12), |
| .store (.register 12) (.register 11), |
| .binary 12 .add (.register 12) (.literal 1), |
| .store (.register 12) (.register 10), |
| .binary 6 .add (.register 6) (.literal 1)] |
|
|
| def pushDigitState (s : Data) (r v P j c degree : ℕ) : Data := |
| put (put (put (put (put (put (storePair s P j (c*r+v,degree)) 11 (c*r)) 11 (c*r+v)) 12 (2*j)) |
| 12 (P+2*j)) 12 (P+2*j+1)) 6 (j+1) |
|
|
| lemma pushDigit_correct {w r v P j c degree : ℕ} (s : Data) |
| (hW : 2<wordModulus w) (hr : r<wordModulus w) (hv : v<wordModulus w) |
| (hP : P+2*j+1<wordModulus w) (hc : c*r+v<wordModulus w) |
| (hc' : c<wordModulus w) (hd : degree<wordModulus w) |
| (h3 : s.registers 3=P) (h6 : s.registers 6=j) |
| (h8 : s.registers 8=c) (h10 : s.registers 10=degree) : |
| Eval w (pushDigit r v) s 8 (pushDigitState s r v P j c degree) := by |
| apply straight_correct |
| have hj' : j+1<wordModulus w := by omega |
| have h1 : 2*j<wordModulus w := by omega |
| have h2 : P+2*j<wordModulus w := by omega |
| have hcr : c*r<wordModulus w := by omega |
| simp [pushDigitState,storePair,execStraight,Atom.eval,operand_register,operand_literal,evalBinOp,put, |
| h3,h6,h8,h10,show j*2=2*j by omega,Nat.mod_eq_of_lt hW,Nat.mod_eq_of_lt hr,Nat.mod_eq_of_lt hv, |
| Nat.mod_eq_of_lt hP,Nat.mod_eq_of_lt hc,Nat.mod_eq_of_lt hc',Nat.mod_eq_of_lt hd, |
| Nat.mod_eq_of_lt hj',Nat.mod_eq_of_lt h1, |
| Nat.mod_eq_of_lt h2,Nat.mod_eq_of_lt hcr] |
|
|
| def tryDigit (r v weight : ℕ) : Command := |
| .seq (.atom (.binary 10 .add (.register 9) (.literal weight))) |
| (.ite .le (.register 10) (.register 2) (pushDigit r v) .skip) |
|
|
| lemma tryDigit_writes (r v weight : ℕ) : (tryDigit r v weight).writes={6,10,11,12} := by |
| simp [tryDigit,pushDigit,straight_writes,Command.writes,Atom.writes] |
| decide |
|
|
| theorem tryDigit_correct {w r v weight D P c degree : ℕ} (s : Data) (l : List Node) |
| (hW : 2<wordModulus w) (hr : r<wordModulus w) (hv : v<wordModulus w) |
| (hP : P+2*l.length+1<wordModulus w) (hc : c*r+v<wordModulus w) |
| (hc' : c<wordModulus w) (hd : degree+weight<wordModulus w) |
| (hD : D<wordModulus w) |
| (h2 : s.registers 2=D) (h3 : s.registers 3=P) (h6 : s.registers 6=l.length) |
| (h8 : s.registers 8=c) (h9 : s.registers 9=degree) (hm : Stored s P l) : |
| ∃ cost t, Eval w (tryDigit r v weight) s cost t ∧ cost≤11 ∧ |
| (∀ j, j≠6 → j≠10 → j≠11 → j≠12 → t.registers j=s.registers j) ∧ |
| let out:=l++(if degree+weight≤D then [(c*r+v,degree+weight)] else []) |
| t.registers 6=out.length ∧ Stored t P out ∧ |
| (∀ a, (a<P+2*l.length ∨ P+2*out.length≤a) → t.memory a=s.memory a) := by |
| let s1:=put s 10 (degree+weight) |
| have e1 : Eval w (.atom (.binary 10 .add (.register 9) (.literal weight))) s 1 s1 := by |
| apply Eval.atom |
| simp [Atom.eval,evalBinOp,operand_register,operand_literal,h9,Nat.mod_eq_of_lt hd, |
| Nat.mod_eq_of_lt (show degree<wordModulus w by omega),Nat.mod_eq_of_lt (show weight<wordModulus w by omega),s1] |
| by_cases h : degree+weight≤D |
| · have ht : test w s1 .le (.register 10) (.register 2)=true := by |
| simp [test,operand_register,evalTest,s1,put,h2,Nat.mod_eq_of_lt hd,Nat.mod_eq_of_lt hD,h] |
| have ep:=pushDigit_correct s1 hW hr hv hP hc hc' hd |
| (by simp [s1,put,h3]) (by simp [s1,put,h6]) (by simp [s1,put,h8]) (by simp [s1,put]) |
| let t:=pushDigitState s1 r v P l.length c (degree+weight) |
| have he : Eval w (tryDigit r v weight) s 11 t := Eval.seq e1 (Eval.iteTrue ht ep) |
| refine ⟨11,t,he,by omega,?_,?_,?_,?_⟩ |
| · intro j h6 h10 h11 h12 |
| exact register_frame he (by simp [tryDigit_writes,h6,h10,h11,h12]) |
| · simp [t,pushDigitState,put,h] |
| · simpa [t,pushDigitState,Stored,put,s1,storePair,h] using storePair_stored s P l (c*r+v,degree+weight) hm |
| · intro a ha |
| have ha' : a<P+2*l.length ∨ P+2*l.length+2≤a := by simpa [h,Nat.mul_add,Nat.add_assoc] using ha |
| exact storePair_outside s P l.length (c*r+v,degree+weight) a ha' |
| · have ht : test w s1 .le (.register 10) (.register 2)=false := by |
| simp [test,operand_register,evalTest,s1,put,h2,Nat.mod_eq_of_lt hd,Nat.mod_eq_of_lt hD,h] |
| have he : Eval w (tryDigit r v weight) s 2 s1 := Eval.seq e1 (Eval.iteFalse ht (Eval.skip s1)) |
| refine ⟨2,s1,he,by omega,?_,?_,?_,?_⟩ |
| · intro j h6 h10 h11 h12 |
| exact register_frame he (by simp [tryDigit_writes,h6,h10,h11,h12]) |
| · simp [s1,put,h,h6] |
| · simpa [s1,put,h,Stored] using hm |
| · intro a ha; rfl |
|
|
| end DeterministicThreeSum.Structured.Pruned |
| namespace DeterministicThreeSum.Structured.Pruned |
| open Command DeterministicThreeSum.Pruned |
|
|
| def accepted (A : Alphabet) (D : ℕ) (p : Node) (vs : List ℕ) : List Node := |
| (vs.filter (fun v => p.2+A.weight v≤D)).map (next A p) |
|
|
| lemma accepted_length (A : Alphabet) (D : ℕ) (p : Node) (vs : List ℕ) : |
| (accepted A D p vs).length≤vs.length := by |
| simpa [accepted] using List.length_filter_le (fun v => decide (p.2+A.weight v≤D)) vs |
|
|
| lemma accepted_cons (A : Alphabet) (D : ℕ) (p : Node) (v : ℕ) (vs : List ℕ) : |
| accepted A D p (v::vs)=(if p.2+A.weight v≤D then [next A p v] else [])++accepted A D p vs := by |
| simp only [accepted,List.filter_cons] |
| split <;> simp_all |
|
|
| def childrenCode (A : Alphabet) : List ℕ → Command |
| | [] => .skip |
| | v::vs => .seq (tryDigit A.radix v (A.weight v)) (childrenCode A vs) |
|
|
| theorem childrenCode_correct {w D P : ℕ} (A : Alphabet) (s : Data) (l : List Node) (p : Node) (vs : List ℕ) |
| (hW : 2<wordModulus w) (hr : A.radix<wordModulus w) |
| (hvs : ∀ v∈vs, v<A.radix) (hP : P+2*(l.length+vs.length)+1<wordModulus w) |
| (hc : ∀ v∈vs, p.1*A.radix+v<wordModulus w) |
| (hc' : p.1<wordModulus w) (hd : ∀ v∈vs, p.2+A.weight v<wordModulus w) |
| (hD : D<wordModulus w) |
| (h2 : s.registers 2=D) (h3 : s.registers 3=P) (h6 : s.registers 6=l.length) |
| (h8 : s.registers 8=p.1) (h9 : s.registers 9=p.2) (hm : Stored s P l) : |
| ∃ cost t, Eval w (childrenCode A vs) s cost t ∧ cost≤11*vs.length ∧ |
| (∀ j, j≠6 → j≠10 → j≠11 → j≠12 → t.registers j=s.registers j) ∧ |
| t.registers 6=(l++accepted A D p vs).length ∧ Stored t P (l++accepted A D p vs) ∧ |
| (∀ a, (a<P+2*l.length ∨ P+2*(l++accepted A D p vs).length≤a) → t.memory a=s.memory a) := by |
| induction vs generalizing s l with |
| | nil => exact ⟨0,s,Eval.skip s,by simp,by simp,by simpa [accepted] using h6,by simpa [accepted] using hm,by simp⟩ |
| | cons v vs ih => |
| have hv : v∈v::vs := by simp |
| obtain ⟨c,t,et,hct,hframe,ht,hm',hout⟩:=tryDigit_correct s l hW hr ((hvs v hv).trans hr) |
| (by simp only [List.length_cons] at hP; omega) (hc v hv) hc' (hd v hv) hD h2 h3 h6 h8 h9 hm |
| let l' := l++(if p.2+A.weight v≤D then [next A p v] else []) |
| have hl' : l'.length≤l.length+1 := by dsimp [l']; split_ifs <;> simp |
| have hl : l.length≤l'.length := by dsimp [l']; simp |
| have ht' : t.registers 6=l'.length := ht |
| have hm'' : Stored t P l' := hm' |
| have hP' : P+2*(l'.length+vs.length)+1<wordModulus w := by |
| simp only [List.length_cons] at hP; omega |
| obtain ⟨c',u,eu,hcu,hframe',hu,hmu,hout'⟩:=ih t l' |
| (by intro j hj; exact hvs j (by simp [hj])) hP' |
| (by intro j hj; exact hc j (by simp [hj])) |
| (by intro j hj; exact hd j (by simp [hj])) |
| ((hframe 2 (by omega) (by omega) (by omega) (by omega)).trans h2) |
| ((hframe 3 (by omega) (by omega) (by omega) (by omega)).trans h3) ht' |
| ((hframe 8 (by omega) (by omega) (by omega) (by omega)).trans h8) |
| ((hframe 9 (by omega) (by omega) (by omega) (by omega)).trans h9) hm'' |
| have heq : l++accepted A D p (v::vs)=l'++accepted A D p vs := by rw [accepted_cons,List.append_assoc] |
| refine ⟨c+c',u,Eval.seq et eu,by simp only [List.length_cons]; omega,?_,?_,?_,?_⟩ |
| · intro j h6 h10 h11 h12 |
| exact (hframe' j h6 h10 h11 h12).trans (hframe j h6 h10 h11 h12) |
| · rwa [heq] |
| · rwa [heq] |
| · intro a ha |
| rw [heq] at ha |
| rw [hout' a (by omega)] |
| exact hout a (by simp only [List.length_append] at ha; change a<P+2*l.length ∨ P+2*l'.length≤a; omega) |
|
|
| end DeterministicThreeSum.Structured.Pruned |
| namespace DeterministicThreeSum.Structured.Pruned |
| open Command DeterministicThreeSum.Pruned |
|
|
| def loadPrefix : Command := straight [ |
| .binary 10 .mul (.register 0) (.literal 2), |
| .binary 10 .add (.register 4) (.register 10), |
| .load 8 (.register 10), |
| .binary 10 .add (.register 10) (.literal 1), |
| .load 9 (.register 10)] |
|
|
| def loadPrefixState (s : Data) (S i : ℕ) (p : Node) : Data := |
| put (put (put (put (put s 10 (2*i)) 10 (S+2*i)) 8 p.1) 10 (S+2*i+1)) 9 p.2 |
|
|
| lemma loadPrefix_correct {w S i : ℕ} (s : Data) (p : Node) |
| (hW : 2<wordModulus w) (hS : S+2*i+1<wordModulus w) |
| (h0 : s.registers 0=i) (h4 : s.registers 4=S) |
| (hm : s.memory (S+2*i)=some p.1 ∧ s.memory (S+2*i+1)=some p.2) : |
| Eval w loadPrefix s 5 (loadPrefixState s S i p) := by |
| apply straight_correct |
| simp [loadPrefixState,execStraight,Atom.eval,operand_register,operand_literal,evalBinOp,put, |
| h0,h4,show i*2=2*i by omega,Nat.mod_eq_of_lt hW,Nat.mod_eq_of_lt hS, |
| Nat.mod_eq_of_lt (show i<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show 2*i<wordModulus w by omega),Nat.mod_eq_of_lt (show S+2*i<wordModulus w by omega), |
| Nat.mod_eq_of_lt (show 1<wordModulus w by omega),hm.1,hm.2] |
|
|
| lemma childrenCode_writes (A : Alphabet) (vs : List ℕ) : |
| (childrenCode A vs).writes⊆({6,10,11,12}:Finset ℕ) := by |
| induction vs with |
| | nil => simp [childrenCode,Command.writes] |
| | cons v vs ih => simp [childrenCode,Command.writes,tryDigit_writes,Finset.insert_subset_iff,ih] |
|
|
| def expandStep (A : Alphabet) : Command := .seq loadPrefix (childrenCode A (List.range A.radix)) |
|
|
| lemma expandStep_writes (A : Alphabet) : (expandStep A).writes⊆({6,8,9,10,11,12}:Finset ℕ) := by |
| intro j hj |
| simp only [expandStep,Command.writes,Finset.mem_union] at hj |
| rcases hj with hj|hj |
| · simp [loadPrefix,straight_writes,Atom.writes] at hj |
| simp only [Finset.mem_insert,Finset.mem_singleton] |
| omega |
| · have h:=childrenCode_writes A (List.range A.radix) hj |
| simp only [Finset.mem_insert,Finset.mem_singleton] at h ⊢ |
| omega |
|
|
| theorem expandStep_correct {w D P S i : ℕ} (A : Alphabet) (s : Data) (l : List Node) (p : Node) |
| (hW : 2<wordModulus w) (hr : A.radix<wordModulus w) |
| (hP : P+2*(l.length+A.radix)+1<wordModulus w) (hS : S+2*i+1<wordModulus w) |
| (hc : ∀ v, v<A.radix → p.1*A.radix+v<wordModulus w) |
| (hc' : p.1<wordModulus w) (hd : ∀ v, v<A.radix → p.2+A.weight v<wordModulus w) |
| (hD : D<wordModulus w) |
| (h0 : s.registers 0=i) (h2 : s.registers 2=D) (h3 : s.registers 3=P) |
| (h4 : s.registers 4=S) (h6 : s.registers 6=l.length) |
| (hp : s.memory (S+2*i)=some p.1 ∧ s.memory (S+2*i+1)=some p.2) |
| (hm : Stored s P l) : |
| ∃ cost t, Eval w (expandStep A) s cost t ∧ cost≤5+11*A.radix ∧ |
| (∀ j, j<8 → j≠6 → t.registers j=s.registers j) ∧ |
| t.registers 6=(l++children A D p).length ∧ Stored t P (l++children A D p) ∧ |
| (∀ a, (a<P+2*l.length ∨ P+2*(l++children A D p).length≤a) → t.memory a=s.memory a) := by |
| have he:=loadPrefix_correct s p hW hS h0 h4 hp |
| obtain ⟨cost,t,et,hcost,hframe,ht,hm',hout⟩:=childrenCode_correct A (loadPrefixState s S i p) l p (List.range A.radix) |
| hW hr (by simp) (by simpa using hP) (by simpa using hc) hc' (by simpa using hd) hD |
| (by simp [loadPrefixState,put,h2]) (by simp [loadPrefixState,put,h3]) |
| (by simp [loadPrefixState,put,h6]) (by simp [loadPrefixState,put]) (by simp [loadPrefixState,put]) |
| (by simpa [loadPrefixState,put,Stored] using hm) |
| have hall : Eval w (expandStep A) s (5+cost) t := Eval.seq he et |
| refine ⟨5+cost,t,hall,by simpa using Nat.add_le_add_left hcost 5,?_,ht,hm',hout⟩ |
| intro j hj h6 |
| exact register_frame hall (by intro h; have hh:=expandStep_writes A h; simp only [Finset.mem_insert,Finset.mem_singleton] at hh; omega) |
|
|
| lemma expand_take (A : Alphabet) (D : ℕ) (l : List Node) {i : ℕ} (hi : i<l.length) : |
| expand A D (l.take (i+1))=expand A D (l.take i)++children A D l[i] := by |
| rw [List.take_succ_eq_append_getElem hi,expand_append] |
| simp [expand] |
|
|
| def expandLoop (A : Alphabet) : Command := .loop .lt (.register 0) (.register 1) |
| (.seq (expandStep A) (.atom (.binary 0 .add (.register 0) (.literal 1)))) |
|
|
| theorem expandLoop_correct {w D P S : ℕ} (A : Alphabet) (s : Data) (l : List Node) |
| (hW : 2<wordModulus w) (hr : A.radix<wordModulus w) |
| (hP : P+2*(l.length*A.radix)+1<wordModulus w) (hS : S+2*l.length+1<wordModulus w) |
| (hdis : P+2*(l.length*A.radix)≤S ∨ S+2*l.length≤P) |
| (hc : ∀ p∈l, ∀ v, v<A.radix → p.1*A.radix+v<wordModulus w) |
| (hc' : ∀ p∈l, p.1<wordModulus w) |
| (hd : ∀ p∈l, ∀ v, v<A.radix → p.2+A.weight v<wordModulus w) |
| (hD : D<wordModulus w) |
| (h0 : s.registers 0=0) (h1 : s.registers 1=l.length) |
| (h2 : s.registers 2=D) (h3 : s.registers 3=P) (h4 : s.registers 4=S) (h6 : s.registers 6=0) |
| (hm : Stored s S l) : |
| ∃ cost t, Eval w (expandLoop A) s cost t ∧ cost≤(11*A.radix+8)*l.length+1 ∧ |
| (∀ j, j<8 → j≠0 → j≠6 → t.registers j=s.registers j) ∧ t.registers 0=l.length ∧ |
| t.registers 6=(expand A D l).length ∧ Stored t P (expand A D l) ∧ |
| (∀ a, (a<P ∨ P+2*(l.length*A.radix)≤a) → t.memory a=s.memory a) := by |
| let Inv : ℕ → Data → Prop := fun i t => |
| (∀ j, j<8 → j≠0 → j≠6 → t.registers j=s.registers j) ∧ t.registers 0=i ∧ |
| t.registers 6=(expand A D (l.take i)).length ∧ Stored t P (expand A D (l.take i)) ∧ Stored t S l ∧ |
| (∀ a, (a<P ∨ P+2*(l.length*A.radix)≤a) → t.memory a=s.memory a) |
| have hN : l.length+1<wordModulus w := by omega |
| have hyes : ∀ i t, i<l.length → Inv i t → test w t .lt (.register 0) (.register 1)=true := by |
| intro i t hi ht |
| have hh:=ht.1 1 (by omega) (by omega) (by omega) |
| simp [test,operand_register,evalTest,ht.2.1,hh,h1, |
| Nat.mod_eq_of_lt (show i<wordModulus w by omega),Nat.mod_eq_of_lt (show l.length<wordModulus w by omega),hi] |
| have hno : ∀ t, Inv l.length t → test w t .lt (.register 0) (.register 1)=false := by |
| intro t ht |
| simp [test,operand_register,evalTest,ht.2.1,ht.1 1 (by omega) (by omega) (by omega),h1] |
| have hbody : ∀ i t, i<l.length → Inv i t → ∃ cost u, |
| Eval w (.seq (expandStep A) (.atom (.binary 0 .add (.register 0) (.literal 1)))) t cost u ∧ |
| cost≤11*A.radix+6 ∧ Inv (i+1) u := by |
| intro i t hi ht |
| let out:=expand A D (l.take i) |
| have hlen : out.length≤ i*A.radix := by simpa [out,List.length_take, min_eq_left hi.le] using expand_length_le A D (l.take i) |
| have hlen' : (out++children A D l[i]).length≤l.length*A.radix := by |
| have hh:=children_length_le A D l[i] |
| have hb:=Nat.mul_le_mul_right A.radix (show i+1≤l.length by omega) |
| simp only [List.length_append]; nlinarith only [hlen,hh,hb] |
| have hp : l[i]∈l := List.getElem_mem .. |
| have hP' : P+2*(out.length+A.radix)+1<wordModulus w := by |
| have hb:=Nat.mul_le_mul_right A.radix (show i+1≤l.length by omega) |
| nlinarith only [hP,hlen,hb] |
| obtain ⟨c,u,eu,hcu,hfr,hu,hmu,hout⟩:=expandStep_correct A t out l[i] hW hr hP' (by omega) |
| (hc _ hp) (hc' _ hp) (hd _ hp) hD ht.2.1 |
| ((ht.1 2 (by omega) (by omega) (by omega)).trans h2) |
| ((ht.1 3 (by omega) (by omega) (by omega)).trans h3) |
| ((ht.1 4 (by omega) (by omega) (by omega)).trans h4) |
| ht.2.2.1 (ht.2.2.2.2.1 i hi) ht.2.2.2.1 |
| have hidx : u.registers 0=i := (hfr 0 (by omega) (by omega)).trans ht.2.1 |
| have einc:=eval_increment (w:=w) (s:=u) (r:=0) (by rw [hidx]; omega) |
| rw [hidx] at einc |
| refine ⟨c+1,put u 0 (i+1),Eval.seq eu einc,by omega,?_,?_,?_,?_,?_,?_⟩ |
| · intro j hj hj0 hj6 |
| simp only [put,Function.update_of_ne hj0] |
| exact (hfr j hj hj6).trans (ht.1 j hj hj0 hj6) |
| · simp [put] |
| · simpa only [put,Function.update_of_ne (by omega : 6≠0),expand_take A D l hi] using hu |
| · simpa only [put,Stored,expand_take A D l hi] using hmu |
| · intro j hj |
| have hS0 : u.memory (S+2*j)=t.memory (S+2*j) := hout _ (by omega) |
| have hS1 : u.memory (S+2*j+1)=t.memory (S+2*j+1) := hout _ (by omega) |
| simpa only [put,hS0,hS1] using ht.2.2.2.2.1 j hj |
| · intro a ha |
| change u.memory a=s.memory a |
| rw [hout a (by omega)] |
| exact ht.2.2.2.2.2 a ha |
| have hstart : Inv 0 s := by |
| refine ⟨by simp,h0,?_,?_,hm,by simp⟩ |
| · simpa [expand] using h6 |
| · simpa [expand] using stored_nil s P |
| obtain ⟨cost,t,he,hcost,ht⟩:=bounded_loop Inv hyes hno hbody (i:=0) (by omega) hstart |
| refine ⟨cost,t,he,by simpa using hcost,ht.1,ht.2.1,?_,?_,ht.2.2.2.2.2⟩ |
| · simpa using ht.2.2.1 |
| · simpa using ht.2.2.2.1 |
|
|
| end DeterministicThreeSum.Structured.Pruned |
| namespace DeterministicThreeSum.Structured.Pruned |
| open Command DeterministicThreeSum.Pruned |
|
|
| def levels (A : Alphabet) (D : ℕ) : ℕ → List Node → List Node |
| | 0,l => l |
| | m+1,l => levels A D m (expand A D l) |
|
|
| def banks (m P S : ℕ) : ℕ × ℕ := if Even m then (P,S) else (S,P) |
| lemma banks_zero (P S : ℕ) : banks 0 P S=(P,S) := by simp [banks] |
| lemma banks_succ (m P S : ℕ) : banks (m+1) P S=banks m S P := by |
| simp only [banks,Nat.even_add_one] |
| by_cases h : Even m <;> simp [h] |
|
|
| def levelUpdate : Command := straight [ |
| .assign 13 (.register 3), .assign 3 (.register 4), .assign 4 (.register 13), |
| .assign 1 (.register 6), .assign 0 (.literal 0), .assign 6 (.literal 0), |
| .binary 5 .sub (.register 5) (.literal 1)] |
|
|
| def levelUpdateState (s : Data) (P S N m : ℕ) : Data := |
| put (put (put (put (put (put (put s 13 P) 3 S) 4 P) 1 N) 0 0) 6 0) 5 m |
|
|
| lemma levelUpdate_correct {w P S N m : ℕ} (s : Data) |
| (hW : 2 < wordModulus w) (hP : P < wordModulus w) (hS : S < wordModulus w) |
| (hN : N < wordModulus w) (hm : m+1 < wordModulus w) |
| (h3 : s.registers 3=P) (h4 : s.registers 4=S) |
| (h5 : s.registers 5=m+1) (h6 : s.registers 6=N) : |
| Eval w levelUpdate s 7 (levelUpdateState s P S N m) := by |
| have he : m+1+wordModulus w-1=m+wordModulus w := by omega |
| apply straight_correct |
| simp [levelUpdateState,execStraight,Atom.eval,operand_register,operand_literal, |
| evalBinOp,put,h3,h4,h5,h6,Nat.mod_eq_of_lt hP,Nat.mod_eq_of_lt hS,Nat.mod_eq_of_lt hN, |
| Nat.mod_eq_of_lt hm,Nat.mod_eq_of_lt (show m < wordModulus w by omega), |
| Nat.mod_eq_of_lt (show 1 < wordModulus w by omega),he] |
|
|
| def levelsCommand (A : Alphabet) : Command := |
| .loop .lt (.literal 0) (.register 5) (.seq (expandLoop A) levelUpdate) |
|
|
| def LevelRegs (s : Data) (D P S m N : ℕ) : Prop := |
| s.registers 0=0 ∧ s.registers 1=N ∧ s.registers 2=D ∧ s.registers 3=P ∧ |
| s.registers 4=S ∧ s.registers 5=m ∧ s.registers 6=0 |
|
|
| theorem levelsCommand_correct {w D K : ℕ} (A : Alphabet) (m : ℕ) |
| (hW : 2 < wordModulus w) (hr : 0 < A.radix) (hrW : A.radix < wordModulus w) |
| (hD : D < wordModulus w) (hm : m < wordModulus w) : |
| ∀ (s : Data) (l : List Node) (P S : ℕ), |
| P+2*K*A.radix+1 < wordModulus w → S+2*K*A.radix+1 < wordModulus w → |
| (P+2*K*A.radix ≤ S ∨ S+2*K*A.radix ≤ P) → |
| (∀ i, i ≤ m → (levels A D i l).length ≤ K) → |
| (∀ i, i < m → ∀ p∈levels A D i l, ∀ v, v < A.radix → p.1*A.radix+v < wordModulus w) → |
| (∀ i, i < m → ∀ p∈levels A D i l, p.1 < wordModulus w) → |
| (∀ i, i < m → ∀ p∈levels A D i l, ∀ v, v < A.radix → p.2+A.weight v < wordModulus w) → |
| LevelRegs s D P S m l.length → Stored s S l → |
| ∃ cost t, Eval w (levelsCommand A) s cost t ∧ |
| cost ≤ m*((11*A.radix+8)*K+10)+1 ∧ |
| LevelRegs t D (banks m P S).1 (banks m P S).2 0 (levels A D m l).length ∧ |
| Stored t (banks m P S).2 (levels A D m l) ∧ |
| (∀ a, (a < P ∨ P+2*K*A.radix ≤ a) → (a < S ∨ S+2*K*A.radix ≤ a) → t.memory a=s.memory a) := by |
| induction m with |
| | zero => |
| intro s l P S hP hS hdis hlen hc hc' hd hreg hmem |
| have ht : test w s .lt (.literal 0) (.register 5)=false := by |
| simp [test,operand_literal,operand_register,evalTest,hreg.2.2.2.2.2.1] |
| exact ⟨1,s,Eval.loopFalse ht,by simp,by simpa [levels,banks_zero] using hreg, |
| by simpa [levels,banks_zero] using hmem,by simp⟩ |
| | succ m ih => |
| intro s l P S hP hS hdis hlen hc hc' hd hreg hmem |
| simp only [Nat.mul_assoc] at hP hS hdis |
| have hlt : l.length ≤ K := hlen 0 (by omega) |
| have hKr : K ≤ K*A.radix := by simpa using Nat.mul_le_mul_left K hr |
| have hlr : l.length*A.radix ≤ K*A.radix := Nat.mul_le_mul_right A.radix hlt |
| have ht : test w s .lt (.literal 0) (.register 5)=true := by |
| simp [test,operand_literal,operand_register,evalTest,hreg.2.2.2.2.2.1,Nat.mod_eq_of_lt hm] |
| obtain ⟨c,u,eu,hcost,hframe,hi,hu,hmu,hout⟩:=expandLoop_correct A s l hW hrW |
| (by nlinarith only [hP,hlr]) (by nlinarith only [hS,hlt,hKr]) (by omega) |
| (hc 0 (by omega)) (hc' 0 (by omega)) (hd 0 (by omega)) hD |
| hreg.1 hreg.2.1 hreg.2.2.1 hreg.2.2.2.1 hreg.2.2.2.2.1 hreg.2.2.2.2.2.2 hmem |
| have hnew : (expand A D l).length ≤ K := by simpa [levels] using hlen 1 (by omega) |
| have h3 : u.registers 3=P := (hframe 3 (by omega) (by omega) (by omega)).trans hreg.2.2.2.1 |
| have h4 : u.registers 4=S := (hframe 4 (by omega) (by omega) (by omega)).trans hreg.2.2.2.2.1 |
| have h5 : u.registers 5=m+1 := (hframe 5 (by omega) (by omega) (by omega)).trans hreg.2.2.2.2.2.1 |
| have eupdate:=levelUpdate_correct u hW (by omega) (by omega) (by omega) hm h3 h4 h5 hu |
| let v:=levelUpdateState u P S (expand A D l).length m |
| have hregv : LevelRegs v D S P m (expand A D l).length := by |
| have h2 : u.registers 2=D := (hframe 2 (by omega) (by omega) (by omega)).trans hreg.2.2.1 |
| simp [v,levelUpdateState,LevelRegs,put,h2] |
| obtain ⟨c',t,et,hcost',hregt,hmt,hout'⟩:=ih (by omega) v (expand A D l) S P (by simpa [Nat.mul_assoc] using hS) (by simpa [Nat.mul_assoc] using hP) (by simpa [Nat.mul_assoc] using Or.symm hdis) |
| (by intro i hi; exact hlen (i+1) (by omega)) |
| (by intro i hi; exact hc (i+1) (by omega)) |
| (by intro i hi; exact hc' (i+1) (by omega)) |
| (by intro i hi; exact hd (i+1) (by omega)) hregv (by simpa [v,levelUpdateState,put,Stored] using hmu) |
| refine ⟨1+(c+7)+1+c',t,Eval.loopTrue ht (Eval.seq eu eupdate) et,?_,?_,?_,?_⟩ |
| · have hh : c ≤ (11*A.radix+8)*K+1 := hcost.trans (by gcongr) |
| nlinarith only [hh,hcost'] |
| · simpa only [banks_succ,levels] using hregt |
| · simpa only [banks_succ,levels] using hmt |
| · intro a ha hb |
| rw [hout' a hb ha] |
| simp only [Nat.mul_assoc] at ha |
| exact hout a (by omega) |
|
|
| end DeterministicThreeSum.Structured.Pruned |
|
|
| namespace DeterministicThreeSum.Pruned |
| def scalarAlphabet (q : ℕ) : Alphabet := ⟨q,id⟩ |
| lemma volume_append (front back : List Alphabet) : volume (front++back)=volume back*volume front := by |
| induction front with |
| | nil => simp [volume] |
| | cons A rest ih => simp [volume,ih,Nat.mul_assoc] |
| lemma volume_replicate (A : Alphabet) (t : ℕ) : volume (List.replicate t A)=A.radix^t := by |
| induction t with |
| | zero => rfl |
| | succ t ih => simp [List.replicate_succ,volume,ih,pow_succ] |
| lemma volume_pos (shape : List Alphabet) (h : ∀ A∈shape, 0 < A.radix) : 0 < volume shape := by |
| induction shape with |
| | nil => decide |
| | cons A rest ih => exact Nat.mul_pos (ih (by intro B hB; exact h B (by simp [hB]))) (h A (by simp)) |
|
|
| end DeterministicThreeSum.Pruned |
| namespace DeterministicThreeSum.Structured.Pruned |
| open Command DeterministicThreeSum.Pruned |
|
|
| lemma levels_enumerate (A : Alphabet) (D i : ℕ) (rest : List Alphabet) : |
| levels A D i (enumerate D rest)=enumerate D (List.replicate i A++rest) := by |
| induction i generalizing rest with |
| | zero => rfl |
| | succ i ih => |
| rw [levels] |
| change levels A D i (enumerate D (A::rest))=_ |
| rw [ih,List.replicate_succ'] |
| simp |
|
|
| lemma levelsCommand_writes (A : Alphabet) : (levelsCommand A).writes⊆Finset.range 14 := by |
| intro r hr |
| simp only [levelsCommand,expandLoop,expandStep,loadPrefix,levelUpdate,Command.writes, |
| straight_writes] at hr |
| have hc := childrenCode_writes A (List.range A.radix) |
| simp only [List.foldr_cons,List.foldr_nil,Atom.writes,Finset.mem_union,Finset.mem_singleton, |
| Finset.notMem_empty,or_false] at hr |
| rcases hr with ((hr|hr)|hr)|hr |
| · rcases hr with rfl|rfl|rfl|rfl|rfl <;> decide |
| · have hh:=hc hr |
| simp only [Finset.mem_insert,Finset.mem_singleton] at hh |
| rcases hh with rfl|rfl|rfl|rfl <;> decide |
| · subst r; decide |
| · rcases hr with rfl|rfl|rfl|rfl|rfl|rfl|rfl <;> decide |
|
|
| lemma volume_prefix_le (front back : List Alphabet) (h : ∀ A∈front, 0 < A.radix) : |
| volume back ≤ volume (front++back) := by |
| rw [volume_append] |
| exact le_mul_of_one_le_right (Nat.zero_le _) (volume_pos front h) |
|
|
| lemma repeat_remaining (A : Alphabet) {i t : ℕ} (hi : i≤t) (rest : List Alphabet) : |
| List.replicate t A++rest=List.replicate (t-i) A++(List.replicate i A++rest) := by |
| rw [←List.append_assoc,←List.replicate_add,Nat.sub_add_cancel hi] |
|
|
| theorem levelsEnumerate_correct {w D K P S t W : ℕ} (A : Alphabet) (rest : List Alphabet) (s : Data) |
| (hW : 2 < wordModulus w) (hA : 0 < A.radix) (hAw : A.radix < wordModulus w) |
| (hzero : A.weight 0=0) (hweight : ∀ v, v < A.radix → A.weight v≤W) |
| (hrest : ∀ B∈rest, 0 < B.radix) (hD : D+W < wordModulus w) (ht : t < wordModulus w) |
| (hP : P+2*K*A.radix+1 < wordModulus w) (hS : S+2*K*A.radix+1 < wordModulus w) |
| (hdis : P+2*K*A.radix≤S ∨ S+2*K*A.radix≤P) |
| (hK : (enumerate D (List.replicate t A++rest)).length≤K) |
| (hV : volume (List.replicate t A++rest)*A.radix < wordModulus w) |
| (hregs : LevelRegs s D P S t (enumerate D rest).length) (hmem : Stored s S (enumerate D rest)) : |
| ∃ cost z, Eval w (levelsCommand A) s cost z ∧ |
| cost≤t*((11*A.radix+8)*K+10)+1 ∧ |
| LevelRegs z D (banks t P S).1 (banks t P S).2 0 (enumerate D (List.replicate t A++rest)).length ∧ |
| Stored z (banks t P S).2 (enumerate D (List.replicate t A++rest)) ∧ |
| (∀ a, (a < P ∨ P+2*K*A.radix≤a) → (a < S ∨ S+2*K*A.radix≤a) → z.memory a=s.memory a) := by |
| have hp (i : ℕ) : ∀ B∈List.replicate i A++rest, 0 < B.radix := by |
| intro B hB |
| rcases List.mem_append.mp hB with hB|hB |
| · obtain ⟨_,rfl⟩:=List.mem_replicate.mp hB; exact hA |
| · exact hrest B hB |
| have hv (i : ℕ) (hi : i≤t) : volume (List.replicate i A++rest)≤volume (List.replicate t A++rest) := by |
| rw [repeat_remaining A hi] |
| exact volume_prefix_le _ _ (by intro B hB; obtain ⟨_,rfl⟩:=List.mem_replicate.mp hB; exact hA) |
| have hkeys (i : ℕ) (p : Node) (hpm : p∈levels A D i (enumerate D rest)) : |
| p.1 < volume (List.replicate i A++rest) ∧ p.2≤D := by |
| rw [levels_enumerate] at hpm |
| have hh:=(enumerate_child D _ (hp i) p).mp hpm |
| exact ⟨hh.1,hh.2.2⟩ |
| obtain ⟨c,z,he,hc,hz,hm,ho⟩:=levelsCommand_correct (K:=K) A t hW hA hAw (by omega) ht s (enumerate D rest) P S hP hS hdis |
| (by |
| intro i hi |
| rw [levels_enumerate] |
| apply le_trans _ hK |
| rw [repeat_remaining A hi] |
| exact length_enumerate_suffix _ _ _ |
| (by intro B hB; obtain ⟨_,rfl⟩:=List.mem_replicate.mp hB; exact hA) |
| (by intro B hB; obtain ⟨_,rfl⟩:=List.mem_replicate.mp hB; exact hzero)) |
| (by |
| intro i hi p hpm v hvv |
| have hkey:=(hkeys i p hpm).1 |
| have hvol:=hv i hi.le |
| have hcode : p.1*A.radix+v < volume (List.replicate t A++rest)*A.radix := by |
| nlinarith only [Nat.mul_le_mul_right A.radix (show p.1+1≤volume (List.replicate t A++rest) by omega),hvv] |
| exact hcode.trans hV) |
| (by |
| intro i hi p hpm |
| have hk : p.1 < volume (List.replicate t A++rest) := (hkeys i p hpm).1.trans_le (hv i hi.le) |
| exact hk.trans_le ((le_mul_of_one_le_right (Nat.zero_le _) hA).trans hV.le)) |
| (by intro i hi p hpm v hv; have hk:=(hkeys i p hpm).2; have hw:=hweight v hv; omega) |
| hregs hmem |
| exact ⟨c,z,he,hc,by simpa only [levels_enumerate] using hz,by simpa only [levels_enumerate] using hm,ho⟩ |
|
|
| end DeterministicThreeSum.Structured.Pruned |
|
|
| end OAI |
|
|
