Download data/lean/OAI/LinearAlgebra/MatrixMultiplication/Recovery/ExactRecovery.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.85 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/Recovery/ExactRecovery.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/LinearAlgebra/MatrixMultiplication/Recovery/ExactRecovery.lean
-
curl -L -o ExactRecovery.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/Recovery/ExactRecovery.lean
6.85 kB
| import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexTensorRestrictionComposition | |
| import OAI.LinearAlgebra.MatrixMultiplication.Separation.FiniteCover | |
| import Mathlib.Data.Finset.Powerset | |
| import Mathlib.Data.Fintype.Powerset | |
| namespace OAI | |
| /-! Finite orbit symmetries, masks and exact recovery operations. -/ | |
| open scoped BigOperators | |
| open MatrixMultiplication.Foundation | |
| namespace MatrixMultiplication.ExactRecovery | |
| variable {K X Y Z I A B C : Type*} [CommSemiring K] | |
| def delete (Q : Tensor K X Y Z) (px : X β Prop) (py : Y β Prop) | |
| (pz : Z β Prop) [DecidablePred px] [DecidablePred py] [DecidablePred pz] : | |
| Tensor K X Y Z := fun x y z => if px x β§ py y β§ pz z then Q x y z else 0 | |
| def presence [Fintype I] [DecidableEq I] (p : I β X β Prop) | |
| [β i, DecidablePred (p i)] (x : X) : Finset I := | |
| Finset.univ.filter fun i => p i x | |
| @[simp] theorem mem_presence [Fintype I] [DecidableEq I] (p : I β X β Prop) | |
| [β i, DecidablePred (p i)] (x : X) (i : I) : | |
| i β presence p x β p i x := by simp [presence] | |
| theorem restrict_rectangles | |
| [Fintype X] [Fintype Y] [Fintype Z] | |
| [Fintype A] [Fintype B] [Fintype C] | |
| [DecidableEq X] [DecidableEq Y] [DecidableEq Z] | |
| [DecidableEq A] [DecidableEq B] [DecidableEq C] | |
| (Q H : Tensor K X Y Z) (cx : X β A) (cy : Y β B) (cz : Z β C) | |
| (fx : A Γ B Γ C β X β X) (fy : A Γ B Γ C β Y β Y) | |
| (fz : A Γ B Γ C β Z β Z) | |
| (h : β x y z, H (fx (cx x, cy y, cz z) x) | |
| (fy (cx x, cy y, cz z) y) (fz (cx x, cy y, cz z) z) = Q x y z) : | |
| Tensor.restrict | |
| (fun x s => if cx x = s.1.1 β§ s.2 = fx s.1 x then (1 : K) else 0) | |
| (fun y s => if cy y = s.1.2.1 β§ s.2 = fy s.1 y then (1 : K) else 0) | |
| (fun z s => if cz z = s.1.2.2 β§ s.2 = fz s.1 z then (1 : K) else 0) | |
| (Tensor.directSum (fun _ : A Γ B Γ C => H)) = Q := by | |
| funext x y z | |
| simp [Tensor.restrict, Tensor.directSum, Fintype.sum_prod_type, | |
| ite_and, ite_mul, mul_ite, h] | |
| theorem repair_of_cover | |
| [Fintype X] [Fintype Y] [Fintype Z] [Fintype I] [DecidableEq I] [Nonempty I] | |
| (Q H : Tensor K X Y Z) | |
| (px : I β X β Prop) (py : I β Y β Prop) (pz : I β Z β Prop) | |
| (fx : I β X β X) (fy : I β Y β Y) (fz : I β Z β Z) | |
| (hshift : β i x y z, H (fx i x) (fy i y) (fz i z) = | |
| K X Y Z _ Q (px i) (py i) (pz i) | |
| (Classical.decPred _) (Classical.decPred _) (Classical.decPred _) x y z) | |
| (hcover : β x y z, Q x y z β 0 β β i, px i x β§ py i y β§ pz i z) : | |
| β (a : X β ((Finset I Γ Finset I Γ Finset I) Γ X) β K) | |
| (b : Y β ((Finset I Γ Finset I Γ Finset I) Γ Y) β K) | |
| (c : Z β ((Finset I Γ Finset I Γ Finset I) Γ Z) β K), | |
| Tensor.restrict a b c | |
| (Tensor.directSum (fun _ : Finset I Γ Finset I Γ Finset I => H)) = Q := by | |
| classical | |
| let pick : Finset I Γ Finset I Γ Finset I β I := fun r => | |
| if h : β i, i β r.1 β§ i β r.2.1 β§ i β r.2.2 then Classical.choose h | |
| else Classical.choice inferInstance | |
| have hpick (r : Finset I Γ Finset I Γ Finset I) | |
| (hr : β i, i β r.1 β§ i β r.2.1 β§ i β r.2.2) : | |
| pick r β r.1 β§ pick r β r.2.1 β§ pick r β r.2.2 := by | |
| simpa [pick, hr] using Classical.choose_spec hr | |
| let cx := presence px | |
| let cy := presence py | |
| let cz := presence pz | |
| have hrect (x : X) (y : Y) (z : Z) : | |
| H (fx (pick (cx x, cy y, cz z)) x) | |
| (fy (pick (cx x, cy y, cz z)) y) | |
| (fz (pick (cx x, cy y, cz z)) z) = Q x y z := by | |
| rw [hshift] | |
| by_cases hq : Q x y z = 0 | |
| Β· simp [delete, hq] | |
| Β· rcases hcover x y z hq with β¨i, hix, hiy, hizβ© | |
| have hp := hpick (cx x, cy y, cz z) | |
| β¨i, by simpa [cx] using hix, by simpa [cy] using hiy, | |
| by simpa [cz] using hizβ© | |
| have hpx : px (pick (cx x, cy y, cz z)) x := by simpa [cx] using hp.1 | |
| have hpy : py (pick (cx x, cy y, cz z)) y := by simpa [cy] using hp.2.1 | |
| have hpz : pz (pick (cx x, cy y, cz z)) z := by simpa [cz] using hp.2.2 | |
| simp [delete, hpx, hpy, hpz] | |
| exact β¨_, _, _, restrict_rectangles Q H cx cy cz | |
| (fun r => fx (pick r)) (fun r => fy (pick r)) (fun r => fz (pick r)) hrectβ© | |
| theorem card_mask_rectangles [Fintype I] : | |
| Fintype.card (Finset I Γ Finset I Γ Finset I) = 2 ^ (3 * Fintype.card I) := by | |
| classical | |
| simp only [Fintype.card_prod, Fintype.card_finset] | |
| rw [Nat.mul_comm 3 (Fintype.card I), pow_mul] | |
| simp [pow_succ, mul_assoc] | |
| theorem repair_of_counting | |
| [Fintype X] [Fintype Y] [Fintype Z] [Fintype I] | |
| [DecidableEq X] [DecidableEq Y] [DecidableEq Z] [DecidableEq I] | |
| (Q H : Tensor K X Y Z) | |
| (px : I β X β Prop) (py : I β Y β Prop) (pz : I β Z β Prop) | |
| (fx : I β X β X) (fy : I β Y β Y) (fz : I β Z β Z) | |
| (hshift : β i x y z, H (fx i x) (fy i y) (fz i z) = | |
| K X Y Z _ Q (px i) (py i) (pz i) | |
| (Classical.decPred _) (Classical.decPred _) (Classical.decPred _) x y z) | |
| (t L : β) (hL : 0 < L) | |
| (hbad : β x y z, Q x y z β 0 β | |
| (.filter I (fun i => Β¬(px i x β§ py i y β§ pz i z)) | |
| (Classical.decPred _) Finset.univ).card β€ t) | |
| (hbudget : (.filter (X Γ Y Γ Z) | |
| (fun p => Q p.1 p.2.1 p.2.2 β 0) (Classical.decPred _) Finset.univ).card * t ^ L < | |
| Fintype.card I ^ L) : | |
| β (a : X β ((Finset (Fin L) Γ Finset (Fin L) Γ Finset (Fin L)) Γ X) β K) | |
| (b : Y β ((Finset (Fin L) Γ Finset (Fin L) Γ Finset (Fin L)) Γ Y) β K) | |
| (c : Z β ((Finset (Fin L) Γ Finset (Fin L) Γ Finset (Fin L)) Γ Z) β K), | |
| Tensor.restrict a b c | |
| (Tensor.directSum (fun _ : Finset (Fin L) Γ Finset (Fin L) Γ Finset (Fin L) => H)) = Q := by | |
| classical | |
| let support : Finset (X Γ Y Γ Z) := .filter (X Γ Y Γ Z) | |
| (fun p => Q p.1 p.2.1 p.2.2 β 0) (Classical.decPred _) Finset.univ | |
| let good (i : I) (p : X Γ Y Γ Z) : Prop := px i p.1 β§ py i p.2.1 β§ pz i p.2.2 | |
| have hbad' : β p β support, (Finset.univ.filter fun i => Β¬good i p).card β€ t := by | |
| intro p hp | |
| have heq : (Finset.univ.filter fun i => Β¬good i p) = | |
| @Finset.filter I (fun i => Β¬(px i p.1 β§ py i p.2.1 β§ pz i p.2.2)) | |
| (Classical.decPred _) Finset.univ := by | |
| ext i | |
| simp only [Finset.mem_filter, good] | |
| rw [heq] | |
| apply hbad p.1 p.2.1 p.2.2 | |
| simpa only [support, Finset.mem_filter, Finset.mem_univ, true_and] using hp | |
| obtain β¨f, hfβ© := FiniteCover.exists_cover support good t L hbad' hbudget | |
| let : Nonempty (Fin L) := β¨β¨0, hLβ©β© | |
| exact repair_of_cover Q H (fun i => px (f i)) (fun i => py (f i)) | |
| (fun i => pz (f i)) (fun i => fx (f i)) (fun i => fy (f i)) | |
| (fun i => fz (f i)) (fun i => hshift (f i)) | |
| (fun x y z hq => hf (x, y, z) (by simp [support, hq])) | |
| end MatrixMultiplication.ExactRecovery | |
| end OAI | |