| import Mathlib |
| import OAI.Computability.DeterministicSum.CacheRows |
| import OAI.Computability.DeterministicSum.PrunedProgram |
|
|
| namespace OAI |
|
|
| /-! Paid prefix-key setup and complete sparse cache production. -/ |
|
|
| namespace DeterministicThreeSum.Structured.Indexed.Cache |
| open Command DeterministicThreeSum.Pruned |
|
|
| def seedKeys : Command := straight [ |
| .assign 0 (.literal 0), .assign 1 (.literal 1), .assign 6 (.literal 0), |
| .store (.register 4) (.literal 0), |
| .binary 13 .add (.register 4) (.literal 1), .store (.register 13) (.literal 0)] |
|
|
| def seeded (s : Data) (Q : ℕ) : Data := |
| put (put (put (put (Pruned.storePair s Q 0 (0,0)) 0 0) 1 1) 6 0) 13 (Q+1) |
|
|
| lemma seedKeys_correct {w Q : ℕ} (s : Data) (hQ : Q+1 < wordModulus w) |
| (h4 : s.registers 4=Q) : Eval w seedKeys s 6 (seeded s Q) := by |
| apply straight_correct |
| have hW : 1 < wordModulus w := by omega |
| simp [seeded,execStraight,Atom.eval,operand_literal,operand_register,evalBinOp, |
| put,Pruned.storePair,h4,Nat.mod_eq_of_lt hQ,Nat.mod_eq_of_lt (by omega : Q < wordModulus w), |
| Nat.mod_eq_of_lt hW,Function.update_comm (show (0:ℕ)≠1 by decide),Nat.zero_mod] |
|
|
| lemma seeded_stored (s : Data) (Q : ℕ) : Pruned.Stored (seeded s Q) Q [(0,0)] := by |
| change Pruned.Stored (Pruned.storePair s Q 0 (0,0)) Q ([]++[(0,0)]) |
| exact Pruned.storePair_stored s Q [] (0,0) (Pruned.stored_nil s Q) |
|
|
| lemma seeded_regs {s : Data} {D P Q d : ℕ} |
| (h2 : s.registers 2=D) (h3 : s.registers 3=P) |
| (h4 : s.registers 4=Q) (h5 : s.registers 5=d) : |
| Pruned.LevelRegs (seeded s Q) D P Q d 1 := by |
| simp [Pruned.LevelRegs,seeded,put,Pruned.storePair,h2,h3,h4,h5] |
|
|
| lemma seeded_frame (s : Data) (Q k r : ℕ) (hk : 26 ≤ k) : |
| (seeded s Q).registers (k+r)=s.registers (k+r) := by |
| simp only [seeded,put,Function.update_of_ne (show k+r≠13 by omega), |
| Function.update_of_ne (show k+r≠6 by omega),Function.update_of_ne (show k+r≠1 by omega), |
| Function.update_of_ne (show k+r≠0 by omega),Pruned.storePair] |
|
|
| def keysHandoff (k : ℕ) : Command := straight [ |
| .assign k (.literal 0), .assign (k+1) (.register 1), .assign (k+2) (.register 4)] |
|
|
| def keyHanded (s : Data) (k rows nodes : ℕ) : Data := |
| put (put (put s k 0) (k+1) rows) (k+2) nodes |
|
|
| lemma keysHandoff_correct {w k rows nodes : ℕ} (s : Data) (hk : 26 ≤ k) |
| (hrows : rows < wordModulus w) (hnodes : nodes < wordModulus w) |
| (h1 : s.registers 1=rows) (h4 : s.registers 4=nodes) : |
| Eval w (keysHandoff k) s 3 (keyHanded s k rows nodes) := by |
| apply straight_correct |
| simp [keyHanded,execStraight,Atom.eval,operand_literal,operand_register,put, |
| show (1:ℕ)≠k by omega,show (4:ℕ)≠k by omega,show (4:ℕ)≠k+1 by omega, |
| h1,h4,Nat.mod_eq_of_lt hrows,Nat.mod_eq_of_lt hnodes] |
|
|
| def prunedKeys (r k : ℕ) : Command := |
| .seq seedKeys (.seq (Pruned.levelsCommand (scalarAlphabet r)) (keysHandoff k)) |
|
|
| theorem prunedKeys_correct {w r D K P Q d k : ℕ} (s : Data) |
| (hW : 2 < wordModulus w) (hr : 0 < r) (hrw : r < wordModulus w) |
| (hD : D+r < wordModulus w) (hd : d < wordModulus w) (hk : 26 ≤ k) |
| (hP : P+2*K*r+1 < wordModulus w) (hQ : Q+2*K*r+1 < wordModulus w) |
| (hdis : P+2*K*r ≤ Q ∨ Q+2*K*r ≤ P) |
| (hK : (enumerate D (List.replicate d (scalarAlphabet r))).length ≤ K) |
| (hvol : r^d*r < wordModulus w) |
| (h2 : s.registers 2=D) (h3 : s.registers 3=P) |
| (h4 : s.registers 4=Q) (h5 : s.registers 5=d) : |
| ∃ cost z, Eval w (prunedKeys r k) s cost z ∧ |
| cost ≤ d*((11*r+8)*K+10)+10 ∧ |
| let nodes:=(Pruned.banks d P Q).2 |
| let l:=enumerate D (List.replicate d (scalarAlphabet r)) |
| Pruned.Stored z nodes l ∧ z.registers k=0 ∧ z.registers (k+1)=l.length ∧ |
| z.registers (k+2)=nodes ∧ |
| (∀ j, 3 ≤ j → z.registers (k+j)=s.registers (k+j)) ∧ |
| (∀ a, (a < P ∨ P+2*K*r ≤ a) → (a < Q ∨ Q+2*K*r ≤ a) → z.memory a=s.memory a) := by |
| have es:=seedKeys_correct (w:=w) s (by omega) h4 |
| obtain ⟨c,u,eu,hc,hur,hum,huf⟩:=Pruned.levelsEnumerate_correct (rest:=[]) (W:=r) |
| (scalarAlphabet r) (seeded s Q) hW hr hrw rfl (by intro v hv; exact hv.le) |
| (by simp) hD hd hP hQ hdis (by simpa only [List.append_nil] using hK) |
| (by simpa only [List.append_nil,volume_replicate,scalarAlphabet] using hvol) |
| (seeded_regs h2 h3 h4 h5) (seeded_stored s Q) |
| simp only [List.append_nil] at hur hum |
| let l:=enumerate D (List.replicate d (scalarAlphabet r)) |
| let nodes:=(Pruned.banks d P Q).2 |
| have hKpos : 0 < K := by |
| have h:=length_enumerate_suffix D (List.replicate d (scalarAlphabet r)) [] |
| (by intro A hA; obtain ⟨_,rfl⟩:=List.mem_replicate.mp hA; exact hr) |
| (by intro A hA; obtain ⟨_,rfl⟩:=List.mem_replicate.mp hA; rfl) |
| simp only [List.append_nil,enumerate,List.length_singleton] at h |
| omega |
| have hKw : K < wordModulus w := by |
| have hx : K ≤ 2*K*r := by nlinarith only [hr] |
| omega |
| have hnodes : nodes < wordModulus w := by |
| dsimp [nodes,Pruned.banks]; split_ifs <;> dsimp <;> omega |
| have eh:=keysHandoff_correct u hk (hK.trans_lt hKw) hnodes hur.2.1 hur.2.2.2.2.1 |
| simp only [scalarAlphabet] at hc |
| refine ⟨6+(c+3),keyHanded u k l.length nodes,Eval.seq es (Eval.seq eu eh),by omega,?_,?_,?_,?_,?_,?_⟩ |
| · exact hum |
| · simp [keyHanded,put,l,nodes] |
| · simp [keyHanded,put,l,nodes] |
| · simp [keyHanded,put,l,nodes] |
| · intro j hj |
| simp only [keyHanded,put,Function.update_of_ne (show k+j≠k+2 by omega), |
| Function.update_of_ne (show k+j≠k+1 by omega),Function.update_of_ne (show k+j≠k by omega)] |
| rw [register_frame eu (by |
| intro hh |
| have hh':=Pruned.levelsCommand_writes (scalarAlphabet r) hh |
| simp only [Finset.mem_range] at hh'; omega)] |
| exact seeded_frame s Q k j hk |
| · intro a haP haQ |
| change u.memory a=s.memory a |
| rw [huf a haP haQ] |
| change (Pruned.storePair s Q 0 (0,0)).memory a=s.memory a |
| exact Pruned.storePair_outside s Q 0 (0,0) a (by |
| have htwo : 2 ≤ 2*K*r := by nlinarith only [hKpos,hr] |
| simp only [Nat.mul_zero,Nat.add_zero] |
| omega) |
| end DeterministicThreeSum.Structured.Indexed.Cache |
| namespace DeterministicThreeSum.Structured.Indexed.Cache |
| open Command DeterministicThreeSum.Pruned Axis |
|
|
| def keyList (D r d : ℕ) : List Node := enumerate D (List.replicate d (scalarAlphabet r)) |
| def keyAt (D r d j : ℕ) : ℕ := ((keyList D r d)[j]?.getD (0,0)).1 |
|
|
| lemma keyAt_eq {D r d j : ℕ} (hj : j < (keyList D r d).length) : |
| keyAt D r d j=(keyList D r d)[j].1 := by simp [keyAt,List.getElem?_eq_getElem hj] |
|
|
| lemma keyAt_bound {D r d j : ℕ} (hr : 0 < r) (hj : j < (keyList D r d).length) : |
| keyAt D r d j < r^d := by |
| rw [keyAt_eq hj] |
| have h:= (enumerate_child D (List.replicate d (scalarAlphabet r)) |
| (by intro A hA; obtain ⟨_,rfl⟩:=List.mem_replicate.mp hA; exact hr) _).mp |
| (List.getElem_mem hj) |
| simpa only [volume_replicate,scalarAlphabet] using h.1 |
|
|
| lemma keyAt_stored {s : Data} {P D r d j : ℕ} (hs : Pruned.Stored s P (keyList D r d)) |
| (hj : j < (keyList D r d).length) : s.memory (P+2*j)=some (keyAt D r d j) := by |
| rw [keyAt_eq hj]; exact (hs j hj).1 |
|
|
| lemma frame_interval {s t : Data} {P Q N A B : ℕ} |
| (hf : ∀ a, (a < P ∨ P+N ≤ a) → (a < Q ∨ Q+N ≤ a) → t.memory a=s.memory a) |
| (hP : P+N ≤ A ∨ A+B ≤ P) (hQ : Q+N ≤ A ∨ A+B ≤ Q) |
| {i : ℕ} (hi : i < B) : t.memory (A+i)=s.memory (A+i) := by |
| apply hf <;> omega |
|
|
| lemma keys_batch_regs {s t : Data} {tail : Bool} {m b q rows nodes dest S D H d T C P V : ℕ} |
| (h0 : t.registers (batchBase tail m b q)=0) |
| (h1 : t.registers (batchBase tail m b q+1)=rows) |
| (h2 : t.registers (batchBase tail m b q+2)=nodes) |
| (hf : ∀ j, 3 ≤ j → t.registers (batchBase tail m b q+j)=s.registers (batchBase tail m b q+j)) |
| (hs : ∀ r, 3 ≤ r → r < 16 → s.registers (batchBase tail m b q+r)= |
| batchValues 0 rows nodes dest (q^d) S D H d (tensorStride q d) T C P V q r) : |
| ∀ r, r < 16 → t.registers (batchBase tail m b q+r)= |
| batchValues 0 rows nodes dest (q^d) S D H d (tensorStride q d) T C P V q r := by |
| intro r hr |
| by_cases h : 3 ≤ r |
| · rw [hf r h,hs r h hr] |
| · interval_cases r <;> simpa only [batchValues,Nat.add_zero] using (by assumption) |
| end DeterministicThreeSum.Structured.Indexed.Cache |
| namespace DeterministicThreeSum.Structured.Indexed.Cache |
| open Command DeterministicThreeSum.Pruned Axis |
|
|
| def prunedBatch (tail : Bool) (r m b q : ℕ) : Command := |
| .seq (prunedKeys r (batchBase tail m b q)) (batchCommand tail m b q) |
|
|
| theorem prunedBatch_correct {w T m b q d D H P S V C L nodes dest rows r Dkey K KP KQ : ℕ} |
| (tail : Bool) (s : Data) (x c : ℕ → ℕ) |
| (hrpos : 0 < r) (hrw : r < wordModulus w) |
| (hDkey : Dkey+r < wordModulus w) |
| (hKP : KP+2*K*r+1 < wordModulus w) (hKQ : KQ+2*K*r+1 < wordModulus w) |
| (hKK : KP+2*K*r ≤ KQ ∨ KQ+2*K*r ≤ KP) |
| (hK : (keyList Dkey r d).length ≤ K) (hkeyvol : r^d*r < wordModulus w) |
| (hrowsEq : rows=(keyList Dkey r d).length) (hnodesEq : nodes=(Pruned.banks d KP KQ).2) |
| (hKPS : KP+2*K*r ≤ S ∨ S+(m*b)^d ≤ KP) |
| (hKQS : KQ+2*K*r ≤ S ∨ S+(m*b)^d ≤ KQ) |
| (hKPC : KP+2*K*r ≤ C ∨ C+q*q ≤ KP) |
| (hKQC : KQ+2*K*r ≤ C ∨ C+q*q ≤ KQ) |
| (h2 : s.registers 2=Dkey) (h3 : s.registers 3=KP) |
| (h4 : s.registers 4=KQ) (h5 : s.registers 5=d) |
| (hm : 1 < m) (hb : 1 < b) (hq : 1 < q) (hR : m*b < wordModulus w) |
| (hT : 0 < T) (hadd : 2*T < wordModulus w) (hmul : T*T < wordModulus w) |
| (hd : d < wordModulus w) (hD : D < wordModulus w) (hH : H < wordModulus w) |
| (hvol : (m*b)^d < wordModulus w) (hsum : m^d+b^d < wordModulus w) |
| (hL : q^d ≤ L) (hLw : L*q+L+3 < wordModulus w) |
| (hP : P+L+1 < wordModulus w) (hV : V+L+1 < wordModulus w) |
| (hS : S+(m*b)^d < wordModulus w) (hC : C+q*q < wordModulus w) |
| (hSP : P+L ≤ S ∨ S+(m*b)^d ≤ P) (hSV : V+L ≤ S ∨ S+(m*b)^d ≤ V) |
| (hVP : P+L ≤ V ∨ V+L ≤ P) |
| (hCP : C+q*q ≤ P ∨ P+L ≤ C) (hCV : C+q*q ≤ V ∨ V+L ≤ C) |
| (hrows : rows+1 < wordModulus w) (hnodes : nodes+2*rows < wordModulus w) |
| (hdest : dest+rows*q^d+1 < wordModulus w) |
| (hDP : P+L ≤ dest ∨ dest+rows*q^d ≤ P) (hDV : V+L ≤ dest ∨ dest+rows*q^d ≤ V) |
| (hDS : dest+rows*q^d ≤ S ∨ S+(m*b)^d ≤ dest) |
| (hDC : dest+rows*q^d ≤ C ∨ C+q*q ≤ dest) |
| (hNP : P+L ≤ nodes ∨ nodes+2*rows ≤ P) (hNV : V+L ≤ nodes ∨ nodes+2*rows ≤ V) |
| (hND : dest+rows*q^d ≤ nodes ∨ nodes+2*rows ≤ dest) |
| (hl : ∀ j, j < rows → ∀ i, i < q^d → leftIndex tail (keyAt Dkey r d j) i < m^d) |
| (hr : ∀ j, j < rows → ∀ i, i < q^d → rightIndex tail (keyAt Dkey r d j) i < b^d) |
| (hxw : ∀ j, j < rows → ∀ i, i < q^d → |
| x (ZipIndex.value m b d (leftIndex tail (keyAt Dkey r d j) i) (rightIndex tail (keyAt Dkey r d j) i)) < T) |
| (hx : ∀ j, j < rows → ∀ i, i < q^d → |
| DigitSum.value m d (leftIndex tail (keyAt Dkey r d j) i)+DigitSum.value b d (rightIndex tail (keyAt Dkey r d j) i) ≤ D → |
| TailOK tail H (DigitSum.value b d (rightIndex tail (keyAt Dkey r d j) i)) → |
| s.memory (S+ZipIndex.value m b d (leftIndex tail (keyAt Dkey r d j) i) (rightIndex tail (keyAt Dkey r d j) i))= |
| some (x (ZipIndex.value m b d (leftIndex tail (keyAt Dkey r d j) i) (rightIndex tail (keyAt Dkey r d j) i)))) |
| (hc : ∀ i, i < q*q → s.memory (C+i)=some (c i) ∧ c i < T) |
| (hregs : ∀ r, 3 ≤ r → r < 16 → s.registers (batchBase tail m b q+r)= |
| batchValues 0 rows nodes dest (q^d) S D H d (tensorStride q d) T C P V q r) : |
| ∃ cost z, Eval w (prunedBatch tail r m b q) s cost z ∧ |
| cost ≤ d*((11*r+8)*K+10)+10+(((14*d+27)*q^d+(((row q q).cost+5)*L+11)*d+49)*rows+1) ∧ |
| (∀ j, j < rows → ∀ v, v < q^d → z.memory (dest+j*q^d+v)=some |
| (tensorValue T q q c d (gathered tail m b d D H (keyAt Dkey r d j) x) v)) ∧ |
| (∀ a, (a < P ∨ P+L ≤ a) → (a < V ∨ V+L ≤ a) → |
| (a < dest ∨ dest+rows*q^d ≤ a) → |
| (a < KP ∨ KP+2*K*r ≤ a) → (a < KQ ∨ KQ+2*K*r ≤ a) → z.memory a=s.memory a) ∧ |
| (∀ r, 3 ≤ r → z.registers (batchBase tail m b q+r)=s.registers (batchBase tail m b q+r)) := by |
| have hkw : r^d < wordModulus w := by |
| have hh : r^d ≤ r^d*r := Nat.le_mul_of_pos_right _ hrpos |
| omega |
| obtain ⟨a,t,et,ha,htm,ht0,ht1,ht2,htr,htf⟩:=prunedKeys_correct s |
| (by omega) hrpos hrw hDkey hd (batchBase_ge ..) hKP hKQ hKK hK hkeyvol h2 h3 h4 h5 |
| have thregs : ∀ j, j < 16 → t.registers (batchBase tail m b q+j)= |
| batchValues 0 rows nodes dest (q^d) S D H d (tensorStride q d) T C P V q j := by |
| apply keys_batch_regs ht0 |
| · simpa only [hrowsEq,keyList] using ht1 |
| · simpa only [hnodesEq] using ht2 |
| · exact htr |
| · exact hregs |
| have thkeys : ∀ j, j < rows → keyAt Dkey r d j < wordModulus w := by |
| intro j hj |
| exact (keyAt_bound hrpos (by simpa only [←hrowsEq] using hj)).trans hkw |
| have thmem : ∀ j, j < rows → t.memory (nodes+2*j)=some (keyAt Dkey r d j) := by |
| intro j hj |
| rw [hnodesEq] |
| exact keyAt_stored htm (by simpa only [←hrowsEq] using hj) |
| have thx : ∀ j, j < rows → ∀ i, i < q^d → |
| DigitSum.value m d (leftIndex tail (keyAt Dkey r d j) i)+DigitSum.value b d (rightIndex tail (keyAt Dkey r d j) i) ≤ D → |
| TailOK tail H (DigitSum.value b d (rightIndex tail (keyAt Dkey r d j) i)) → |
| t.memory (S+ZipIndex.value m b d (leftIndex tail (keyAt Dkey r d j) i) (rightIndex tail (keyAt Dkey r d j) i))= |
| some (x (ZipIndex.value m b d (leftIndex tail (keyAt Dkey r d j) i) (rightIndex tail (keyAt Dkey r d j) i))) := by |
| intro j hj i hi hdeg htail |
| rw [frame_interval htf hKPS hKQS (ZipIndex.value_lt (by omega) (by omega) d _ _)] |
| exact hx j hj i hi hdeg htail |
| have thc : ∀ i, i < q*q → t.memory (C+i)=some (c i) ∧ c i < T := by |
| intro i hi |
| rw [frame_interval htf hKPC hKQC hi] |
| exact hc i hi |
| obtain ⟨b,z,ez,hb,hzm,hzf,hzr⟩:=batchCommand_correct tail t x c (keyAt Dkey r d) |
| hm hb hq hR hT hadd hmul hd hD hH hvol hsum hL hLw hP hV hS hC |
| hSP hSV hVP hCP hCV hrows hnodes hdest hDP hDV hDS hDC hNP hNV hND |
| thkeys thmem hl hr hxw thx thc thregs |
| refine ⟨a+b,z,Eval.seq et ez,by omega,hzm,?_,?_⟩ |
| · intro addr hp hv hd hkp hkq |
| rw [hzf addr hp hv hd,htf addr hkp hkq] |
| · intro j hj |
| exact (hzr j (by omega)).trans (htr j hj) |
| end DeterministicThreeSum.Structured.Indexed.Cache |
|
|
| end OAI |
|
|
