| import OAI.Dynamics.StandardMap.EntropyEndpoint |
| import OAI.Dynamics.StandardMap.Coupling.ActualFiniteRecodingBounds |
|
|
| namespace OAI |
|
|
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators |
| variable {A B C : Type*} {k t R : ℕ} |
|
|
| def blockWindow (b : Fin (k+t) → A) (i : Fin (k-2*R)) : Fin (2*R+1) → A := |
| fun j => b ⟨i.val+j.val,by have := i.isLt |
| def blockCenter (a : Fin k → C) (i : Fin (k-2*R)) : C := |
| a ⟨i.val+R,by have := i.isLt |
|
|
| noncomputable def decoderNameCost (H : C → B) (D : (Fin (2*R+1) → A) → B) |
| (a : Fin k → C) (b : Fin (k+t) → A) : ℝ := |
| ∑ i : Fin (k-2*R),symbolCost (H (blockCenter a i)) (D (blockWindow b i)) |
|
|
| noncomputable def fixedWindowCost (F : C → A) (H : C → B) |
| (D : (Fin (2*R+1) → A) → B) (a : Fin k → C) (b : Fin (k+t) → A) : ℝ := |
| (prefixNameCost F a b+decoderNameCost H D a b)/(2*(k+t : ℕ)) |
|
|
| lemma decoderNameCost_nonneg (H : C → B) (D : (Fin (2*R+1) → A) → B) |
| (a : Fin k → C) (b : Fin (k+t) → A) : 0≤decoderNameCost H D a b := |
| Finset.sum_nonneg (fun _ _ => symbolCost_nonneg _ _) |
| lemma decoderNameCost_le_length (H : C → B) (D : (Fin (2*R+1) → A) → B) |
| (a : Fin k → C) (b : Fin (k+t) → A) : decoderNameCost H D a b≤(k-2*R : ℕ) := by |
| calc |
| _≤∑ _ : Fin (k-2*R),(1 : ℝ) := Finset.sum_le_sum (fun _ _ => symbolCost_le_one _ _) |
| _=_ := by simp |
| lemma fixedWindowCost_nonneg (F : C → A) (H : C → B) (D : (Fin (2*R+1) → A) → B) |
| (a : Fin k → C) (b : Fin (k+t) → A) : 0≤fixedWindowCost F H D a b := |
| div_nonneg (add_nonneg (prefixNameCost_nonneg F a b) (decoderNameCost_nonneg H D a b)) (by positivity) |
| lemma fixedWindowCost_le_one (hn : 0<k+t) (F : C → A) (H : C → B) |
| (D : (Fin (2*R+1) → A) → B) (a : Fin k → C) (b : Fin (k+t) → A) : |
| fixedWindowCost F H D a b≤1 := by |
| apply (div_le_one (by positivity : (0 : ℝ)<2*(k+t : ℕ))).mpr |
| have h₁ := prefixNameCost_le_length F a b |
| have h₂ := decoderNameCost_le_length H D a b |
| have h₃ : ((k-2*R : ℕ) : ℝ)≤(k : ℝ) := by exact_mod_cast Nat.sub_le k (2*R) |
| push_cast |
| linarith |
|
|
| lemma symbolCost_factor_le (F : C → B) (a b : C) : symbolCost (F a) (F b)≤ symbolCost a b := by |
| classical |
| by_cases h : a=b |
| · subst b; simp [symbolCost] |
| · simpa only [symbolCost,ite_eq_right h] using symbolCost_le_one (F a) (F b) |
| |
| lemma symbolCost_function_le_sum {ι : Type*} [Fintype ι] (a b : ι → A) : |
| symbolCost a b≤∑ i,symbolCost (a i) (b i) := by |
| classical |
| by_cases h : a=b |
| · subst b; simp [symbolCost] |
| · obtain ⟨i,hi⟩ := Function.ne_iff.mp h |
| have hh := Finset.single_le_sum (fun i _ => symbolCost_nonneg (a i) (b i)) (Finset.mem_univ i) |
| simpa only [symbolCost,ite_eq_right h,ite_eq_right hi] using hh |
|
|
| lemma sum_blockWindow_cost_le (b d : Fin (k+t) → A) : |
| (∑ i : Fin (k-2*R),nameCost (blockWindow b i) (blockWindow d i))≤(2*R+1 : ℕ)*nameCost b d := by |
| classical |
| unfold nameCost |
| rw [Finset.sum_comm] |
| calc |
| _≤∑ _ : Fin (2*R+1),∑ j : Fin (k+t),symbolCost (b j) (d j) := by |
| apply Finset.sum_le_sum |
| intro j _ |
| let f : Fin (k-2*R) → Fin (k+t) := fun i => ⟨i.val+j.val,by have:=i.isLt |
| have hf : Function.Injective f := by intro i i' h; have := congrArg Fin.val h; apply Fin.ext; dsimp [f] at this; omega |
| calc |
| _=(∑ z ∈ Finset.univ.image f,symbolCost (b z) (d z)) := (Finset.sum_image (fun i hi i' hi' h => hf h)).symm |
| _≤_ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) |
| (fun i _ _ => symbolCost_nonneg (b i) (d i)) |
| _=_ := by simp |
| |
| lemma decoderNameCost_modify (H : C → B) (D : (Fin (2*R+1) → A) → B) |
| (a : Fin k → C) (b d : Fin (k+t) → A) : |
| decoderNameCost H D a d≤decoderNameCost H D a b+(2*R+1 : ℕ)*nameCost b d := by |
| have hi (i : Fin (k-2*R)) := symbolCost_triangle (H (blockCenter a i)) (D (blockWindow b i)) (D (blockWindow d i)) |
| have hj (i : Fin (k-2*R)) := (symbolCost_factor_le D (blockWindow b i) (blockWindow d i)).trans |
| (symbolCost_function_le_sum (blockWindow b i) (blockWindow d i)) |
| have hh := Finset.sum_le_sum (s:=Finset.univ) (fun i _ => hi i |>.trans (add_le_add_right (hj i) _)) |
| rw [Finset.sum_add_distrib] at hh |
| exact hh.trans (add_le_add_right (sum_blockWindow_cost_le b d) _) |
| |
| lemma fixedWindowCost_markWord [Fintype A] (F : C → A) (H : C → B) |
| (D : (Fin (2*R+1) → A) → B) (a : Fin k → C) (b : Fin (k+t) → A) |
| (r : ℕ) (zero one : A) : |
| fixedWindowCost F H D a (Marker.markWord r zero one b)≤fixedWindowCost F H D a b+ |
| ((2*R+2 : ℕ) : ℝ)*(Marker.reserved (k+t) r).card/(2*(k+t : ℕ)) := by |
| classical |
| have hp := prefixNameCost_modify F a b (Marker.markWord r zero one b) |
| have hd := decoderNameCost_modify H D a b (Marker.markWord r zero one b) |
| have hm := Marker.markWord_cost (r:=r) zero one b |
| unfold fixedWindowCost |
| rw [←add_div] |
| apply div_le_div_of_nonneg_right _ (by positivity) |
| push_cast at * |
| nlinarith |
| end HyperbolicCoding |
| |
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {A B C : Type*} {k t R : ℕ} |
| |
| lemma finite_sum_injective_le {ι κ : Type*} [Fintype ι] [Fintype κ] |
| (f : ι → κ) (hf : Function.Injective f) (g : κ → ℝ) (hg : ∀ j,0≤g j) : |
| (∑ i,g (f i))≤∑ j,g j := by |
| classical |
| calc |
| _=(∑ j∈Finset.univ.image f,g j) := (Finset.sum_image (fun i hi i' hi' h => hf h)).symm |
| _≤_ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (fun i _ _ => hg i) |
| |
| lemma fixedWindowCost_factor_triangle (F : C → A) (H : C → B) |
| (D : (Fin (2*R+1) → A) → B) (a : Fin k → C) (b : Fin (k+t) → C) (d : Fin (k+t) → A) : |
| fixedWindowCost F H D a d≤normalizedPrefixCost id a b+ |
| fixedWindowCost F H D (fun i => b (Fin.castAdd t i)) d := by |
| let b₀ : Fin k → C := fun i => b (Fin.castAdd t i) |
| have hp : prefixNameCost F a d≤prefixNameCost id a b+prefixNameCost F b₀ d := by |
| unfold prefixNameCost |
| rw [←Finset.sum_add_distrib] |
| apply Finset.sum_le_sum |
| intro i _ |
| exact (symbolCost_triangle _ (F (b₀ i)) _).trans |
| (add_le_add_left (symbolCost_factor_le F (a i) (b₀ i)) _) |
| have hd : decoderNameCost H D a d≤prefixNameCost id a b+decoderNameCost H D b₀ d := by |
| have hh : decoderNameCost H D a d≤ |
| (∑ i : Fin (k-2*R),symbolCost (blockCenter a i) (blockCenter b₀ i))+decoderNameCost H D b₀ d := by |
| unfold decoderNameCost |
| rw [←Finset.sum_add_distrib] |
| apply Finset.sum_le_sum |
| intro i _ |
| exact (symbolCost_triangle _ (H (blockCenter b₀ i)) _).trans |
| (add_le_add_left (symbolCost_factor_le H (blockCenter a i) (blockCenter b₀ i)) _) |
| apply hh.trans |
| apply add_le_add_left |
| let f : Fin (k-2*R) → Fin k := fun i => ⟨i.val+R,by have := i.isLt; omega⟩ |
| have hf : Function.Injective f := by |
| intro i j h |
| have hh := congrArg Fin.val h |
| apply Fin.ext |
| dsimp [f] at hh |
| omega |
| exact finite_sum_injective_le f hf (fun i => symbolCost (a i) (b₀ i)) (fun _ => symbolCost_nonneg _ _) |
| unfold fixedWindowCost normalizedPrefixCost |
| have hn0 : (0 : ℝ)≤(k+t : ℕ) := Nat.cast_nonneg _ |
| by_cases hn : k+t=0 |
| · simp [hn] |
| · have hnpos : (0 : ℝ)<(k+t : ℕ) := Nat.cast_pos.mpr (Nat.pos_of_ne_zero hn) |
| apply (div_le_iff₀ (by positivity : (0 : ℝ)<2*(k+t : ℕ))).mpr |
| have heq : (prefixNameCost id a b/(k+t : ℕ)+ |
| (prefixNameCost F b₀ d+decoderNameCost H D b₀ d)/(2*(k+t : ℕ)))*(2*(k+t : ℕ))= |
| 2*prefixNameCost id a b+(prefixNameCost F b₀ d+decoderNameCost H D b₀ d) := by field_simp |
| change prefixNameCost F a d+decoderNameCost H D a d≤_ |
| rw [heq] |
| linarith |
| |
| variable [MeasurableSpace A] |
| |
| lemma graph_window_word [Fintype A] [MeasurableSingletonClass A] |
| [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] |
| (_decoder : (Fin (2*R+1) → A) → B) (y : ℤ → A) (i : Fin (k-2*R)) : |
| centeredWindow R (iidShift^[i.val+R] y)=blockWindow (word iidShift (fun y : ℤ → A => y 0) (k+t) y) i := by |
| funext j |
| simp only [centeredWindow,iidShift_iterate,blockWindow,iid_word_eq] |
| congr 1 |
| omega |
| |
| variable [Fintype A] [MeasurableSingletonClass A] |
| [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] |
| |
| lemma graph_fixedWindowCost_zero (D : (Fin (2*R+1) → A) → B) (y : ℤ → A) : |
| fixedWindowCost (k:=k) (t:=t) Prod.fst Prod.snd D |
| (word iidShift (fun w : ℤ → A => (w 0,D (centeredWindow R w))) k y) |
| (word iidShift (fun w : ℤ → A => w 0) (k+t) y)=0 := by |
| have hp : prefixNameCost Prod.fst |
| (word iidShift (fun w : ℤ → A => (w 0,D (centeredWindow R w))) k y) |
| (word iidShift (fun w : ℤ → A => w 0) (k+t) y)=0 := by simp [prefixNameCost,word,symbolCost] |
| have hd : decoderNameCost Prod.snd D |
| (word iidShift (fun w : ℤ → A => (w 0,D (centeredWindow R w))) k y) |
| (word iidShift (fun w : ℤ → A => w 0) (k+t) y)=0 := by |
| unfold decoderNameCost |
| apply Finset.sum_eq_zero |
| intro i _ |
| dsimp only [blockCenter,word,Prod.snd] |
| rw [graph_window_word D y i,symbolCost_self] |
| simp only [fixedWindowCost,hp,hd,add_zero,zero_div] |
| |
| theorem lift_joint_graph_transport {X : Type*} [MeasurableSpace X] |
| (μ : Measure X) [IsProbabilityMeasure μ] (e : X → X) (he : Measurable e) |
| (p : X → A×B) (hp : Measurable p) |
| (ν : Measure (ℤ → A)) [IsProbabilityMeasure ν] |
| (D : (Fin (2*R+1) → A) → B) |
| (S : MatrixCoupling (mass μ (word e p (k+t))) |
| (mass ν (word iidShift (fun y : ℤ → A => (y 0,D (centeredWindow R y))) (k+t)))) : |
| ∃ T : MatrixCoupling (mass μ (word e p k)) (mass ν (word iidShift (fun y : ℤ → A => y 0) (k+t))), |
| T.cost (fixedWindowCost Prod.fst Prod.snd D)≤S.cost nameCost/(k+t : ℕ) := by |
| classical |
| obtain ⟨P,hP⟩ := lift_prefix_transport (k:=k) (t:=t) μ e he p hp id S |
| let g : (ℤ → A) → A×B := fun y => (y 0,D (centeredWindow R y)) |
| have hg : Measurable g := (measurable_pi_apply 0).prodMk ((measurable_of_countable D).comp (measurable_centeredWindow R)) |
| let Q := MatrixCoupling.observations ν (word iidShift g (k+t)) |
| (word iidShift (fun y : ℤ → A => y 0) (k+t)) |
| (word_measurable iidShift iidShift.measurable g hg _) |
| (word_measurable iidShift iidShift.measurable _ (measurable_pi_apply 0) _) |
| let c := fun (a : Fin (k+t) → A×B) (b : Fin (k+t) → A) => |
| fixedWindowCost Prod.fst Prod.snd D (fun i : Fin k => a (Fin.castAdd t i)) b |
| have hQ : Q.cost c=0 := by |
| rw [MatrixCoupling.observations_cost] |
| have hzero (y : ℤ → A) : c (word iidShift g (k+t) y) (word iidShift (fun y : ℤ → A => y 0) (k+t) y)=0 := |
| graph_fixedWindowCost_zero D y |
| simp only [hzero,integral_zero] |
| refine ⟨P.comp Q,?_⟩ |
| have hh := P.comp_cost_le Q (normalizedPrefixCost id) c (fixedWindowCost Prod.fst Prod.snd D) |
| (fixedWindowCost_factor_triangle Prod.fst Prod.snd D) |
| rw [hQ,add_zero] at hh |
| exact hh.trans hP |
| end HyperbolicCoding |
| |
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X A B : Type*} [MeasurableSpace X] [StandardBorelSpace X] |
| [TopologicalSpace X] [SecondCountableTopology X] [OpensMeasurableSpace X] |
| [MeasurableSpace A] [Fintype A] [DecidableEq A] [MeasurableSingletonClass A] [Nonempty A] |
| [TopologicalSpace A] [DiscreteTopology A] [BorelSpace A] |
| [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] [Nonempty B] |
| |
| theorem fixed_window_fd_graph (μ : Measure X) [IsProbabilityMeasure μ] [NullSingletonClass μ] |
| (e : X ≃ᵐ X) (he : Ergodic e μ) (p : X → A) (hp : Measurable p) |
| (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) (hβentropy : 0<weightEntropy β) |
| (H : FiniteRateSupremum μ e (weightEntropy β)) |
| (hcode : MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β))) |
| (α : X → B) (hα : Measurable α) |
| (happrox : ∀ ε : ℝ,0<ε → ∃ r : X → A×B,Measurable r ∧ WeakBernoulliProcess μ e r ∧ |
| μ.real {x | (p x,α x)≠r x}<ε) {η : ℝ} (hη : 0<η) : |
| ∃ R : ℕ,∃ D : (Fin (2*R+1) → A) → B,∃ s : ℕ,0<s ∧ |
| ∀ n : ℕ,∃ W : MatrixCoupling (mass μ (word e (fun x => (p x,α x)) (n*s))) |
| (mass (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)) |
| (word iidShift (fun y : ℤ → A => (y 0,D (centeredWindow R y))) (n*s))), |
| W.cost nameCost≤η*(n*s : ℕ) := by |
| let : IsProbabilityMeasure (finiteWeightLaw β) := finiteWeightLaw_probability β hβ hβsum |
| obtain ⟨m,s,hs,δ,hδ,hfd⟩ := weakBernoulli_limit_finite_determination (Y:=ℤ → A) |
| μ e he.toMeasurePreserving (fun x => (p x,α x)) (hp.prodMk hα) happrox hη |
| obtain ⟨R,D,hLaw,hRate⟩ := relative_iid_window_graph μ e he p hp β hβ hβsum hβentropy H hcode α hα m hδ |
| refine ⟨R,D,s,hs,?_⟩ |
| apply hfd _ inferInstance iidShift (iidShift_preserving _) _ |
| ((measurable_pi_apply 0).prodMk ((measurable_of_countable D).comp (measurable_centeredWindow R))) hLaw |
| simp only [Function.comp_apply] |
| rw [hRate] |
| have hh := H.upper (fun x => (p x,α x)) (hp.prodMk hα) |
| linarith |
| end HyperbolicCoding |
| |
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set Filter StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal Topology |
| variable {X A C : Type*} [MeasurableSpace X] |
| [Fintype A] [DecidableEq A] [Nonempty A] |
| [MeasurableSpace C] [Fintype C] [DecidableEq C] [MeasurableSingletonClass C] |
| |
| theorem synchronized_cost_producer [MeasurableSpace A] [MeasurableSingletonClass A] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (f : X → X) (hf : MeasurePreserving f μ μ) |
| (htotal : ∀ m : ℕ, 0 < m → Ergodic (f^[m]) μ) |
| (p : X → C) (hp : Measurable p) |
| (β : 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)), |
| ∀ (c : (Fin (n*K*m) → C) → (Fin (n*K*m+n*m) → A) → ℝ), |
| (∀ a b,0≤c a b) → (∀ a b,c a b≤1) → |
| ∀ (d : ℝ), (∀ a b,c a (Marker.markWord r zero one b)≤c a b+d) → |
| ∃ (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 c<R.cost c+ε+d := 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 c hc0 hc1 d hd |
| 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) |
| c hc0 hc1 d hd |
| 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] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
| |
| lemma tower_error_integral [StandardBorelSpace X] |
| (μ : Measure X) [IsFiniteMeasure μ] (e : X ≃ᵐ X) |
| (he : MeasurePreserving e μ μ) {U : Set X} (hU : MeasurableSet U) (m : ℕ) |
| (p q : X → A) (hp : Measurable p) (hq : Measurable q) : |
| μ.real {x | p x≠q x}≤μ.real (⋃ i : Fin m,(e^[i.val]) '' U)ᶜ+ |
| ∫ b in U,∑ i : Fin m,symbolCost (p (e^[i.val] b)) (q (e^[i.val] b)) ∂μ := by |
| let Bad := fun i : Fin m => U∩{b | p (e^[i.val] b)≠q (e^[i.val] b)} |
| have hsub : {x | p x≠q x}⊆(⋃ i : Fin m,(e^[i.val]) '' U)ᶜ ∪ |
| ⋃ i : Fin m,(e^[i.val]) '' Bad i := by |
| intro x hx |
| by_cases ht : x∈⋃ i : Fin m,(e^[i.val]) '' U |
| · obtain ⟨i,b,hb,rfl⟩ := mem_iUnion.mp ht |
| exact Or.inr (mem_iUnion.mpr ⟨i,b,⟨hb,hx⟩,rfl⟩) |
| · exact Or.inl ht |
| have hbound : μ {x | p x≠q x}≤μ (⋃ i : Fin m,(e^[i.val]) '' U)ᶜ+∑ i : Fin m,μ (Bad i) := by |
| calc |
| _≤_ := measure_mono hsub |
| _≤μ (⋃ i : Fin m,(e^[i.val]) '' U)ᶜ+μ (⋃ i : Fin m,(e^[i.val]) '' Bad i) := measure_union_le _ _ |
| _≤μ (⋃ i : Fin m,(e^[i.val]) '' U)ᶜ+∑' i : Fin m,μ ((e^[i.val]) '' Bad i) := add_le_add_right (measure_iUnion_le _) _ |
| _=_ := by simp only [measure_iterate_image μ e he,tsum_fintype] |
| have hsumfin : (∑ i : Fin m,μ (Bad i))≠⊤ := ENNReal.sum_ne_top.mpr (fun i _ => measure_ne_top _ _) |
| have hreal := ENNReal.toReal_mono (show μ (⋃ i : Fin m,(e^[i.val]) '' U)ᶜ+∑ i : Fin m,μ (Bad i)≠⊤ from ENNReal.add_ne_top.mpr ⟨measure_ne_top _ _,hsumfin⟩) hbound |
| rw [ENNReal.toReal_add (measure_ne_top _ _) hsumfin,ENNReal.toReal_sum (by intro i hi; exact measure_ne_top _ _)] at hreal |
| have hint (i : Fin m) : Integrable (fun b => symbolCost (p (e^[i.val] b)) (q (e^[i.val] b))) (μ.restrict U) := |
| integrable_finite_observation (μ.restrict U) (fun b => (p (e^[i.val] b),q (e^[i.val] b))) |
| ((hp.comp (e.measurable.iterate i.val)).prodMk (hq.comp (e.measurable.iterate i.val))) |
| (fun a => symbolCost a.1 a.2) |
| rw [integral_finsetSum _ (fun i _ => hint i)] |
| have heq (i : Fin m) : (∫ b in U,symbolCost (p (e^[i.val] b)) (q (e^[i.val] b)) ∂μ)=μ.real (Bad i) := by |
| rw [finite_symbolCost_integral (μ.restrict U) (fun b => p (e^[i.val] b)) (fun b => q (e^[i.val] b)) (hp.comp (e.measurable.iterate i.val)) (hq.comp (e.measurable.iterate i.val))] |
| rw [Measure.real,Measure.restrict_apply' hU,inter_comm] |
| rfl |
| simp only [heq] |
| exact hreal |
| 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] |
|
|
| lemma boundedCost_left_triangle {B D : Type*} (c : B → D → ℝ) |
| (h0 : ∀ a b,0≤c a b) (h1 : ∀ a b,c a b≤1) (a b : B) (d : D) : |
| c a d≤ symbolCost a b+c b d := by |
| classical |
| by_cases h : a=b |
| · subst b; simp [symbolCost] |
| · simp only [symbolCost,ite_eq_right h] |
| linarith [h0 b d,h1 a d] |
|
|
| theorem lift_cost_transport [Nonempty C] (μ : 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) |
| (c : (Fin k → C) → (Fin (k+t) → A) → ℝ) |
| (hc0 : ∀ a b,0≤c a b) (hc1 : ∀ a b,c a b≤1) |
| (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) ∧ |
| (∫ x in U,c (word e p k x) (word e q (k+t) x) ∂μ)≤μ.real U*(R.cost c+ε) ∧ |
| (∀ x,x∉⋃ i : Fin (k+t),(e^[i.val]) '' U → q x=F (p x)) ∧ |
| μ.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 hC := S.comp_cost_le R symbolCost c c (boundedCost_left_triangle c hc0 hc1) |
| 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 d => symbolCost_triangle a b (D d)) |
| 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 hWC : W'.cost c≤μ.real U*(R.cost c+ε) := by |
| change W.cost c≤_ |
| rw [MatrixCoupling.scale_cost] |
| apply mul_le_mul_of_nonneg_left _ hc |
| linarith |
| 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,hjoint,hbase,_hpaint,hoff⟩ := |
| realize_prefix_tower_coupling μ e he.toMeasurePreserving hU k t hd p hp F _ W' |
| 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 => by rw [hbase w,hmark w hw,mul_zero]) |
| have hb := marked_tower_prefix_decoder_error μ e he.toMeasurePreserving p q hn hr zero one h01 D c₀ hU hmarked |
| rw [prefix_tower_decoder_error μ e hU k t p q hp hq W' hjoint D] at hb |
| refine ⟨U,q,hU,hUp,hq,hd,hcover,hbase,?_,hoff,?_⟩ |
| · rw [integral_cost_of_realization (μ.restrict U) (word e p k) hw (word e q (k+t)) |
| (word_measurable e e.measurable q hq _) W' hjoint c] |
| exact hWC |
| · 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 hD0 := R.cost_nonneg (fun a b => symbolCost a (D b)) (fun _ _ => symbolCost_nonneg _ _) |
| have hh := mul_le_mul_of_nonneg_right hmass |
| (show 0≤ε+R.cost (fun a b => symbolCost a (D b)) by linarith) |
| have hbound := mul_le_mul_of_nonneg_left hWD (Nat.cast_nonneg (k+t)) |
| nlinarith |
| end HyperbolicCoding |
| |
| end |
| |
| end OAI |
| |
