openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Recovery /InheritedMaskConcentration.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Recovery.PermutationMatchingHalves | |
| import OAI.LinearAlgebra.MatrixMultiplication.Recovery.InheritedMasks | |
| import OAI.LinearAlgebra.MatrixMultiplication.Recovery.OrbitCounting | |
| import Mathlib.Algebra.BigOperators.Field | |
| namespace OAI | |
| /-! Finite orbit symmetries, masks and exact recovery operations. -/ | |
| namespace MatrixMultiplication.PermutationMatching | |
| open scoped BigOperators | |
| open Classical | |
| noncomputable section | |
| section ClassProducts | |
| variable {C : Type*} [Fintype C] [DecidableEq C] {P : C → Type*} | |
| [∀ c, Fintype (P c)] [∀ c, DecidableEq (P c)] | |
| abbrev ClassPermutations (P : C → Type*) := ∀ c, Equiv.Perm (P c) | |
| def populationSize (P : C → Type*) [∀ c, Fintype (P c)] : ℝ := | |
| ∑ c, (Fintype.card (P c) : ℝ) | |
| def totalMatchingCount (A B : ∀ c, Finset (P c)) | |
| (p : ClassPermutations P) : ℝ := | |
| ∑ c, matchingCount (A c) (B c) (p c) | |
| def totalMatchingMean (A B : ∀ c, Finset (P c)) : ℝ := | |
| ∑ c, average (matchingCount (A c) (B c)) | |
| theorem average_totalMatchingCount (A B : ∀ c, Finset (P c)) : | |
| average (totalMatchingCount A B) = totalMatchingMean A B := by | |
| classical | |
| unfold totalMatchingCount totalMatchingMean | |
| rw [average_sum] | |
| apply Finset.sum_congr rfl | |
| intro c _ | |
| exact average_pi_eval (X := fun c => Equiv.Perm (P c)) c | |
| (matchingCount (A c) (B c)) | |
| omit [DecidableEq C] in | |
| theorem totalMatchingMean_eq [∀ c, Nonempty (P c)] | |
| (A B : ∀ c, Finset (P c)) : | |
| totalMatchingMean A B = | |
| ∑ c, ((A c).card : ℝ) * ((B c).card : ℝ) / (Fintype.card (P c) : ℝ) := by | |
| classical | |
| unfold totalMatchingMean | |
| apply Finset.sum_congr rfl | |
| intro c _ | |
| exact average_matchingCount (A c) (B c) | |
| theorem totalMatchingCount_variance_le (A B : ∀ c, Finset (P c)) | |
| (hn : ∀ c, 2 ≤ Fintype.card (P c)) : | |
| average (fun p : ClassPermutations P => | |
| (totalMatchingCount A B p - totalMatchingMean A B) ^ 2) ≤ | |
| populationSize P / 8 := by | |
| classical | |
| calc | |
| _ = ∑ c, average (fun p : Equiv.Perm (P c) => | |
| (matchingCount (A c) (B c) p - average (matchingCount (A c) (B c))) ^ 2) := by | |
| simpa only [totalMatchingCount, totalMatchingMean, Finset.sum_sub_distrib] | |
| using average_pi_sum_centered_sq (fun c => matchingCount (A c) (B c)) | |
| _ ≤ ∑ c, (Fintype.card (P c) : ℝ) / 8 := | |
| Finset.sum_le_sum fun c _ => matchingCount_variance_le (A c) (B c) (hn c) | |
| _ = populationSize P / 8 := by rw [← Finset.sum_div]; rfl | |
| theorem totalMatchingCount_deviation_le (A B : ∀ c, Finset (P c)) | |
| (hn : ∀ c, 2 ≤ Fintype.card (P c)) (δ : ℝ) (hδ : 0 < δ) : | |
| average (fun p : ClassPermutations P => | |
| if δ ≤ |totalMatchingCount A B p - totalMatchingMean A B| then 1 else 0) ≤ | |
| populationSize P / (8 * δ ^ 2) := by | |
| classical | |
| have h := (deviation_bound (totalMatchingCount A B) (totalMatchingMean A B) δ hδ).trans | |
| (totalMatchingCount_variance_le A B hn) | |
| calc | |
| _ ≤ (populationSize P / 8) / δ ^ 2 := (le_div_iff₀ (sq_pos_of_pos hδ)).2 h | |
| _ = _ := by rw [div_div] | |
| theorem normalizedMatchingCount_deviation_le (A B : ∀ c, Finset (P c)) | |
| (hn : ∀ c, 2 ≤ Fintype.card (P c)) | |
| (hm : 0 < populationSize P) (η : ℝ) (hη : 0 < η) : | |
| average (fun p : ClassPermutations P => | |
| if η / 2 ≤ |totalMatchingCount A B p / populationSize P - | |
| totalMatchingMean A B / populationSize P| then 1 else 0) ≤ | |
| 1 / (2 * populationSize P * η ^ 2) := by | |
| classical | |
| have hδ : 0 < populationSize P * η / 2 := by positivity | |
| calc | |
| _ ≤ average (fun p : ClassPermutations P => | |
| if populationSize P * η / 2 ≤ | |
| |totalMatchingCount A B p - totalMatchingMean A B| then 1 else 0) := by | |
| apply average_mono | |
| intro p | |
| have hi : η / 2 ≤ |totalMatchingCount A B p / populationSize P - | |
| totalMatchingMean A B / populationSize P| → | |
| populationSize P * η / 2 ≤ | |
| |totalMatchingCount A B p - totalMatchingMean A B| := by | |
| intro hp | |
| rw [← sub_div, abs_div, abs_of_pos hm] at hp | |
| have hh := (le_div_iff₀ hm).mp hp | |
| nlinarith | |
| split_ifs <;> simp_all | |
| _ ≤ populationSize P / (8 * (populationSize P * η / 2) ^ 2) := | |
| totalMatchingCount_deviation_le A B hn _ hδ | |
| _ = _ := by | |
| field_simp [ne_of_gt hm, ne_of_gt hη] | |
| ring | |
| theorem inheritedMask_rejection_le (A B : ∀ c, Finset (P c)) | |
| (hn : ∀ c, 2 ≤ Fintype.card (P c)) | |
| (hm : 0 < populationSize P) (η ν : ℝ) (hη : 0 < η) | |
| (hmargin : |totalMatchingMean A B / populationSize P - ν| ≤ η / 2) : | |
| average (fun p : ClassPermutations P => | |
| if η < |totalMatchingCount A B p / populationSize P - ν| then 1 else 0) ≤ | |
| 1 / (2 * populationSize P * η ^ 2) := by | |
| classical | |
| refine le_trans (average_mono ?_) (normalizedMatchingCount_deviation_le A B hn hm η hη) | |
| intro p | |
| have hi : η < |totalMatchingCount A B p / populationSize P - ν| → | |
| η / 2 ≤ |totalMatchingCount A B p / populationSize P - | |
| totalMatchingMean A B / populationSize P| := by | |
| intro hp | |
| have ht : |totalMatchingCount A B p / populationSize P - ν| ≤ | |
| |totalMatchingCount A B p / populationSize P - | |
| totalMatchingMean A B / populationSize P| + | |
| |totalMatchingMean A B / populationSize P - ν| := by | |
| simpa only [sub_add_sub_cancel] using abs_add_le | |
| (totalMatchingCount A B p / populationSize P - totalMatchingMean A B / populationSize P) | |
| (totalMatchingMean A B / populationSize P - ν) | |
| linarith | |
| split_ifs <;> simp_all | |
| theorem finite_inheritedMask_rejection_le {I : Type*} [Fintype I] | |
| (A B : I → ∀ c, Finset (P c)) | |
| (hn : ∀ c, 2 ≤ Fintype.card (P c)) (hm : 0 < populationSize P) | |
| (η ν : I → ℝ) (hη : ∀ i, 0 < η i) | |
| (hmargin : ∀ i, |totalMatchingMean (A i) (B i) / populationSize P - ν i| ≤ η i / 2) : | |
| average (fun p : ClassPermutations P => | |
| if ∃ i, η i < |totalMatchingCount (A i) (B i) p / populationSize P - ν i| | |
| then 1 else 0) ≤ ∑ i, 1 / (2 * populationSize P * (η i) ^ 2) := by | |
| classical | |
| refine le_trans (average_indicator_exists_le_sum _) ?_ | |
| exact Finset.sum_le_sum fun i _ => | |
| inheritedMask_rejection_le (A i) (B i) hn hm (η i) (ν i) (hη i) (hmargin i) | |
| theorem pushforward_sum_rejection_le {I : Type*} [Fintype I] | |
| (A B : I → ∀ c, Finset (P c)) | |
| (hn : ∀ c, 2 ≤ Fintype.card (P c)) (hm : 0 < populationSize P) | |
| (η : ℝ) (ν : I → ℝ) (hη : 0 < η) | |
| (hmargin : ∀ i, |totalMatchingMean (A i) (B i) / populationSize P - ν i| ≤ | |
| (η / Fintype.card I) / 2) : | |
| average (fun p : ClassPermutations P => | |
| if η < |(∑ i, totalMatchingCount (A i) (B i) p / populationSize P) - ∑ i, ν i| | |
| then 1 else 0) ≤ | |
| ∑ _i : I, 1 / (2 * populationSize P * (η / Fintype.card I) ^ 2) := by | |
| classical | |
| by_cases hIcard : Fintype.card I = 0 | |
| · have : IsEmpty I := Fintype.card_eq_zero_iff.mp hIcard | |
| simp [not_lt.mpr (le_of_lt hη)] | |
| have : Nonempty I := Fintype.card_pos_iff.mp (Nat.pos_of_ne_zero hIcard) | |
| have hcard : (0 : ℝ) < Fintype.card I := by | |
| exact_mod_cast Fintype.card_pos | |
| have htol : 0 < η / (Fintype.card I : ℝ) := div_pos hη hcard | |
| refine le_trans (average_mono ?_) | |
| (finite_inheritedMask_rejection_le A B hn hm (fun _ => η / Fintype.card I) | |
| ν (fun _ => htol) hmargin) | |
| intro p | |
| have hi : η < |(∑ i, totalMatchingCount (A i) (B i) p / populationSize P) - | |
| ∑ i, ν i| → | |
| ∃ i, η / Fintype.card I < | |
| |totalMatchingCount (A i) (B i) p / populationSize P - ν i| := by | |
| intro hp | |
| by_contra h | |
| push Not at h | |
| have he : |(∑ i, totalMatchingCount (A i) (B i) p / populationSize P) - | |
| ∑ i, ν i| ≤ η := by | |
| rw [← Finset.sum_sub_distrib] | |
| calc | |
| _ ≤ ∑ i, |totalMatchingCount (A i) (B i) p / populationSize P - ν i| := | |
| Finset.abs_sum_le_sum_abs _ _ | |
| _ ≤ ∑ _i : I, η / Fintype.card I := Finset.sum_le_sum fun i _ => h i | |
| _ = η := by | |
| simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul] | |
| field_simp [ne_of_gt hcard] | |
| linarith | |
| split_ifs <;> simp_all | |
| def totalTwoHalfCount (A B : ∀ c, Finset (P c)) | |
| (p : ClassPermutations P × ClassPermutations P) : ℝ := | |
| ∑ c, twoHalfCount (A c) (B c) (p.1 c) (p.2 c) | |
| theorem average_totalTwoHalfCount_test (A B : ∀ c, Finset (P c)) (f : ℝ → ℝ) : | |
| average (fun p : ClassPermutations P × ClassPermutations P => | |
| f (totalTwoHalfCount A B p)) = | |
| average (fun p : ClassPermutations P => f (totalMatchingCount A B p)) := by | |
| calc | |
| _ = average (fun p : ClassPermutations P × ClassPermutations P => | |
| f (totalMatchingCount A B (relativeFamily P p.1 p.2))) := by | |
| apply average_congr | |
| intro p | |
| exact congrArg f (sum_twoHalfCount_eq_matchingCount P A B p.1 p.2) | |
| _ = _ := average_relativeFamily P (fun p => f (totalMatchingCount A B p)) | |
| theorem average_totalTwoHalfCounts_test {I : Type*} | |
| (A B : I → ∀ c, Finset (P c)) (f : (I → ℝ) → ℝ) : | |
| average (fun p : ClassPermutations P × ClassPermutations P => | |
| f (fun i => totalTwoHalfCount (A i) (B i) p)) = | |
| average (fun p : ClassPermutations P => | |
| f (fun i => totalMatchingCount (A i) (B i) p)) := by | |
| calc | |
| _ = average (fun p : ClassPermutations P × ClassPermutations P => | |
| f (fun i => totalMatchingCount (A i) (B i) (relativeFamily P p.1 p.2))) := by | |
| apply average_congr | |
| intro p | |
| apply congrArg f | |
| funext i | |
| exact sum_twoHalfCount_eq_matchingCount P (A i) (B i) p.1 p.2 | |
| _ = _ := average_relativeFamily P | |
| (fun p => f (fun i => totalMatchingCount (A i) (B i) p)) | |
| theorem twoHalf_pushforward_sum_rejection_le {I : Type*} [Fintype I] | |
| (A B : I → ∀ c, Finset (P c)) | |
| (hn : ∀ c, 2 ≤ Fintype.card (P c)) (hm : 0 < populationSize P) | |
| (η : ℝ) (ν : I → ℝ) (hη : 0 < η) | |
| (hmargin : ∀ i, |totalMatchingMean (A i) (B i) / populationSize P - ν i| ≤ | |
| (η / Fintype.card I) / 2) : | |
| average (fun p : ClassPermutations P × ClassPermutations P => | |
| if η < |(∑ i, totalTwoHalfCount (A i) (B i) p / populationSize P) - ∑ i, ν i| | |
| then 1 else 0) ≤ | |
| ∑ _i : I, 1 / (2 * populationSize P * (η / Fintype.card I) ^ 2) := by | |
| classical | |
| rw [average_totalTwoHalfCounts_test A B | |
| (fun k => if η < |(∑ i, k i / populationSize P) - ∑ i, ν i| then 1 else 0)] | |
| exact pushforward_sum_rejection_le A B hn hm η ν hη hmargin | |
| theorem twoHalf_inheritedMask_rejection_le (A B : ∀ c, Finset (P c)) | |
| (hn : ∀ c, 2 ≤ Fintype.card (P c)) | |
| (hm : 0 < populationSize P) (η ν : ℝ) (hη : 0 < η) | |
| (hmargin : |totalMatchingMean A B / populationSize P - ν| ≤ η / 2) : | |
| average (fun p : ClassPermutations P × ClassPermutations P => | |
| if η < |totalTwoHalfCount A B p / populationSize P - ν| then 1 else 0) ≤ | |
| 1 / (2 * populationSize P * η ^ 2) := by | |
| classical | |
| rw [average_totalTwoHalfCount_test A B | |
| (fun k => if η < |k / populationSize P - ν| then 1 else 0)] | |
| exact inheritedMask_rejection_le A B hn hm η ν hη hmargin | |
| def selectedTwoHalfCount (D : Finset C) (A B : ∀ c, Finset (P c)) | |
| (p : ClassPermutations P × ClassPermutations P) : ℝ := | |
| totalTwoHalfCount (fun c : D => A c) (fun c : D => B c) | |
| ((fun c => p.1 c), (fun c => p.2 c)) | |
| theorem selectedTwoHalfMask_rejection_le (D : Finset C) (A B : ∀ c, Finset (P c)) | |
| (hn : ∀ c ∈ D, 2 ≤ Fintype.card (P c)) | |
| (hm : 0 < populationSize (fun c : D => P c)) (η ν : ℝ) (hη : 0 < η) | |
| (hmargin : |totalMatchingMean (fun c : D => A c) (fun c : D => B c) / | |
| populationSize (fun c : D => P c) - ν| ≤ η / 2) : | |
| average (fun p : ClassPermutations P × ClassPermutations P => | |
| if η < |selectedTwoHalfCount D A B p / populationSize (fun c : D => P c) - ν| | |
| then 1 else 0) ≤ 1 / (2 * populationSize (fun c : D => P c) * η ^ 2) := by | |
| classical | |
| have havg := average_prod_pi_restrict (X := fun c => Equiv.Perm (P c)) D | |
| (fun p : ClassPermutations (fun c : D => P c) × | |
| ClassPermutations (fun c : D => P c) => | |
| if η < |totalTwoHalfCount (fun c : D => A c) (fun c : D => B c) p / | |
| populationSize (fun c : D => P c) - ν| then (1 : ℝ) else 0) | |
| change average (fun p : ClassPermutations P × ClassPermutations P => | |
| if η < |totalTwoHalfCount (fun c : D => A c) (fun c : D => B c) | |
| ((fun c => p.1 c), (fun c => p.2 c)) / | |
| populationSize (fun c : D => P c) - ν| then 1 else 0) ≤ _ | |
| rw [havg] | |
| exact twoHalf_inheritedMask_rejection_le (P := fun c : D => P c) | |
| (fun c : D => A c) (fun c : D => B c) | |
| (fun c : D => hn c c.property) hm η ν hη hmargin | |
| theorem finite_selectedTwoHalfMask_rejection_le {I : Type*} [Fintype I] | |
| (D : I → Finset C) (A B : I → ∀ c, Finset (P c)) | |
| (hn : ∀ i c, c ∈ D i → 2 ≤ Fintype.card (P c)) | |
| (hm : ∀ i, 0 < populationSize (fun c : D i => P c)) | |
| (η ν : I → ℝ) (hη : ∀ i, 0 < η i) | |
| (hmargin : ∀ i, | |
| |totalMatchingMean (fun c : D i => A i c) (fun c : D i => B i c) / | |
| populationSize (fun c : D i => P c) - ν i| ≤ η i / 2) : | |
| average (fun p : ClassPermutations P × ClassPermutations P => | |
| if ∃ i, η i < |selectedTwoHalfCount (D i) (A i) (B i) p / | |
| populationSize (fun c : D i => P c) - ν i| then 1 else 0) ≤ | |
| ∑ i, 1 / (2 * populationSize (fun c : D i => P c) * (η i) ^ 2) := by | |
| classical | |
| refine le_trans (average_indicator_exists_le_sum _) ?_ | |
| exact Finset.sum_le_sum fun i _ => selectedTwoHalfMask_rejection_le | |
| (D i) (A i) (B i) (hn i) (hm i) (η i) (ν i) (hη i) (hmargin i) | |
| theorem inverse_linear_mask_constant {I : Type*} [Fintype I] | |
| (mass η : I → ℝ) (N : ℝ) : | |
| (∑ i, 1 / (2 * (mass i * N) * (η i) ^ 2)) = | |
| (∑ i, 1 / (2 * mass i * (η i) ^ 2)) / N := by | |
| rw [Finset.sum_div] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| rw [div_div] | |
| congr 1 | |
| ring | |
| theorem finite_selectedTwoHalfMask_inverse_linear {I : Type*} [Fintype I] | |
| (D : I → Finset C) (A B : I → ∀ c, Finset (P c)) | |
| (hn : ∀ i c, c ∈ D i → 2 ≤ Fintype.card (P c)) | |
| (mass η ν : I → ℝ) (N : ℝ) (hN : 0 < N) | |
| (hmass : ∀ i, 0 < mass i) (hη : ∀ i, 0 < η i) | |
| (hsize : ∀ i, populationSize (fun c : D i => P c) = mass i * N) | |
| (hmargin : ∀ i, | |
| |totalMatchingMean (fun c : D i => A i c) (fun c : D i => B i c) / | |
| populationSize (fun c : D i => P c) - ν i| ≤ η i / 2) : | |
| average (fun p : ClassPermutations P × ClassPermutations P => | |
| if ∃ i, η i < |selectedTwoHalfCount (D i) (A i) (B i) p / | |
| populationSize (fun c : D i => P c) - ν i| then 1 else 0) ≤ | |
| (∑ i, 1 / (2 * mass i * (η i) ^ 2)) / N := by | |
| have hm (i : I) : 0 < populationSize (fun c : D i => P c) := by | |
| rw [hsize] | |
| exact mul_pos (hmass i) hN | |
| have h := finite_selectedTwoHalfMask_rejection_le D A B hn hm η ν hη hmargin | |
| simpa only [hsize, inverse_linear_mask_constant] using h | |
| end ClassProducts | |
| section CompleteSymbols | |
| variable {P A S : Type*} [Fintype P] [DecidableEq P] [DecidableEq S] | |
| omit [DecidableEq P] in | |
| theorem statisticPositions_card [Fintype S] | |
| (w : P → A) (statistic : A → S) (s : S) : | |
| (statisticPositions w statistic s).card = | |
| MatrixMultiplication.Foundation.wordPopulation (statistic ∘ w) s := by | |
| unfold statisticPositions MatrixMultiplication.Foundation.wordPopulation | |
| rw [Fintype.card_subtype] | |
| apply congrArg Finset.card | |
| ext i | |
| simp | |
| end CompleteSymbols | |
| section OrbitFractions | |
| variable {G X : Type*} [Group G] [MulAction G X] [Fintype G] [DecidableEq X] | |
| theorem average_bad_shift_eq_orbit_fraction (x : X) (bad : X → Prop) | |
| [DecidablePred bad] : | |
| average (fun g : G => if bad (g • x) then 1 else 0) = | |
| (((OrbitCounting.orbitSet (G := G) x).filter bad).card : ℝ) / | |
| (OrbitCounting.orbitSet (G := G) x).card := by | |
| rw [average_indicator_eq] | |
| exact OrbitCounting.bad_shift_fraction x bad | |
| end OrbitFractions | |
| end | |
| end MatrixMultiplication.PermutationMatching | |
| end OAI | |