| import OAI.Dynamics.StandardMap.EntropyEndpoint |
| import OAI.Dynamics.StandardMap.Towers.ScaledFiniteCoupling |
| import OAI.Dynamics.StandardMap.Coding.TypicalDecodableCoupling |
|
|
| namespace OAI |
|
|
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X A C : Type*} [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] |
|
|
| noncomputable def prefixNameCost {k t : ℕ} (F : C → A) |
| (a : Fin k → C) (b : Fin (k+t) → A) : ℝ := |
| ∑ i : Fin k,symbolCost (F (a i)) (b (Fin.castAdd t i)) |
|
|
| omit [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] in |
| lemma nameCost_le_prefixNameCost {k t : ℕ} (F : C → A) |
| (a : Fin (k+t) → C) (b : Fin (k+t) → A) : |
| nameCost (F ∘ a) b ≤ prefixNameCost F (fun i => a (Fin.castAdd t i)) b + t := by |
| rw [nameCost,Fin.sum_univ_add] |
| unfold prefixNameCost |
| apply add_le_add_right |
| calc |
| (∑ i : Fin t,symbolCost (F (a (Fin.natAdd k i))) (b (Fin.natAdd k i))) ≤ |
| ∑ _ : Fin t,(1 : ℝ) := Finset.sum_le_sum (fun _ _ => symbolCost_le_one _ _) |
| _ = (t : ℝ) := by simp |
|
|
| theorem realize_prefix_tower_coupling (μ : Measure X) [IsFiniteMeasure μ] [NullSingletonClass μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) |
| {U : Set X} (hU : MeasurableSet U) (k t : ℕ) |
| (hd : Pairwise (fun i j : Fin (k+t) => Disjoint ((e^[i.val]) '' U) ((e^[j.val]) '' U))) |
| (p : X → C) (hp : Measurable p) (F : C → A) (v : (Fin (k+t) → A) → ℝ) |
| (R : MatrixCoupling (mass (μ.restrict U) (word e p k)) v) : |
| ∃ q : X → A,Measurable q ∧ |
| (∀ a b,mass (μ.restrict U) (fun x => (word e p k x,word e q (k+t) x)) (a,b)=R.weight a b) ∧ |
| (∀ b,mass (μ.restrict U) (word e q (k+t)) b=v b) ∧ |
| μ.real {x | F (p x)≠q x}≤R.cost (prefixNameCost F)+(t : ℝ)*μ.real U ∧ |
| ∀ x,x∉⋃ i : Fin (k+t),(e^[i.val]) '' U → q x=F (p x) := by |
| have hF : Measurable F := measurable_of_countable F |
| have hpw := word_measurable e e.measurable p hp k |
| obtain ⟨B,hB,hR⟩ := realize_finite_coupling_finite (μ.restrict U) (word e p k) hpw v R |
| let q := paintTower e U (k+t) B (F ∘ p) |
| have hq : Measurable q := measurable_paintTower e hU (k+t) hd hB (hF.comp hp) |
| have hj (a : Fin k → C) (b : Fin (k+t) → A) : |
| mass (μ.restrict U) (fun x => (word e p k x,word e q (k+t) x)) (a,b)=R.weight a b := by |
| rw [←hR a b] |
| unfold mass |
| apply congrArg ENNReal.toReal |
| apply measure_congr |
| filter_upwards [ae_restrict_mem hU] with x hx |
| change ((word e p k x,word e q (k+t) x)=(a,b)) = ((word e p k x,B x)=(a,b)) |
| rw [show word e q (k+t) x=B x from paintTower_word e U (k+t) hd B (F ∘ p) hx] |
| refine ⟨q,hq,hj,?_,?_,fun x hx => paintTower_off e U (k+t) B (F ∘ p) hx⟩ |
| · intro b |
| rw [mass_joint_col (μ.restrict U) (word e p k) (word e q (k+t)) hpw |
| (word_measurable e e.measurable q hq (k+t))] |
| simp_rw [hj] |
| exact R.col b |
| · change μ.real {x | (F ∘ p) x≠q x}≤_ |
| rw [paintTower_repaint_integral μ e he hU (k+t) hd hB (hF.comp hp)] |
| have hprefix : Integrable (fun x => prefixNameCost F (word e p k x) (B x)) (μ.restrict U) := |
| integrable_finite_observation (μ.restrict U) (fun x => (word e p k x,B x)) |
| (hpw.prodMk hB) (fun ab => prefixNameCost F ab.1 ab.2) |
| have hfull : Integrable (fun x => nameCost (word e (F ∘ p) (k+t) x) (B x)) (μ.restrict U) := |
| integrable_finite_observation (μ.restrict U) (fun x => (word e (F ∘ p) (k+t) x,B x)) |
| ((word_measurable e e.measurable (F ∘ p) (hF.comp hp) (k+t)).prodMk hB) |
| (fun ab => nameCost ab.1 ab.2) |
| have hb := integral_mono hfull (hprefix.add (integrable_const (t : ℝ))) |
| (fun x => nameCost_le_prefixNameCost F (word e p (k+t) x) (B x)) |
| dsimp only [Pi.add_apply] at hb |
| rw [integral_add hprefix (integrable_const (t : ℝ)), integral_const] at hb |
| rw [integral_cost_of_realization (μ.restrict U) (word e p k) hpw B hB R hR (prefixNameCost F)] at hb |
| simpa only [Measure.real,Measure.restrict_apply_univ,smul_eq_mul,mul_comm] using hb |
|
|
| omit [StandardBorelSpace X] [Nonempty A] in |
| lemma prefix_tower_decoder_error (μ : Measure X) [IsFiniteMeasure μ] |
| (e : X ≃ᵐ X) {U : Set X} (_hU : MeasurableSet U) (k t : ℕ) |
| (p : X → C) (q : X → A) (hp : Measurable p) (hq : Measurable q) |
| {v : (Fin (k+t) → A) → ℝ} (R : MatrixCoupling (mass (μ.restrict U) (word e p k)) v) |
| (hR : ∀ a b,mass (μ.restrict U) (fun x => (word e p k x,word e q (k+t) x)) (a,b)=R.weight a b) |
| (D : (Fin (k+t) → A) → (Fin k → C)) : |
| μ.real (U∩{x | D (word e q (k+t) x)≠word e p k x})= |
| R.cost (fun a b => symbolCost a (D b)) := by |
| have hpw := word_measurable e e.measurable p hp k |
| have hqw := word_measurable e e.measurable q hq (k+t) |
| have hD : Measurable D := measurable_of_countable D |
| have hh := finite_symbolCost_integral (μ.restrict U) (word e p k) (D ∘ word e q (k+t)) hpw (hD.comp hqw) |
| have heq : (μ.restrict U).real {x | word e p k x≠(D ∘ word e q (k+t)) x}= |
| μ.real (U∩{x | D (word e q (k+t) x)≠word e p k x}) := by |
| have hm : MeasurableSet {x | word e p k x≠(D ∘ word e q (k+t)) x} := |
| (measurableSet_eq_fun hpw (hD.comp hqw)).compl |
| rw [Measure.real,Measure.real,Measure.restrict_apply hm,inter_comm] |
| congr 2 |
| ext x |
| simp only [mem_inter_iff,mem_ofPred_eq,Function.comp_apply,ne_comm] |
| rw [heq] at hh |
| exact hh.symm.trans (integral_cost_of_realization (μ.restrict U) (word e p k) hpw |
| (word e q (k+t)) hqw R hR (fun a b => symbolCost a (D b))) |
|
|
| omit [StandardBorelSpace X] [MeasurableSpace C] [MeasurableSingletonClass C] in |
| lemma ae_observation_of_zero_bad_mass (μ : Measure X) [IsFiniteMeasure μ] |
| (p : X → C) (Q : C → Prop) (hbad : ∀ c,¬Q c → mass μ p c=0) : |
| ∀ᵐ x ∂μ,Q (p x) := by |
| have hh (c : C) : ∀ᵐ x ∂μ,p x=c → Q c := by |
| by_cases hc : Q c |
| · exact ae_of_all _ (fun _ _ => hc) |
| · apply ae_iff.mpr |
| have hz : μ (p ⁻¹' {c})=0 := by |
| have ht := hbad c hc |
| change (μ (p ⁻¹' {c})).toReal=0 at ht |
| exact ((ENNReal.toReal_eq_zero_iff _).mp ht).resolve_right (measure_ne_top _ _) |
| convert hz using 1 |
| congr 1 |
| ext x |
| simp only [Set.mem_ofPred_eq,mem_preimage,mem_singleton_iff,hc,imp_false,not_not] |
| filter_upwards [ae_all_iff.mpr hh] with x hx |
| exact hx (p x) rfl |
|
|
| theorem decoded_prefix_tower_copy (μ : Measure X) [IsFiniteMeasure μ] [NullSingletonClass μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) |
| {U : Set X} (hU : MeasurableSet U) {k t r : ℕ} (hn : 0<k+t) (hr : r<k+t) |
| (hd : Pairwise (fun i j : Fin (k+t) => Disjoint ((e^[i.val]) '' U) ((e^[j.val]) '' U))) |
| (p : X → C) (hp : Measurable p) (F : C → A) (v : (Fin (k+t) → A) → ℝ) |
| (R : MatrixCoupling (mass (μ.restrict U) (word e p k)) v) |
| (zero one : A) (h01 : zero≠one) |
| (hmark : ∀ w,¬Marker.MarkedBlock hr zero one w → v w=0) |
| (D : (Fin (k+t) → A) → (Fin k → C)) (c₀ : C) : |
| ∃ q : X → A,Measurable q ∧ |
| (∀ b,mass (μ.restrict U) (word e q (k+t)) b=v b) ∧ |
| μ.real {x | F (p x)≠q x}≤R.cost (prefixNameCost F)+(t : ℝ)*μ.real U ∧ |
| μ.real {x | Marker.decodeWindow hn hr zero one (extendPrefixDecoder D c₀) |
| (word e q (2*(k+t)) (integerIterate e (-((k+t : ℕ) : ℤ)) x))≠p x} ≤ |
| μ.real (⋃ i : Fin (k+t),(e^[i.val]) '' U)ᶜ+ |
| (k+t : ℕ)*R.cost (fun a b => symbolCost a (D b))+(t : ℝ)*μ.real U := by |
| obtain ⟨q,hq,hjoint,hbase,hpaint,_hoff⟩ := |
| realize_prefix_tower_coupling μ e he hU k t hd p hp F v R |
| refine ⟨q,hq,hbase,hpaint,?_⟩ |
| have hmarked : ∀ᵐ b ∂μ.restrict U,Marker.MarkedBlock hr zero one (word e q (k+t) b) := |
| ae_observation_of_zero_bad_mass (μ.restrict U) (word e q (k+t)) |
| (Marker.MarkedBlock hr zero one) (fun w hw => (hbase w).trans (hmark w hw)) |
| have hb := marked_tower_prefix_decoder_error μ e he p q hn hr zero one h01 D c₀ hU hmarked |
| rw [prefix_tower_decoder_error μ e hU k t p q hp hq R hjoint D] at hb |
| exact hb |
|
|
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open scoped BigOperators |
| variable {A C : Type*} {k t r : ℕ} |
|
|
| lemma prefixNameCost_nonneg (F : C → A) (a : Fin k → C) (b : Fin (k+t) → A) : |
| 0 ≤ prefixNameCost F a b := |
| Finset.sum_nonneg (fun _ _ => symbolCost_nonneg _ _) |
|
|
| lemma prefixNameCost_le_length (F : C → A) (a : Fin k → C) (b : Fin (k+t) → A) : |
| prefixNameCost F a b ≤ (k : ℝ) := by |
| calc |
| _ ≤ ∑ _ : Fin k,(1 : ℝ) := Finset.sum_le_sum (fun _ _ => symbolCost_le_one _ _) |
| _ = _ := by simp |
|
|
| lemma prefixNameCost_modify (F : C → A) (a : Fin k → C) (b d : Fin (k+t) → A) : |
| prefixNameCost F a d ≤ prefixNameCost F a b+nameCost b d := by |
| have htri : prefixNameCost F a d ≤ prefixNameCost F a b+ |
| ∑ i : Fin k,symbolCost (b (Fin.castAdd t i)) (d (Fin.castAdd t i)) := by |
| unfold prefixNameCost |
| rw [←Finset.sum_add_distrib] |
| exact Finset.sum_le_sum (fun _ _ => symbolCost_triangle _ _ _) |
| apply htri.trans |
| apply add_le_add_right |
| rw [nameCost,Fin.sum_univ_add] |
| exact le_add_of_nonneg_right (Finset.sum_nonneg (fun _ _ => symbolCost_nonneg _ _)) |
|
|
| noncomputable def normalizedPrefixCost {k t : ℕ} (F : C → A) |
| (a : Fin k → C) (b : Fin (k+t) → A) : ℝ := prefixNameCost F a b/(k+t : ℕ) |
|
|
| lemma normalizedPrefixCost_nonneg (F : C → A) (a : Fin k → C) (b : Fin (k+t) → A) : |
| 0 ≤ normalizedPrefixCost F a b := div_nonneg (prefixNameCost_nonneg F a b) (Nat.cast_nonneg _) |
|
|
| lemma normalizedPrefixCost_le_one (hn : 0<k+t) (F : C → A) |
| (a : Fin k → C) (b : Fin (k+t) → A) : normalizedPrefixCost F a b ≤ 1 := by |
| apply (div_le_one (Nat.cast_pos.mpr hn)).mpr |
| exact (prefixNameCost_le_length F a b).trans (by exact_mod_cast Nat.le_add_right k t) |
|
|
| lemma normalizedPrefixCost_markWord [Fintype A] (F : C → A) (a : Fin k → C) (b : Fin (k+t) → A) |
| (zero one : A) : normalizedPrefixCost F a (Marker.markWord r zero one b) ≤ |
| normalizedPrefixCost F a b + (Marker.reserved (k+t) r).card/(k+t : ℕ) := by |
| classical |
| rw [normalizedPrefixCost,normalizedPrefixCost,←add_div] |
| apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _) |
| exact (prefixNameCost_modify F a b (Marker.markWord r zero one b)).trans |
| (add_le_add_right (Marker.markWord_cost zero one b) _) |
|
|
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set Filter StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal Topology |
| variable {X A C : Type*} [MeasurableSpace X] |
| [MeasurableSpace A] [Fintype A] [DecidableEq A] [MeasurableSingletonClass A] [Nonempty A] |
| [MeasurableSpace C] [Fintype C] [DecidableEq C] [MeasurableSingletonClass C] |
|
|
| omit [MeasurableSpace A] [MeasurableSingletonClass A] in |
| theorem synchronized_codebook_producer (μ : Measure X) [IsProbabilityMeasure μ] |
| (f : X → X) (hf : MeasurePreserving f μ μ) |
| (htotal : ∀ m : ℕ, 0 < m → Ergodic (f^[m]) μ) |
| (p : X → C) (hp : Measurable p) (F : C → A) |
| (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) |
| (hβentropy : 0<weightEntropy β) (hrate : rate μ f p≤weightEntropy β) |
| (zero one : A) {ε : ℝ} (hε : 0<ε) : |
| ∃ K r m : ℕ,0<K ∧ 0<r ∧ 0 < m ∧ ∀ᶠ n : ℕ in atTop, |
| 0<n ∧ r<n*K*m+n*m ∧ |
| ((n*m : ℕ) : ℝ)/(n*K*m+n*m : ℕ)<ε ∧ |
| ((Marker.reserved (n*K*m+n*m) r).card : ℝ)/(n*K*m+n*m : ℕ)<ε ∧ |
| ∀ R : MatrixCoupling (mass μ (word f p (n*K*m))) (productWordWeight β (n*K*m+n*m)), |
| ∃ (D : (Fin (n*K*m+n*m) → A) → (Fin (n*K*m) → C)) |
| (H : MatrixCoupling (mass μ (word f p (n*K*m))) |
| (pushWeight (productWordWeight β (n*K*m+n*m)) (Marker.markWord r zero one))), |
| H.cost (fun a b => symbolCost a (D b))<ε ∧ |
| H.cost (normalizedPrefixCost F)<R.cost (normalizedPrefixCost F)+2*ε := by |
| let θ : ℝ := min (ε/16) (1/16) |
| have hθ : 0<θ := lt_min (by positivity) (by norm_num) |
| have hθsmall : θ<1/4 := lt_of_le_of_lt (min_le_right _ _) (by norm_num) |
| have hθeps : θ≤ε/16 := min_le_left _ _ |
| obtain ⟨K,r,hK,hr,δ,hδ,_hsuffix,hparams⟩ := exists_entropy_slack_parameters |
| (Fintype.card A) (weightEntropy β) ε (by exact_mod_cast Fintype.card_pos) hβentropy hε |
| obtain ⟨m,hm,hsource⟩ := entropy_rate_codebook μ f hf htotal p hp hδ |
| have hKgo : Tendsto (fun n : ℕ => n*K) atTop atTop := |
| tendsto_atTop_mono (fun n => Nat.le_mul_of_pos_right n hK) tendsto_id |
| have hNgo : Tendsto (fun n : ℕ => n*K*m+n*m) atTop atTop := |
| tendsto_atTop_mono (fun n => (Nat.le_mul_of_pos_right n hm).trans (Nat.le_add_left _ _)) tendsto_id |
| have hM : 0<(1-4*θ)*MatrixCoupling.decodingThreshold (ε/2) := |
| mul_pos (by linarith) (MatrixCoupling.decodingThreshold_pos (by positivity)) |
| have hsource' := hKgo.eventually (hsource θ hθ) |
| have htarget := hNgo.eventually (eventually_iid_typical_words β hβ hβsum hδ hθ) |
| have hpar := hparams m hm ((1-4*θ)*MatrixCoupling.decodingThreshold (ε/2)) hM |
| refine ⟨K,r,m,hK,hr,hm,?_⟩ |
| filter_upwards [hsource',htarget,hpar] with n hnS hnT hnP |
| obtain ⟨S,hScard,hSbad⟩ := hnS |
| obtain ⟨T,hT,hTbad⟩ := hnT |
| obtain ⟨hn,hrn,htail,hreserve,hsize⟩ := hnP |
| have hnn : 0<n*K*m+n*m := lt_trans hr hrn |
| refine ⟨hn,hrn,htail,hreserve,?_⟩ |
| intro R |
| have hsum : (∑ a,mass μ (word f p (n*K*m)) a)=1 := by |
| rw [mass_sum μ _ (word_measurable f hf.measurable p hp _)]; simp |
| have hScard' : (S.card : ℝ)≤Real.exp ((n*K*m : ℕ)*(weightEntropy β+δ)) := |
| hScard.trans (Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left (add_le_add_left hrate δ) (Nat.cast_nonneg _))) |
| have hSmall : (S.card : ℝ)*(2*(Fintype.card A : ℝ)^(Marker.reserved (n*K*m+n*m) r).card* |
| Real.exp (-((n*K*m+n*m : ℕ) : ℝ)*(weightEntropy β-δ))) ≤ |
| (1-4*θ)*MatrixCoupling.decodingThreshold (ε/2) := by |
| apply le_trans (mul_le_mul_of_nonneg_right hScard' (by positivity)) |
| convert hsize.le using 1 |
| ring |
| obtain ⟨D,H,hD,hH⟩ := MatrixCoupling.marked_word_decodable_coupling β hβ hβsum |
| (by positivity : 0<ε/2) hθ.le hθsmall R hsum S T |
| (mass_codebook_lower μ _ (word_measurable f hf.measurable p hp _) S hSbad).le |
| (L:=((n*K*m+n*m : ℕ) : ℝ)*(weightEntropy β-δ)) |
| (by simpa only [neg_mul] using hT) hTbad.le zero one (by simpa only [neg_mul] using hSmall) |
| (normalizedPrefixCost F) (normalizedPrefixCost_nonneg F) (normalizedPrefixCost_le_one hnn F) |
| (((Marker.reserved (n*K*m+n*m) r).card : ℝ)/(n*K*m+n*m : ℕ)) |
| (fun a b => normalizedPrefixCost_markWord F a b zero one) |
| exact ⟨D,H,by linarith,by linarith⟩ |
|
|
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X A : Type*} [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace A] [Fintype A] [DecidableEq A] [MeasurableSingletonClass A] [Nonempty A] |
|
|
| theorem unsanitize_tower (μ : Measure X) [IsFiniteMeasure μ] [NullSingletonClass μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) {U : Set X} (hU : MeasurableSet U) |
| (n : ℕ) (hd : Pairwise (fun i j : Fin n => Disjoint ((e^[i.val]) '' U) ((e^[j.val]) '' U))) |
| (p : X → A) (hp : Measurable p) (v : (Fin n → A) → ℝ) |
| (hv : ∀ w,0≤v w) (hs : ∑ w,v w=1) |
| (g : (Fin n → A) → (Fin n → A)) (K : ℝ) (hK : ∀ w,nameCost (g w) w≤K) |
| (hbase : ∀ w,mass (μ.restrict U) (word e p n) w=μ.real U*pushWeight v g w) : |
| ∃ q : X → A,Measurable q ∧ |
| (∀ w,mass (μ.restrict U) (word e q n) w=μ.real U*v w) ∧ |
| μ.real {x | p x≠q x}≤K*μ.real U := by |
| classical |
| let R : MatrixCoupling (mass (μ.restrict U) (word e p n)) (fun w => μ.real U*v w) := { |
| weight := fun a b => if g b=a then μ.real U*v b else 0 |
| nonneg := fun a b => by split_ifs; exact mul_nonneg measureReal_nonneg (hv b); exact le_rfl |
| row := fun a => by |
| rw [hbase] |
| simp only [pushWeight,Finset.mul_sum,mul_ite,mul_zero] |
| col := fun b => by simp } |
| obtain ⟨q,hq,_hjoint,hqbase,hcost,_hoff⟩ := realize_tower_coupling μ e he hU n hd p hp _ R |
| refine ⟨q,hq,hqbase,?_⟩ |
| rw [hcost] |
| change (∑ a,∑ b,(if g b=a then μ.real U*v b else 0)*nameCost a b)≤_ |
| rw [Finset.sum_comm] |
| simp only [ite_mul,zero_mul,Finset.sum_ite_eq,Finset.mem_univ,ite_true] |
| calc |
| _ ≤ ∑ b,μ.real U*v b*K := Finset.sum_le_sum (fun b _ => |
| mul_le_mul_of_nonneg_left (hK b) (mul_nonneg measureReal_nonneg (hv b))) |
| _ = K*μ.real U := by rw [←Finset.sum_mul,←Finset.mul_sum,hs,mul_one,mul_comm] |
|
|
| theorem unsanitize_marked_tower (μ : Measure X) [IsFiniteMeasure μ] [NullSingletonClass μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) {U : Set X} (hU : MeasurableSet U) |
| (n r : ℕ) (hd : Pairwise (fun i j : Fin n => Disjoint ((e^[i.val]) '' U) ((e^[j.val]) '' U))) |
| (p : X → A) (hp : Measurable p) (v : (Fin n → A) → ℝ) |
| (hv : ∀ w,0≤v w) (hs : ∑ w,v w=1) (zero one : A) |
| (hbase : ∀ w,mass (μ.restrict U) (word e p n) w= |
| μ.real U*pushWeight v (Marker.markWord r zero one) w) : |
| ∃ q : X → A,Measurable q ∧ |
| (∀ w,mass (μ.restrict U) (word e q n) w=μ.real U*v w) ∧ |
| μ.real {x | p x≠q x}≤(Marker.reserved n r).card*μ.real U := by |
| apply unsanitize_tower μ e he hU n hd p hp v hv hs (Marker.markWord r zero one) _ _ hbase |
| intro w |
| rw [nameCost_comm] |
| exact Marker.markWord_cost zero one w |
|
|
| omit [StandardBorelSpace X] [Nonempty A] in |
| lemma word_disagreement_le (μ : Measure X) [IsFiniteMeasure μ] |
| (f : X → X) (hf : MeasurePreserving f μ μ) (p q : X → A) |
| (hp : Measurable p) (hq : Measurable q) (m : ℕ) : |
| μ.real {x | word f p m x≠word f q m x}≤(m : ℝ)*μ.real {x | p x≠q x} := by |
| have hset : {x | word f p m x≠word f q m x}= |
| ⋃ i : Fin m,(f^[i.val]) ⁻¹' {x | p x≠q x} := by |
| ext x |
| simp only [mem_ofPred_eq,mem_iUnion,mem_preimage] |
| constructor |
| · intro hx |
| by_contra hn |
| apply hx |
| funext i |
| have hh : ∀ i : Fin m,p (f^[i.val] x)=q (f^[i.val] x) := by simpa using hn |
| exact hh i |
| · rintro ⟨i,hi⟩ h |
| exact hi (congrFun h i) |
| rw [hset] |
| apply (measureReal_iUnion_fintype_le _).trans |
| have hE : MeasurableSet {x | p x≠q x} := (measurableSet_eq_fun hp hq).compl |
| have he (i : Fin m) : μ.real ((f^[i.val]) ⁻¹' {x | p x≠q x})=μ.real {x | p x≠q x} := by |
| rw [Measure.real,Measure.real,(hf.iterate i.val).measure_preimage hE.nullMeasurableSet] |
| simp only [he,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,le_refl] |
|
|
| omit [StandardBorelSpace X] [Nonempty A] in |
| lemma word_lawClose_of_repaint (μ : Measure X) [IsFiniteMeasure μ] |
| (f : X → X) (hf : MeasurePreserving f μ μ) (p q : X → A) |
| (hp : Measurable p) (hq : Measurable q) (m : ℕ) : |
| LawClose (μ.map (word f p m)) (μ.map (word f q m)) ((m : ℝ)*μ.real {x | p x≠q x}) := by |
| intro D hD |
| exact (law_distance_le_disagreement μ (word_measurable f hf.measurable p hp m) |
| (word_measurable f hf.measurable q hq m) hD).trans (word_disagreement_le μ f hf p q hp hq m) |
|
|
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X A C : Type*} [MeasurableSpace X] [StandardBorelSpace X] |
| [TopologicalSpace X] [SecondCountableTopology X] [OpensMeasurableSpace X] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] [Nonempty C] |
|
|
| omit [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] [Nonempty C] in |
| lemma normalizedPrefixCost_left_triangle {k t : ℕ} (hn : 0<k+t) (F : C → A) |
| (a b : Fin k → C) (c : Fin (k+t) → A) : |
| normalizedPrefixCost F a c ≤ symbolCost a b+normalizedPrefixCost F b c := by |
| classical |
| by_cases hab : a=b |
| · subst b; simp [symbolCost] |
| · have h1 := normalizedPrefixCost_le_one hn F a c |
| have h0 := normalizedPrefixCost_nonneg F b c |
| simp only [symbolCost,ite_eq_right hab] |
| linarith |
|
|
| omit [StandardBorelSpace X] [TopologicalSpace X] [SecondCountableTopology X] |
| [OpensMeasurableSpace X] in |
| lemma tower_real_mass_le_one (μ : Measure X) [IsProbabilityMeasure μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) {U : Set X} (hU : MeasurableSet U) |
| (n : ℕ) (hd : Pairwise (fun i j : Fin n => Disjoint ((e^[i.val]) '' U) ((e^[j.val]) '' U))) : |
| (n : ℝ)*μ.real U≤1 := by |
| have hh := congrArg ENNReal.toReal (tower_measure μ e he hU n hd) |
| rw [ENNReal.toReal_mul,ENNReal.toReal_natCast] at hh |
| have hi := measureReal_mono (μ:=μ) (subset_univ (⋃ i : Fin n,(e^[i.val]) '' U)) |
| simpa only [Measure.real,measure_univ,ENNReal.toReal_one,hh] using hi |
|
|
| omit [StandardBorelSpace X] [TopologicalSpace X] [SecondCountableTopology X] |
| [OpensMeasurableSpace X] in |
| lemma tower_suffix_mass_le (μ : Measure X) [IsProbabilityMeasure μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) {U : Set X} (hU : MeasurableSet U) |
| {k t : ℕ} (hn : 0<k+t) |
| (hd : Pairwise (fun i j : Fin (k+t) => Disjoint ((e^[i.val]) '' U) ((e^[j.val]) '' U))) : |
| (t : ℝ)*μ.real U≤(t : ℝ)/(k+t : ℕ) := by |
| apply (le_div_iff₀ (Nat.cast_pos.mpr hn)).mpr |
| have hh := mul_le_mul_of_nonneg_left (tower_real_mass_le_one μ e he hU (k+t) hd) (Nat.cast_nonneg t) |
| nlinarith |
|
|
| omit [Nonempty C] in |
| theorem lift_decoded_prefix_transport (μ : Measure X) [IsProbabilityMeasure μ] |
| [NullSingletonClass μ] [μ.OuterRegular] (e : X ≃ᵐ X) (he : Ergodic e μ) |
| {k t r : ℕ} (hn : 0<k+t) (hr : r<k+t) |
| (p : X → C) (hp : Measurable p) (F : C → A) |
| (v : (Fin (k+t) → A) → ℝ) |
| (R : MatrixCoupling (mass μ (word e p k)) v) |
| (zero one : A) (h01 : zero≠one) |
| (hmark : ∀ w,¬Marker.MarkedBlock hr zero one w → v w=0) |
| (D : (Fin (k+t) → A) → (Fin k → C)) (c₀ : C) |
| {ε : ℝ} (hε : 0<ε) : |
| ∃ (U : Set X) (q : X → A),MeasurableSet U ∧ 0<μ U ∧ Measurable q ∧ |
| Pairwise (fun i j : Fin (k+t) => Disjoint ((e^[i.val]) '' U) ((e^[j.val]) '' U)) ∧ |
| μ.real (⋃ i : Fin (k+t),(e^[i.val]) '' U)ᶜ<ε ∧ |
| (∀ b,mass (μ.restrict U) (word e q (k+t)) b=μ.real U*v b) ∧ |
| μ.real {x | F (p x)≠q x}≤R.cost (normalizedPrefixCost F)+ε+(t : ℝ)/(k+t : ℕ) ∧ |
| μ.real {x | Marker.decodeWindow hn hr zero one (extendPrefixDecoder D c₀) |
| (word e q (2*(k+t)) (integerIterate e (-((k+t : ℕ) : ℤ)) x))≠p x} < |
| 2*ε+R.cost (fun a b => symbolCost a (D b))+(t : ℝ)/(k+t : ℕ) := by |
| have hw := word_measurable e e.measurable p hp k |
| obtain ⟨U,hU,hUp,hd,hcover,hclose⟩ := exists_unbiased_rohlin_tower μ e he hn (word e p k) hw hε |
| let ν := (μ U)⁻¹ • μ.restrict U |
| have : IsProbabilityMeasure ν := normalized_restriction_probability μ hUp |
| obtain ⟨S,hS⟩ := coupling_of_observation_lawClose ν μ (word e p k) (word e p k) hw hw hclose |
| have hP := S.comp_cost_le R symbolCost (normalizedPrefixCost F) (normalizedPrefixCost F) |
| (normalizedPrefixCost_left_triangle hn F) |
| have hD := S.comp_cost_le R symbolCost (fun a b => symbolCost a (D b)) |
| (fun a b => symbolCost a (D b)) (fun a b c => symbolCost_triangle a b (D c)) |
| have hc : 0≤μ.real U := measureReal_nonneg |
| let W := (S.comp R).scale (μ.real U) hc |
| let W' : MatrixCoupling (mass (μ.restrict U) (word e p k)) (fun b => μ.real U*v b) := { |
| weight := W.weight |
| nonneg := W.nonneg |
| row := fun a => (W.row a).trans (normalize_mass_cancel μ hUp (word e p k) a) |
| col := W.col } |
| have hWP : W'.cost (prefixNameCost F)≤μ.real U*((k+t : ℕ)*(ε+R.cost (normalizedPrefixCost F))) := by |
| change W.cost (prefixNameCost F)≤_ |
| rw [show prefixNameCost F=(fun a b => ((k+t : ℕ) : ℝ)*normalizedPrefixCost F a b) by |
| funext a b |
| unfold normalizedPrefixCost |
| exact (mul_div_cancel₀ _ (Nat.cast_ne_zero.mpr hn.ne')).symm] |
| rw [MatrixCoupling.cost_mul,MatrixCoupling.scale_cost] |
| have hh := mul_le_mul_of_nonneg_left (le_trans hP (add_le_add hS le_rfl)) hc |
| have hh' := mul_le_mul_of_nonneg_left hh (Nat.cast_nonneg (k+t)) |
| nlinarith |
| have hWD : W'.cost (fun a b => symbolCost a (D b))≤ |
| μ.real U*(ε+R.cost (fun a b => symbolCost a (D b))) := by |
| change W.cost _≤_ |
| rw [MatrixCoupling.scale_cost] |
| exact mul_le_mul_of_nonneg_left (hD.trans (add_le_add hS le_rfl)) hc |
| obtain ⟨q,hq,hbase,hpaint,hdecode⟩ := decoded_prefix_tower_copy μ e he.toMeasurePreserving |
| hU hn hr hd p hp F _ W' zero one h01 (fun w hw => by rw [hmark w hw,mul_zero]) D c₀ |
| have hmass := tower_real_mass_le_one μ e he.toMeasurePreserving hU (k+t) hd |
| have htail := tower_suffix_mass_le μ e he.toMeasurePreserving hU hn hd |
| have hP0 := R.cost_nonneg (normalizedPrefixCost F) (normalizedPrefixCost_nonneg F) |
| have hD0 := R.cost_nonneg (fun a b => symbolCost a (D b)) (fun _ _ => symbolCost_nonneg _ _) |
| refine ⟨U,q,hU,hUp,hq,hd,hcover,hbase,?_,?_⟩ |
| · have hh := mul_le_mul_of_nonneg_right hmass (show 0≤ε+R.cost (normalizedPrefixCost F) by linarith) |
| nlinarith |
| · have hh := mul_le_mul_of_nonneg_right hmass |
| (show 0≤ε+R.cost (fun a b => symbolCost a (D b)) by linarith) |
| have hn0 : (0 : ℝ)≤(k+t : ℕ) := Nat.cast_nonneg _ |
| have hbound := mul_le_mul_of_nonneg_left hWD hn0 |
| nlinarith |
|
|
| end HyperbolicCoding |
|
|
| end |
|
|
| end OAI |
|
|
