| import OAI.MeasureTheory.SelfSimilar.EntropyBounds |
|
|
| namespace OAI |
|
|
| universe uα uβ uγ |
|
|
| section |
| open scoped BigOperators ENNReal |
| open MeasureTheory |
| namespace EntropyRateDimension |
| namespace FiniteDistribution |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| theorem entropy_map_le {α : Type uα} {β : Type uβ} (p : FiniteDistribution α) (f : α → β) : |
| (p.map f).entropy ≤ p.entropy := by |
| classical |
| rw [p.entropy_map_on f p.support (fun _ h => h),p.entropy_on p.support (fun _ h => h)] |
| exact FiniteEntropy.observableEntropy_le _ _ _ (fun a _ => p.nonneg a) |
|
|
| theorem js_le_map_add {α : Type uα} {β : Type uβ} (p q : FiniteDistribution α) (f : α → β) : |
| p.js q ≤ (p.map f).js (q.map f)+(p.mix q).entropy-((p.mix q).map f).entropy := by |
| classical |
| have he : ((p.map f).mix (q.map f)).entropy=((p.mix q).map f).entropy := by |
| let s := p.support ∪ q.support |
| rw [mix_map_entropy p q f s Finset.subset_union_left Finset.subset_union_right, |
| (p.mix q).entropy_map_on f s (by exact fun _ h => h)] |
| rfl |
| have hp := p.entropy_map_le f |
| have hq := q.entropy_map_le f |
| unfold js |
| rw [he] |
| linarith |
|
|
| theorem tv_maps_le_disagreement {α : Type uα} {β : Type uβ} (p : FiniteDistribution α) (f g : α → β) : |
| (p.map f).tv (p.map g) ≤ ∑ a ∈ p.support, if f a = g a then 0 else p.weight a := by |
| classical |
| let t := (p.map f).support ∪ (p.map g).support |
| rw [(p.map f).tv_on (p.map g) t Finset.subset_union_left Finset.subset_union_right] |
| unfold FiniteEntropy.totalVariation |
| have hm (k : α → β) (b : β) : (p.map k).weight b = |
| ∑ a ∈ p.support, if k a=b then p.weight a else 0 := by |
| rw [map_weight_on p k p.support (fun _ h => h)] |
| simp only [FiniteEntropy.mass,Finset.sum_filter] |
| have hsum : ∑ b ∈ t, |(p.map f).weight b-(p.map g).weight b| ≤ |
| ∑ a ∈ p.support, if f a = g a then 0 else 2*p.weight a := by |
| calc |
| _ ≤ ∑ b ∈ t, ∑ a ∈ p.support, |
| |(if f a=b then p.weight a else 0)-(if g a=b then p.weight a else 0)| := by |
| apply Finset.sum_le_sum |
| intro b _ |
| rw [hm f b,hm g b,← Finset.sum_sub_distrib] |
| exact Finset.abs_sum_le_sum_abs _ _ |
| _ = _ := by |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro a ha |
| by_cases h : f a=g a |
| · simp [h] |
| · have hf : f a ∈ t := Finset.mem_union_left _ (Finset.mem_image_of_mem f ha) |
| have hg : g a ∈ t := Finset.mem_union_right _ (Finset.mem_image_of_mem g ha) |
| have habs : ∀ b, |(if f a=b then p.weight a else 0)-(if g a=b then p.weight a else 0)| = |
| (if f a=b then p.weight a else 0)+(if g a=b then p.weight a else 0) := by |
| intro b |
| by_cases hfb : f a=b <;> by_cases hgb : g a=b |
| · exact (h (hfb.trans hgb.symm)).elim |
| · simp [hfb,hgb,abs_of_nonneg (p.nonneg a)] |
| · simp [hfb,hgb,abs_of_nonneg (p.nonneg a)] |
| · simp [hfb,hgb] |
| simp_rw [habs] |
| rw [Finset.sum_add_distrib] |
| simp only [Finset.sum_ite_eq,hf,hg,ite_true,h,ite_false] |
| ring |
| have he : (∑ a ∈ p.support, if f a=g a then 0 else 2*p.weight a) = |
| 2*∑ a ∈ p.support, if f a=g a then 0 else p.weight a := by |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro a _ |
| split_ifs <;> ring |
| rw [he] at hsum |
| linarith |
| |
| end FiniteDistribution |
| namespace RandomGrid |
| |
| local instance unitCircleProbability : IsProbabilityMeasure (volume : Measure (AddCircle (1 : ℝ))) := |
| ⟨by simp⟩ |
|
|
| noncomputable def hit (c : AddCircle (1 : ℝ)) (r : ℝ) (u : AddCircle (1 : ℝ)) : ℝ := |
| if dist u c ≤ r then 1 else 0 |
|
|
| theorem hit_eq_indicator (c : AddCircle (1 : ℝ)) (r : ℝ) : |
| hit c r = (Metric.closedBall c r).indicator (fun _ => (1 : ℝ)) := by |
| classical |
| ext u |
| change (if dist u c ≤ r then 1 else 0) = (if u ∈ Metric.closedBall c r then 1 else 0) |
| rfl |
|
|
| theorem hit_integrable (c : AddCircle (1 : ℝ)) (r : ℝ) : Integrable (hit c r) := by |
| rw [hit_eq_indicator] |
| exact (integrable_const 1).indicator measurableSet_closedBall |
|
|
| theorem integral_hit (c : AddCircle (1 : ℝ)) {r : ℝ} (hr : 0 ≤ r) : |
| (∫ u, hit c r u) = min 1 (2 * r) := by |
| rw [hit_eq_indicator, integral_indicator_const _ measurableSet_closedBall] |
| simp only [Measure.real, AddCircle.volume_closedBall, smul_eq_mul, mul_one] |
| exact ENNReal.toReal_ofReal (le_min (by norm_num) (mul_nonneg (by norm_num) hr)) |
|
|
| theorem circle_norm_le_of_floor_ne {x y : ℝ} (h : ⌊x⌋ ≠ ⌊y⌋) : |
| ‖(x : AddCircle (1 : ℝ))‖ ≤ |y - x| := by |
| rw [AddCircle.norm_eq] |
| simp only [inv_one, one_mul, mul_one] |
| rcases lt_or_gt_of_ne h with hxy | hxy |
| · apply (round_le x (⌊x⌋ + 1)).trans |
| have hy : (⌊x⌋ : ℝ) + 1 ≤ y := by |
| have hh : ⌊x⌋ + 1 ≤ ⌊y⌋ := hxy |
| have hh' : (⌊x⌋ : ℝ) + 1 ≤ (⌊y⌋ : ℝ) := by exact_mod_cast hh |
| exact hh'.trans (Int.floor_le y) |
| have hx := Int.lt_floor_add_one x |
| rw [Int.cast_add, Int.cast_one, abs_of_nonpos (by linarith), abs_of_nonneg (by linarith)] |
| linarith |
| · apply (round_le x ⌊x⌋).trans |
| have hy : y ≤ (⌊x⌋ : ℝ) := by |
| have hh : ⌊y⌋ + 1 ≤ ⌊x⌋ := hxy |
| have hh' : (⌊y⌋ : ℝ) + 1 ≤ (⌊x⌋ : ℝ) := by exact_mod_cast hh |
| exact (Int.lt_floor_add_one y).le.trans hh' |
| have hx := Int.floor_le x |
| rw [abs_of_nonneg (by linarith), abs_of_nonpos (by linarith)] |
| linarith |
|
|
| end RandomGrid |
|
|
| namespace MeasureEntropy |
|
|
| theorem observationLaw_map_weight {α : Type uα} {β : Type uβ} {γ : Type uγ} [MeasurableSpace α] [MeasurableSpace β] |
| [MeasurableSingletonClass β] (μ : Measure α) [IsProbabilityMeasure μ] |
| (f : α → β) (hf : Measurable f) (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) |
| (g : β → γ) (c : γ) : |
| ((observationLaw μ f hf s hs).map g).weight c = mass μ (g ∘ f) c := by |
| classical |
| rw [FiniteDistribution.map_weight_on _ _ s (fun _ h => h)] |
| exact (mass_comp μ f hf s hs g c).symm |
|
|
| theorem integral_finite_observation {α : Type uα} {β : Type uβ} [MeasurableSpace α] [MeasurableSpace β] |
| [MeasurableSingletonClass β] (μ : Measure α) [IsFiniteMeasure μ] |
| (f : α → β) (hf : Measurable f) (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) |
| (F : β → ℝ) : ∫ x, F (f x) ∂μ = ∑ b ∈ s, mass μ f b*F b := by |
| classical |
| have he : (fun x => F (f x)) =ᵐ[μ] |
| fun x => ∑ b ∈ s, ({x | f x=b} : Set α).indicator (fun _ => F b) x := by |
| filter_upwards [hs] with x hx |
| simp only [Set.indicator_apply,Set.mem_ofPred] |
| simp [Finset.sum_ite_eq,hx] |
| rw [integral_congr_ae he, integral_finsetSum] |
| · apply Finset.sum_congr rfl |
| intro b _ |
| change (∫ a, (f ⁻¹' {b}).indicator (fun _ => F b) a ∂μ) = _ |
| rw [integral_indicator_const _ ((measurableSet_singleton b).preimage hf)] |
| rfl |
| · intro b _ |
| exact (integrable_const _).indicator ((measurableSet_singleton b).preimage hf) |
|
|
| theorem entropy_binary_extra {α : Type uα} {β : Type uβ} [MeasurableSpace α] [MeasurableSpace β] |
| [MeasurableSingletonClass β] [DecidableEq β] |
| (μ : Measure α) [IsProbabilityMeasure μ] (f : α → β) (g : α → ℤ) |
| (hf : Measurable f) (hg : Measurable g) (s : Finset β) |
| (hs : ∀ᵐ x ∂μ, f x ∈ s) (hg01 : ∀ᵐ x ∂μ, g x ∈ Finset.Icc (0 : ℤ) 1) |
| (bad : β → Prop) [DecidablePred bad] |
| (hgood : ∀ᵐ x ∂μ, ¬bad (f x) → g x=0) : |
| entropy μ (fun x => (g x,f x))-entropy μ f ≤ |
| (∫ x, if bad (f x) then (1 : ℝ) else 0 ∂μ)*Real.log 2 := by |
| classical |
| let t := ((Finset.Icc (0 : ℤ) 1) ×ˢ s).filter (fun y => bad y.2 ∨ y.1=0) |
| let F := fun x => (g x,f x) |
| have hF : Measurable F := hg.prodMk hf |
| have ht : ∀ᵐ x ∂μ, F x ∈ t := by |
| filter_upwards [hs,hg01,hgood] with x hx hgx hgoodx |
| exact Finset.mem_filter.mpr ⟨Finset.mem_product.mpr ⟨hgx,hx⟩,or_iff_not_imp_left.mpr hgoodx⟩ |
| have hh := FiniteEntropy.conditionalEntropy_le_bad_mass t (mass μ F) Prod.fst Prod.snd bad |
| (fun a _ => mass_nonneg μ F a) (by |
| intro a ha b hb hab hbad |
| have ha' := (Finset.mem_filter.mp ha).2.resolve_left hbad |
| have hb' := (Finset.mem_filter.mp hb).2.resolve_left (hab ▸ hbad) |
| exact ha'.trans hb'.symm) |
| have hi : (fun a : ℤ × β => (a.1,a.2))=id := rfl |
| unfold FiniteEntropy.conditionalEntropy at hh |
| rw [hi,FiniteEntropy.observableEntropy_id,← entropy_comp μ F hF t ht Prod.snd] at hh |
| change FiniteEntropy.entropy t (mass μ F)-entropy μ f ≤ _ at hh |
| unfold FiniteEntropy.entropy at hh |
| rw [← entropy_eq_sum μ F t ht] at hh |
| have hbad0 : 0 ≤ ∑ a ∈ t, if bad a.2 then mass μ F a else 0 := by |
| apply Finset.sum_nonneg |
| intro a _ |
| split_ifs |
| · exact mass_nonneg μ F a |
| · exact le_rfl |
| have hc : (t.image Prod.fst).card ≤ 2 := by |
| have hsub : t.image Prod.fst ⊆ Finset.Icc (0 : ℤ) 1 := by |
| rintro a ha |
| obtain ⟨b,hb,rfl⟩ := Finset.mem_image.mp ha |
| exact (Finset.mem_product.mp (Finset.mem_filter.mp hb).1).1 |
| simpa using Finset.card_le_card hsub |
| have hl : Real.log (t.image Prod.fst).card ≤ Real.log 2 := by |
| by_cases hz : (t.image Prod.fst).card=0 |
| · simp [hz,Real.log_nonneg (by norm_num : (1 : ℝ) ≤ 2)] |
| · apply Real.log_le_log (Nat.cast_pos.mpr (Nat.pos_of_ne_zero hz)) |
| exact_mod_cast hc |
| have he : (∫ x, if bad (f x) then (1 : ℝ) else 0 ∂μ) = |
| ∑ a ∈ t, if bad a.2 then mass μ F a else 0 := by |
| have h := integral_finite_observation μ F hF t ht |
| (fun a : ℤ × β => if bad a.2 then (1 : ℝ) else 0) |
| simpa only [F, mul_ite, mul_one, mul_zero] using h |
|
|
| rw [he] |
| exact hh.trans (mul_le_mul_of_nonneg_left hl hbad0) |
|
|
| end MeasureEntropy |
|
|
| end EntropyRateDimension |
| end |
|
|
| end OAI |
|
|
