openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Recovery /RecoverySupport.lean
| import Mathlib.Data.Finset.Card | |
| import Mathlib.Data.Fintype.BigOperators | |
| import Mathlib.Analysis.SpecialFunctions.Log.Basic | |
| import Mathlib.Tactic.Linarith | |
| import Mathlib.Tactic.NormNum | |
| import Mathlib.Tactic.Ring | |
| namespace OAI | |
| /-! Finite orbit symmetries, masks and exact recovery operations. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.RecoverySupport | |
| variable {K X Y Z : Type*} [Zero K] [Fintype X] [Fintype Y] [Fintype Z] | |
| def support (Q : X → Y → Z → K) : Finset (X × Y × Z) := by | |
| classical | |
| exact Finset.univ.filter fun p => Q p.1 p.2.1 p.2.2 ≠ 0 | |
| theorem support_card_le (Q : X → Y → Z → K) : | |
| (support Q).card ≤ Fintype.card X * Fintype.card Y * Fintype.card Z := by | |
| classical | |
| have h := Finset.card_filter_le (s := (Finset.univ : Finset (X × Y × Z))) | |
| (p := fun p => Q p.1 p.2.1 p.2.2 ≠ 0) | |
| simpa only [support, Finset.card_univ, Fintype.card_prod, Nat.mul_assoc] using h | |
| theorem support_card_le_exp (Q : X → Y → Z → K) {bX bY bZ : ℝ} (N : ℕ) | |
| (hX : (Fintype.card X : ℝ) ≤ Real.exp (bX * N)) | |
| (hY : (Fintype.card Y : ℝ) ≤ Real.exp (bY * N)) | |
| (hZ : (Fintype.card Z : ℝ) ≤ Real.exp (bZ * N)) : | |
| ((support Q).card : ℝ) ≤ Real.exp ((bX + bY + bZ) * N) := by | |
| have hcard : ((support Q).card : ℝ) ≤ | |
| (Fintype.card X : ℝ) * Fintype.card Y * Fintype.card Z := by | |
| exact_mod_cast support_card_le Q | |
| calc | |
| ((support Q).card : ℝ) ≤ | |
| (Fintype.card X : ℝ) * Fintype.card Y * Fintype.card Z := hcard | |
| _ ≤ (Real.exp (bX * N) * Real.exp (bY * N)) * Real.exp (bZ * N) := | |
| mul_le_mul (mul_le_mul hX hY (Nat.cast_nonneg _) (Real.exp_pos _).le) | |
| hZ (Nat.cast_nonneg _) (mul_nonneg (Real.exp_pos _).le (Real.exp_pos _).le) | |
| _ = Real.exp ((bX + bY + bZ) * N) := by | |
| rw [← Real.exp_add, ← Real.exp_add] | |
| congr 1 | |
| ring | |
| theorem word_card_eq_exp {d : ℕ} (hd : 0 < d) (a N : ℕ) : | |
| (Fintype.card (Fin (a * N) → Fin d) : ℝ) = | |
| Real.exp (((a : ℝ) * Real.log (d : ℝ)) * N) := by | |
| have hdr : 0 < (d : ℝ) := by exact_mod_cast hd | |
| simp only [Fintype.card_fun, Fintype.card_fin, Nat.cast_pow] | |
| calc | |
| (d : ℝ) ^ (a * N) = Real.exp (((a * N : ℕ) : ℝ) * Real.log (d : ℝ)) := by | |
| rw [Real.exp_nat_mul, Real.exp_log hdr] | |
| _ = Real.exp (((a : ℝ) * Real.log (d : ℝ)) * N) := by | |
| simp only [Nat.cast_mul] | |
| congr 1 | |
| ring | |
| theorem card_le_exp_of_word_embedding {d : ℕ} (hd : 0 < d) (a N : ℕ) | |
| (e : X ↪ (Fin (a * N) → Fin d)) : | |
| (Fintype.card X : ℝ) ≤ Real.exp (((a : ℝ) * Real.log (d : ℝ)) * N) := by | |
| rw [← word_card_eq_exp hd a N] | |
| exact_mod_cast Fintype.card_le_of_injective e e.injective | |
| theorem support_card_le_exp_of_word_embeddings (Q : X → Y → Z → K) | |
| {d : ℕ} (hd : 0 < d) (a N : ℕ) | |
| (ex : X ↪ (Fin (a * N) → Fin d)) | |
| (ey : Y ↪ (Fin (a * N) → Fin d)) | |
| (ez : Z ↪ (Fin (a * N) → Fin d)) : | |
| ((support Q).card : ℝ) ≤ Real.exp ((3 * (a : ℝ) * Real.log (d : ℝ)) * N) := by | |
| have h := support_card_le_exp Q N | |
| (card_le_exp_of_word_embedding hd a N ex) | |
| (card_le_exp_of_word_embedding hd a N ey) | |
| (card_le_exp_of_word_embedding hd a N ez) | |
| convert h using 1 | |
| congr 1 | |
| ring | |
| def cw5SupportRate (a : ℕ) : ℝ := 3 * (a : ℝ) * Real.log 7 + 1 | |
| theorem cw5SupportRate_pos (a : ℕ) : 0 < cw5SupportRate a := by | |
| have hlog : 0 ≤ Real.log 7 := Real.log_nonneg (by norm_num) | |
| have h := mul_nonneg (mul_nonneg (by norm_num : (0 : ℝ) ≤ 3) (Nat.cast_nonneg a)) hlog | |
| unfold cw5SupportRate | |
| linarith | |
| theorem cw5_support_card_le_exp (Q : X → Y → Z → K) (a N : ℕ) | |
| (ex : X ↪ (Fin (a * N) → Fin 7)) | |
| (ey : Y ↪ (Fin (a * N) → Fin 7)) | |
| (ez : Z ↪ (Fin (a * N) → Fin 7)) : | |
| ((support Q).card : ℝ) ≤ Real.exp (cw5SupportRate a * N) := by | |
| apply (support_card_le_exp_of_word_embeddings Q (by norm_num) a N ex ey ez).trans | |
| apply Real.exp_le_exp.mpr | |
| unfold cw5SupportRate | |
| simp only [Nat.cast_ofNat] | |
| exact mul_le_mul_of_nonneg_right (le_add_of_nonneg_right zero_le_one) (Nat.cast_nonneg N) | |
| end MatrixMultiplication.RecoverySupport | |
| end | |
| end OAI | |