openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /JointExtraction /EntropyMax.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ComplexEntropyContinuity | |
| import Mathlib.Tactic.Linarith | |
| namespace OAI | |
| /-! Joint tensor extraction, compatibility and entropy estimates. -/ | |
| noncomputable section | |
| open scoped BigOperators | |
| open MatrixMultiplication.Foundation | |
| namespace MatrixMultiplication.JointEntropyMax | |
| theorem entropy_nonneg {A : Type*} [Fintype A] (p : FiniteLaw A) : | |
| 0 ≤ finiteEntropy p.mass := | |
| FiniteLaw.entropy_nonneg p | |
| theorem map_entropy_le {A B : Type*} [Fintype A] [Fintype B] | |
| (p : FiniteLaw A) (f : A → B) : | |
| finiteEntropy (p.map f).mass ≤ finiteEntropy p.mass := | |
| FiniteLaw.map_entropy_le p f | |
| theorem entropy_sub_map_nonneg {A B : Type*} [Fintype A] [Fintype B] | |
| (p : FiniteLaw A) (f : A → B) : | |
| 0 ≤ finiteEntropy p.mass - finiteEntropy (p.map f).mass := | |
| sub_nonneg.mpr (map_entropy_le p f) | |
| theorem entropyTerm_le_crossEntropyTerm {p q : ℝ} (hp : 0 < p) (hq : 0 ≤ q) : | |
| entropyTerm q ≤ -q * Real.log p + p - q := by | |
| by_cases hzero : q = 0 | |
| · simpa [hzero] using hp.le | |
| have hqpos : 0 < q := lt_of_le_of_ne hq (Ne.symm hzero) | |
| have hlog := Real.log_le_sub_one_of_pos (div_pos hp hqpos) | |
| rw [Real.log_div hp.ne' hqpos.ne'] at hlog | |
| have hmul := mul_le_mul_of_nonneg_left hlog hq | |
| have hcancel : q * (p / q - 1) = p - q := by | |
| field_simp | |
| rw [hcancel] at hmul | |
| unfold entropyTerm | |
| linarith | |
| theorem entropy_le_crossEntropy {A : Type*} [Fintype A] | |
| (p q : FiniteLaw A) (hp : ∀ a, 0 < p.mass a) : | |
| finiteEntropy q.mass ≤ ∑ a, -q.mass a * Real.log (p.mass a) := by | |
| calc | |
| finiteEntropy q.mass ≤ | |
| ∑ a, (-q.mass a * Real.log (p.mass a) + p.mass a - q.mass a) := | |
| Finset.sum_le_sum fun a _ => entropyTerm_le_crossEntropyTerm (hp a) (q.nonneg a) | |
| _ = ∑ a, -q.mass a * Real.log (p.mass a) := by | |
| rw [Finset.sum_sub_distrib, Finset.sum_add_distrib, p.total, q.total] | |
| ring | |
| theorem sum_mass_mul_coordinate {A B : Type*} [Fintype A] [Fintype B] | |
| (p : FiniteLaw A) (f : A → B) (v : B → ℝ) : | |
| (∑ a, p.mass a * v (f a)) = ∑ b, (p.map f).mass b * v b := by | |
| classical | |
| simp_rw [FiniteLaw.map_mass, Finset.sum_mul, ite_mul, zero_mul] | |
| rw [Finset.sum_comm] | |
| simp | |
| theorem sum_mass_mul_coordinate_eq {A B : Type*} [Fintype A] [Fintype B] | |
| (p q : FiniteLaw A) (f : A → B) (v : B → ℝ) | |
| (hmarginal : (q.map f).mass = (p.map f).mass) : | |
| (∑ a, q.mass a * v (f a)) = ∑ a, p.mass a * v (f a) := by | |
| rw [sum_mass_mul_coordinate q f v, sum_mass_mul_coordinate p f v, hmarginal] | |
| theorem entropy_le_of_three_marginals | |
| {A X Y Z : Type*} [Fintype A] [Fintype X] [Fintype Y] [Fintype Z] | |
| (p q : FiniteLaw A) (fX : A → X) (fY : A → Y) (fZ : A → Z) | |
| (u : X → ℝ) (v : Y → ℝ) (w : Z → ℝ) (c : ℝ) | |
| (hp : ∀ a, 0 < p.mass a) | |
| (hlog : ∀ a, Real.log (p.mass a) = u (fX a) + v (fY a) + w (fZ a) - c) | |
| (hX : (q.map fX).mass = (p.map fX).mass) | |
| (hY : (q.map fY).mass = (p.map fY).mass) | |
| (hZ : (q.map fZ).mass = (p.map fZ).mass) : | |
| finiteEntropy q.mass ≤ finiteEntropy p.mass := by | |
| have hx := sum_mass_mul_coordinate_eq p q fX u hX | |
| have hy := sum_mass_mul_coordinate_eq p q fY v hY | |
| have hz := sum_mass_mul_coordinate_eq p q fZ w hZ | |
| have hexpand (r : FiniteLaw A) : | |
| (∑ a, r.mass a * (u (fX a) + v (fY a) + w (fZ a) - c)) = | |
| (∑ a, r.mass a * u (fX a)) + (∑ a, r.mass a * v (fY a)) + | |
| (∑ a, r.mass a * w (fZ a)) - c := by | |
| simp_rw [mul_sub, mul_add] | |
| rw [Finset.sum_sub_distrib, Finset.sum_add_distrib, Finset.sum_add_distrib, | |
| ← Finset.sum_mul, r.total, one_mul] | |
| have hexpect : (∑ a, q.mass a * Real.log (p.mass a)) = | |
| ∑ a, p.mass a * Real.log (p.mass a) := by | |
| simp_rw [hlog] | |
| rw [hexpand q, hexpand p, hx, hy, hz] | |
| calc | |
| finiteEntropy q.mass ≤ ∑ a, -q.mass a * Real.log (p.mass a) := | |
| entropy_le_crossEntropy p q hp | |
| _ = -(∑ a, q.mass a * Real.log (p.mass a)) := by | |
| simp only [neg_mul, Finset.sum_neg_distrib] | |
| _ = -(∑ a, p.mass a * Real.log (p.mass a)) := by rw [hexpect] | |
| _ = finiteEntropy p.mass := by | |
| simp only [finiteEntropy, entropyTerm, neg_mul, Finset.sum_neg_distrib] | |
| def normalizedPositiveLaw {A : Type*} [Fintype A] [Nonempty A] | |
| (weight : A → ℝ) (hweight : ∀ a, 0 < weight a) : FiniteLaw A where | |
| mass a := weight a / ∑ b, weight b | |
| nonneg a := div_nonneg (hweight a).le | |
| (Finset.sum_nonneg fun b _ => (hweight b).le) | |
| total := by | |
| have htotal : 0 < ∑ b, weight b := | |
| Finset.sum_pos (fun b _ => hweight b) Finset.univ_nonempty | |
| rw [← Finset.sum_div, div_self htotal.ne'] | |
| theorem normalizedPositiveLaw_mass_pos {A : Type*} [Fintype A] [Nonempty A] | |
| (weight : A → ℝ) (hweight : ∀ a, 0 < weight a) (a : A) : | |
| 0 < (normalizedPositiveLaw weight hweight).mass a := by | |
| exact div_pos (hweight a) | |
| (Finset.sum_pos (fun b _ => hweight b) Finset.univ_nonempty) | |
| theorem entropy_le_normalized_product | |
| {A X Y Z : Type*} [Fintype A] [Nonempty A] | |
| [Fintype X] [Fintype Y] [Fintype Z] | |
| (fX : A → X) (fY : A → Y) (fZ : A → Z) | |
| (wx : X → ℝ) (wy : Y → ℝ) (wz : Z → ℝ) | |
| (hx : ∀ x, 0 < wx x) (hy : ∀ y, 0 < wy y) (hz : ∀ z, 0 < wz z) | |
| (q : FiniteLaw A) | |
| (hX : (q.map fX).mass = | |
| ((normalizedPositiveLaw (fun a => wx (fX a) * wy (fY a) * wz (fZ a)) | |
| (fun _ => mul_pos (mul_pos (hx _) (hy _)) (hz _))).map fX).mass) | |
| (hY : (q.map fY).mass = | |
| ((normalizedPositiveLaw (fun a => wx (fX a) * wy (fY a) * wz (fZ a)) | |
| (fun _ => mul_pos (mul_pos (hx _) (hy _)) (hz _))).map fY).mass) | |
| (hZ : (q.map fZ).mass = | |
| ((normalizedPositiveLaw (fun a => wx (fX a) * wy (fY a) * wz (fZ a)) | |
| (fun _ => mul_pos (mul_pos (hx _) (hy _)) (hz _))).map fZ).mass) : | |
| finiteEntropy q.mass ≤ | |
| finiteEntropy (normalizedPositiveLaw | |
| (fun a => wx (fX a) * wy (fY a) * wz (fZ a)) | |
| (fun _ => mul_pos (mul_pos (hx _) (hy _)) (hz _))).mass := by | |
| let weight : A → ℝ := fun a => wx (fX a) * wy (fY a) * wz (fZ a) | |
| have hweight : ∀ a, 0 < weight a := fun a => mul_pos (mul_pos (hx _) (hy _)) (hz _) | |
| let p := normalizedPositiveLaw weight hweight | |
| have htotal : 0 < ∑ a, weight a := | |
| Finset.sum_pos (fun a _ => hweight a) Finset.univ_nonempty | |
| apply entropy_le_of_three_marginals p q fX fY fZ | |
| (fun x => Real.log (wx x)) (fun y => Real.log (wy y)) | |
| (fun z => Real.log (wz z)) (Real.log (∑ a, weight a)) | |
| (normalizedPositiveLaw_mass_pos weight hweight) | |
| · intro a | |
| change Real.log (weight a / ∑ b, weight b) = _ | |
| rw [Real.log_div (hweight a).ne' htotal.ne'] | |
| dsimp only [weight] | |
| rw [Real.log_mul (mul_pos (hx _) (hy _)).ne' (hz _).ne', | |
| Real.log_mul (hx _).ne' (hy _).ne'] | |
| · exact hX | |
| · exact hY | |
| · exact hZ | |
| end MatrixMultiplication.JointEntropyMax | |
| end | |
| end OAI | |