Download data/lean/OAI/LinearAlgebra/MatrixMultiplication/Entropy/FiniteAverage.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 9.35 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/Entropy/FiniteAverage.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/LinearAlgebra/MatrixMultiplication/Entropy/FiniteAverage.lean
-
curl -L -o FiniteAverage.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixMultiplication/Entropy/FiniteAverage.lean
9.35 kB
| import Mathlib.Basic.Real.Basic | |
| import Mathlib.Data.Fintype.BigOperators | |
| import Mathlib.Data.Fintype.Pi | |
| import Mathlib.Logic.Equiv.Prod | |
| import Mathlib.Algebra.BigOperators.Ring.Finset | |
| import Mathlib.Algebra.Order.BigOperators.Group.Finset | |
| import Mathlib.Tactic.Ring | |
| import Mathlib.Tactic.Positivity | |
| import Mathlib.Tactic.Linarith | |
| namespace OAI | |
| /-! Finite entropy, rate estimates and ordered asymptotic limits. -/ | |
| namespace MatrixMultiplication.PermutationMatching | |
| open scoped BigOperators | |
| open Classical | |
| noncomputable section | |
| variable {Ξ© Ξ : Type*} [Fintype Ξ©] [Fintype Ξ] | |
| def average (f : Ξ© β β) : β := (β Ο, f Ο) / Fintype.card Ξ© | |
| theorem average_congr {f g : Ξ© β β} (h : β Ο, f Ο = g Ο) : | |
| average f = average g := by | |
| unfold average | |
| congr 1 | |
| exact Finset.sum_congr rfl (fun Ο _ => h Ο) | |
| @[simp] theorem average_const [Nonempty Ξ©] (c : β) : | |
| average (fun _ : Ξ© => c) = c := by | |
| have hcard : (Fintype.card Ξ© : β) β 0 := by | |
| exact_mod_cast Fintype.card_ne_zero | |
| simp [average, hcard] | |
| @[simp] theorem average_zero : average (fun _ : Ξ© => (0 : β)) = 0 := by | |
| simp [average] | |
| theorem average_add (f g : Ξ© β β) : | |
| average (fun Ο => f Ο + g Ο) = average f + average g := by | |
| simp [average, Finset.sum_add_distrib, add_div] | |
| theorem average_sub (f g : Ξ© β β) : | |
| average (fun Ο => f Ο - g Ο) = average f - average g := by | |
| simp [average, Finset.sum_sub_distrib, sub_div] | |
| theorem average_mul_const (f : Ξ© β β) (c : β) : | |
| average (fun Ο => f Ο * c) = average f * c := by | |
| simp only [average, β Finset.sum_mul] | |
| ring | |
| theorem average_const_mul (c : β) (f : Ξ© β β) : | |
| average (fun Ο => c * f Ο) = c * average f := by | |
| simp only [average, β Finset.mul_sum] | |
| ring | |
| theorem average_finset_sum {I : Type*} (s : Finset I) (f : I β Ξ© β β) : | |
| average (fun Ο => β i β s, f i Ο) = β i β s, average (f i) := by | |
| unfold average | |
| rw [Finset.sum_comm] | |
| simp only [div_eq_mul_inv, Finset.sum_mul] | |
| theorem average_sum {I : Type*} (s : Finset I) (f : Ξ© β I β β) : | |
| average (fun Ο => β i β s, f Ο i) = β i β s, average (fun Ο => f Ο i) := | |
| average_finset_sum s (fun i Ο => f Ο i) | |
| theorem average_nonneg {f : Ξ© β β} (h : β Ο, 0 β€ f Ο) : 0 β€ average f := by | |
| exact div_nonneg (Finset.sum_nonneg (fun Ο _ => h Ο)) (Nat.cast_nonneg _) | |
| theorem average_mono {f g : Ξ© β β} (h : β Ο, f Ο β€ g Ο) : | |
| average f β€ average g := by | |
| exact div_le_div_of_nonneg_right (Finset.sum_le_sum (fun Ο _ => h Ο)) | |
| (Nat.cast_nonneg _) | |
| theorem average_indicator_eq (P : Ξ© β Prop) [DecidablePred P] : | |
| average (fun Ο => if P Ο then (1 : β) else 0) = | |
| ((Finset.univ.filter P).card : β) / (Fintype.card Ξ© : β) := by | |
| simp [average] | |
| theorem average_equiv (e : Ξ© β Ξ) (f : Ξ β β) : | |
| average (fun Ο => f (e Ο)) = average f := by | |
| unfold average | |
| rw [Fintype.card_congr e, e.sum_comp] | |
| theorem average_prod (f : Ξ© β β) (g : Ξ β β) : | |
| average (fun p : Ξ© Γ Ξ => f p.1 * g p.2) = average f * average g := by | |
| simp only [average, Fintype.sum_prod_type, Fintype.card_prod, Nat.cast_mul, | |
| β Finset.mul_sum, β Finset.sum_mul] | |
| exact mul_div_mul_comm _ _ _ _ | |
| theorem average_prod_average (f : Ξ© Γ Ξ β β) : | |
| average f = average (fun Ο => average (fun Ξ³ => f (Ο, Ξ³))) := by | |
| simp only [average, Fintype.sum_prod_type, Fintype.card_prod, Nat.cast_mul, | |
| div_eq_mul_inv, β Finset.sum_mul, mul_inv_rev] | |
| ring | |
| @[simp] theorem average_prod_fst [Nonempty Ξ] (f : Ξ© β β) : | |
| average (fun p : Ξ© Γ Ξ => f p.1) = average f := by | |
| simpa using average_prod f (fun _ : Ξ => (1 : β)) | |
| @[simp] theorem average_prod_snd [Nonempty Ξ©] (g : Ξ β β) : | |
| average (fun p : Ξ© Γ Ξ => g p.2) = average g := by | |
| simpa using average_prod (fun _ : Ξ© => (1 : β)) g | |
| theorem average_centered_sq [Nonempty Ξ©] (f : Ξ© β β) : | |
| average (fun Ο => (f Ο - average f) ^ 2) = | |
| average (fun Ο => f Ο ^ 2) - (average f) ^ 2 := by | |
| calc | |
| average (fun Ο => (f Ο - average f) ^ 2) = | |
| average (fun Ο => f Ο ^ 2 - (2 * average f) * f Ο + (average f) ^ 2) := by | |
| apply average_congr | |
| intro Ο | |
| ring | |
| _ = _ := by rw [average_add, average_sub, average_const_mul, average_const]; ring | |
| section Coordinates | |
| variable {I : Type*} [Fintype I] [DecidableEq I] {X : I β Type*} | |
| [β i, Fintype (X i)] [β i, Nonempty (X i)] | |
| theorem average_pi_eval (i : I) (f : X i β β) : | |
| average (fun Ο : β i, X i => f (Ο i)) = average f := by | |
| classical | |
| change average (fun Ο => (fun p : X i Γ (β j : {j // j β i}, X j) => f p.1) | |
| ((Equiv.piSplitAt i X) Ο)) = average f | |
| rw [average_equiv (Equiv.piSplitAt i X) | |
| (fun p : X i Γ (β j : {j // j β i}, X j) => f p.1), average_prod_fst] | |
| theorem average_pi_restrict (D : Finset I) (f : (β i : {i // i β D}, X i) β β) : | |
| average (fun Ο : β i, X i => f (fun i => Ο i)) = average f := by | |
| classical | |
| change average (fun Ο => | |
| (fun p : (β i : {i // i β D}, X i) Γ (β i : {i // i β D}, X i) => f p.1) | |
| ((Equiv.piEquivPiSubtypeProd (fun i => i β D) X) Ο)) = average f | |
| rw [average_equiv (Equiv.piEquivPiSubtypeProd (fun i => i β D) X) | |
| (fun p : (β i : {i // i β D}, X i) Γ (β i : {i // i β D}, X i) => f p.1), | |
| average_prod_fst] | |
| theorem average_prod_pi_restrict (D : Finset I) | |
| (f : ((β i : {i // i β D}, X i) Γ (β i : {i // i β D}, X i)) β β) : | |
| average (fun p : (β i, X i) Γ (β i, X i) => | |
| f ((fun i => p.1 i), (fun i => p.2 i))) = average f := by | |
| classical | |
| rw [average_prod_average] | |
| calc | |
| _ = average (fun x : β i, X i => | |
| average (fun y : β i : {i // i β D}, X i => f ((fun i => x i), y))) := by | |
| apply average_congr | |
| intro x | |
| exact average_pi_restrict D (fun y => f ((fun i => x i), y)) | |
| _ = average (fun x : β i : {i // i β D}, X i => average (fun y => f (x, y))) := | |
| average_pi_restrict D (fun x => average (fun y => f (x, y))) | |
| _ = average f := (average_prod_average f).symm | |
| theorem average_pi_eval_mul (i j : I) (hij : i β j) (f : X i β β) (g : X j β β) : | |
| average (fun Ο : β i, X i => f (Ο i) * g (Ο j)) = average f * average g := by | |
| classical | |
| change average (fun Ο => | |
| (fun p : X i Γ (β k : {k // k β i}, X k) => | |
| f p.1 * g (p.2 β¨j, Ne.symm hijβ©)) ((Equiv.piSplitAt i X) Ο)) = _ | |
| rw [average_equiv (Equiv.piSplitAt i X) | |
| (fun p : X i Γ (β k : {k // k β i}, X k) => | |
| f p.1 * g (p.2 β¨j, Ne.symm hijβ©)), | |
| average_prod f (fun k : β k : {k // k β i}, X k => g (k β¨j, Ne.symm hijβ©))] | |
| exact congrArg (fun t => average f * t) | |
| (average_pi_eval (X := fun k : {k // k β i} => X k) β¨j, Ne.symm hijβ© g) | |
| theorem average_pi_sum_centered_sq (f : β i, X i β β) : | |
| average (fun Ο : β i, X i => (β i, (f i (Ο i) - average (f i))) ^ 2) = | |
| β i, average (fun x => (f i x - average (f i)) ^ 2) := by | |
| classical | |
| let c : β i, X i β β := fun i x => f i x - average (f i) | |
| have hc (i : I) : average (c i) = 0 := by | |
| simp [c, average_sub] | |
| change average (fun Ο : β i, X i => (β i, c i (Ο i)) ^ 2) = | |
| β i, average (fun x => (c i x) ^ 2) | |
| calc | |
| _ = β i, β j, average (fun Ο : β i, X i => c i (Ο i) * c j (Ο j)) := by | |
| simp only [pow_two, Finset.sum_mul, Finset.mul_sum, average_finset_sum] | |
| exact Finset.sum_comm | |
| _ = _ := by | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| calc | |
| (β j, average (fun Ο : β i, X i => c i (Ο i) * c j (Ο j))) = | |
| average (fun Ο : β i, X i => c i (Ο i) * c i (Ο i)) := by | |
| apply Finset.sum_eq_single i | |
| Β· intro j hj hji | |
| rw [average_pi_eval_mul i j (Ne.symm hji), hc, hc, zero_mul] | |
| Β· simp | |
| _ = average (fun x => (c i x) ^ 2) := by | |
| simp only [pow_two] | |
| exact average_pi_eval i (fun x => c i x * c i x) | |
| end Coordinates | |
| theorem deviation_bound (f : Ξ© β β) (ΞΌ Ξ΄ : β) (hΞ΄ : 0 < Ξ΄) : | |
| average (fun Ο => if Ξ΄ β€ |f Ο - ΞΌ| then (1 : β) else 0) * Ξ΄ ^ 2 β€ | |
| average (fun Ο => (f Ο - ΞΌ) ^ 2) := by | |
| rw [β average_mul_const] | |
| apply average_mono | |
| intro Ο | |
| split_ifs with h | |
| Β· simp only [one_mul] | |
| have hh := (sq_le_sqβ (le_of_lt hΞ΄) (abs_nonneg (f Ο - ΞΌ))).2 h | |
| simpa only [sq_abs] using hh | |
| Β· simp only [zero_mul] | |
| exact sq_nonneg _ | |
| theorem average_indicator_exists_le_sum {I : Type*} [Fintype I] | |
| (P : I β Ξ© β Prop) [β i Ο, Decidable (P i Ο)] : | |
| average (fun Ο => if β i, P i Ο then (1 : β) else 0) β€ | |
| β i, average (fun Ο => if P i Ο then (1 : β) else 0) := by | |
| classical | |
| rw [β average_finset_sum] | |
| apply average_mono | |
| intro Ο | |
| by_cases h : β i, P i Ο | |
| Β· rw [ite_eq_left h] | |
| obtain β¨i, hiβ© := h | |
| calc | |
| (1 : β) = (if P i Ο then (1 : β) else 0) := by simp [hi] | |
| _ β€ β j, if P j Ο then (1 : β) else 0 := | |
| Finset.single_le_sum (f := fun j => if P j Ο then (1 : β) else 0) | |
| (fun j _ => by split_ifs <;> norm_num) (Finset.mem_univ i) | |
| Β· rw [ite_eq_right h] | |
| exact Finset.sum_nonneg (fun i _ => by split_ifs <;> norm_num) | |
| end | |
| end MatrixMultiplication.PermutationMatching | |
| end OAI | |