File size: 7,248 Bytes
cdec422 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 | import OAI.LinearAlgebra.MatrixMultiplication.Entropy.ComplexFiniteEntropy
import Mathlib.Analysis.SpecialFunctions.Log.NegMulLog
import Mathlib.Analysis.Convex.Jensen
namespace OAI
/-! Finite entropy, rate estimates and ordered asymptotic limits. -/
noncomputable section
open scoped Topology
open Filter
namespace MatrixMultiplication.Foundation
theorem entropyTerm_eq_negMulLog (p : ℝ) : entropyTerm p = Real.negMulLog p := rfl
@[simp] theorem entropyTerm_one : entropyTerm 1 = 0 := by simp [entropyTerm]
theorem mul_entropyTerm_inv (x : ℝ) : x * entropyTerm x⁻¹ = Real.log x := by
by_cases hx : x = 0
· simp [hx]
· simp only [entropyTerm, Real.log_inv]
calc
_ = (x * x⁻¹) * Real.log x := by ring
_ = Real.log x := by rw [mul_inv_cancel₀ hx, one_mul]
theorem finiteEntropy_uniform {A : Type*} [Fintype A] :
finiteEntropy (fun _a : A => (Fintype.card A : ℝ)⁻¹) =
Real.log (Fintype.card A) := by
simp only [finiteEntropy, Finset.sum_const, Finset.card_univ, nsmul_eq_mul]
exact mul_entropyTerm_inv (Fintype.card A)
theorem finiteEntropy_deterministic {A : Type*} [Fintype A] [DecidableEq A]
(a : A) : finiteEntropy (fun b => if b = a then 1 else 0) = 0 := by
apply Finset.sum_eq_zero
intro b hb
change entropyTerm (if b = a then 1 else 0) = 0
split_ifs <;> simp
@[fun_prop] theorem continuous_entropyTerm : Continuous entropyTerm :=
Real.continuous_negMulLog
theorem entropyTerm_nonneg {p : ℝ} (hp₀ : 0 ≤ p) (hp₁ : p ≤ 1) :
0 ≤ entropyTerm p :=
Real.negMulLog_nonneg hp₀ hp₁
theorem concaveOn_entropyTerm : ConcaveOn ℝ (Set.Ici 0) entropyTerm :=
Real.concaveOn_negMulLog
@[fun_prop] theorem continuous_finiteEntropy {A : Type*} [Fintype A] :
Continuous (finiteEntropy : (A → ℝ) → ℝ) := by
unfold finiteEntropy
exact continuous_finsetSum _ fun value _ =>
continuous_entropyTerm.comp (continuous_apply value)
theorem tendsto_entropyTerm {I : Type*} {l : Filter I} {p : I → ℝ} {q : ℝ}
(h : Tendsto p l (𝓝 q)) :
Tendsto (fun i => entropyTerm (p i)) l (𝓝 (entropyTerm q)) :=
continuous_entropyTerm.continuousAt.tendsto.comp h
theorem tendsto_entropyTerm_zero {I : Type*} {l : Filter I} {p : I → ℝ}
(h : Tendsto p l (𝓝 0)) :
Tendsto (fun i => entropyTerm (p i)) l (𝓝 0) := by
simpa only [entropyTerm_zero] using tendsto_entropyTerm h
theorem tendsto_finiteEntropy_of_tendsto {I A : Type*} [Fintype A]
{l : Filter I} {p : I → A → ℝ} {q : A → ℝ}
(h : ∀ a, Tendsto (fun i => p i a) l (𝓝 (q a))) :
Tendsto (fun i => finiteEntropy (p i)) l (𝓝 (finiteEntropy q)) :=
continuous_finiteEntropy.continuousAt.tendsto.comp (tendsto_pi_nhds.mpr h)
theorem finiteEntropy_nonneg {A : Type*} [Fintype A] (p : A → ℝ)
(hp₀ : ∀ a, 0 ≤ p a) (hp₁ : ∀ a, p a ≤ 1) : 0 ≤ finiteEntropy p := by
exact Finset.sum_nonneg fun a _ => entropyTerm_nonneg (hp₀ a) (hp₁ a)
theorem finiteEntropy_mix_le {A : Type*} [Fintype A] (p q : A → ℝ)
(hp : ∀ i, 0 ≤ p i) (hq : ∀ i, 0 ≤ q i)
{a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a + b = 1) :
a * finiteEntropy p + b * finiteEntropy q ≤
finiteEntropy (fun i => a * p i + b * q i) := by
calc
a * finiteEntropy p + b * finiteEntropy q =
∑ i, (a * entropyTerm (p i) + b * entropyTerm (q i)) := by
simp only [finiteEntropy, Finset.sum_add_distrib, ← Finset.mul_sum]
_ ≤ finiteEntropy (fun i => a * p i + b * q i) := by
apply Finset.sum_le_sum
intro i hi
exact concaveOn_entropyTerm.2 (hp i) (hq i) ha hb hab
theorem finiteEntropy_le_log_card {A : Type*} [Fintype A] (p : A → ℝ)
(hp : ∀ a, 0 ≤ p a) (htotal : ∑ a, p a = 1) :
finiteEntropy p ≤ Real.log (Fintype.card A) := by
classical
have hcard : 0 < Fintype.card A := by
by_contra h
have : IsEmpty A := Fintype.card_eq_zero_iff.mp (Nat.eq_zero_of_not_pos h)
simp at htotal
have hn : (0 : ℝ) < Fintype.card A := Nat.cast_pos.mpr hcard
have hw : ∑ _a : A, (Fintype.card A : ℝ)⁻¹ = 1 := by
simp [Finset.sum_const, nsmul_eq_mul, hn.ne']
have hJ := concaveOn_entropyTerm.le_map_sum
(t := (Finset.univ : Finset A))
(w := fun _a : A => (Fintype.card A : ℝ)⁻¹) (p := p)
(fun _a _ha => (inv_pos.mpr hn).le) hw (fun a _ha => hp a)
have hJ' : (Fintype.card A : ℝ)⁻¹ * finiteEntropy p ≤
entropyTerm (Fintype.card A : ℝ)⁻¹ := by
simpa only [smul_eq_mul, ← Finset.mul_sum, htotal, mul_one, finiteEntropy] using hJ
calc
finiteEntropy p = (Fintype.card A : ℝ) *
((Fintype.card A : ℝ)⁻¹ * finiteEntropy p) := by
rw [← mul_assoc, mul_inv_cancel₀ hn.ne', one_mul]
_ ≤ (Fintype.card A : ℝ) * entropyTerm (Fintype.card A : ℝ)⁻¹ :=
mul_le_mul_of_nonneg_left hJ' hn.le
_ = Real.log (Fintype.card A) := mul_entropyTerm_inv (Fintype.card A)
namespace FiniteLaw
variable {A : Type*} [Fintype A]
def uniform (A : Type*) [Fintype A] [Nonempty A] : FiniteLaw A where
mass _a := (Fintype.card A : ℝ)⁻¹
nonneg _a := inv_nonneg.mpr (Nat.cast_nonneg _)
total := by
have hn : (Fintype.card A : ℝ) ≠ 0 :=
(Nat.cast_pos.mpr (Fintype.card_pos : 0 < Fintype.card A)).ne'
simp [Finset.sum_const, nsmul_eq_mul, hn]
@[simp] theorem uniform_mass [Nonempty A] (a : A) :
(uniform A).mass a = (Fintype.card A : ℝ)⁻¹ := rfl
@[simp] theorem uniform_entropy [Nonempty A] :
finiteEntropy (uniform A).mass = Real.log (Fintype.card A) :=
finiteEntropy_uniform
def pure (a : A) : FiniteLaw A := by
classical
exact
{ mass := fun b => if b = a then 1 else 0
nonneg := fun b => by split_ifs <;> norm_num
total := by simp }
@[simp] theorem pure_entropy (a : A) : finiteEntropy (pure a).mass = 0 := by
classical
exact finiteEntropy_deterministic a
theorem mass_le_one (p : FiniteLaw A) (a : A) : p.mass a ≤ 1 := by
calc
p.mass a ≤ ∑ b, p.mass b :=
Finset.single_le_sum (fun b _hb => p.nonneg b) (Finset.mem_univ a)
_ = 1 := p.total
theorem entropy_nonneg (p : FiniteLaw A) : 0 ≤ finiteEntropy p.mass :=
finiteEntropy_nonneg p.mass p.nonneg p.mass_le_one
theorem entropy_le_log_card (p : FiniteLaw A) :
finiteEntropy p.mass ≤ Real.log (Fintype.card A) :=
finiteEntropy_le_log_card p.mass p.nonneg p.total
theorem map_entropy_le {B : Type*} [Fintype B] (p : FiniteLaw A) (f : A → B) :
finiteEntropy (p.map f).mass ≤ finiteEntropy p.mass := by
calc
finiteEntropy (p.map f).mass ≤ finiteEntropy (p.map f).mass +
∑ b, (p.map f).mass b * finiteEntropy (p.conditional f b).mass :=
le_add_of_nonneg_right (Finset.sum_nonneg fun b _ =>
mul_nonneg ((p.map f).nonneg b) ((p.conditional f b).entropy_nonneg))
_ = finiteEntropy p.mass := (p.entropy_eq_map_add_conditional f).symm
theorem entropy_tendsto {I : Type*} {l : Filter I}
{p : I → FiniteLaw A} {q : FiniteLaw A}
(h : ∀ a, Tendsto (fun i => (p i).mass a) l (𝓝 (q.mass a))) :
Tendsto (fun i => finiteEntropy (p i).mass) l (𝓝 (finiteEntropy q.mass)) :=
tendsto_finiteEntropy_of_tendsto h
end FiniteLaw
end MatrixMultiplication.Foundation
end
end OAI
|