openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Completion /ProgramPrefixes.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Completion.Labels | |
| namespace OAI | |
| /-! Readable tensor completion and its finite arithmetic realization. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.CompletionLabels.TopologicalFlatten | |
| open MatrixMultiplication.Foundation RecursiveCompletion | |
| universe u v w z | |
| theorem labelRecordOf_eq_iff {A : Type u} {Label : ℕ → Type v} | |
| (labels : ∀ n, A → Label n) (n : ℕ) (a b : A) : | |
| labelRecordOf labels n a = labelRecordOf labels n b ↔ | |
| ∀ k, k < n → labels k a = labels k b := by | |
| constructor | |
| · intro h k hk | |
| exact label_eq_of_record_eq labels h hk | |
| · intro h | |
| revert h | |
| induction n with | |
| | zero => intro h; rfl | |
| | succ n ih => | |
| intro h | |
| apply Prod.ext | |
| · exact ih (fun k hk => h k (Nat.lt_succ_of_lt hk)) | |
| · exact h n (Nat.lt_succ_self n) | |
| namespace Program | |
| variable {A : Type u} {Coord : Color → Type v} | |
| {Context OtherContext : Type z} {Code : Type w} {d e : ℕ} | |
| theorem append_record_eq_iff | |
| (p : Program A Coord Context Code d) (q : Program A Coord OtherContext Code e) | |
| (sameView : ∀ side a, p.view side a = q.view side a) | |
| (derive : Context → (Fin d → Code) → OtherContext) | |
| (derive_correct : ∀ a, derive (p.context a) (fun j => p.labels j.val a) = q.context a) | |
| (k : ℕ) (a b : A) : | |
| labelRecordOf (p.append q sameView derive derive_correct).labels (d + k) a = | |
| labelRecordOf (p.append q sameView derive derive_correct).labels (d + k) b ↔ | |
| labelRecordOf p.labels d a = labelRecordOf p.labels d b ∧ | |
| labelRecordOf q.labels k a = labelRecordOf q.labels k b := by | |
| simp only [labelRecordOf_eq_iff] | |
| constructor | |
| · intro h | |
| constructor | |
| · intro n hn | |
| have heq := h n (by omega) | |
| simpa only [append_labels_left p q sameView derive derive_correct n hn] using heq | |
| · intro n hn | |
| have heq := h (d + n) (by omega) | |
| simpa only [append_labels_right] using heq | |
| · rintro ⟨hp, hq⟩ n hn | |
| by_cases hd : n < d | |
| · simpa only [append_labels_left p q sameView derive derive_correct n hd] using hp n hd | |
| · have hdn : d + (n - d) = n := Nat.add_sub_of_le (Nat.le_of_not_gt hd) | |
| have heq := hq (n - d) (by omega) | |
| have ha := append_labels_right p q sameView derive derive_correct (n - d) a | |
| have hb := append_labels_right p q sameView derive derive_correct (n - d) b | |
| rw [hdn] at ha hb | |
| exact ha.trans (heq.trans hb.symm) | |
| theorem recode_record_eq_iff {NewCode : Type*} | |
| (p : Program A Coord Context Code d) (encode : Code → NewCode) | |
| (decode : NewCode → Code) (roundtrip : Function.LeftInverse decode encode) | |
| (k : ℕ) (a b : A) : | |
| labelRecordOf (p.recode encode decode roundtrip).labels k a = | |
| labelRecordOf (p.recode encode decode roundtrip).labels k b ↔ | |
| labelRecordOf p.labels k a = labelRecordOf p.labels k b := by | |
| simp only [labelRecordOf_eq_iff] | |
| constructor | |
| · intro h n hn | |
| exact roundtrip.injective (h n hn) | |
| · intro h n hn | |
| exact congrArg encode (h n hn) | |
| theorem pow_record_eq_iff [Inhabited Code] | |
| (p : Program A Coord Context Code d) (m : ℕ) (i : Fin m) | |
| (k : ℕ) (hk : k ≤ d) (a b : Fin m → A) : | |
| labelRecordOf (p.pow m).labels (i.val * d + k) a = | |
| labelRecordOf (p.pow m).labels (i.val * d + k) b ↔ | |
| (∀ j : Fin m, j.val < i.val → | |
| labelRecordOf p.labels d (a j) = labelRecordOf p.labels d (b j)) ∧ | |
| labelRecordOf p.labels k (a i) = labelRecordOf p.labels k (b i) := by | |
| simp only [labelRecordOf_eq_iff] | |
| constructor | |
| · intro h | |
| constructor | |
| · intro j hj n hn | |
| have hindex : j.val * d + n < i.val * d + k := by | |
| calc | |
| j.val * d + n < j.val * d + d := Nat.add_lt_add_left hn _ | |
| _ = (j.val + 1) * d := by rw [Nat.add_mul, Nat.one_mul] | |
| _ ≤ i.val * d := Nat.mul_le_mul_right d (Nat.succ_le_of_lt hj) | |
| _ ≤ i.val * d + k := Nat.le_add_right _ _ | |
| have heq := h (j.val * d + n) hindex | |
| simpa only [pow_labels p m a j n hn, pow_labels p m b j n hn] using heq | |
| · intro n hn | |
| have hnd : n < d := lt_of_lt_of_le hn hk | |
| have heq := h (i.val * d + n) (Nat.add_lt_add_left hn _) | |
| simpa only [pow_labels p m a i n hnd, pow_labels p m b i n hnd] using heq | |
| · rintro ⟨hp, hc⟩ n hn | |
| have hd : 0 < d := by | |
| by_contra h | |
| have hz : d = 0 := by omega | |
| simp [hz] at hk hn | |
| omega | |
| have hq : n / d ≤ i.val := by | |
| have hbound : n < (i.val + 1) * d := by | |
| rw [Nat.add_mul, Nat.one_mul] | |
| exact lt_of_lt_of_le hn (Nat.add_le_add_left hk _) | |
| exact Nat.le_of_lt_succ ((Nat.div_lt_iff_lt_mul hd).2 hbound) | |
| let j : Fin m := ⟨n / d, lt_of_le_of_lt hq i.isLt⟩ | |
| have hrem : n % d < d := Nat.mod_lt n hd | |
| have hsplit : j.val * d + n % d = n := by | |
| simpa only [j, Nat.mul_comm] using Nat.div_add_mod n d | |
| have heq : p.labels (n % d) (a j) = p.labels (n % d) (b j) := by | |
| by_cases hj : j.val < i.val | |
| · exact hp j hj (n % d) hrem | |
| · have hji : j = i := Fin.ext (by dsimp [j] at hj ⊢; omega) | |
| have hcur : n % d < k := by | |
| rw [hji] at hsplit | |
| omega | |
| simpa only [hji] using hc (n % d) hcur | |
| rw [← hsplit, pow_labels p m a j (n % d) hrem, pow_labels p m b j (n % d) hrem] | |
| exact heq | |
| end Program | |
| end MatrixMultiplication.CompletionLabels.TopologicalFlatten | |
| namespace MatrixMultiplication.CompletionLabels | |
| open MatrixMultiplication.Foundation RecursiveCompletion TopologicalFlatten | |
| attribute [local instance] Classical.propDecidable Classical.decEq | |
| universe uCoord | |
| variable {X Y Z : Type uCoord} | |
| theorem completionLocalProgram_label_root {Code : Type*} [Inhabited Code] {depth : ℕ} | |
| (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ) | |
| (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth) | |
| (context_eq : ∀ a, p.context a = leafColor S a) | |
| (view_eq : ∀ side a, p.view side a = coordinate a.val side) | |
| (n : ℕ) (hn : n < 3) (a : Leaf (complete S center m)) : | |
| (completionLocalProgram S center m p context_eq view_eq).labels n a = | |
| encodePattern (if leafColor (complete S center m) a = rootColor n then | |
| some (pattern S center m a) else none) := by | |
| change (if n < 3 then encodePattern ((patternProgram S center m).labels n a) | |
| else (inheritedProgram S center m p view_eq).labels (n - 3) a) = _ | |
| rw [ite_eq_left hn] | |
| rfl | |
| theorem completionLocalProgram_pair_root {Code : Type*} [Inhabited Code] {depth : ℕ} | |
| (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ) | |
| (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth) | |
| (context_eq : ∀ a, p.context a = leafColor S a) | |
| (view_eq : ∀ side a, p.view side a = coordinate a.val side) | |
| (n : ℕ) (hn : n < 3) : | |
| (completionLocalProgram S center m p context_eq view_eq).pair n = | |
| ownerPair center (rootColor n) := by | |
| change (if n < 3 then ownerPair center (rootColor n) else p.pair ((n - 3) % depth)) = _ | |
| rw [ite_eq_left hn] | |
| theorem completionLocalProgram_label_slot {Code : Type*} [Inhabited Code] {depth : ℕ} | |
| (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ) | |
| (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth) | |
| (context_eq : ∀ a, p.context a = leafColor S a) | |
| (view_eq : ∀ side a, p.view side a = coordinate a.val side) | |
| (i : Fin m) (k : ℕ) (hk : k < depth) (a : Leaf (complete S center m)) : | |
| (completionLocalProgram S center m p context_eq view_eq).labels (3 + (i.val * depth + k)) a = | |
| encodeOld (p.labels k (slot S center m a i)) := by | |
| change (if 3 + (i.val * depth + k) < 3 then | |
| encodePattern ((patternProgram S center m).labels (3 + (i.val * depth + k)) a) | |
| else (inheritedProgram S center m p view_eq).labels | |
| (3 + (i.val * depth + k) - 3) a) = _ | |
| have hsub : 3 + (i.val * depth + k) - 3 = i.val * depth + k := by omega | |
| rw [ite_eq_right (by omega), hsub] | |
| change ((p.recode encodeOld decodeOld oldCode_roundtrip).pow m).labels | |
| (i.val * depth + k) (slot S center m a) = _ | |
| rw [Program.pow_labels _ m _ i k hk] | |
| rfl | |
| theorem completionLocalProgram_pair_slot {Code : Type*} [Inhabited Code] {depth : ℕ} | |
| (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ) | |
| (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth) | |
| (context_eq : ∀ a, p.context a = leafColor S a) | |
| (view_eq : ∀ side a, p.view side a = coordinate a.val side) | |
| (i : Fin m) (k : ℕ) (hk : k < depth) : | |
| (completionLocalProgram S center m p context_eq view_eq).pair (3 + (i.val * depth + k)) = | |
| p.pair k := by | |
| change (if 3 + (i.val * depth + k) < 3 then _ | |
| else p.pair ((3 + (i.val * depth + k) - 3) % depth)) = _ | |
| rw [ite_eq_right (by omega)] | |
| have hsub : 3 + (i.val * depth + k) - 3 = i.val * depth + k := by omega | |
| rw [hsub, Nat.mul_add_mod_self_right, Nat.mod_eq_of_lt hk] | |
| theorem patternProgram_record_eq_iff (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ) | |
| (a b : Leaf (complete S center m)) : | |
| labelRecordOf (patternProgram S center m).labels 3 a = | |
| labelRecordOf (patternProgram S center m).labels 3 b ↔ | |
| leafColor (complete S center m) a = leafColor (complete S center m) b ∧ | |
| pattern S center m a = pattern S center m b := by | |
| constructor | |
| · intro h | |
| have heq := label_eq_of_record_eq (patternProgram S center m).labels h | |
| (rootIndex (leafColor (complete S center m) a)).isLt | |
| change (if leafColor (complete S center m) a = | |
| rootColor (rootIndex (leafColor (complete S center m) a)).val | |
| then some (pattern S center m a) else none) = | |
| (if leafColor (complete S center m) b = | |
| rootColor (rootIndex (leafColor (complete S center m) a)).val | |
| then some (pattern S center m b) else none) at heq | |
| rw [rootColor_rootIndex, ite_eq_left rfl] at heq | |
| by_cases hb : leafColor (complete S center m) b = leafColor (complete S center m) a | |
| · rw [ite_eq_left hb] at heq | |
| exact ⟨hb.symm, Option.some.inj heq⟩ | |
| · rw [ite_eq_right hb] at heq | |
| cases heq | |
| · rintro ⟨hc, hp⟩ | |
| apply (labelRecordOf_eq_iff _ _ _ _).mpr | |
| intro n hn | |
| change (if leafColor (complete S center m) a = rootColor n then | |
| some (pattern S center m a) else none) = | |
| (if leafColor (complete S center m) b = rootColor n then | |
| some (pattern S center m b) else none) | |
| rw [hc, hp] | |
| theorem completionProgram_record_eq_iff {Code : Type*} [Inhabited Code] {depth : ℕ} | |
| (S : FlaggedTensor X Y Z) (center : Color) (m : ℕ) | |
| (p : Program (Leaf S) (Coordinate X Y Z) Color Code depth) | |
| (context_eq : ∀ a, p.context a = leafColor S a) | |
| (view_eq : ∀ side a, p.view side a = coordinate a.val side) | |
| (i : Fin m) (k : ℕ) (hk : k ≤ depth) | |
| (a b : Leaf (complete S center m)) : | |
| labelRecordOf (completionLocalProgram S center m p context_eq view_eq).labels | |
| (3 + (i.val * depth + k)) a = | |
| labelRecordOf (completionLocalProgram S center m p context_eq view_eq).labels | |
| (3 + (i.val * depth + k)) b ↔ | |
| (leafColor (complete S center m) a = leafColor (complete S center m) b ∧ | |
| pattern S center m a = pattern S center m b) ∧ | |
| ((∀ j : Fin m, j.val < i.val → | |
| labelRecordOf p.labels depth (slot S center m a j) = | |
| labelRecordOf p.labels depth (slot S center m b j)) ∧ | |
| labelRecordOf p.labels k (slot S center m a i) = | |
| labelRecordOf p.labels k (slot S center m b i)) := by | |
| change labelRecordOf (completionProgram S center m p context_eq view_eq).labels | |
| (3 + (i.val * depth + k)) a = | |
| labelRecordOf (completionProgram S center m p context_eq view_eq).labels | |
| (3 + (i.val * depth + k)) b ↔ _ | |
| trans | |
| (labelRecordOf ((patternProgram S center m).recode (encodePattern (Code := Code)) | |
| decodePatternCode patternCode_roundtrip).labels 3 a = | |
| labelRecordOf ((patternProgram S center m).recode (encodePattern (Code := Code)) | |
| decodePatternCode patternCode_roundtrip).labels 3 b ∧ | |
| labelRecordOf (inheritedProgram S center m p view_eq).labels (i.val * depth + k) a = | |
| labelRecordOf (inheritedProgram S center m p view_eq).labels (i.val * depth + k) b) | |
| · exact Program.append_record_eq_iff _ _ _ _ _ (i.val * depth + k) a b | |
| rw [Program.recode_record_eq_iff, patternProgram_record_eq_iff] | |
| have htail : | |
| (labelRecordOf (inheritedProgram S center m p view_eq).labels (i.val * depth + k) a = | |
| labelRecordOf (inheritedProgram S center m p view_eq).labels (i.val * depth + k) b) ↔ | |
| (labelRecordOf ((p.recode (encodeOld (m := m)) decodeOld oldCode_roundtrip).pow m).labels | |
| (i.val * depth + k) (slot S center m a) = | |
| labelRecordOf ((p.recode (encodeOld (m := m)) decodeOld oldCode_roundtrip).pow m).labels | |
| (i.val * depth + k) (slot S center m b)) := by | |
| simp only [labelRecordOf_eq_iff] | |
| rfl | |
| rw [htail, Program.pow_record_eq_iff _ m i k hk] | |
| simp only [Program.recode_record_eq_iff] | |
| end MatrixMultiplication.CompletionLabels | |
| end | |
| end OAI | |