| 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) = |
| @delete 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) = |
| @delete 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 → |
| (@Finset.filter I (fun i => ¬(px i x ∧ py i y ∧ pz i z)) |
| (Classical.decPred _) Finset.univ).card ≤ t) |
| (hbudget : (@Finset.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) := @Finset.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 |
|
|
