openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /JointExtraction /GibbsApproximation.lean
| import OAI.LinearAlgebra.MatrixMultiplication.JointExtraction.EntropyMax | |
| namespace OAI | |
| /-! Joint tensor extraction, compatibility and entropy estimates. -/ | |
| noncomputable section | |
| open scoped BigOperators Topology | |
| open Filter MatrixMultiplication.Foundation | |
| open MatrixMultiplication.JointEntropyMax | |
| namespace MatrixMultiplication.JointGibbsApproximation | |
| def marginalError {A B : Type*} [Fintype A] [Fintype B] | |
| (p q : FiniteLaw A) (f : A → B) (v : B → ℝ) : ℝ := | |
| ∑ b, |(q.map f).mass b - (p.map f).mass b| * |v b| | |
| theorem marginalError_nonneg {A B : Type*} [Fintype A] [Fintype B] | |
| (p q : FiniteLaw A) (f : A → B) (v : B → ℝ) : | |
| 0 ≤ marginalError p q f v := | |
| Finset.sum_nonneg fun _ _ => mul_nonneg (abs_nonneg _) (abs_nonneg _) | |
| theorem entropy_le_crossEntropy_of_support {A : Type*} [Fintype A] | |
| (p q : FiniteLaw A) (hsupport : ∀ a, p.mass a = 0 → q.mass a = 0) : | |
| finiteEntropy q.mass ≤ ∑ a, -q.mass a * Real.log (p.mass a) := by | |
| have hterm (a : A) : | |
| entropyTerm (q.mass a) ≤ -q.mass a * Real.log (p.mass a) + p.mass a - q.mass a := by | |
| by_cases hp : p.mass a = 0 | |
| · simp [hp, hsupport a hp] | |
| · exact entropyTerm_le_crossEntropyTerm | |
| (lt_of_le_of_ne (p.nonneg a) (Ne.symm hp)) (q.nonneg a) | |
| 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 _ => hterm 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 | |
| private theorem potential_difference_le {A B : Type*} [Fintype A] [Fintype B] | |
| (p q : FiniteLaw A) (f : A → B) (v : B → ℝ) : | |
| (∑ a, p.mass a * v (f a)) - (∑ a, q.mass a * v (f a)) ≤ | |
| marginalError p q f v := by | |
| rw [sum_mass_mul_coordinate p f v, sum_mass_mul_coordinate q f v, | |
| ← Finset.sum_sub_distrib] | |
| apply Finset.sum_le_sum | |
| intro b _ | |
| calc | |
| (p.map f).mass b * v b - (q.map f).mass b * v b = | |
| ((p.map f).mass b - (q.map f).mass b) * v b := by ring | |
| _ ≤ |((p.map f).mass b - (q.map f).mass b) * v b| := le_abs_self _ | |
| _ = |(q.map f).mass b - (p.map f).mass b| * |v b| := by | |
| rw [abs_mul, abs_sub_comm] | |
| theorem entropy_le_of_marginal_errors_of_support | |
| {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 : ℝ) | |
| (hsupport : ∀ a, p.mass a = 0 → q.mass a = 0) | |
| (hlog : ∀ a, 0 < p.mass a → | |
| Real.log (p.mass a) = u (fX a) + v (fY a) + w (fZ a) - c) : | |
| finiteEntropy q.mass ≤ finiteEntropy p.mass + | |
| marginalError p q fX u + marginalError p q fY v + marginalError p q fZ w := by | |
| have hexpand (r : FiniteLaw A) (hr : ∀ a, p.mass a = 0 → r.mass a = 0) : | |
| (∑ a, r.mass a * Real.log (p.mass a)) = | |
| (∑ a, r.mass a * u (fX a)) + (∑ a, r.mass a * v (fY a)) + | |
| (∑ a, r.mass a * w (fZ a)) - c := by | |
| have hterm (a : A) : r.mass a * Real.log (p.mass a) = | |
| r.mass a * (u (fX a) + v (fY a) + w (fZ a) - c) := by | |
| by_cases hp : p.mass a = 0 | |
| · simp [hr a hp] | |
| · rw [hlog a (lt_of_le_of_ne (p.nonneg a) (Ne.symm hp))] | |
| simp_rw [hterm, 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 hcross : (∑ a, -q.mass a * Real.log (p.mass a)) = | |
| finiteEntropy p.mass + | |
| ((∑ a, p.mass a * u (fX a)) - (∑ a, q.mass a * u (fX a))) + | |
| ((∑ a, p.mass a * v (fY a)) - (∑ a, q.mass a * v (fY a))) + | |
| ((∑ a, p.mass a * w (fZ a)) - (∑ a, q.mass a * w (fZ a))) := by | |
| have hp : finiteEntropy p.mass = -(∑ a, p.mass a * Real.log (p.mass a)) := by | |
| simp only [finiteEntropy, entropyTerm, neg_mul, Finset.sum_neg_distrib] | |
| simp only [neg_mul, Finset.sum_neg_distrib] | |
| rw [hp, hexpand p (fun _ h => h), hexpand q hsupport] | |
| ring | |
| calc | |
| finiteEntropy q.mass ≤ ∑ a, -q.mass a * Real.log (p.mass a) := | |
| entropy_le_crossEntropy_of_support p q hsupport | |
| _ = _ := hcross | |
| _ ≤ _ := add_le_add | |
| (add_le_add (add_le_add_right (potential_difference_le p q fX u) _) | |
| (potential_difference_le p q fY v)) (potential_difference_le p q fZ w) | |
| theorem entropy_le_of_marginal_errors | |
| {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) : | |
| finiteEntropy q.mass ≤ finiteEntropy p.mass + | |
| marginalError p q fX u + marginalError p q fY v + marginalError p q fZ w := | |
| entropy_le_of_marginal_errors_of_support p q fX fY fZ u v w c | |
| (fun a h => ((hp a).ne' h).elim) (fun a _ => hlog a) | |
| theorem tendsto_map_mass {I A B : Type*} [Fintype A] [Fintype B] | |
| {l : Filter I} {pN : I → FiniteLaw A} {p : FiniteLaw A} | |
| (h : ∀ a, Tendsto (fun n => (pN n).mass a) l (𝓝 (p.mass a))) | |
| (f : A → B) (b : B) : | |
| Tendsto (fun n => ((pN n).map f).mass b) l (𝓝 ((p.map f).mass b)) := by | |
| classical | |
| simp_rw [FiniteLaw.map_mass] | |
| apply tendsto_finsetSum | |
| intro a _ | |
| by_cases hab : f a = b | |
| · simpa only [hab, ite_true] using h a | |
| · simp only [hab, ite_false] | |
| exact tendsto_const_nhds | |
| theorem tendsto_marginalError {I A B : Type*} [Fintype A] [Fintype B] | |
| {l : Filter I} {pN : I → FiniteLaw A} {p : FiniteLaw A} | |
| (h : ∀ a, Tendsto (fun n => (pN n).mass a) l (𝓝 (p.mass a))) | |
| (f : A → B) (v : B → ℝ) : | |
| Tendsto (fun n => marginalError p (pN n) f v) l (𝓝 0) := by | |
| have hterm (b : B) : | |
| Tendsto (fun n => |((pN n).map f).mass b - (p.map f).mass b| * |v b|) | |
| l (𝓝 0) := by | |
| have hconst : Tendsto (fun _ : I => (p.map f).mass b) l | |
| (𝓝 ((p.map f).mass b)) := tendsto_const_nhds | |
| simpa only [sub_self, abs_zero, zero_mul] using | |
| ((tendsto_map_mass h f b).sub hconst).abs.mul_const |v b| | |
| simpa only [marginalError, Finset.sum_const_zero] using | |
| tendsto_finsetSum Finset.univ (fun b _ => hterm b) | |
| theorem eventually_entropy_le_of_tendsto_of_support | |
| {I A X Y Z : Type*} [Fintype A] [Fintype X] [Fintype Y] [Fintype Z] | |
| {l : Filter I} (p : FiniteLaw A) (pN : I → FiniteLaw A) | |
| (fX : A → X) (fY : A → Y) (fZ : A → Z) | |
| (u : X → ℝ) (v : Y → ℝ) (w : Z → ℝ) (c : ℝ) | |
| (hlog : ∀ a, 0 < p.mass a → | |
| Real.log (p.mass a) = u (fX a) + v (fY a) + w (fZ a) - c) | |
| (hN : ∀ a, Tendsto (fun n => (pN n).mass a) l (𝓝 (p.mass a))) | |
| {η : ℝ} (hη : 0 < η) : | |
| ∀ᶠ n in l, ∀ q : FiniteLaw A, | |
| (∀ a, p.mass a = 0 → q.mass a = 0) → | |
| (q.map fX).mass = ((pN n).map fX).mass → | |
| (q.map fY).mass = ((pN n).map fY).mass → | |
| (q.map fZ).mass = ((pN n).map fZ).mass → | |
| finiteEntropy q.mass ≤ finiteEntropy p.mass + η := by | |
| have herror : Tendsto (fun n => marginalError p (pN n) fX u + | |
| marginalError p (pN n) fY v + marginalError p (pN n) fZ w) l (𝓝 0) := by | |
| simpa only [add_zero] using | |
| ((tendsto_marginalError hN fX u).add (tendsto_marginalError hN fY v)).add | |
| (tendsto_marginalError hN fZ w) | |
| have hsmall := herror.eventually (gt_mem_nhds hη) | |
| filter_upwards [hsmall] with n hn | |
| intro q hs hX hY hZ | |
| have hbound := entropy_le_of_marginal_errors_of_support p q fX fY fZ u v w c hs hlog | |
| have hx : marginalError p q fX u = marginalError p (pN n) fX u := by | |
| unfold marginalError | |
| rw [hX] | |
| have hy : marginalError p q fY v = marginalError p (pN n) fY v := by | |
| unfold marginalError | |
| rw [hY] | |
| have hz : marginalError p q fZ w = marginalError p (pN n) fZ w := by | |
| unfold marginalError | |
| rw [hZ] | |
| rw [hx, hy, hz] at hbound | |
| linarith | |
| theorem eventually_entropy_le_of_tendsto | |
| {I A X Y Z : Type*} [Fintype A] [Fintype X] [Fintype Y] [Fintype Z] | |
| {l : Filter I} (p : FiniteLaw A) (pN : I → 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) | |
| (hN : ∀ a, Tendsto (fun n => (pN n).mass a) l (𝓝 (p.mass a))) | |
| {η : ℝ} (hη : 0 < η) : | |
| ∀ᶠ n in l, ∀ q : FiniteLaw A, | |
| (q.map fX).mass = ((pN n).map fX).mass → | |
| (q.map fY).mass = ((pN n).map fY).mass → | |
| (q.map fZ).mass = ((pN n).map fZ).mass → | |
| finiteEntropy q.mass ≤ finiteEntropy p.mass + η := by | |
| filter_upwards [eventually_entropy_le_of_tendsto_of_support p pN fX fY fZ u v w c | |
| (fun a _ => hlog a) hN hη] with n hn | |
| intro q hX hY hZ | |
| exact hn q (fun a h => ((hp a).ne' h).elim) hX hY hZ | |
| end MatrixMultiplication.JointGibbsApproximation | |
| end | |
| end OAI | |