| import OAI.Dynamics.StandardMap.EntropyEndpoint |
| import OAI.Dynamics.StandardMap.Stable.PerronStability |
| import OAI.Dynamics.StandardMap.Entropy.ObservableEntropy |
|
|
| namespace OAI |
|
|
| section |
| section |
| namespace StandardMapEntropy.Entropy |
| open MeasureTheory Set Filter |
| open scoped BigOperators ENNReal |
| variable {α β : Type*} [Fintype α] [Fintype β] |
|
|
| lemma shannon_support_bound (p : α → ℝ) (hp : ∀ a,0≤p a) (s : Finset α) |
| (hs : ∀ a,a∉s → p a=0) : |
| shannon p≤Real.negMulLog (∑ a,p a)+(∑ a,p a)*Real.log (s.card : ℝ) := by |
| classical |
| have hsum : ∑ a : s,p a=∑ a,p a := by |
| rw [Finset.sum_coe_sort] |
| exact Finset.sum_subset (Finset.subset_univ s) (fun a _ ha => hs a ha) |
| have hent : shannon (fun a : s => p a)=shannon p := by |
| unfold shannon |
| dsimp only |
| rw [←Finset.sum_subtype s (fun a => Iff.rfl) (fun a => Real.negMulLog (p a))] |
| exact Finset.sum_subset (Finset.subset_univ s) (fun a _ ha => by rw [hs a ha,Real.negMulLog_zero]) |
| have h := shannon_total_bound (fun a : s => p a) (fun a => hp a) |
| simpa only [hent,hsum,Fintype.card_coe] using h |
|
|
| variable {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsFiniteMeasure μ] |
| variable [MeasurableSpace α] [MeasurableSpace β] |
| variable [MeasurableSingletonClass α] [MeasurableSingletonClass β] |
| lemma cond_support_bound (p : Ω → α) (q : Ω → β) (hp : Measurable p) (hq : Measurable q) |
| (S : β → Finset α) (hS : ∀ x,p x∈S (q x)) : |
| cond μ p q≤∑ b,mass μ q b*Real.log ((S b).card : ℝ) := by |
| classical |
| have rz (b : β) (a : α) (ha : a∉S b) : mass μ (fun x => (p x,q x)) (a,b)=0 := by |
| have he : (fun x => (p x,q x)) ⁻¹' {(a,b)}=∅ := by |
| apply Set.eq_empty_iff_forall_notMem.mpr |
| intro x hx |
| obtain ⟨hx1,hx2⟩ := Prod.mk.inj hx |
| exact ha (hx1 ▸ hx2 ▸ hS x) |
| simp only [mass,he,measure_empty,ENNReal.toReal_zero] |
| have hh := Finset.sum_le_sum (s:=Finset.univ) (fun b _ => |
| shannon_support_bound (fun a => mass μ (fun x => (p x,q x)) (a,b)) |
| (fun a => mass_nonneg μ _ _) (S b) (rz b)) |
| simp only [←mass_joint_col μ p q hp hq,shannon,Finset.sum_add_distrib] at hh |
| unfold cond obs shannon |
| rw [Fintype.sum_prod_type,Finset.sum_comm] |
| linarith |
|
|
| end StandardMapEntropy.Entropy |
| end |
| section |
| namespace StandardMapEntropy.Entropy |
| open MeasureTheory Set Filter |
| open scoped BigOperators ENNReal Topology |
| variable {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ] |
| variable {α : Type*} [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α] |
|
|
| noncomputable def errorObs (p q : Ω → α) (x : Ω) : Bool := by |
| classical |
| exact decide (p x≠q x) |
| lemma errorObs_measurable (p q : Ω → α) (hp : Measurable p) (hq : Measurable q) : |
| Measurable (errorObs p q) := by |
| classical |
| exact (measurable_of_countable (fun v : α×α => decide (v.1≠v.2))).comp (hp.prodMk hq) |
| omit [MeasurableSpace Ω] [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α] in |
| lemma errorObs_false (p q : Ω → α) (x : Ω) : errorObs p q x=false ↔ p x=q x := by |
| classical |
| simp [errorObs] |
| lemma obs_bool (e : Ω → Bool) (he : Measurable e) : |
| obs μ e=Real.negMulLog (mass μ e true)+Real.negMulLog (1-mass μ e true) := by |
| have hm := mass_sum μ e he |
| simp only [Fintype.sum_bool,measure_univ,ENNReal.toReal_one] at hm |
| have hf : mass μ e false=1-mass μ e true := by linarith |
| simp only [obs,shannon,Fintype.sum_bool,hf] |
|
|
| lemma cond_fano (p q : Ω → α) (hp : Measurable p) (hq : Measurable q) : |
| cond μ p q≤obs μ (errorObs p q)+mass μ (errorObs p q) true*Real.log (Fintype.card α) := by |
| classical |
| let e := errorObs p q |
| have he := errorObs_measurable p q hp hq |
| let S : Bool×α → Finset α := fun v => if v.1 then Finset.univ else {v.2} |
| have hs (x : Ω) : p x∈S (e x,q x) := by |
| by_cases h : p x=q x <;> simp [S,e,errorObs,h] |
| have hb := cond_support_bound μ p (fun x => (e x,q x)) hp (he.prodMk hq) S hs |
| have hv : (∑ v : Bool×α,mass μ (fun x => (e x,q x)) v*Real.log ((S v).card : ℝ))= |
| mass μ e true*Real.log (Fintype.card α) := by |
| simp only [Fintype.sum_prod_type,Fintype.sum_bool,S,Bool.false_eq_true,↓reduceIte, |
| Finset.card_univ,Finset.card_singleton,Nat.cast_one,Real.log_one,mul_zero,Finset.sum_const_zero,add_zero] |
| rw [←Finset.sum_mul,←mass_joint_row μ e q he hq true] |
| rw [hv] at hb |
| have hm := obs_pair_ge_right μ e (fun x => (p x,q x)) he (hp.prodMk hq) |
| rw [obs_triple_assoc] at hm |
| have hc := cond_chain μ e q p |
| have ho := cond_le_obs μ e q he hq |
| unfold cond at hb hc ho ⊢ |
| linarith |
| lemma cond_fano_bound (p q : Ω → α) (hp : Measurable p) (hq : Measurable q) : |
| cond μ p q≤Real.negMulLog (mass μ (errorObs p q) true)+ |
| Real.negMulLog (1-mass μ (errorObs p q) true)+ |
| mass μ (errorObs p q) true*Real.log (Fintype.card α) := by |
| rw [←obs_bool μ _ (errorObs_measurable p q hp hq)] |
| exact cond_fano μ p q hp hq |
|
|
| lemma cond_small_of_error (ε : ℝ) (hε : 0<ε) : |
| ∃ η : ℝ,0<η ∧ ∀ (p q : Ω → α), Measurable p → Measurable q → |
| mass μ (errorObs p q) true<η → cond μ p q<ε := by |
| let B : ℝ → ℝ := fun d => Real.negMulLog d+Real.negMulLog (1-d)+d*Real.log (Fintype.card α) |
| have hB : Continuous B := Real.continuous_negMulLog.add |
| (Real.continuous_negMulLog.comp (continuous_const.sub continuous_id)) |>.add |
| (continuous_id.mul continuous_const) |
| have hB0 : B 0=0 := by simp [B] |
| have hev : ∀ᶠ d in 𝓝 (0 : ℝ),B d<ε := |
| (hB.continuousAt : ContinuousAt B 0).eventually (gt_mem_nhds (show B 0<ε by rw [hB0]; exact hε)) |
| obtain ⟨η,hη,hball⟩ := Metric.mem_nhds_iff.mp hev |
| refine ⟨η,hη,?_⟩ |
| intro p q hp hq he |
| have hm := mass_nonneg μ (errorObs p q) true |
| have hb := hball (show mass μ (errorObs p q) true∈Metric.ball 0 η from by |
| simpa only [Metric.mem_ball,Real.dist_eq,sub_zero,abs_of_nonneg hm] using he) |
| exact lt_of_le_of_lt (cond_fano_bound μ p q hp hq) hb |
|
|
| end StandardMapEntropy.Entropy |
|
|
| end |
| section |
| namespace StandardMapEntropy.Entropy |
| open MeasureTheory Set Filter |
| open scoped BigOperators ENNReal Topology |
| variable {Ω : Type*} [MetricSpace Ω] [MeasurableSpace Ω] [BorelSpace Ω] |
| variable (μ : Measure Ω) [IsProbabilityMeasure μ] [μ.InnerRegularCompactLTTop] |
| variable {α : Type*} [Fintype α] [Nonempty α] [MeasurableSpace α] [MeasurableSingletonClass α] |
|
|
| lemma compact_partition_core (p : Ω → α) (hp : Measurable p) (ε : ℝ) (hε : 0<ε) : |
| ∃ K : Set Ω, IsCompact K ∧ μ Kᶜ≤ENNReal.ofReal ε ∧ |
| ∃ δ : ℝ,0<δ ∧ ∀ x∈K,∀ y∈K,dist x y<δ → p x=p y := by |
| classical |
| have hc : (0 : ℝ)<Fintype.card α := by exact_mod_cast Fintype.card_pos |
| have hr : 0<ε/(Fintype.card α : ℝ) := div_pos hε hc |
| have ha (a : α) := (hp (measurableSet_singleton a)).exists_isCompact_sdiff_lt |
| (measure_ne_top μ _) (ENNReal.ofReal_pos.mpr hr).ne' |
| choose K hKsub hKcompact hKerr using ha |
| have herr : μ (⋃ a,K a)ᶜ≤ENNReal.ofReal ε := by |
| have hs : (⋃ a,K a)ᶜ=⋃ a,(p ⁻¹' {a})\K a := by |
| ext x |
| simp only [mem_compl_iff,mem_iUnion,not_exists,Set.mem_sdiff,mem_preimage,mem_singleton_iff] |
| constructor |
| · intro h; exact ⟨p x,rfl,h (p x)⟩ |
| · rintro ⟨a,ha,haK⟩ b hb |
| have hpb := hKsub b hb |
| exact haK ((ha.symm.trans hpb) ▸ hb) |
| rw [hs] |
| calc |
| _ ≤ ∑ a,μ ((p ⁻¹' {a})\K a) := by simpa only [tsum_fintype] using measure_iUnion_le (fun a => (p ⁻¹' {a})\K a) |
| _ ≤ ∑ _a : α,ENNReal.ofReal (ε/(Fintype.card α : ℝ)) := Finset.sum_le_sum (fun a _ => (hKerr a).le) |
| _ = (Fintype.card α : ℝ≥0∞)*ENNReal.ofReal (ε/(Fintype.card α : ℝ)) := by simp |
| _ = ENNReal.ofReal ((Fintype.card α : ℝ)*(ε/(Fintype.card α : ℝ))) := by |
| rw [ENNReal.ofReal_mul hc.le,ENNReal.ofReal_natCast] |
| _ = ENNReal.ofReal ε := by congr 1; field_simp |
| have hsep (ab : α×α) : ∃ δ : ℝ,0<δ ∧ ∀ x∈K ab.1,∀ y∈K ab.2,ab.1≠ab.2 → δ<dist x y := by |
| by_cases he : ab.1=ab.2 |
| · exact ⟨1,by norm_num,fun _ _ _ _ h => False.elim (h he)⟩ |
| have hd : Disjoint (K ab.1) (K ab.2) := by |
| apply disjoint_left.mpr |
| intro x hx hy |
| exact he ((hKsub ab.1 hx).symm.trans (hKsub ab.2 hy)) |
| obtain ⟨δ,hδ,hxy⟩ := Metric.exists_pos_forall_lt_edist (hKcompact ab.1) (hKcompact ab.2).isClosed hd |
| refine ⟨δ,hδ,?_⟩ |
| intro x hx y hy _ |
| have h := (ENNReal.toReal_lt_toReal ENNReal.coe_ne_top (edist_ne_top x y)).mpr (hxy x hx y hy) |
| simpa only [edist_dist,ENNReal.coe_toReal,ENNReal.toReal_ofReal dist_nonneg] using h |
| choose d hd hdsep using hsep |
| let δ := Finset.univ.inf' (Finset.univ_nonempty : (Finset.univ : Finset (α×α)).Nonempty) d |
| have hδ : 0<δ := (Finset.lt_inf'_iff _).mpr (fun ab _ => hd ab) |
| refine ⟨⋃ a,K a,isCompact_iUnion hKcompact,herr,δ,hδ,?_⟩ |
| intro x hx y hy hxy |
| obtain ⟨a,ha⟩ := mem_iUnion.mp hx |
| obtain ⟨b,hb⟩ := mem_iUnion.mp hy |
| have he : a=b := by |
| by_contra h |
| have hs := hdsep (a,b) x ha y hb h |
| exact (not_lt_of_ge ((Finset.inf'_le d (Finset.mem_univ (a,b))).trans hs.le)) hxy |
| exact (hKsub a ha).trans (he.trans (hKsub b hb).symm) |
|
|
| lemma cond_small_of_diameter (p : Ω → α) (hp : Measurable p) (ε : ℝ) (hε : 0<ε) : |
| ∃ δ : ℝ,0<δ ∧ ∀ {β : Type} [Fintype β] [MeasurableSpace β] [MeasurableSingletonClass β] |
| (q : Ω → β),Measurable q → |
| (∀ x y,q x=q y → dist x y<δ) → cond μ p q<ε := by |
| classical |
| obtain ⟨η,hη,hsmall⟩ := cond_small_of_error (α:=α) μ ε hε |
| obtain ⟨K,hK,hKerr,δ,hδ,hsep⟩ := compact_partition_core μ p hp (η/2) (by positivity) |
| refine ⟨δ,hδ,?_⟩ |
| intro β _ _ _ q hq hdiam |
| let g : β → α := fun b => if h : ∃ x∈K,q x=b then p h.choose else Classical.choice inferInstance |
| have he (x : Ω) (hx : x∈K) : g (q x)=p x := by |
| have h : ∃ y∈K,q y=q x := ⟨x,hx,rfl⟩ |
| dsimp only [g] |
| rw [dite_eq_left h] |
| exact hsep h.choose h.choose_spec.1 x hx (hdiam _ _ h.choose_spec.2) |
| have hm : mass μ (errorObs p (g ∘ q)) true<η := by |
| have hs : (errorObs p (g ∘ q)) ⁻¹' {true}⊆Kᶜ := by |
| intro x hx hxK |
| have heq := (errorObs_false p (g ∘ q) x).mpr (he x hxK).symm |
| have htrue : errorObs p (g ∘ q) x=true := hx |
| rw [htrue] at heq |
| cases heq |
| have hu := ENNReal.toReal_mono ENNReal.ofReal_ne_top ((measure_mono hs).trans hKerr) |
| rw [ENNReal.toReal_ofReal (by positivity)] at hu |
| exact lt_of_le_of_lt hu (by linarith) |
| have hh := hsmall p (g ∘ q) hp ((measurable_of_countable g).comp hq) hm |
| exact lt_of_le_of_lt (cond_factor_right μ p q g hp hq) hh |
|
|
| end StandardMapEntropy.Entropy |
|
|
| end |
| section |
| namespace StandardMapEntropy |
| open MeasureTheory Set Filter |
| open scoped BigOperators ENNReal Topology |
|
|
| lemma circleRep_dist_le (x y : Circle) : dist x y≤|circleRep x-circleRep y| := by |
| have h : ‖((circleRep x-circleRep y : ℝ) : Circle)‖≤‖circleRep x-circleRep y‖ := |
| QuotientAddGroup.norm_mk_le_norm |
| simpa only [QuotientAddGroup.mk_sub,coe_circleRep,←dist_eq_norm,Real.dist_eq] using h |
| lemma gridLabel_dist_le (Q : ℕ) (hQ : 0<Q) {z w : Torus} |
| (h : gridLabel Q hQ z=gridLabel Q hQ w) : dist z w≤1/(Q : ℝ) := by |
| obtain ⟨h1,h2⟩ := (gridLabel_eq_iff Q hQ z w).mp h |
| exact max_le ((circleRep_dist_le z.1 w.1).trans (gridIndex_close Q hQ h1)) |
| ((circleRep_dist_le z.2 w.2).trans (gridIndex_close Q hQ h2)) |
|
|
| lemma metricEntropy_le_of_grid_rates (f : Torus → Torus) (hf : MeasurePreserving f area area) (b : ℝ) |
| (hb : ∀ ε : ℝ,0<ε → ∃ Q₀ : ℕ,∀ Q : ℕ,Q₀≤Q → ∀ hQ : 0<Q, |
| Entropy.rate area f (gridLabel Q hQ)≤b+ε) : |
| metricEntropy area f≤ENNReal.ofReal b := by |
| apply iSup_le |
| intro r |
| apply iSup_le |
| intro p |
| rw [partitionEntropy_eq_ofReal_rate area f hf p] |
| apply ENNReal.ofReal_le_ofReal |
| apply le_of_forall_pos_le_add |
| intro ε hε |
| obtain ⟨δ,hδ,hsmall⟩ := Entropy.cond_small_of_diameter area p.val p.property (ε/2) (by positivity) |
| obtain ⟨Q₀,hupper⟩ := hb (ε/2) (by positivity) |
| obtain ⟨Q,hQbig⟩ := exists_nat_gt (max (Q₀ : ℝ) (max 1 δ⁻¹)) |
| have hQpos : (0 : ℝ)<Q := lt_trans zero_lt_one ((le_max_left _ _).trans_lt ((le_max_right _ _).trans_lt hQbig)) |
| have hQ : 0<Q := by exact_mod_cast hQpos |
| have hQQ : Q₀≤Q := by exact_mod_cast ((le_max_left _ _).trans hQbig.le) |
| have hm : 1/(Q : ℝ)<δ := (div_lt_iff₀ hQpos).mpr (by |
| have hDQ : δ⁻¹<(Q : ℝ) := (le_max_right _ _).trans_lt ((le_max_right _ _).trans_lt hQbig) |
| have hv := mul_lt_mul_of_pos_left hDQ hδ |
| rw [mul_inv_cancel₀ hδ.ne'] at hv |
| simpa only [mul_comm] using hv) |
| have hs := hsmall (gridLabel Q hQ) (measurable_gridLabel Q hQ) |
| (fun x y h => (gridLabel_dist_le Q hQ h).trans_lt hm) |
| have hu := hupper Q hQQ hQ |
| have hc := Entropy.rate_comparison area f hf p.val (gridLabel Q hQ) p.property (measurable_gridLabel Q hQ) |
| linarith |
|
|
| end StandardMapEntropy |
|
|
| end |
| section |
| namespace StandardMapEntropy |
| open MeasureTheory Set Filter |
| open scoped Topology ENNReal BigOperators |
|
|
| noncomputable def complexRep (z : Torus) : ℂ := ⟨circleRep z.1,circleRep z.2⟩ |
| @[simp] lemma complexProjection_complexRep (z : Torus) : complexProjection (complexRep z)=z := by |
| ext <;> simp only [complexProjection,complexRep,coe_circleRep] |
| lemma gridLabel_complexRep_close (Q : ℕ) (hQ : 0<Q) {z w : Torus} |
| (h : gridLabel Q hQ z=gridLabel Q hQ w) : ‖complexRep z-complexRep w‖≤2/(Q : ℝ) := by |
| obtain ⟨h1,h2⟩ := (gridLabel_eq_iff Q hQ z w).mp h |
| have hh := add_le_add (gridIndex_close Q hQ h1) (gridIndex_close Q hQ h2) |
| calc |
| _ ≤ |circleRep z.1-circleRep w.1|+|circleRep z.2-circleRep w.2| := Complex.norm_le_abs_re_add_abs_im _ |
| _ ≤ 1/(Q : ℝ)+1/(Q : ℝ) := hh |
| _ = _ := by ring |
|
|
| lemma integrable_log_standardDerivativeProduct (k : ℝ) (n : ℕ) : |
| Integrable (fun z => Real.log ‖standardDerivativeProduct k z n‖) area := |
| ((continuous_standardDerivativeProduct k n).norm.log (fun z => |
| ne_of_gt (lt_of_lt_of_le zero_lt_one (standardDerivativeProduct_norm_ge_one k z n)))).integrable_of_hasCompactSupport |
| (HasCompactSupport.of_compactSpace _) |
|
|
| lemma standard_iterate_grid_cover (k : ℝ) (n : ℕ) {C : ℝ} (hC : 0≤C) |
| (hLip : ∀ z w : ℂ,‖standardDerivativeProduct k (complexProjection z) n- |
| standardDerivativeProduct k (complexProjection w) n‖≤C*‖z-w‖) |
| (Q : ℕ) (hQ : 0<Q) (hQC : 4*C≤(Q : ℝ)) (z : Torus) : |
| ∃ S : Finset (Fin (Q*Q+1)),(S.card : ℝ)≤1000*‖standardDerivativeProduct k z n‖ ∧ |
| ∀ w : Torus,gridLabel Q hQ w=gridLabel Q hQ z → gridLabel Q hQ ((standardMap k)^[n] w)∈S := by |
| have hQp : (0 : ℝ)<Q := Nat.cast_pos.mpr hQ |
| obtain ⟨S,hcard,hcover⟩ := (standardDerivativeProduct_area k z n).grid_cover Q hQ ((standardLift k)^[n] (complexRep z)) |
| refine ⟨S,hcard,?_⟩ |
| intro w hw |
| have hdist := gridLabel_complexRep_close Q hQ hw |
| have ht := quadratic_taylor_of_derivative_lipschitz ((standardLift k)^[n]) |
| (fun u => standardDerivativeProduct k (complexProjection u) n) |
| (hasFDerivAt_standardLift_iterate k n) hC hLip (complexRep z) (complexRep w) |
| rw [complexProjection_complexRep] at ht |
| have herror : ‖(standardLift k)^[n] (complexRep w)-(standardLift k)^[n] (complexRep z)- |
| standardDerivativeProduct k z n (complexRep w-complexRep z)‖≤1/(Q : ℝ) := by |
| apply ht.trans |
| calc |
| _ ≤ C*(2/(Q : ℝ))^2 := mul_le_mul_of_nonneg_left (sq_le_sq₀ (norm_nonneg _) (by positivity) |>.mpr hdist) hC |
| _ ≤ 1/(Q : ℝ) := by |
| calc |
| C*(2/(Q : ℝ))^2 = (4*C)/(Q : ℝ)^2 := by ring |
| _ ≤ 1/(Q : ℝ) := by |
| apply (div_le_div_iff₀ (sq_pos_of_pos hQp) hQp).mpr |
| nlinarith |
| have hh := hcover (complexRep w-complexRep z) ((standardLift k)^[n] (complexRep w)) hdist herror |
| simpa only [complexProjection_iterate,complexProjection_complexRep] using hh |
|
|
| lemma standard_iterate_grid_log_variation (k : ℝ) (n : ℕ) {C : ℝ} (hC : 0≤C) |
| (hLip : ∀ z w : ℂ,‖standardDerivativeProduct k (complexProjection z) n- |
| standardDerivativeProduct k (complexProjection w) n‖≤C*‖z-w‖) |
| (Q : ℕ) (hQ : 0<Q) {z w : Torus} (hw : gridLabel Q hQ w=gridLabel Q hQ z) : |
| Real.log ‖standardDerivativeProduct k z n‖≤Real.log ‖standardDerivativeProduct k w n‖+2*C/(Q : ℝ) := by |
| have hdist := gridLabel_complexRep_close Q hQ hw.symm |
| have hd := hLip (complexRep z) (complexRep w) |
| simp only [complexProjection_complexRep] at hd |
| have hl := (le_abs_self (Real.log ‖standardDerivativeProduct k z n‖-Real.log ‖standardDerivativeProduct k w n‖)).trans |
| (log_norm_sub_le_of_one_le (standardDerivativeProduct_norm_ge_one k z n) (standardDerivativeProduct_norm_ge_one k w n)) |
| have hh := hl.trans (hd.trans (mul_le_mul_of_nonneg_left hdist hC)) |
| rw [show C*(2/(Q : ℝ))=2*C/(Q : ℝ) by ring] at hh |
| linarith |
|
|
| end StandardMapEntropy |
|
|
| end |
| section |
| namespace StandardMapEntropy |
| open MeasureTheory Set Filter |
| open scoped Topology ENNReal |
| lemma exists_dyadic_level {r : ℝ} (hr : 0<r) : ∃ n : ℕ,1≤(2 : ℝ)^n*r := by |
| obtain ⟨n,hn⟩ := pow_unbounded_of_one_lt r⁻¹ (show (1 : ℝ)<2 by norm_num) |
| refine ⟨n,?_⟩ |
| have hh := mul_lt_mul_of_pos_right hn hr |
| rw [inv_mul_cancel₀ hr.ne'] at hh |
| exact hh.le |
| noncomputable def dyadicLevel (r : ℝ) (hr : 0<r) : ℕ := Nat.find (exists_dyadic_level hr) |
| lemma dyadicLevel_lower (r : ℝ) (hr : 0<r) : 1≤(2 : ℝ)^(dyadicLevel r hr)*r := |
| Nat.find_spec (exists_dyadic_level hr) |
| lemma dyadicLevel_upper (r : ℝ) (hr : 0<r) (hr1 : r≤1) : |
| (2 : ℝ)^(dyadicLevel r hr)*r≤2 := by |
| generalize hn : dyadicLevel r hr=n |
| cases n with |
| | zero => simpa only [pow_zero,one_mul] using hr1.trans (show (1 : ℝ)≤2 by norm_num) |
| | succ n => |
| have hnot : ¬1≤(2 : ℝ)^n*r := Nat.find_min (exists_dyadic_level hr) (by change n<dyadicLevel r hr; rw [hn]; omega) |
| rw [pow_succ] |
| nlinarith [not_le.mp hnot] |
| lemma dyadicLevel_mono_bound {r s : ℝ} (hr : 0<r) (hs : 0<s) (J : ℕ) |
| (h : r≤(2 : ℝ)^J*s) : dyadicLevel s hs≤dyadicLevel r hr+J := by |
| apply Nat.find_min' (exists_dyadic_level hs) |
| rw [pow_add,mul_assoc] |
| exact (dyadicLevel_lower r hr).trans (mul_le_mul_of_nonneg_left h (by positivity)) |
| lemma measurable_dyadicLevel {Ω : Type*} [MeasurableSpace Ω] (r : Ω → ℝ) |
| (hr : ∀ x,0<r x) (hm : Measurable r) : Measurable (fun x => dyadicLevel (r x) (hr x)) := by |
| exact measurable_find (fun x => exists_dyadic_level (hr x)) |
| (fun n => measurableSet_le measurable_const (measurable_const.mul hm)) |
| lemma inv_dyadicLevel_le (r : ℝ) (hr : 0<r) : 1/(2 : ℝ)^(dyadicLevel r hr)≤r := |
| (div_le_iff₀ (by positivity)).mpr (by simpa only [mul_comm] using dyadicLevel_lower r hr) |
|
|
| end StandardMapEntropy |
| end |
| section |
| namespace StandardMapEntropy |
| open MeasureTheory Set Filter |
| open scoped Topology ENNReal BigOperators |
|
|
| abbrev AdaptiveSymbol := ℕ×ℕ |
| noncomputable def dyadicGridVal (n : ℕ) (z : Torus) : ℕ := |
| (gridLabel (2^n) (by positivity) z).val |
| lemma measurable_dyadicGridVal (n : ℕ) : Measurable (dyadicGridVal n) := by |
| have hv : Measurable (fun j : Fin (2^n*2^n+1) => j.val) := measurable_of_countable _ |
| exact hv.comp (measurable_gridLabel (2^n) (by positivity)) |
| noncomputable def adaptiveLabel (l : Torus → ℕ) (z : Torus) : AdaptiveSymbol := |
| (l z,dyadicGridVal (l z) z) |
| lemma measurable_nat_select {X : Type*} [MeasurableSpace X] (g : ℕ → X → ℕ) |
| (hg : ∀ n,Measurable (g n)) (l : X → ℕ) (hl : Measurable l) : |
| Measurable (fun z => g (l z) z) := by |
| have hm : Measurable (fun w : ℕ×X => g w.1 w.2) := |
| measurable_from_prod_countable_right (f:=fun w : ℕ×X => g w.1 w.2) hg |
| exact hm.comp (hl.prodMk measurable_id) |
| lemma measurable_adaptiveLabel (l : Torus → ℕ) (hl : Measurable l) : Measurable (adaptiveLabel l) := by |
| have hm := measurable_nat_select dyadicGridVal measurable_dyadicGridVal l hl |
| apply Measurable.prodMk hl hm |
| lemma adaptiveLabel_level {l : Torus → ℕ} {z w : Torus} (h : adaptiveLabel l z=adaptiveLabel l w) : l z=l w := congrArg Prod.fst h |
| lemma adaptiveLabel_grid {l : Torus → ℕ} {z w : Torus} (h : adaptiveLabel l z=adaptiveLabel l w) : |
| gridLabel (2^(l z)) (by positivity) z=gridLabel (2^(l z)) (by positivity) w := by |
| have hh := congrArg Prod.snd h |
| simp only [adaptiveLabel] at hh |
| rw [←adaptiveLabel_level h] at hh |
| exact Fin.ext hh |
| lemma adaptiveLabel_rep_close {l : Torus → ℕ} {z w : Torus} (h : adaptiveLabel l z=adaptiveLabel l w) : |
| ‖complexRep z-complexRep w‖≤2/(2 : ℝ)^(l z) := by |
| have hh := gridLabel_complexRep_close (2^(l z)) (by positivity) (adaptiveLabel_grid h) |
| simpa only [Nat.cast_pow,Nat.cast_ofNat] using hh |
|
|
| noncomputable def adaptiveCenter (l : Torus → ℕ) (a : AdaptiveSymbol) : Torus := by |
| classical |
| exact if h : ∃ z,adaptiveLabel l z=a then Classical.choose h else (0,0) |
| lemma adaptiveCenter_label (l : Torus → ℕ) (z : Torus) : |
| adaptiveLabel l (adaptiveCenter l (adaptiveLabel l z))=adaptiveLabel l z := by |
| simp only [adaptiveCenter,dite_eq_left (show ∃ w,adaptiveLabel l w=adaptiveLabel l z from ⟨z,rfl⟩)] |
| exact Classical.choose_spec (show ∃ w,adaptiveLabel l w=adaptiveLabel l z from ⟨z,rfl⟩) |
| noncomputable def adaptiveSuccessors (k : ℝ) (l : Torus → ℕ) (J M : ℕ) (a : AdaptiveSymbol) : Finset AdaptiveSymbol := |
| (Finset.Icc (a.1-J) (a.1+J)).biUnion (fun m => |
| (liftGridCover (2^m) (by positivity) (standardLift k (complexRep (adaptiveCenter l a))) M).image (fun j => (m,j.val))) |
| lemma adaptiveSuccessors_card (k : ℝ) (l : Torus → ℕ) (J M : ℕ) (a : AdaptiveSymbol) : |
| (adaptiveSuccessors k l J M a).card≤(2*J+1)*(2*M+3)^2 := by |
| apply Finset.card_biUnion_le.trans |
| calc |
| _ ≤ ∑ _m∈Finset.Icc (a.1-J) (a.1+J),(2*M+3)^2 := |
| Finset.sum_le_sum (fun m _ => Finset.card_image_le.trans (liftGridCover_card _ _ _ _)) |
| _ ≤ (2*J+1)*(2*M+3)^2 := by |
| simp only [Finset.sum_const,smul_eq_mul,Nat.card_Icc] |
| exact Nat.mul_le_mul_right _ (by omega) |
|
|
| lemma standardLift_lipschitz_bound (k : ℝ) (hk : 0≤k) (z w : ℂ) : |
| ‖standardLift k z-standardLift k w‖≤(9*growthBase k)*‖z-w‖ := |
| norm_sub_le_of_derivative_bound _ _ (hasFDerivAt_standardLift k) (fun _ => standardDerivative_norm_bound k hk _) z w |
|
|
| lemma adaptive_successor_mem (k : ℝ) (hk : 0≤k) (l : Torus → ℕ) (J M : ℕ) |
| (hM : 2*(9*growthBase k)*(2 : ℝ)^J≤M) (z : Torus) |
| (hnext : l (standardMap k z)≤l z+J) (hprev : l z≤l (standardMap k z)+J) : |
| adaptiveLabel l (standardMap k z)∈adaptiveSuccessors k l J M (adaptiveLabel l z) := by |
| let n := l z |
| let m := l (standardMap k z) |
| let c := adaptiveCenter l (adaptiveLabel l z) |
| have hlab : adaptiveLabel l z=adaptiveLabel l c := (adaptiveCenter_label l z).symm |
| have hdist := adaptiveLabel_rep_close hlab |
| have hL : 0≤9*growthBase k := by have hg := growthBase_ge_four k hk; linarith |
| have hpow : (2 : ℝ)^m≤(2 : ℝ)^n*(2 : ℝ)^J := by rw [←pow_add]; exact pow_le_pow_right₀ (by norm_num) hnext |
| have hb : ‖standardLift k (complexRep z)-standardLift k (complexRep c)‖≤(M : ℝ)/(2 : ℝ)^m := by |
| calc |
| _ ≤ (9*growthBase k)*(2/(2 : ℝ)^n) := (standardLift_lipschitz_bound k hk _ _).trans |
| (mul_le_mul_of_nonneg_left hdist hL) |
| _ ≤ (M : ℝ)/(2 : ℝ)^m := by |
| apply (le_div_iff₀ (by positivity)).mpr |
| have hh := mul_le_mul_of_nonneg_left hpow (show 0≤(9*growthBase k)*(2/(2 : ℝ)^n) by positivity) |
| have he : (9*growthBase k)*(2/(2 : ℝ)^n)*((2 : ℝ)^n*(2 : ℝ)^J)=2*(9*growthBase k)*(2 : ℝ)^J := by field_simp |
| exact hh.trans (he.le.trans hM) |
| apply Finset.mem_biUnion.mpr |
| refine ⟨m,Finset.mem_Icc.mpr ⟨by change n-J ≤ m; omega,hnext⟩,?_⟩ |
| apply Finset.mem_image.mpr |
| refine ⟨gridLabel (2^m) (by positivity) (standardMap k z),?_,rfl⟩ |
| have hm := liftGridCover_mem (2^m) (by positivity) (standardLift k (complexRep c)) |
| (standardLift k (complexRep z)) M (by simpa only [Nat.cast_pow,Nat.cast_ofNat] using hb) |
| simpa only [complexProjection_standardLift,complexProjection_complexRep] using hm |
|
|
| end StandardMapEntropy |
|
|
| end |
| end |
|
|
| end OAI |
|
|
