| import OAI.Dynamics.StandardMap.EntropyEndpoint |
| import OAI.Dynamics.StandardMap.Coupling.FiniteConditionalLawTests |
| import OAI.Dynamics.StandardMap.Coupling.FiniteVectorEntropy |
|
|
| namespace OAI |
|
|
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X Y A B : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
| [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] |
|
|
| lemma observations_vector_cost [Nonempty B] (μ : Measure X) [IsProbabilityMeasure μ] |
| (N : ℕ) (P : X → Fin N → A) (Q : X → Fin N → B) (hP : Measurable P) (hQ : Measurable Q) |
| (d : A → B → ℝ) : |
| (MatrixCoupling.observations μ P Q hP hQ).cost (fun v w => ∑ i,d (v i) (w i))= |
| ∑ i : Fin N,(MatrixCoupling.observations μ (fun x => P x i) (fun x => Q x i) |
| ((measurable_pi_apply i).comp hP) ((measurable_pi_apply i).comp hQ)).cost d := by |
| simp only [MatrixCoupling.observations_cost] |
| exact integral_finsetSum _ (fun i _ => integrable_finite_observation μ |
| (fun x => (P x i,Q x i)) (((measurable_pi_apply i).comp hP).prodMk |
| ((measurable_pi_apply i).comp hQ)) (fun ab => d ab.1 ab.2)) |
|
|
| lemma recodingLaw_entropy_lower [Nonempty B] (μ : Measure X) [IsProbabilityMeasure μ] |
| (p : X → A) (r : X → B) (hp : Measurable p) (hr : Measurable r) |
| (ν : Measure Y) [IsProbabilityMeasure ν] (N : ℕ) (Q : Y → Fin N → A) (hQ : Measurable Q) |
| {η : ℝ} |
| (hin : ∀ i : Fin N,obs ν (fun y => Q y i)≤obs μ p+η) |
| (hout : ∀ i : Fin N,obs μ r-η≤obs (recodingLaw μ p r hp hr ν N Q) (fun vw => vw.2 i)) : |
| obs ν Q+(N : ℝ)*(obs μ r-obs μ p-2*η)≤ |
| obs (recodingLaw μ p r hp hr ν N Q) Prod.snd := by |
| have := recodingLaw_probability μ p r hp hr ν N Q hQ |
| have hh := finiteChannelLaw_entropy N (mass ν Q) (mass_nonneg _ _) |
| (by simpa using mass_sum ν Q hQ) (fun _ => recodingKernel μ p r hp hr) |
| (fun _ => recodingKernel_nonneg μ p r hp hr) (fun _ => recodingKernel_sum μ p r hp hr) |
| change obs ν Q+(∑ i : Fin N,(obs (recodingLaw μ p r hp hr ν N Q) (fun vw => vw.2 i)- |
| obs (recodingLaw μ p r hp hr ν N Q) (fun vw => vw.1 i)))≤_ at hh |
| apply le_trans _ hh |
| apply add_le_add (le_refl _) |
| calc |
| _=∑ _i : Fin N,(obs μ r-obs μ p-2*η) := by simp; ring |
| _≤_ := by |
| apply Finset.sum_le_sum |
| intro i _ |
| have he : obs (recodingLaw μ p r hp hr ν N Q) (fun vw => vw.1 i)=obs ν (fun y => Q y i) := by |
| unfold obs |
| congr 1 |
| funext a |
| exact recodingLaw_input_coordinate μ p r hp hr ν N Q hQ i a |
| rw [he] |
| linarith [hin i,hout i] |
|
|
| lemma recodingLaw_transport_cost [Nonempty B] (μ : Measure X) [IsProbabilityMeasure μ] |
| (p : X → A) (r : X → B) (hp : Measurable p) (hr : Measurable r) |
| (ν : Measure Y) [IsProbabilityMeasure ν] (N : ℕ) (Q : Y → Fin N → A) (hQ : Measurable Q) |
| {δ M : ℝ} (hM : 0≤M) (hlaw : ∀ i : Fin N,LawClose (μ.map p) (ν.map (fun y => Q y i)) δ) |
| (d : A → B → ℝ) (hd : ∀ a b,|d a b|≤M) : |
| ∃ R : MatrixCoupling (mass ν Q) (mass (recodingLaw μ p r hp hr ν N Q) Prod.snd), |
| R.cost (fun v w => ∑ i,d (v i) (w i))≤ |
| (N : ℝ)*((MatrixCoupling.observations μ p r hp hr).cost d+2*δ*M) := by |
| let ξ := recodingLaw μ p r hp hr ν N Q |
| have : IsProbabilityMeasure ξ := recodingLaw_probability μ p r hp hr ν N Q hQ |
| let S := MatrixCoupling.observations ξ Prod.fst Prod.snd measurable_fst measurable_snd |
| let R : MatrixCoupling (mass ν Q) (mass ξ Prod.snd) := { |
| weight := S.weight |
| nonneg := S.nonneg |
| row := fun v => (S.row v).trans (recodingLaw_input_mass μ p r hp hr ν N Q v) |
| col := S.col } |
| refine ⟨R,?_⟩ |
| change S.cost (fun v w => ∑ i,d (v i) (w i))≤_ |
| rw [observations_vector_cost] |
| calc |
| _≤∑ _i : Fin N,((MatrixCoupling.observations μ p r hp hr).cost d+2*δ*M) := by |
| apply Finset.sum_le_sum |
| intro i _ |
| apply channel_cost_stability μ ξ p r (fun vw => vw.1 i) (fun vw => vw.2 i) hp hr |
| ((measurable_pi_apply i).comp measurable_fst) ((measurable_pi_apply i).comp measurable_snd) |
| (recodingKernel μ p r hp hr) (recodingKernel_nonneg μ p r hp hr) |
| (recodingKernel_sum μ p r hp hr) (recodingKernel_joint μ p r hp hr) |
| (recodingLaw_joint_coordinate μ p r hp hr ν N Q hQ i) hM _ d hd |
| change LawClose (μ.map p) ((recodingLaw μ p r hp hr ν N Q).map (fun vw => vw.1 i)) δ |
| rw [recodingLaw_input_law μ p r hp hr ν N Q hQ i] |
| exact hlaw i |
| _=_ := by simp; ring |
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X Y A : Type*} |
|
|
| noncomputable def nestedPack (M J s : ℕ) : (Fin ((M*J)*s) → A) ≃ (Fin M → Fin J → Fin s → A) := |
| (wordPack (M*J) s).trans (wordPack M J) |
|
|
| lemma nestedPack_symm [MeasurableSpace Y] [StandardBorelSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (M J s : ℕ) (V : Y → Fin M → Fin J → Fin s → A) : |
| (nestedPack M J s).symm ∘ V=nestedOutput M J s V := rfl |
|
|
| lemma nestedPack_word [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (f : X → X) (p : X → A) (M J s : ℕ) (x : X) : |
| nestedPack M J s (word f p ((M*J)*s) x)= |
| word (f^[J*s]) (word (f^[s]) (word f p s) J) M x := by |
| funext I j a |
| simp only [nestedPack,Equiv.trans_apply,wordPack_apply_coord,word] |
| change p (f^[a.val+s*(j.val+J*I.val)] x)=_ |
| simp only [←Function.iterate_mul,←Function.iterate_add_apply] |
| congr 2 |
| ring |
|
|
| lemma obs_nestedPack_word [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (f : X → X) (p : X → A) (M J s : ℕ) : |
| obs μ (word (f^[J*s]) (word (f^[s]) (word f p s) J) M)= |
| obs μ (word f p ((M*J)*s)) := by |
| simpa only [Function.comp_def,nestedPack_word] using |
| obs_equiv μ (word f p ((M*J)*s)) (nestedPack M J s) |
|
|
| lemma obs_nestedOutput [MeasurableSpace Y] [StandardBorelSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (ν : Measure Y) [IsProbabilityMeasure ν] |
| (M J s : ℕ) (V : Y → Fin M → Fin J → Fin s → A) : |
| obs ν (nestedOutput M J s V)=obs ν V := |
| obs_equiv ν V (nestedPack M J s).symm |
|
|
| noncomputable def fineWordCost (J s : ℕ) (v w : Fin J → Fin s → A) : ℝ := |
| nameCost ((wordPack J s).symm v) ((wordPack J s).symm w) |
|
|
| lemma fineWordCost_sum [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (J s : ℕ) (v w : Fin J → Fin s → A) : |
| fineWordCost J s v w=∑ j,nameCost (v j) (w j) := by |
| simp only [fineWordCost,nameCost_wordPack,Equiv.apply_symm_apply] |
|
|
| lemma nameCost_nestedPack [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (M J s : ℕ) (v w : Fin ((M*J)*s) → A) : |
| nameCost v w=∑ I : Fin M,fineWordCost J s (nestedPack M J s v I) (nestedPack M J s w I) := by |
| rw [nameCost_wordPack,←Equiv.sum_comp finProdFinEquiv (fun i : Fin (M*J) => |
| nameCost (wordPack (M*J) s v i) (wordPack (M*J) s w i)),Fintype.sum_prod_type] |
| simp only [fineWordCost_sum,nestedPack,Equiv.trans_apply,wordPack_apply_coord] |
|
|
| lemma observations_word_cost [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (f : X → X) (hf : MeasurePreserving f μ μ) (p r : X → A) (hp : Measurable p) (hr : Measurable r) |
| (n : ℕ) : |
| (MatrixCoupling.observations μ (word f p n) (word f r n) |
| (word_measurable f hf.measurable p hp n) (word_measurable f hf.measurable r hr n)).cost nameCost= |
| (n : ℝ)*μ.real {x | p x≠r x} := by |
| rw [show nameCost=(fun v w : Fin n → A => ∑ i,symbolCost (v i) (w i)) from rfl, |
| observations_vector_cost] |
| have hi (i : Fin n) : (MatrixCoupling.observations μ (fun x => word f p n x i) |
| (fun x => word f r n x i) ((measurable_pi_apply i).comp (word_measurable f hf.measurable p hp n)) |
| ((measurable_pi_apply i).comp (word_measurable f hf.measurable r hr n))).cost symbolCost= |
| μ.real {x | p x≠r x} := by |
| rw [MatrixCoupling.observations_cost] |
| rw [finite_symbolCost_integral μ (fun x => word f p n x i) (fun x => word f r n x i) |
| ((measurable_pi_apply i).comp (word_measurable f hf.measurable p hp n)) |
| ((measurable_pi_apply i).comp (word_measurable f hf.measurable r hr n))] |
| change μ.real ((f^[i.val]) ⁻¹' {x | p x≠r x})=μ.real {x | p x≠r x} |
| exact congrArg ENNReal.toReal ((hf.iterate i.val).measure_preimage |
| (measurableSet_eq_fun hp hr).compl.nullMeasurableSet) |
| simp only [hi,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] |
| |
| lemma observations_fineWordCost [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (f : X → X) (hf : MeasurePreserving f μ μ) (p r : X → A) (hp : Measurable p) (hr : Measurable r) |
| (J s : ℕ) : |
| (MatrixCoupling.observations μ (word (f^[s]) (word f p s) J) (word (f^[s]) (word f r s) J) |
| (word_measurable _ (hf.measurable.iterate _) _ (word_measurable f hf.measurable p hp s) J) |
| (word_measurable _ (hf.measurable.iterate _) _ (word_measurable f hf.measurable r hr s) J)).cost |
| (fineWordCost J s)=(J*s : ℕ)*μ.real {x | p x≠r x} := by |
| rw [MatrixCoupling.observations_cost] |
| have he (x : X) : fineWordCost J s (word (f^[s]) (word f p s) J x) |
| (word (f^[s]) (word f r s) J x)=nameCost (word f p (J*s) x) (word f r (J*s) x) := by |
| simp only [fineWordCost,←wordPack_apply,Equiv.symm_apply_apply] |
| simp_rw [he] |
| rw [←MatrixCoupling.observations_cost μ _ _ |
| (word_measurable f hf.measurable p hp _) (word_measurable f hf.measurable r hr _)] |
| exact observations_word_cost μ f hf p r hp hr (J*s) |
| |
| lemma fineWordCost_abs_le [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (J s : ℕ) (v w : Fin J → Fin s → A) : |
| |fineWordCost J s v w|≤(J*s : ℕ) := by |
| unfold fineWordCost |
| rw [abs_of_nonneg (nameCost_nonneg _ _)] |
| exact nameCost_le_card _ _ |
| |
| lemma obs_word_rate_lower [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (f : X → X) (hf : MeasurePreserving f μ μ) (p : X → A) (hp : Measurable p) (n : ℕ) : |
| (n : ℝ)*rate μ f p≤obs μ (word f p n) := by |
| by_cases hn : n=0 |
| · subst n; simpa using obs_nonneg μ (word f p 0) (word_measurable f hf.measurable p hp 0) |
| · have hh := (le_div_iff₀ (show (0 : ℝ)<n by exact_mod_cast Nat.pos_of_ne_zero hn)).mp |
| (rate_le_div μ f hf p hp hn) |
| nlinarith |
| end HyperbolicCoding |
| |
| end |
| section |
| namespace HyperbolicCoding |
| lemma recoding_entropy_scalar {n j s a δ hp hr P S Q O : ℝ} |
| (hn : 0≤n) (hδ : s*δ≤a^2) |
| (hQ : n*j*s*(hp-δ)≤Q) (hP : P≤j*s*hp+j*a^2) (hS : j*s*hr≤S) |
| (hO : Q+n*(S-P-2)≤O) (hj : 0≤j) : |
| n*j*s*hr-2*(n*j)*a^2-2*n≤O := by |
| have h₁ := mul_le_mul_of_nonneg_left hP hn |
| have h₂ := mul_le_mul_of_nonneg_left hS hn |
| have h₃ := mul_le_mul_of_nonneg_left hδ (mul_nonneg hn hj) |
| nlinarith only [hQ,h₁,h₂,h₃,hO] |
| |
| lemma recoding_deficit_scalar {n j s L C a hr O : ℝ} |
| (hn : 0≤n) (hB : 2+L*C≤j*a^2) |
| (hO : n*j*s*hr-2*(n*j)*a^2-2*n≤O) : |
| n*j*(s*hr+a^2)+n*L*C-O≤4*(n*j)*a^2 := by |
| have h₁ := mul_le_mul_of_nonneg_left hB hn |
| nlinarith only [h₁,hO] |
| |
| lemma recoding_wb_cost_scalar {c n j k g L a δ D : ℝ} |
| (hn : 0≤n) (hj : 0≤j) (hk : 0≤k) (hg : 0≤g) (ha : 0<a) |
| (hδ : δ≤a) (hB : 2*L≤j*a) (hgap : g≤a*k) |
| (hD : D≤4*(n*j)*a^2) |
| (hc : c≤k*(n*j*(3*a+a+7*δ)+2*(n*L)+D/a)+n*j*g) : |
| c≤17*a*(n*j*(k+g)) := by |
| have hdiv : D/a≤4*(n*j)*a := (div_le_iff₀ ha).mpr (by nlinarith only [hD]) |
| have h₁ := mul_le_mul_of_nonneg_left hδ (mul_nonneg hn hj) |
| have h₂ := mul_le_mul_of_nonneg_left hB hn |
| have h₃ := mul_le_mul_of_nonneg_left hgap (mul_nonneg hn hj) |
| have hinside : n*j*(3*a+a+7*δ)+2*(n*L)+D/a≤16*a*(n*j) := by |
| nlinarith only [hdiv,h₁,h₂] |
| have h₄ := mul_le_mul_of_nonneg_left hinside hk |
| have h₅ := mul_nonneg (mul_nonneg (mul_nonneg hn hj) hg) ha.le |
| nlinarith only [hc,h₃,h₄,h₅] |
| end HyperbolicCoding |
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X Y A : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A] |
| |
| lemma nestedOutput_word [StandardBorelSpace X] (f : X → X) (p : X → A) (n J s : ℕ) : |
| nestedOutput n J s (word (f^[J*s]) (word (f^[s]) (word f p s) J) n)= |
| word f p ((n*J)*s) := by |
| funext x |
| change (nestedPack n J s).symm (word (f^[J*s]) (word (f^[s]) (word f p s) J) n x)=_ |
| rw [←nestedPack_word,Equiv.symm_apply_apply] |
| |
| lemma recoding_nested_entropy [StandardBorelSpace X] [StandardBorelSpace Y] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (ν : Measure Y) [IsProbabilityMeasure ν] (n J s : ℕ) |
| (P S : X → Fin J → Fin s → A) (hP : Measurable P) (hS : Measurable S) |
| (Q : Y → Fin n → Fin J → Fin s → A) (hQ : Measurable Q) |
| {a δ hp hr : ℝ} (hδ : (s : ℝ)*δ≤a^2) |
| (hQlo : ((n*J)*s : ℕ)*(hp-δ)≤obs ν Q) |
| (hPhi : obs μ P≤(J*s : ℕ)*hp+(J : ℝ)*a^2) |
| (hSlo : (J*s : ℕ)*hr≤obs μ S) |
| (hin : ∀ i : Fin n,obs ν (fun y => Q y i)≤obs μ P+1) |
| (hout : ∀ i : Fin n,obs μ S-1≤obs (recodingLaw μ P S hP hS ν n Q) (fun vw => vw.2 i)) : |
| ((n*J)*s : ℕ)*hr-2*(n*J : ℕ)*a^2-2*(n : ℝ)≤ |
| obs (recodingLaw μ P S hP hS ν n Q) (nestedOutput n J s Prod.snd) := by |
| let : StandardBorelSpace (Fin n → Fin J → Fin s → A) := inferInstance |
| have := recodingLaw_probability μ P S hP hS ν n Q hQ |
| rw [obs_nestedOutput] |
| have hh := recodingLaw_entropy_lower μ P S hP hS ν n Q hQ hin hout |
| push_cast at hQlo hPhi hSlo ⊢ |
| exact recoding_entropy_scalar (Nat.cast_nonneg n) hδ hQlo hPhi hSlo (by simpa only [mul_one] using hh) |
| (Nat.cast_nonneg J) |
| |
| lemma nested_reindex_transport [StandardBorelSpace Y] |
| {Z : Type*} [MeasurableSpace Z] [StandardBorelSpace Z] |
| (ν : Measure Y) [IsProbabilityMeasure ν] (ξ : Measure Z) [IsProbabilityMeasure ξ] |
| (n J s : ℕ) (Q : Y → Fin n → Fin J → Fin s → A) (V : Z → Fin n → Fin J → Fin s → A) |
| (R : MatrixCoupling (mass ν Q) (mass ξ V)) : |
| ∃ R' : MatrixCoupling (mass ν (nestedOutput n J s Q)) (mass ξ (nestedOutput n J s V)), |
| R'.cost nameCost=R.cost (fun v w => ∑ i,fineWordCost J s (v i) (w i)) := by |
| let E := nestedPack (A:=A) n J s |
| let U := R.reindex E E |
| have hrow (w : Fin ((n*J)*s) → A) : mass ν Q (E w)=mass ν (nestedOutput n J s Q) w := |
| (mass_equiv_inverse_finite ν Q E.symm w).symm |
| have hcol (w : Fin ((n*J)*s) → A) : mass ξ V (E w)=mass ξ (nestedOutput n J s V) w := |
| (mass_equiv_inverse_finite ξ V E.symm w).symm |
| let R' : MatrixCoupling (mass ν (nestedOutput n J s Q)) (mass ξ (nestedOutput n J s V)) := { |
| weight := U.weight |
| nonneg := U.nonneg |
| row := fun w => (U.row w).trans (hrow w) |
| col := fun w => (U.col w).trans (hcol w) } |
| refine ⟨R',?_⟩ |
| change U.cost nameCost=_ |
| have hc : (nameCost : (Fin ((n*J)*s) → A) → (Fin ((n*J)*s) → A) → ℝ)= |
| fun v w => ∑ i,fineWordCost J s (E v i) (E w i) := |
| funext (fun v => funext (fun w => nameCost_nestedPack n J s v w)) |
| rw [hc] |
| exact MatrixCoupling.reindex_cost R E E (fun v w => ∑ i,fineWordCost J s (v i) (w i)) |
| |
| lemma recoding_nested_transport [StandardBorelSpace X] [StandardBorelSpace Y] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (ν : Measure Y) [IsProbabilityMeasure ν] (n J s : ℕ) |
| (P S : X → Fin J → Fin s → A) (hP : Measurable P) (hS : Measurable S) |
| (Q : Y → Fin n → Fin J → Fin s → A) (hQ : Measurable Q) |
| {δ : ℝ} (hb : ∀ i : Fin n,LawClose (μ.map P) (ν.map (fun y => Q y i)) δ) : |
| ∃ R : MatrixCoupling (mass ν (nestedOutput n J s Q)) |
| (mass (recodingLaw μ P S hP hS ν n Q) (nestedOutput n J s Prod.snd)), |
| R.cost nameCost≤(n : ℝ)*((MatrixCoupling.observations μ P S hP hS).cost |
| (fineWordCost J s)+2*δ*(J*s : ℕ)) := by |
| let : StandardBorelSpace (Fin n → Fin J → Fin s → A) := inferInstance |
| let ξ := recodingLaw μ P S hP hS ν n Q |
| have : IsProbabilityMeasure ξ := recodingLaw_probability μ P S hP hS ν n Q hQ |
| obtain ⟨R,hR⟩ := recodingLaw_transport_cost μ P S hP hS ν n Q hQ |
| (Nat.cast_nonneg (J*s)) hb (fineWordCost J s) (fineWordCost_abs_le J s) |
| obtain ⟨R',hR'⟩ := nested_reindex_transport ν ξ n J s Q Prod.snd R |
| exact ⟨R',hR'.trans_le hR⟩ |
| |
| lemma block_recoding_small_cost [StandardBorelSpace X] [StandardBorelSpace Y] |
| (μ : Measure X) (ν : Measure Y) |
| [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] [NullSingletonClass μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) (r : X → A) (hr : Measurable r) |
| (k g L n J : ℕ) (V : Y → Fin n → Fin J → Fin (k+g) → A) (hV : Measurable V) |
| {a δ : ℝ} (ha : 0<a) (hδ₀ : 0≤δ) (hδ : δ≤a) |
| (hgap : (g : ℝ)≤a*k) (hB₁ : 2+(L : ℝ)*Real.log (Fintype.card (Fin (k+g) → A))≤(J : ℝ)*a^2) |
| (hB₂ : 2*(L : ℝ)≤(J : ℝ)*a) |
| (hremote : ∀ T : ℕ,LawClose |
| (μ.map (fun x => (word e r T (e^[k+g] x),word e r k x))) |
| ((μ.map (fun x => word e r T (e^[k+g] x))).prod (μ.map (word e r k))) a) |
| (hlaw : ∀ I : Fin n,LawClose |
| (μ.map (word (e^[k+g]) (word e r (k+g)) J)) (ν.map (fun y => V y I)) δ) |
| (htest : ∀ (q : Y → Fin (k+g) → A) (v : Y → Fin L → Fin (k+g) → A), |
| Measurable q → Measurable v → |
| LawClose (μ.map (fun x => (word e r (k+g) x, |
| word (e^[k+g]) (word e r (k+g)) L (e^[k+g] x)))) |
| (ν.map (fun y => (q y,v y))) δ → StandardMapEntropy.Entropy.cond ν q v≤ |
| (k+g : ℕ)*rate μ e r+a^2) |
| (hentropy : ((n*J)*(k+g) : ℕ)*rate μ e r-2*(n*J : ℕ)*a^2-2*(n : ℝ)≤ |
| obs ν (nestedOutput n J (k+g) V)) : |
| ∃ R : MatrixCoupling (mass μ (word e r ((n*J)*(k+g)))) |
| (mass ν (nestedOutput n J (k+g) V)), |
| R.cost nameCost≤17*a*((n*J)*(k+g) : ℕ) := by |
| have hH : 0≤(k+g : ℕ)*rate μ e r+a^2 := by |
| have := rate_nonneg μ e he r hr |
| positivity |
| obtain ⟨R,hR⟩ := block_recoding_word_transport μ ν e he r hr k g L n J V hV |
| ha.le ha hδ₀ hH hremote hlaw htest |
| refine ⟨R,?_⟩ |
| have hD : (n*J : ℕ)*((k+g : ℕ)*rate μ e r+a^2)+(n*L : ℕ)*Real.log (Fintype.card (Fin (k+g) → A))- |
| obs ν (nestedOutput n J (k+g) V)≤4*(n*J : ℕ)*a^2 := by |
| push_cast at hentropy ⊢ |
| exact recoding_deficit_scalar (Nat.cast_nonneg n) hB₁ hentropy |
| push_cast at hR hD ⊢ |
| exact recoding_wb_cost_scalar (Nat.cast_nonneg n) (Nat.cast_nonneg J) (Nat.cast_nonneg k) |
| (Nat.cast_nonneg g) ha hδ hB₂ hgap hD hR |
| end HyperbolicCoding |
| |
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set Filter StandardMapEntropy.Entropy |
| open scoped ENNReal BigOperators |
| variable {X A B : Type*} [MeasurableSpace X] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
| [MeasurableSpace B] |
| |
| lemma WeakBernoulliProcess.factor [Fintype B] [MeasurableSingletonClass B] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (e : X ≃ᵐ X) (p : X → A) (hp : Measurable p) (hwb : WeakBernoulliProcess μ e p) |
| (d : A → B) : WeakBernoulliProcess μ e (d ∘ p) := by |
| let D : (ℕ → A) → (ℕ → B) := fun w i => d (w i) |
| have hD : Measurable D := Measurable.of_eval |
| (fun i => (measurable_of_countable d).comp (measurable_pi_apply i)) |
| intro ε hε |
| filter_upwards [hwb ε hε] with n hn |
| have h := hn.map (hD.prodMap hD) |
| have hrem := measurable_remotePair e.measurable e.symm.measurable hp n |
| have hlu := measurable_tailName e.symm.measurable hp 0 |
| have hru := measurable_tailName e.measurable hp 0 |
| rw [Measure.map_map (hD.prodMap hD) hrem] at h |
| unfold remoteProductLaw at h |
| rw [←Measure.map_prod_map _ _ hD hD,Measure.map_map hD hlu,Measure.map_map hD hru] at h |
| exact h |
| |
| theorem separating_wb_approximation [StandardBorelSpace X] |
| (μ : Measure X) [IsProbabilityMeasure μ] (e : X ≃ᵐ X) |
| (α : ℕ → ℕ → X → Bool) (hα : ∀ i j,Measurable (α i j)) |
| (hsep : Function.Injective (fun x => fun i j => α i j x)) |
| (hwb : ∀ M,WeakBernoulliProcess μ e (joinedBinary α M)) |
| [Nonempty A] (p : X → A) (hp : Measurable p) {ε : ℝ} (hε : 0<ε) : |
| ∃ q : X → A,Measurable q ∧ WeakBernoulliProcess μ e q ∧ μ.real {x | q x≠p x}<ε := by |
| obtain ⟨M,D,hD⟩ := joinedBinary_approximates μ α hα hsep p hp hε |
| exact ⟨D ∘ joinedBinary α M,(measurable_of_countable D).comp (measurable_joinedBinary hα M), |
| WeakBernoulliProcess.factor μ e (joinedBinary α M) (measurable_joinedBinary hα M) (hwb M) D,hD⟩ |
| end HyperbolicCoding |
| |
| end |
| section |
| universe u v w |
| namespace HyperbolicCoding |
| open MeasureTheory Set Filter StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal Topology |
| variable {X : Type u} {Y : Type v} {A : Type w} |
| [MeasurableSpace X] [MeasurableSpace Y] [StandardBorelSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
| |
| lemma finite_observation_entropy_test_uniform [StandardBorelSpace X] [Nonempty A] |
| (μ : Measure X) (p : X → A) (hp : Measurable p) |
| {ε : ℝ} (hε : 0<ε) : |
| ∃ δ : ℝ,0<δ ∧ ∀ (Z : Type v) [MeasurableSpace Z] (ν : Measure Z) (q : Z → A), |
| Measurable q → LawClose (μ.map p) (ν.map q) δ → |obs μ p-obs ν q|<ε := by |
| obtain ⟨δ,hδ,ht⟩ := finite_entropy_continuity (μ.map p) hε |
| refine ⟨δ,hδ,?_⟩ |
| intro Z mZ ν q hq hlaw |
| have hh := ht (ν.map q) hlaw |
| rwa [←obs_eq_entropy_map μ p hp,←obs_eq_entropy_map ν q hq] at hh |
| |
| theorem weakBernoulli_limit_finite_determination [StandardBorelSpace X] [Nonempty A] |
| (μ : Measure X) [IsProbabilityMeasure μ] [NullSingletonClass μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) (p : X → A) (hp : Measurable p) |
| (happrox : ∀ ε : ℝ,0<ε → ∃ r : X → A,Measurable r ∧ WeakBernoulliProcess μ e r ∧ |
| μ.real {x | p x≠r x}<ε) {η : ℝ} (hη : 0<η) : |
| ∃ m s₀ : ℕ,0<s₀ ∧ ∃ δ : ℝ,0<δ ∧ |
| ∀ (ν : Measure Y) (_ : IsProbabilityMeasure ν) (T : Y → Y) |
| (_hT : MeasurePreserving T ν ν) (q : Y → A),Measurable q → |
| LawClose (μ.map (word e p m)) (ν.map (word T q m)) δ → |
| rate μ e p-δ≤rate ν T q → |
| ∀ n : ℕ,∃ R : MatrixCoupling (mass μ (word e p (n*s₀))) (mass ν (word T q (n*s₀))), |
| R.cost nameCost≤η*(n*s₀ : ℕ) := by |
| let a := η/100 |
| have ha : 0<a := div_pos hη (by norm_num) |
| have ha2 : 0<a^2 := sq_pos_of_pos ha |
| obtain ⟨r,hr,hwb,hpaint⟩ := happrox a ha |
| obtain ⟨g,hg⟩ := weakBernoulli_forward_blocks μ e he r hr hwb ha |
| obtain ⟨k,hk⟩ := exists_nat_gt ((g : ℝ)/a+1) |
| have hkpos : 0<k := by |
| have hh : 0≤(g : ℝ)/a := div_nonneg (Nat.cast_nonneg _) ha.le |
| have : (0 : ℝ)<k := by linarith |
| exact_mod_cast this |
| have hgap : (g : ℝ)≤a*(k : ℝ) := by |
| have hh := (div_lt_iff₀ ha).mp (show (g : ℝ)/a<(k : ℝ) by linarith) |
| nlinarith |
| let s := k+g |
| have hs : 0<s := by dsimp [s]; omega |
| have hsR : (0 : ℝ)<s := by exact_mod_cast hs |
| let pr := word e r s |
| let pp := word e p s |
| have hpr : Measurable pr := word_measurable e he.measurable r hr s |
| have hpp : Measurable pp := word_measurable e he.measurable p hp s |
| obtain ⟨L,hL⟩ := (eventually_conditional_single_test μ (e^[s]) (he.iterate _) pr hpr |
| (show 0<a^2/2 by positivity)).exists |
| rw [rate_power_word μ e he r hr s hs] at hL |
| have hfuture : Measurable (fun x => word (e^[s]) pr L (e^[s] x)) := |
| (word_measurable _ (he.measurable.iterate _) pr hpr L).comp (he.measurable.iterate _) |
| obtain ⟨δc,hδc,hct⟩ := conditional_entropy_law_test_uniform.{w} μ pr |
| (fun x => word (e^[s]) pr L (e^[s] x)) hpr hfuture (show 0<a^2/2 by positivity) |
| let C := Real.log (Fintype.card (Fin s → A)) |
| have hC : 0≤C := Real.log_nonneg (by exact_mod_cast Fintype.card_pos (α:=Fin s → A)) |
| have hconv := (rate_tendsto μ (e^[s]) (he.iterate _) pp hpp).eventually |
| (gt_mem_nhds (show rate μ (e^[s]) pp<rate μ (e^[s]) pp+a^2 by linarith)) |
| rw [rate_power_word μ e he p hp s hs] at hconv |
| obtain ⟨J₀,hJ₀⟩ := exists_nat_gt (max ((2+(L : ℝ)*C)/a^2) (2*(L : ℝ)/a)+1) |
| obtain ⟨J,hJbound,hJconv⟩ := (hconv.and (eventually_ge_atTop J₀)).exists |
| |
| have hJge : J₀≤J := hJconv |
| have hJent : obs μ (word (e^[s]) pp J)/(J : ℝ)<(s : ℝ)*rate μ e p+a^2 := hJbound |
| have hJpos : 0<J := by |
| have hb : 0≤(2+(L : ℝ)*C)/a^2 := div_nonneg (by positivity) ha2.le |
| have hJr : (0 : ℝ)<J₀ := by linarith [le_max_left ((2+(L : ℝ)*C)/a^2) (2*(L : ℝ)/a)] |
| have : 0<J₀ := by exact_mod_cast hJr |
| omega |
| have hJR : (0 : ℝ)<J := by exact_mod_cast hJpos |
| have hboundary₁ : 2+(L : ℝ)*C≤(J : ℝ)*a^2 := by |
| have h₀ : (2+(L : ℝ)*C)/a^2<(J : ℝ) := by |
| have hnat : (J₀ : ℝ)≤J := by exact_mod_cast hJge |
| linarith [le_max_left ((2+(L : ℝ)*C)/a^2) (2*(L : ℝ)/a)] |
| exact ((div_lt_iff₀ ha2).mp h₀).le |
| have hboundary₂ : 2*(L : ℝ)≤(J : ℝ)*a := by |
| have h₀ : 2*(L : ℝ)/a<(J : ℝ) := by |
| have hnat : (J₀ : ℝ)≤J := by exact_mod_cast hJge |
| linarith [le_max_right ((2+(L : ℝ)*C)/a^2) (2*(L : ℝ)/a)] |
| exact ((div_lt_iff₀ ha).mp h₀).le |
| let P := word (e^[s]) pp J |
| let S := word (e^[s]) pr J |
| have hP : Measurable P := word_measurable _ (he.measurable.iterate _) pp hpp J |
| have hS : Measurable S := word_measurable _ (he.measurable.iterate _) pr hpr J |
| obtain ⟨δp,hδp,hpt⟩ := finite_observation_entropy_test_uniform.{u,v} μ P hP (show (0 : ℝ)<1 by norm_num) |
| obtain ⟨δr,hδr,hrt⟩ := finite_observation_entropy_test_uniform.{u,w} μ S hS (show (0 : ℝ)<1 by norm_num) |
| let δ := min (a/2) (min (a^2/s) (min (δc/2) (min δp (δr/2)))) |
| have hδ : 0<δ := lt_min (by positivity) (lt_min (by positivity) (lt_min (by positivity) |
| (lt_min hδp (by positivity)))) |
| have hd₁ : 2*δ≤a := by have := min_le_left (a/2) (min (a^2/s) (min (δc/2) (min δp (δr/2)))); dsimp [δ]; linarith |
| have hd₂ : (s : ℝ)*δ≤a^2 := by |
| have hh : δ≤a^2/(s : ℝ) := (min_le_right _ _).trans (min_le_left _ _) |
| have hh' := (le_div_iff₀ hsR).mp hh |
| nlinarith |
| have hd₃ : 2*δ≤δc := by |
| have hh : δ≤δc/2 := (min_le_right _ _).trans ((min_le_right _ _).trans (min_le_left _ _)) |
| linarith |
| have hd₄ : δ≤δp := (min_le_right _ _).trans ((min_le_right _ _).trans ((min_le_right _ _).trans (min_le_left _ _))) |
| have hd₅ : 2*δ≤δr := by |
| have hh : δ≤δr/2 := (min_le_right _ _).trans ((min_le_right _ _).trans ((min_le_right _ _).trans (min_le_right _ _))) |
| linarith |
| refine ⟨J*s,J*s,Nat.mul_pos hJpos hs,δ,hδ,?_⟩ |
| intro ν hν T hT q hq hclose hrate n |
| rw [←Nat.mul_assoc] |
| let := hν |
| let Q₀ := word (T^[s]) (word T q s) J |
| let Q := word (T^[J*s]) Q₀ n |
| have hQ₀ : Measurable Q₀ := word_measurable _ (hT.measurable.iterate _) _ (word_measurable T hT.measurable q hq s) J |
| have hQ : Measurable Q := word_measurable _ (hT.measurable.iterate _) Q₀ hQ₀ n |
| have hb₀ : LawClose (μ.map P) (ν.map Q₀) δ := by |
| have hh := hclose.map (measurable_of_countable (wordPack J s)) |
| rw [Measure.map_map (measurable_of_countable (wordPack J s)) (word_measurable e he.measurable p hp _), |
| Measure.map_map (measurable_of_countable (wordPack J s)) (word_measurable T hT.measurable q hq _)] at hh |
| simpa only [Function.comp_def,wordPack_apply] using hh |
| have hb (i : Fin n) : LawClose (μ.map P) (ν.map (fun y => Q y i)) δ := by |
| rw [map_word_coordinate ν (T^[J*s]) (hT.iterate _) Q₀ hQ₀ n i] |
| exact hb₀ |
| let : StandardBorelSpace (Fin n → Fin J → Fin s → A) := inferInstance |
| let ξ := recodingLaw μ P S hP hS ν n Q |
| have : IsProbabilityMeasure ξ := recodingLaw_probability μ P S hP hS ν n Q hQ |
| have houtlaw (i : Fin n) : LawClose (μ.map S) (ξ.map (fun vw => vw.2 i)) (2*δ) := |
| recodingLaw_output_lawClose μ P S hP hS ν n Q hQ i (hb i) |
| have hin (i : Fin n) : obs ν (fun y => Q y i)≤obs μ P+1 := by |
| have hh := hpt Y ν (fun y => Q y i) ((measurable_pi_apply i).comp hQ) ((hb i).mono hd₄) |
| linarith [(abs_lt.mp hh).1] |
| have hout (i : Fin n) : obs μ S-1≤obs ξ (fun vw => vw.2 i) := by |
| have hh := hrt _ ξ (fun vw => vw.2 i) ((measurable_pi_apply i).comp measurable_snd) |
| ((houtlaw i).mono hd₅) |
| linarith [(abs_lt.mp hh).2] |
| have hentropy := recodingLaw_entropy_lower μ P S hP hS ν n Q hQ hin hout |
| have hquadlo : ((n*J)*s : ℕ)*rate ν T q≤obs ν Q := by |
| rw [obs_nestedPack_word] |
| exact obs_word_rate_lower ν T hT q hq _ |
| have hSlo : (J*s : ℕ)*rate μ e r≤obs μ S := by |
| rw [obs_word_pack] |
| exact obs_word_rate_lower μ e he r hr _ |
| have hPhi : obs μ P≤(J*s : ℕ)*rate μ e p+(J : ℝ)*a^2 := by |
| have hh := (div_lt_iff₀ hJR).mp hJent |
| dsimp only [P] |
| push_cast |
| nlinarith |
| have hQlo : ((n*J)*s : ℕ)*(rate μ e p-δ)≤obs ν Q := |
| (mul_le_mul_of_nonneg_left hrate (Nat.cast_nonneg ((n*J)*s))).trans hquadlo |
| have hwholeEntropy := recoding_nested_entropy μ ν n J s P S hP hS Q hQ hd₂ hQlo hPhi hSlo hin hout |
| obtain ⟨R₁,hR₁budget⟩ := block_recoding_small_cost μ ξ e he r hr k g L n J Prod.snd measurable_snd |
| ha (show 0≤2*δ by positivity) hd₁ hgap hboundary₁ hboundary₂ (hg k) houtlaw (by |
| intro u v hu hv hlaw |
| have hh := hct _ ξ u v hu hv (hlaw.mono hd₃) |
| have hh' := (abs_lt.mp hh).1 |
| dsimp only [pr,s] at hL hh' ⊢ |
| linarith only [hh',hL]) hwholeEntropy |
| have htransport := recoding_nested_transport μ ν n J s P S hP hS Q hQ hb |
| have hQflat : nestedOutput n J s Q=word T q ((n*J)*s) := nestedOutput_word T q n J s |
| rw [hQflat] at htransport |
| obtain ⟨R₂,hR₂⟩ := htransport |
| rw [observations_fineWordCost μ e he p r hp hr J s] at hR₂ |
| have hR₂budget : R₂.cost nameCost≤2*a*((n*J)*s : ℕ) := by |
| have hs' : μ.real {x | p x≠r x}+2*δ≤2*a := by linarith only [hpaint,hd₁] |
| have hh := mul_le_mul_of_nonneg_left hs' (Nat.cast_nonneg ((n*J)*s)) |
| apply hR₂.trans |
| push_cast at hh ⊢ |
| nlinarith only [hh] |
| let R₀ := MatrixCoupling.observations μ (word e p ((n*J)*s)) (word e r ((n*J)*s)) |
| (word_measurable e he.measurable p hp _) (word_measurable e he.measurable r hr _) |
| have hR₀ : R₀.cost nameCost≤a*((n*J)*s : ℕ) := by |
| change (MatrixCoupling.observations μ _ _ _ _).cost nameCost≤_ |
| rw [observations_word_cost μ e he p r hp hr] |
| have hh := mul_le_mul_of_nonneg_left hpaint.le (Nat.cast_nonneg ((n*J)*s)) |
| nlinarith only [hh] |
| let R := (R₀.comp R₁).comp R₂.symm |
| have hR : R.cost nameCost≤η*((n*J)*s : ℕ) := by |
| have h₁ := MatrixCoupling.comp_cost_le R₀ R₁ nameCost nameCost nameCost nameCost_triangle |
| have h₂ := MatrixCoupling.comp_cost_le (R₀.comp R₁) R₂.symm nameCost nameCost nameCost nameCost_triangle |
| rw [MatrixCoupling.symm_cost R₂ nameCost nameCost_comm] at h₂ |
| have hηa : η=100*a := by dsimp [a]; ring |
| dsimp only [R] |
| rw [hηa] |
| have hpos := mul_nonneg ha.le (Nat.cast_nonneg ((n*J)*s)) |
| nlinarith only [h₁,h₂,hR₀,hR₁budget,hR₂budget,hpos] |
| exact ⟨R,hR⟩ |
| end HyperbolicCoding |
| |
| end |
| |
| end OAI |
| |
