lean/OAI/MeasureTheory/SelfSimilar/Coding.lean

import OAI.MeasureTheory.SelfSimilar.Bernoulli

namespace OAI

universe uι

section
open scoped BigOperators ENNReal
open MeasureTheory
open MeasureTheory Metric Set Filter
open scoped Topology ENNReal
open MeasureTheory Filter Set ProbabilityTheory
open scoped Topology
namespace EntropyRateDimension
namespace Coding
open Filter Set
open scoped Topology

variable {ι : Type uι} [Fintype ι] [Nonempty ι]

def shift (ω : ℕ → ι) (n : ℕ) : ι := ω (n+1)

def slope (S : System ι) (ω : ℕ → ι) (n : ℕ) : ℝ :=
  ∏ j ∈ Finset.range n, S.ratio (ω j)

def term (S : System ι) (ω : ℕ → ι) (n : ℕ) : ℝ :=
  slope S ω n * S.offset (ω n)

noncomputable def point (S : System ι) (ω : ℕ → ι) : ℝ := ∑' n, term S ω n

omit [Nonempty ι] in
theorem slope_zero (S : System ι) (ω : ℕ → ι) : slope S ω 0 = 1 := by simp [slope]

omit [Nonempty ι] in
theorem slope_succ (S : System ι) (ω : ℕ → ι) (n : ℕ) :
    slope S ω (n+1) = slope S ω n * S.ratio (ω n) := by
  simp [slope, Finset.prod_range_succ]

