import OAI.MeasureTheory.SelfSimilar.GridCoupling

namespace OAI

universe uα uβ uγ

section
open scoped BigOperators ENNReal
open MeasureTheory
namespace EntropyRateDimension
namespace FiniteRefinement

open FiniteEntropy

variable {α : Type uα} {β : Type uβ} [Fintype α] [DecidableEq β]

noncomputable def cellMean (p : α → ℝ) (v : α → ℝ) (g : α → β) (b : β) : ℝ :=
  ∑ a, ((if g a = b then p a else 0) / mass Finset.univ p g b) * v a

theorem distance_mean_le (p : α → ℝ) (v : α → ℝ) (z R : ℝ)
    (hp : ∀ a, 0 ≤ p a) (hp1 : ∑ a, p a = 1)
    (hR : ∀ a, p a ≠ 0 → |z-v a| ≤ R) : |z - ∑ a, p a * v a| ≤ R := by
  have he : z - ∑ a, p a * v a = ∑ a, p a * (z-v a) := by
    simp only [mul_sub, Finset.sum_sub_distrib, ← Finset.sum_mul, hp1, one_mul]
  rw [he]
  apply (Finset.abs_sum_le_sum_abs _ _).trans
  calc
    (∑ a, |p a * (z-v a)|) ≤ ∑ a, p a * R := by
      apply Finset.sum_le_sum
      intro a _
      rw [abs_mul, abs_of_nonneg (hp a)]
      by_cases ha : p a = 0
      · simp only [ha, zero_mul, le_refl]
      · exact mul_le_mul_of_nonneg_left (hR a ha) (hp a)
    _ = R := by rw [← Finset.sum_mul, hp1, one_mul]

omit [Fintype α] in
theorem mass_pos {γ : Type uγ} [DecidableEq γ] (s : Finset α) (p : α → ℝ)
    (g : α → γ) (hp : ∀ a ∈ s, 0 < p a) {b : γ} (hb : b ∈ s.image g) :
    0 < mass s p g b := by
  classical
  obtain ⟨a,ha,rfl⟩ := Finset.mem_image.mp hb
  exact (hp a ha).trans_le (Finset.single_le_sum
    (fun x hx => (hp x (Finset.mem_filter.mp hx).1).le) (by simp [ha]))

theorem cellMass_eq (p : α → ℝ) (g : α → β) {k : ℕ} (c : Fin k → β) (i : Fin k) :
    ProductLaw.cellMass (fun _ : Fin k => p) (fun _ => g) c i = mass Finset.univ p g (c i) := by
  simp only [ProductLaw.cellMass, mass, Finset.sum_filter]

theorem conditional_mean_eq (p : α → ℝ) (v : α → ℝ) (g : α → β)
    {k : ℕ} (c : Fin k → β) (i : Fin k) :
    (∑ a, ProductLaw.conditional (fun _ : Fin k => p) (fun _ => g) c i a * v a) =
      cellMean p v g (c i) := by
  simp only [cellMean, ProductLaw.conditional, cellMass_eq]

theorem conditional_mean_distance_le (p : α → ℝ) (v : α → ℝ) (g : α → β)
    (hp : ∀ a, 0 ≤ p a) {k : ℕ} (c : Fin k → β) (i : Fin k)
    (hc : mass Finset.univ (ProductLaw.weight (fun _ : Fin k => p))
      (fun x i => g (x i)) c ≠ 0) (x : α) (hx : g x = c i) (R : ℝ)
    (hd : ∀ a b, g a = g b → |v a-v b| ≤ R) :
    |v x-cellMean p v g (c i)| ≤ R := by
  rw [← conditional_mean_eq p v g c i]
  apply distance_mean_le _ _ _ R
    (ProductLaw.conditional_nonneg _ _ _ (fun _ a => hp a) i)
    (ProductLaw.conditional_sum _ _ _ hc i)
  intro a ha
  have hga : g a = c i := by
    by_contra hn
    exact ha (by simp only [ProductLaw.conditional, ite_eq_right hn, zero_div])
  exact hd x a (hx.trans hga.symm)

theorem fiber_entropy_hit_bound (p : α → ℝ) (v : α → ℝ) (g : α → β)
    (hp : ∀ a, 0 < p a) (k : ℕ) (hk : 1 ≤ k) (δ : ℝ) (hδ : 0 < δ)
    (hd : ∀ a b, g a = g b → |v a-v b| ≤ 4*δ) (u : AddCircle (1 : ℝ))
    (c : Fin k → β)
    (hc : c ∈ (Finset.univ : Finset (Fin k → α)).image (fun x i => g (x i))) :
    conditionalEntropy (Finset.univ.filter (fun x : Fin k → α => (fun i => g (x i)) = c))
      (fun x => ProductLaw.weight (fun _ : Fin k => p) x /
        mass Finset.univ (ProductLaw.weight (fun _ : Fin k => p)) (fun x i => g (x i)) c)
      (fun x i => RandomGrid.cell δ u (v (x i))) (fun x => ∑ i, v (x i)) ≤
    11*k*(∑ x ∈ Finset.univ.filter (fun x : Fin k → α => (fun i => g (x i)) = c),
      (ProductLaw.weight (fun _ : Fin k => p) x /
        mass Finset.univ (ProductLaw.weight (fun _ : Fin k => p)) (fun x i => g (x i)) c) *
      ∑ i, ∑ j, RandomGrid.hit (-(cellMean p v g (c j)/δ : ℝ) : AddCircle (1 : ℝ))
        (4*k*|v (x i)-cellMean p v g (c i)|/δ) u)*Real.log 2 := by
  classical
  let w : (Fin k → α) → ℝ := ProductLaw.weight (fun _ : Fin k => p)
  let G : (Fin k → α) → (Fin k → β) := fun x i => g (x i)
  have hw : ∀ x : Fin k → α, 0 < w x := fun x => Finset.prod_pos (fun i _ => hp (x i))
  have hP : 0 < mass Finset.univ w G c := mass_pos Finset.univ w G (fun x _ => hw x) hc
  have hnc : mass Finset.univ w G c ≠ 0 := ne_of_gt hP
  let s₀ : Finset (Fin k → α) := Finset.univ.filter (fun x => G x = c)
  let p₀ : (Fin k → α) → ℝ := fun x => w x / mass Finset.univ w G c
  let v₀ : (Fin k → α) → Fin k → ℝ := fun x i => v (x i)
  let m₀ : Fin k → ℝ := fun i => cellMean p v g (c i)
  have hp₀ : ∀ x ∈ s₀, 0 ≤ p₀ x := fun x _ => div_nonneg (hw x).le hP.le
  have hp₀1 : ∑ x ∈ s₀, p₀ x = 1 := by
    rw [show (∑ x ∈ s₀, p₀ x) = mass Finset.univ w G c / mass Finset.univ w G c by
      exact (Finset.sum_div _ _ _).symm]
    exact div_self hnc
  have hv₀ : ∀ x ∈ s₀, ∀ i, |v₀ x i-m₀ i| ≤ 4*δ := by
    intro x hx i
    have he : G x = c := (Finset.mem_filter.mp hx).2
    exact conditional_mean_distance_le p v g (fun a => (hp a).le) c i hnc (x i)
      (congrFun he i) (4*δ) hd
  have hind : ∀ a : ℝ, ∀ i j : Fin k, i ≠ j →
      (∑ x ∈ s₀, if a/(4*k) ≤ |v₀ x i-m₀ i| ∧ a/(4*k) ≤ |v₀ x j-m₀ j| then p₀ x else 0) =
      (∑ x ∈ s₀, if a/(4*k) ≤ |v₀ x i-m₀ i| then p₀ x else 0) *
      (∑ x ∈ s₀, if a/(4*k) ≤ |v₀ x j-m₀ j| then p₀ x else 0) := by
    intro a i j hij
    let E := fun (i : Fin k) (x : α) => a/(4*k) ≤ |v x-cellMean p v g (c i)|
    have heen := ProductLaw.two_coordinate_events
      (ProductLaw.conditional (fun _ : Fin k => p) (fun _ => g) c) E
      (ProductLaw.conditional_sum _ _ _ hnc) i j hij
    rw [← ProductLaw.conditional_event (fun _ : Fin k => p) (fun _ => g) c (fun x => E i (x i) ∧ E j (x j)),
      ← ProductLaw.conditional_event (fun _ : Fin k => p) (fun _ => g) c (fun x => E i (x i)),
      ← ProductLaw.conditional_event (fun _ : Fin k => p) (fun _ => g) c (fun x => E j (x j))] at heen
    exact heen
  exact RandomGrid.refinement_entropy_hit_bound s₀ p₀ k hk v₀ m₀ δ hδ u hp₀ hp₀1 hv₀ hind