omit [Nonempty ι] in
theorem slope_shift (S : System ι) (ω : ℕ → ι) (n : ℕ) :
    slope S ω (n+1) = S.ratio (ω 0) * slope S (shift ω) n := by
  simp only [slope, Finset.prod_range_succ', shift]
  ring

omit [Nonempty ι] in
theorem abs_slope_le (S : System ι) (ω : ℕ → ι) {c : ℝ}
    (hc : 0 ≤ c) (hr : ∀ i, |S.ratio i| ≤ c) (n : ℕ) :
    |slope S ω n| ≤ c^n := by
  induction n with
  | zero => simp [slope_zero]
  | succ n ih =>
    rw [slope_succ, abs_mul, pow_succ]
    exact mul_le_mul ih (hr _) (abs_nonneg _) (pow_nonneg hc _)

omit [Nonempty ι] in
theorem abs_term_le (S : System ι) (ω : ℕ → ι) {c T : ℝ}
    (hc : 0 ≤ c) (_hT : 0 ≤ T) (hr : ∀ i, |S.ratio i| ≤ c)
    (ht : ∀ i, |S.offset i| ≤ T) (n : ℕ) : |term S ω n| ≤ c^n*T := by
  rw [term, abs_mul]
  exact mul_le_mul (abs_slope_le S ω hc hr n) (ht _) (abs_nonneg _) (pow_nonneg hc n)

theorem term_summable (S : System ι) (ω : ℕ → ι) : Summable (term S ω) := by
  obtain ⟨c,T,hc,hc1,hT,hr,ht⟩ := S.exists_uniform_bounds
  apply Summable.of_norm_bounded ((summable_geometric_of_lt_one hc.le hc1).mul_right T)
  intro n
  simpa only [Real.norm_eq_abs] using abs_term_le S ω hc.le hT hr ht n

theorem point_shift (S : System ι) (ω : ℕ → ι) :
    point S ω = S.affine (ω 0) (point S (shift ω)) := by
  rw [point, (term_summable S ω).tsum_eq_zero_add]
  have he : (fun n => term S ω (n+1)) = fun n => S.ratio (ω 0)*term S (shift ω) n := by
    funext n
    simp only [term, slope_shift, shift]
    ring
  rw [he, tsum_mul_left]
  simp only [term, slope_zero, one_mul, System.affine, point]
  ring

variable [MeasurableSpace ι] [MeasurableSingletonClass ι]

omit [Nonempty ι] in
theorem slope_measurable (S : System ι) (n : ℕ) : Measurable (fun ω => slope S ω n) := by
  apply Finset.measurable_prod
  intro j hj
  exact (measurable_of_finite _).comp (measurable_pi_apply j)

omit [Nonempty ι] in
theorem term_measurable (S : System ι) (n : ℕ) : Measurable (fun ω => term S ω n) :=
  (slope_measurable S n).mul ((measurable_of_finite _).comp (measurable_pi_apply n))

theorem point_measurable (S : System ι) : Measurable (point S) := by
  apply measurable_of_tendsto_metrizable
    (fun n => Finset.measurable_sum (s := Finset.range n) (fun j _ => term_measurable S j))
  apply tendsto_pi_nhds.mpr
  intro ω
  exact (term_summable S ω).hasSum.tendsto_sum_nat

noncomputable def symbolMeasure (S : System ι) : Measure ι :=
  ∑ i, ENNReal.ofReal (S.weight i) • Measure.dirac i

instance symbolMeasure_probability (S : System ι) : IsProbabilityMeasure (symbolMeasure S) where
  measure_univ := by
    simp only [symbolMeasure, Measure.finsetSum_apply, Measure.smul_apply,
      Measure.dirac_apply_of_mem (Set.mem_univ _), smul_eq_mul, mul_one]
    rw [← ENNReal.ofReal_sum_of_nonneg (fun i _ => S.weight_nonneg i), S.weight_sum]
    simp

noncomputable def addressMeasure (S : System ι) : Measure (ℕ → ι) :=
  Measure.infinitePi fun _ : ℕ => symbolMeasure S

instance addressMeasure_probability (S : System ι) : IsProbabilityMeasure (addressMeasure S) :=
  inferInstanceAs (IsProbabilityMeasure (Measure.infinitePi fun _ : ℕ => symbolMeasure S))

noncomputable def law (S : System ι) : Measure ℝ := (addressMeasure S).map (point S)

instance law_probability (S : System ι) : IsProbabilityMeasure (law S) :=
  (Measure.isProbabilityMeasure_map_iff (point_measurable S).aemeasurable).2 inferInstance

theorem head_tail_point_law (S : System ι) :
    (addressMeasure S).map (fun ω => (ω 0,point S (shift ω))) =
      (symbolMeasure S).prod (law S) := by
  have h := congrArg (Measure.map (Prod.map id (point S)))
    (Bernoulli.head_tail_law (symbolMeasure S))
  rw [Measure.map_map (measurable_id.prodMap (point_measurable S))
      ((measurable_pi_apply 0).prodMk Bernoulli.shift_measurable)] at h
  rw [← Measure.map_prod_map _ _ measurable_id (point_measurable S), Measure.map_id] at h
  exact h

theorem law_selfSimilar (S : System ι) : S.SelfSimilar (law S) := by
  classical
  let f : ι × ℝ → ℝ := fun z => S.affine z.1 z.2
  have hf : Measurable f := by
    exact ((measurable_of_finite S.ratio).comp measurable_fst).mul measurable_snd |>.add
      ((measurable_of_finite S.offset).comp measurable_fst)
  have hh := congrArg (Measure.map f) (head_tail_point_law S)
  have hp : Measurable (fun ω : ℕ → ι => (ω 0,point S (shift ω))) :=
    (measurable_pi_apply 0).prodMk ((point_measurable S).comp Bernoulli.shift_measurable)
  rw [Measure.map_map hf hp] at hh
  have he : f ∘ (fun ω => (ω 0,point S (shift ω))) = point S :=
    funext fun ω => (point_shift S ω).symm
  rw [he] at hh
  change law S = _ at hh
  change law S = _
  conv_lhs => rw [hh]
  change ((∑ i, ENNReal.ofReal (S.weight i) • Measure.dirac i).prod (law S)).map f = _
  rw [← Measure.sum_fintype, Measure.prod_sum_left, Measure.sum_fintype,
    Measure.map_finset_sum hf.aemeasurable]
  apply Finset.sum_congr rfl
  intro i hi
  rw [Measure.prod_smul_left, Measure.map_smul _ hf.aemeasurable, Measure.dirac_prod,
    Measure.map_map hf measurable_prodMk_left]
  rfl

end Coding
end EntropyRateDimension

end

end OAI