theorem entropy_step_hit_bound (p : α → ℝ) (v : α → ℝ) (g : α → β)
    (hp : ∀ a, 0 < p a)
    (k : ℕ) (hk : 1 ≤ k) (δ : ℝ) (hδ : 0 < δ)
    (hd : ∀ a b, g a = g b → |v a-v b| ≤ 4*δ)
    (u : AddCircle (1 : ℝ)) :
    conditionalEntropy Finset.univ (ProductLaw.weight (fun _ : Fin k => p))
      (fun x i => RandomGrid.cell δ u (v (x i)))
      (fun x => (∑ i, v (x i), fun i => g (x i))) ≤
    11*k*(∑ x : Fin k → α, ProductLaw.weight (fun _ : Fin k => p) x * ∑ i, ∑ j,
      RandomGrid.hit (-(cellMean p v g (g (x j))/δ : ℝ) : AddCircle (1 : ℝ))
        (4*k*|v (x i)-cellMean p v g (g (x i))|/δ) u)*Real.log 2 := by
  classical
  let w := ProductLaw.weight (fun _ : Fin k => p)
  let G := fun (x : Fin k → α) i => g (x i)
  let Y := fun (x : Fin k → α) => ∑ i, v (x i)
  let C := fun (x : Fin k → α) i => RandomGrid.cell δ u (v (x i))
  let P := mass Finset.univ w G
  let M := fun (c : Fin k → β) i => cellMean p v g (c i)
  let cost := fun (c : Fin k → β) (x : Fin k → α) => ∑ i, ∑ j,
    RandomGrid.hit (-(M c j/δ : ℝ) : AddCircle (1 : ℝ)) (4*k*|v (x i)-M c i|/δ) u
  have hw : ∀ x : Fin k → α, 0 < w x := fun x => Finset.prod_pos (fun i _ => hp (x i))
  have hP : ∀ c ∈ Finset.univ.image G, 0 < P c :=
    fun c hc => mass_pos Finset.univ w G (fun x _ => hw x) hc
  have hcstep : ∀ c ∈ Finset.univ.image G,
      conditionalEntropy (Finset.univ.filter (fun x => G x = c)) (fun x => w x/P c) C Y ≤
        11*k*(∑ x ∈ Finset.univ.filter (fun x => G x = c), (w x/P c)*cost c x)*Real.log 2 :=
    fun c hc => fiber_entropy_hit_bound p v g hp k hk δ hδ hd u c hc
  rw [conditionalEntropy_disintegrate Finset.univ w C G Y (fun x _ => (hw x).le)]
  calc
    _ ≤ ∑ c ∈ Finset.univ.image G, P c *
        (11*k*(∑ x ∈ Finset.univ.filter (fun x => G x = c), (w x/P c)*cost c x)*Real.log 2) := by
      apply Finset.sum_le_sum
      intro c hc
      exact mul_le_mul_of_nonneg_left (hcstep c hc) (hP c hc).le
    _ = 11*k*(∑ c ∈ Finset.univ.image G,
        ∑ x ∈ Finset.univ.filter (fun x => G x = c), w x*cost (G x) x)*Real.log 2 := by
      simp only [Finset.sum_mul, Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro c hc
      apply Finset.sum_congr rfl
      intro x hx
      rw [(Finset.mem_filter.mp hx).2]
      field_simp [ne_of_gt (hP c hc)]
    _ = _ := by
      rw [Finset.sum_fiberwise_of_maps_to (fun x (_ : x ∈ Finset.univ) => Finset.mem_image_of_mem G (Finset.mem_univ x))]

theorem mean_deviation_le_coupling (p : α → ℝ) (v : α → ℝ) (g : α → β)
    (hp : ∀ a, 0 < p a) :
    (∑ a, p a * |v a-cellMean p v g (g a)|) ≤
      ∑ a, ∑ b, (if g a = g b then p a*p b/mass Finset.univ p g (g a) else 0) *
        |v a-v b| := by
  classical
  apply Finset.sum_le_sum
  intro a _
  have hP : 0 < mass Finset.univ p g (g a) :=
    mass_pos Finset.univ p g (fun x _ => hp x) (Finset.mem_image.mpr ⟨a, Finset.mem_univ a, rfl⟩)
  let q : α → ℝ := fun b => (if g b = g a then p b else 0)/mass Finset.univ p g (g a)
  have hq : ∀ b, 0 ≤ q b := by
    intro b
    exact div_nonneg (by split_ifs <;> first | exact (hp b).le | exact le_rfl) hP.le
  have hq1 : ∑ b, q b = 1 := by
    dsimp only [q]
    rw [← Finset.sum_div]
    simpa only [mass, Finset.sum_filter] using div_self (ne_of_gt hP)
  have he : v a-cellMean p v g (g a) = ∑ b, q b*(v a-v b) := by
    simp only [mul_sub, Finset.sum_sub_distrib, ← Finset.sum_mul, hq1, one_mul]
    rfl
  rw [he]
  calc
    p a * |∑ b, q b*(v a-v b)| ≤ p a * ∑ b, |q b*(v a-v b)| :=
      mul_le_mul_of_nonneg_left (Finset.abs_sum_le_sum_abs _ _) (hp a).le
    _ = _ := by
      rw [Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro b _
      rw [abs_mul, abs_of_nonneg (hq b)]
      dsimp only [q]
      by_cases hg : g a = g b
      · simp only [hg, ite_true]
        ring
      · simp only [hg, Ne.symm hg, ite_false, zero_div, mul_zero, zero_mul]

theorem product_mean_deviation (p : α → ℝ) (v : α → ℝ) (g : α → β)
    (hp1 : ∑ a, p a = 1) (k : ℕ) :
    (∑ x : Fin k → α, ProductLaw.weight (fun _ : Fin k => p) x *
      ∑ i, |v (x i)-cellMean p v g (g (x i))|) =
      k * ∑ a, p a*|v a-cellMean p v g (g a)| := by
  classical
  simp only [Finset.mul_sum]
  rw [Finset.sum_comm]
  have h : ∀ i : Fin k, (∑ x : Fin k → α, ProductLaw.weight (fun _ : Fin k => p) x *
      |v (x i)-cellMean p v g (g (x i))|) = ∑ a, p a*|v a-cellMean p v g (g a)| := by
    intro i
    simpa only [Finset.prod_singleton] using ProductLaw.moment (fun _ : Fin k => p)
      (fun _ a => |v a-cellMean p v g (g a)|) {i} (fun _ => hp1)
  simp only [h, Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
  rw [Finset.mul_sum]

theorem exists_entropy_step (p : α → ℝ) (v : α → ℝ) (g : α → β)
    (hp : ∀ a, 0 < p a) (hp1 : ∑ a, p a = 1)
    (k : ℕ) (hk : 1 ≤ k) (δ : ℝ) (hδ : 0 < δ)
    (hd : ∀ a b, g a = g b → |v a-v b| ≤ 4*δ) :
    ∃ u : AddCircle (1 : ℝ),
    conditionalEntropy Finset.univ (ProductLaw.weight (fun _ : Fin k => p))
      (fun x i => RandomGrid.cell δ u (v (x i)))
      (fun x => (∑ i, v (x i), fun i => g (x i))) ≤
    (88*k^4/δ)*(∑ a, p a*|v a-cellMean p v g (g a)|)*Real.log 2 := by
  classical
  obtain ⟨u,hu⟩ := RandomGrid.exists_shift_variation_bound Finset.univ
    (ProductLaw.weight (fun _ : Fin k => p)) k (fun x i => v (x i))
    (fun x i => cellMean p v g (g (x i))) δ hδ
    (fun x _ => ProductLaw.weight_nonneg _ (fun _ a => (hp a).le) x)
  refine ⟨u, (entropy_step_hit_bound p v g hp k hk δ hδ hd u).trans ?_⟩
  have hm := mul_le_mul_of_nonneg_right
    (mul_le_mul_of_nonneg_left hu (by positivity : 0 ≤ (11 : ℝ)*k))
    (Real.log_pos (by norm_num : (1 : ℝ) < 2)).le
  rw [product_mean_deviation p v g hp1 k] at hm
  convert hm using 1; ring

theorem refinement_increment (p : α → ℝ) (v : α → ℝ) (g : α → List ℤ)
    (hp : ∀ a, 0 ≤ p a) (k : ℕ) (δ : ℝ) (u : AddCircle (1 : ℝ)) :
    conditionalEntropy Finset.univ (ProductLaw.weight (fun _ : Fin k => p))
      (fun x i => RandomGrid.cell δ u (v (x i)) :: g (x i)) (fun x => ∑ i, v (x i)) =
    conditionalEntropy Finset.univ (ProductLaw.weight (fun _ : Fin k => p))
      (fun x i => g (x i)) (fun x => ∑ i, v (x i)) +
    conditionalEntropy Finset.univ (ProductLaw.weight (fun _ : Fin k => p))
      (fun x i => RandomGrid.cell δ u (v (x i)))
      (fun x => (∑ i, v (x i), fun i => g (x i))) := by
  classical
  let w : (Fin k → α) → ℝ := ProductLaw.weight (fun _ : Fin k => p)
  let G := fun (x : Fin k → α) i => g (x i)
  let C := fun (x : Fin k → α) i => RandomGrid.cell δ u (v (x i))
  let Y := fun (x : Fin k → α) => ∑ i, v (x i)
  have hw : ∀ x ∈ (Finset.univ : Finset (Fin k → α)), 0 ≤ w x :=
    fun x _ => ProductLaw.weight_nonneg _ (fun _ a => hp a) x
  have he := conditionalEntropy_eq_of_fibers Finset.univ w
    (fun x i => C x i :: G x i) (fun x => (C x,G x)) Y hw (by
      intro x _ y _
      constructor
      · intro h
        apply Prod.ext
        · funext i
          exact (List.cons.inj (congrFun h i)).1
        · funext i
          exact (List.cons.inj (congrFun h i)).2
      · intro h
        rw [Prod.mk.injEq] at h
        rw [h.1,h.2])
  rw [he, conditionalEntropy_chain Finset.univ w C G Y hw,
    conditionalEntropy_condition_swap Finset.univ w C G Y hw]

end FiniteRefinement

end EntropyRateDimension
end

end OAI