import OAI.NumberTheory.GaussianMoat.PrimeMass

namespace OAI

universe uOmega uAlpha uBeta uGamma uIota uDelta

namespace GaussianMoat
open Filter Topology Finset

namespace FinLaw
open scoped BigOperators
variable {Ω : Type uOmega} {α : Type uAlpha} [Fintype Ω] {k : ℕ}

theorem cHf_eq_of_fibers {β : Type uBeta} {γ : Type uGamma} (p : FinLaw Ω)
    (X : Ω → α) (Y : Ω → β) (C : Ω → γ)
    (h : ∀ ω ν, C ω = C ν → (X ω = X ν ↔ Y ω = Y ν)) :
    p.cHf X C = p.cHf Y C := by
  unfold cHf
  congr 1
  apply p.Hf_eq_of_fibers
  intro ω ν
  simp only [Prod.mk.injEq]
  constructor <;> intro hh
  · exact ⟨(h ω ν hh.2).mp hh.1,hh.2⟩
  · exact ⟨(h ω ν hh.2).mpr hh.1,hh.2⟩

theorem cHf_le_of_determined {β : Type uBeta} {γ : Type uGamma} (p : FinLaw Ω)
    (X : Ω → α) (Y : Ω → β) (C : Ω → γ)
    (h : ∀ ω ν, Y ω = Y ν → C ω = C ν → X ω = X ν) :
    p.cHf X C ≤ p.cHf Y C := by
  apply sub_le_sub_right
  apply p.Hf_le_of_determined
  intro ω ν hh
  rcases Prod.mk.inj hh with ⟨hy,hc⟩
  exact Prod.ext (h ω ν hy hc) hc

theorem cHf_finset_subadd {ι : Type uIota} {β : Type uBeta} (p : FinLaw Ω)
    (X : Ω → ι → α) (C : Ω → β) (S : Finset ι) :
    p.cHf (fun ω (i : S) => X ω i) C ≤ ∑ i ∈ S, p.cHf (fun ω => X ω i) C := by
  classical
  induction S using Finset.induction_on with
  | empty =>
    have he : p.cHf (fun ω (i : (∅:Finset ι)) => X ω i) C = p.cHf (fun _ => ()) C := by
      apply p.cHf_eq_of_fibers
      intro ω ν _
      simp only [iff_true]
      funext i
      exact False.elim (Finset.notMem_empty i.val i.property)
    have hc : p.cHf (fun _ => ()) C = 0 := by
      unfold cHf
      have hh := p.Hf_eq_of_fibers (fun ω => ((),C ω)) C (fun _ _ => by simp)
      rw [hh,sub_self]
    simp [he,hc]
  | @insert i S hi ih =>
    have he : p.cHf (fun ω (j : (insert i S : Finset ι)) => X ω j) C =
        p.cHf (fun ω => (X ω i,fun j : S => X ω j)) C := by
      apply p.cHf_eq_of_fibers
      intro ω ν _
      constructor
      · intro h
        apply Prod.ext
        · exact congrFun h ⟨i,Finset.mem_insert_self _ _⟩
        · funext j; exact congrFun h ⟨j,Finset.mem_insert_of_mem j.property⟩
      · intro h
        funext j
        rcases Finset.mem_insert.mp j.property with hj | hj
        · simpa [hj] using congrArg Prod.fst h
        · exact congrFun (congrArg Prod.snd h) ⟨j,hj⟩
    rw [he,Finset.sum_insert hi]
    have hh := p.cHf_pair_subadd (fun ω => X ω i) (fun ω (j : S) => X ω j) C
    linarith

theorem cHf_fintype_subadd {ι : Type uIota} {β : Type uBeta} [Fintype ι] (p : FinLaw Ω)
    (X : Ω → ι → α) (C : Ω → β) :
    p.cHf X C ≤ ∑ i, p.cHf (fun ω => X ω i) C := by
  have h := p.cHf_finset_subadd X C Finset.univ
  have he : p.cHf (fun ω (i : (Finset.univ : Finset ι)) => X ω i) C = p.cHf X C := by
    apply p.cHf_eq_of_fibers
    intro ω ν _
    exact ⟨fun hh => funext (fun i => congrFun hh ⟨i,Finset.mem_univ i⟩),
      fun hh => funext (fun i => congrFun hh i)⟩
  rwa [he] at h

omit [Fintype Ω] in

theorem prefixVar_swap (X : Ω → Fin k → α) (π : Equiv.Perm (Fin k)) (s : ℕ)
    (i j : Fin k) (hi : s ≤ i.val) (hj : s ≤ j.val) :
    prefixVar X (π*Equiv.swap i j) s = prefixVar X π s := by
  classical
  funext ω a
  by_cases ha : a.val<s
  · have hai : a≠i := by intro he; subst a; omega
    have haj : a≠j := by intro he; subst a; omega
    simp [prefixVar,ha,Equiv.Perm.mul_apply,Equiv.swap_apply_of_ne_of_ne hai haj]
  · simp [prefixVar,ha]

theorem ordered_remaining_exchange_cond {β : Type uBeta} (p : FinLaw Ω)
    (X : Ω → Fin k → α) (C : Equiv.Perm (Fin k) → Ω → β)
    (i j : Fin k) (hC : ∀ π, C (π*Equiv.swap i j) = C π) :
    (𝔼 π : Equiv.Perm (Fin k), p.cHf (fun ω => X ω (π i)) (C π)) =
      𝔼 π : Equiv.Perm (Fin k), p.cHf (fun ω => X ω (π j)) (C π) := by
  classical
  apply Fintype.expect_equiv (Equiv.mulRight (Equiv.swap i j))
  intro π
  change p.cHf (fun ω => X ω (π i)) (C π) =
    p.cHf (fun ω => X ω ((π*Equiv.swap i j) j)) (C (π*Equiv.swap i j))
  rw [hC]
  simp only [Equiv.Perm.mul_apply,Equiv.swap_apply_right]

theorem prefix_conditional_block {β : Type uBeta} (p : FinLaw Ω)
    (X : Ω → Fin k → α) (π : Equiv.Perm (Fin k)) (C : Ω → β)
    {b q : ℕ} (hbq : b ≤ q) (hq : q ≤ k)
    (hC : ∀ ω ν, C ω = C ν → prefixVar X π b ω = prefixVar X π b ν) :
    p.cHf (prefixVar X π q) C ≤
      ∑ j : Fin (q-b), p.cHf (fun ω => X ω (π ⟨b+j.val,by omega⟩)) C := by
  let R := fun ω (j : Fin (q-b)) => X ω (π ⟨b+j.val,by omega⟩)
  apply (p.cHf_le_of_determined (prefixVar X π q) R C ?_).trans
    (p.cHf_fintype_subadd R C)
  intro ω ν hR hcond
  funext i
  by_cases hi : i.val < b
  · have h := congrFun (hC ω ν hcond) i
    simpa [prefixVar,hi,show i.val<q by omega] using h
  by_cases hiq : i.val < q
  · have h := congrFun hR ⟨i.val-b,by omega⟩
    have hidx : (⟨b+(i.val-b), by omega⟩ : Fin k) = i := by
      apply Fin.ext
      change b+(i.val-b)=i.val
      omega
    simpa only [R,hidx,prefixVar,hiq,ite_eq_left] using congrArg some h
  · simp [prefixVar,hiq]

theorem ordered_prefix_conditional_bound {β : Type uBeta} (p : FinLaw Ω)
    (X : Ω → Fin k → α) (C : Equiv.Perm (Fin k) → Ω → β)
    {b q : ℕ} (hbq : b < q) (hq : q ≤ k)
    (hC : ∀ π ω ν, C π ω = C π ν → prefixVar X π b ω = prefixVar X π b ν)
    (hswap : ∀ π (j : Fin k), b ≤ j.val →
      C (π*Equiv.swap ⟨b,by omega⟩ j) = C π) :
    (𝔼 π : Equiv.Perm (Fin k), p.cHf (prefixVar X π q) (C π)) ≤
      (q-b : ℕ) * (𝔼 π : Equiv.Perm (Fin k),
        p.cHf (fun ω => X ω (π ⟨b,by omega⟩)) (C π)) := by
  have h := Finset.expect_le_expect (s := Finset.univ) (fun π _ =>
    p.prefix_conditional_block X π (C π) hbq.le hq (hC π))
  rw [Finset.expect_sum_comm] at h
  have he (j : Fin (q-b)) :
      (𝔼 π : Equiv.Perm (Fin k), p.cHf (fun ω => X ω (π ⟨b+j.val,by omega⟩)) (C π)) =
      𝔼 π : Equiv.Perm (Fin k), p.cHf (fun ω => X ω (π ⟨b,by omega⟩)) (C π) := by
    exact (p.ordered_remaining_exchange_cond X C ⟨b,by omega⟩ ⟨b+j.val,by omega⟩
      (fun π => hswap π _ (by change b ≤ b+j.val; omega))).symm
  simpa only [he,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] using h

theorem ordered_enrichment_accounting {β : Type uBeta} {γ : Type uGamma} {δ : Type uDelta} (p : FinLaw Ω)
    (X Y Z : Ω → Fin k → α) (d : Ω → Fin k → β) (H : Ω → γ) (E : Ω → δ)
    {b q : ℕ} (hb : 0 < b) (hbq : b < q) (hq : q ≤ k)
    (hd : ∀ i ω ν, X ω i = X ν i → Y ω i = Y ν i → d ω i = d ν i)
    (hY : ∀ i ω ν, X ω i = X ν i → d ω i = d ν i → Y ω i = Y ν i)
    (hH : ∀ i ω ν, H ω = H ν → d ω i = d ν i)
    (hZ : ∀ i ω ν, X ω i = X ν i → E ω = E ν → Z ω i = Z ν i) :
    (b : ℝ) * ((q-b : ℕ) *
      (𝔼 π : Equiv.Perm (Fin k), p.cHf (fun ω => d ω (π ⟨b,by omega⟩))
        (fun ω => (prefixVar X π b ω,prefixVar Y π b ω))) +
      p.orderedEntropy Z q-p.Hf H-p.Hf E) ≤
      (q : ℝ)*(p.orderedEntropy X b+p.orderedEntropy Y b) := by
  let C := fun (π : Equiv.Perm (Fin k)) ω =>
    ((prefixVar X π b ω,prefixVar Y π b ω),H ω)
  let A := 𝔼 π : Equiv.Perm (Fin k),
    p.cHf (fun ω => X ω (π ⟨b,by omega⟩)) (C π)
  let F := 𝔼 π : Equiv.Perm (Fin k),
    p.cHf (fun ω => d ω (π ⟨b,by omega⟩))
      (fun ω => (prefixVar X π b ω,prefixVar Y π b ω))
  have hblock := p.ordered_prefix_conditional_bound X C hbq hq
    (fun π ω ν hh => congrArg (fun c => c.1.1) hh) (by
      intro π j hj
      dsimp [C]
      rw [prefixVar_swap X π b _ j (by exact le_rfl) hj,
        prefixVar_swap Y π b _ j (by exact le_rfl) hj])
  have hlow (π : Equiv.Perm (Fin k)) :
      p.Hf (prefixVar Z π q)-p.Hf E-p.Hf (prefixVar X π b)-
        p.Hf (prefixVar Y π b)-p.Hf H ≤ p.cHf (prefixVar X π q) (C π) := by
    have hz : p.Hf (prefixVar Z π q) ≤ p.Hf (prefixVar X π q)+p.Hf E := by
      apply (p.Hf_le_of_determined (prefixVar Z π q)
        (fun ω => (prefixVar X π q ω,E ω)) ?_).trans (p.Hf_pair_subadd _ _)
      intro ω ν hh
      funext i
      by_cases hi : i.val<q
      · have hx : X ω (π i)=X ν (π i) := by
          simpa [prefixVar,hi] using congrFun (congrArg Prod.fst hh) i
        simpa only [prefixVar,hi,ite_eq_left] using congrArg some
          (hZ (π i) ω ν hx (congrArg Prod.snd hh))
      · simp [prefixVar,hi]
    have hc : p.Hf (C π) ≤ p.Hf (prefixVar X π b)+p.Hf (prefixVar Y π b)+p.Hf H := by
      have h1 := p.Hf_pair_subadd (fun ω => (prefixVar X π b ω,prefixVar Y π b ω)) H
      have h2 := p.Hf_pair_subadd (prefixVar X π b) (prefixVar Y π b)
      dsimp [C]
      linarith
    have hx := p.Hf_pair_ge_snd (C π) (prefixVar X π q)
    rw [p.Hf_pair_comm] at hx
    unfold cHf
    linarith
  have hav := Finset.expect_le_expect (s := Finset.univ) (fun π _ => hlow π)
  simp only [Finset.expect_sub_distrib,Fintype.expect_const] at hav
  have hal : p.orderedEntropy Z q-p.Hf E-p.orderedEntropy X b-
      p.orderedEntropy Y b-p.Hf H ≤ (q-b : ℕ)*A := hav.trans hblock
  have hchain := Finset.expect_le_expect (s := Finset.univ) (fun π _ =>
    p.enrichment_chain (fun ω => X ω (π ⟨b,by omega⟩)) (fun ω => Y ω (π ⟨b,by omega⟩))
      (prefixVar X π b) (prefixVar Y π b) (fun ω => d ω (π ⟨b,by omega⟩)) H
      (hd _) (hY _) (hH _))
  simp only [Finset.expect_sub_distrib,Finset.expect_add_distrib] at hchain
  have hchain' : F ≤ (p.orderedEntropy X (b+1)-p.orderedEntropy X b)+
      (p.orderedEntropy Y (b+1)-p.orderedEntropy Y b)-A := by
    rwa [p.orderedEntropy_step X (by omega),p.orderedEntropy_step Y (by omega)]
  have hx := p.orderedEntropy_slope X hb (by omega)
  have hy := p.orderedEntropy_slope Y hb (by omega)
  have haux : A+F ≤ (p.orderedEntropy X b+p.orderedEntropy Y b)/b := by
    rw [add_div]
    linarith
  have hbR : (0 : ℝ)<b := by exact_mod_cast hb
  have hqR : (0 : ℝ)≤(q-b : ℕ) := by positivity
  have hm := mul_le_mul_of_nonneg_left haux hqR
  have hbmul := mul_le_mul_of_nonneg_left hm hbR.le
  have hn : ((q-b : ℕ) : ℝ) = q-b := by rw [Nat.cast_sub hbq.le]
  have hdiv : (b : ℝ)*((q-b : ℕ)*((p.orderedEntropy X b+p.orderedEntropy Y b)/b)) =
      (q-b : ℕ)*(p.orderedEntropy X b+p.orderedEntropy Y b) := by field_simp
  rw [hdiv] at hbmul
  have hlowmul := mul_le_mul_of_nonneg_left hal hbR.le
  change (b : ℝ)*((q-b : ℕ)*F+p.orderedEntropy Z q-p.Hf H-p.Hf E) ≤ _
  rw [hn] at hbmul hlowmul ⊢
  nlinarith

end FinLaw

open scoped BigOperators

lemma perm_expect_exchange {ι : Type uIota} [Fintype ι] [DecidableEq ι] (f : ι → ℝ) (i j : ι) :
    (𝔼 π : Equiv.Perm ι, f (π i)) = 𝔼 π : Equiv.Perm ι, f (π j) := by
  classical
  apply Fintype.expect_equiv (Equiv.mulRight (Equiv.swap i j))
  intro π
  change f (π i) = f ((π*Equiv.swap i j) j)
  simp only [Equiv.Perm.mul_apply,Equiv.swap_apply_right]

theorem perm_covariance_nonpos {ι : Type uIota} [Fintype ι] [DecidableEq ι] (f : ι → ℝ)
    (hf : ∑ i, f i = 0) {i j : ι} (hij : i ≠ j) :
    (𝔼 π : Equiv.Perm ι, f (π i)*f (π j)) ≤ 0 := by
  classical
  let S := Finset.univ.erase i
  have hS : S.Nonempty := ⟨j,Finset.mem_erase.mpr ⟨hij.symm,Finset.mem_univ _⟩⟩
  have hex (a : ι) (ha : a ∈ S) :
      (𝔼 π : Equiv.Perm ι, f (π i)*f (π a)) =
        𝔼 π : Equiv.Perm ι, f (π i)*f (π j) := by
    have hai : i ≠ a := (Finset.mem_erase.mp ha).1.symm
    apply Fintype.expect_equiv (Equiv.mulRight (Equiv.swap a j))
    intro π
    change f (π i)*f (π a) = f ((π*Equiv.swap a j) i)*f ((π*Equiv.swap a j) j)
    simp only [Equiv.Perm.mul_apply,Equiv.swap_apply_right,
      Equiv.swap_apply_of_ne_of_ne hai hij]
  have hsum (π : Equiv.Perm ι) : (∑ a ∈ S, f (π a)) = -f (π i) := by
    have h := Equiv.sum_comp π f
    rw [hf] at h
    have hi := Finset.sum_erase_add (s := Finset.univ) (f := fun a => f (π a))
      (Finset.mem_univ i)
    dsimp [S]
    linarith
  have hid : (S.card : ℝ)*(𝔼 π : Equiv.Perm ι, f (π i)*f (π j)) =
      -(𝔼 π : Equiv.Perm ι, f (π i)^2) := by
    calc
      _ = ∑ a ∈ S, (𝔼 π : Equiv.Perm ι, f (π i)*f (π a)) := by
        rw [show (∑ a ∈ S, (𝔼 π : Equiv.Perm ι, f (π i)*f (π a))) =
            ∑ _a ∈ S, (𝔼 π : Equiv.Perm ι, f (π i)*f (π j)) from
              Finset.sum_congr rfl (fun a ha => hex a ha)]
        simp [nsmul_eq_mul]
      _ = 𝔼 π : Equiv.Perm ι, ∑ a ∈ S, f (π i)*f (π a) :=
        (Finset.expect_sum_comm _ _ _).symm
      _ = -(𝔼 π : Equiv.Perm ι, f (π i)^2) := by
        simp_rw [← Finset.mul_sum,hsum,mul_neg,← sq]
        rw [Finset.expect_neg_distrib]
  have hvar : 0 ≤ (𝔼 π : Equiv.Perm ι, f (π i)^2) :=
    Finset.expect_nonneg (fun _ _ => sq_nonneg _)
  have hc : (0 : ℝ) < S.card := by exact_mod_cast hS.card_pos
  nlinarith

theorem perm_sample_second_moment {ι : Type uIota} [Fintype ι] [DecidableEq ι] (f : ι → ℝ)
    (hf : ∑ i, f i = 0) (S : Finset ι) {M : ℝ} (hM : ∀ i, (f i)^2 ≤ M) :
    (𝔼 π : Equiv.Perm ι, (∑ i ∈ S, f (π i))^2) ≤ S.card*M := by
  classical
  induction S using Finset.induction_on with
  | empty => simp
  | @insert i S hi ih =>
    have hsqr (π : Equiv.Perm ι) : (∑ j ∈ insert i S, f (π j))^2 =
        (f (π i))^2+(∑ j ∈ S, f (π j))^2+2*(∑ j ∈ S, f (π i)*f (π j)) := by
      rw [Finset.sum_insert hi,← Finset.mul_sum]
      ring
    simp_rw [hsqr,Finset.expect_add_distrib,← Finset.mul_expect,Finset.expect_sum_comm]
    have hb : (𝔼 π : Equiv.Perm ι, f (π i)^2) ≤ M :=
      (Finset.expect_le_expect (s := Finset.univ) (fun π _ => hM (π i))).trans_eq
        (Fintype.expect_const _)
    have hc : (∑ j ∈ S, (𝔼 π : Equiv.Perm ι, f (π i)*f (π j))) ≤ 0 := by
      apply Finset.sum_nonpos
      intro j hj
      exact perm_covariance_nonpos f hf (fun he => hi (he.symm ▸ hj))
    rw [Finset.card_insert_of_notMem hi,Nat.cast_add,Nat.cast_one]
    nlinarith

theorem expect_lower_tail_le {Ω : Type uOmega} [Fintype Ω] [Nonempty Ω]
    (Z : Ω → ℝ) {a δ V : ℝ} (hδ : 0 < δ)
    (hV : (𝔼 ω, (Z ω-a)^2) ≤ V) :
    (𝔼 ω, if Z ω < a-δ then (1 : ℝ) else 0) ≤ V/δ^2 := by
  classical
  have he : ∀ ω, δ^2*(if Z ω < a-δ then (1 : ℝ) else 0) ≤ (Z ω-a)^2 := by
    intro ω
    split_ifs with hh
    · nlinarith
    · simpa using sq_nonneg (Z ω-a)
  have h := Finset.expect_le_expect (s := Finset.univ) (fun ω _ => he ω)
  rw [← Finset.mul_expect] at h
  exact (le_div_iff₀ (sq_pos_of_pos hδ)).mpr (by nlinarith)

theorem perm_sample_interval_tail {ι : Type uIota} [Fintype ι] [DecidableEq ι] [Nonempty ι]
    (f : ι → ℝ) (S : Finset ι) {a M δ : ℝ} (hδ : 0 < δ)
    (hf : ∀ i, a ≤ f i ∧ f i ≤ a+M) :
    (𝔼 π : Equiv.Perm ι,
      if (∑ i ∈ S, f (π i)) < S.card*(𝔼 i, f i)-δ then (1 : ℝ) else 0) ≤
      S.card*M^2/δ^2 := by
  let μ := 𝔼 i, f i
  have hlo : a ≤ μ := by
    have h := Finset.expect_le_expect (s := Finset.univ) (fun i _ => (hf i).1)
    simpa only [Fintype.expect_const] using h
  have hhi : μ ≤ a+M := by
    have h := Finset.expect_le_expect (s := Finset.univ) (fun i _ => (hf i).2)
    simpa only [Fintype.expect_const] using h
  have hsum : ∑ i, (f i-μ) = 0 := by
    simp only [Finset.sum_sub_distrib,Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
    rw [show (Fintype.card ι : ℝ)*μ = ∑ i, f i from Fintype.card_mul_expect f]
    ring
  have hsq (i : ι) : (f i-μ)^2 ≤ M^2 := by
    have h := hf i
    nlinarith
  have hvar := perm_sample_second_moment (fun i => f i-μ) hsum S hsq
  have hid (π : Equiv.Perm ι) : (∑ i ∈ S, (f (π i)-μ)) =
      (∑ i ∈ S, f (π i))-S.card*μ := by
    simp only [Finset.sum_sub_distrib,Finset.sum_const,nsmul_eq_mul]
  simp_rw [hid] at hvar
  exact expect_lower_tail_le _ hδ hvar

namespace FinLaw
open scoped BigOperators
variable {Ω : Type uOmega} {α : Type uAlpha} [Fintype Ω] {k : ℕ}

noncomputable def uniform (Ω : Type uOmega) [Fintype Ω] [Nonempty Ω] : FinLaw Ω where
  mass := fun _ => (Fintype.card Ω : ℝ)⁻¹
  nonneg := fun _ => inv_nonneg.mpr (Nat.cast_nonneg _)
  sum_one := by
    simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
    exact mul_inv_cancel₀ (by exact_mod_cast (Fintype.card_pos : 0 < Fintype.card Ω).ne')

@[simp] theorem uniform_mass [Nonempty Ω] (ω : Ω) :
    uniform Ω ω = (Fintype.card Ω : ℝ)⁻¹ := rfl

theorem uniform_Hf_injective {β : Type uBeta} [Nonempty Ω] (X : Ω → β)
    (hX : Function.Injective X) : (uniform Ω).Hf X = Real.log (Fintype.card Ω) := by
  classical
  have hN : (Fintype.card Ω : ℝ) ≠ 0 := by exact_mod_cast (Fintype.card_pos : 0 < Fintype.card Ω).ne'
  unfold Hf
  simp only [hX.eq_iff,uniform_mass,Finset.sum_ite_eq',Finset.mem_univ,ite_true,
    Finset.sum_const,Finset.card_univ,nsmul_eq_mul,Real.log_inv]
  rw [← mul_assoc,mul_inv_cancel₀ hN]
  ring

theorem Hf_le_log_card_type {β : Type uBeta} [Fintype β] (p : FinLaw Ω) (X : Ω → β) :
    p.Hf X ≤ Real.log (Fintype.card β) := by
  rw [p.Hf_eq_H]
  exact (p.map X).entropy_le_log_card

theorem Hf_le_log_card_set {β : Type uBeta} (p : FinLaw Ω) (X : Ω → β)
    (S : Finset β) (hX : ∀ ω, X ω ∈ S) : p.Hf X ≤ Real.log S.card := by
  classical
  let Y := fun ω => (⟨X ω,hX ω⟩ : S)
  have he : p.Hf X = p.Hf Y := by
    apply p.Hf_eq_of_fibers
    intro ω ν
    exact ⟨fun h => Subtype.ext h, fun h => congrArg Subtype.val h⟩
  rw [he]
  simpa using p.Hf_le_log_card_type Y

theorem map_mix {ι : Type uIota} {β : Type uBeta} [Fintype ι] [Fintype β]
    (p : FinLaw ι) (q : ι → FinLaw Ω) (X : Ω → β) :
    (p.mix q).map X = p.mix (fun i => (q i).map X) := by
  classical
  ext b
  simp only [map_mass,mix_mass,Finset.mul_sum]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro ω _
  split_ifs <;> simp

theorem Hf_mix_ge {ι : Type uIota} {β : Type uBeta} [Fintype ι]
    (p : FinLaw ι) (q : ι → FinLaw Ω) (X : Ω → β) :
    (∑ i, p i*(q i).Hf X) ≤ (p.mix q).Hf X := by
  classical
  let Y := fun ω => (⟨X ω,⟨ω,rfl⟩⟩ : Set.range X)
  let : Fintype (Set.range X) := Fintype.ofFinite _
  have he (r : FinLaw Ω) : r.Hf X = r.Hf Y := by
    apply r.Hf_eq_of_fibers
    intro ω ν
    exact ⟨fun h => Subtype.ext h, fun h => congrArg Subtype.val h⟩
  simp_rw [he,Hf_eq_H]
  change (∑ i, p i*((q i).map Y).entropy) ≤ ((p.mix q).map Y).entropy
  rw [map_mix]
  exact p.entropy_mix_ge _

theorem Hf_prefix_le (p : FinLaw Ω) (X : Ω → Fin k → α) (π : Equiv.Perm (Fin k))
    (s : ℕ) : p.Hf (prefixVar X π s) ≤ p.Hf X := by
  exact p.Hf_le_of_determined _ _ (fun ω ν hh =>
    congrArg (fun y (i : Fin k) => if i.val < s then some (y (π i)) else none) hh)

theorem Hf_fintype_subadd {ι : Type uIota} {β : Type uBeta} [Fintype ι] (p : FinLaw Ω)
    (X : Ω → ι → β) : p.Hf X ≤ ∑ i, p.Hf (fun ω => X ω i) := by
  classical
  have he : p.Hf (fun ω (i : (Finset.univ : Finset ι)) => X ω i) = p.Hf X := by
    apply p.Hf_eq_of_fibers
    intro ω ν
    constructor
    · intro hh
      funext i
      exact congrFun hh ⟨i,Finset.mem_univ _⟩
    · intro hh
      funext i
      exact congrFun hh i
  simpa only [he] using p.Hf_finset_subadd X Finset.univ

theorem Hf_prefix_le_sum (p : FinLaw Ω) (X : Ω → Fin k → α)
    (L : Fin k → ℝ) (hL : ∀ i, p.Hf (fun ω => X ω i) ≤ L i)
    (π : Equiv.Perm (Fin k)) {s : ℕ} (hs : s ≤ k) :
    p.Hf (prefixVar X π s) ≤ ∑ j : Fin s, L (π ⟨j.val,by omega⟩) := by
  let Y := fun ω (j : Fin s) => X ω (π ⟨j.val,by omega⟩)
  have he : p.Hf (prefixVar X π s) = p.Hf Y := by
    apply p.Hf_eq_of_fibers
    intro ω ν
    constructor
    · intro hh
      funext j
      have h := congrFun hh ⟨j.val,by omega⟩
      simpa [prefixVar,j.isLt,Y] using h
    · intro hh
      funext j
      by_cases hj : j.val < s
      · have h := congrFun hh ⟨j.val,hj⟩
        simpa [prefixVar,hj,Y] using congrArg some h
      · simp [prefixVar,hj]
  rw [he]
  exact (p.Hf_fintype_subadd Y).trans (Finset.sum_le_sum (fun j _ => hL _))

theorem fresh_entropy_from_prefix {β : Type uBeta} (p : FinLaw Ω)
    (X Y : Ω → Fin k → α) (d : Ω → Fin k → β) {b s : ℕ}
    (hbs : b < s) (hs : s ≤ k)
    (hd : ∀ i ω ν, X ω i = X ν i → Y ω i = Y ν i → d ω i = d ν i) :
    p.orderedEntropy d s-p.orderedEntropy X b-p.orderedEntropy Y b ≤
      (s-b : ℕ)*(𝔼 π : Equiv.Perm (Fin k),
        p.cHf (fun ω => d ω (π ⟨b,by omega⟩))
          (fun ω => (prefixVar X π b ω,prefixVar Y π b ω))) := by
  let C := fun (π : Equiv.Perm (Fin k)) ω => (prefixVar X π b ω,prefixVar Y π b ω)
  have hdet : ∀ π ω ν, C π ω=C π ν → prefixVar d π b ω=prefixVar d π b ν := by
    intro π ω ν hh
    funext i
    by_cases hi : i.val < b
    · have hx := congrFun (congrArg Prod.fst hh) i
      have hy := congrFun (congrArg Prod.snd hh) i
      simp only [C,prefixVar,hi,ite_eq_left,Option.some.injEq] at hx hy
      simpa only [prefixVar,hi,ite_eq_left] using congrArg some (hd (π i) ω ν hx hy)
    · simp [prefixVar,hi]
  have hblock := p.ordered_prefix_conditional_bound d C hbs hs hdet (by
    intro π j hj
    dsimp [C]
    rw [prefixVar_swap X π b _ j (by exact le_rfl) hj,
      prefixVar_swap Y π b _ j (by exact le_rfl) hj])
  have hlow (π : Equiv.Perm (Fin k)) : p.Hf (prefixVar d π s)-
      p.Hf (prefixVar X π b)-p.Hf (prefixVar Y π b) ≤
        p.cHf (prefixVar d π s) (C π) := by
    have h1 := p.Hf_pair_subadd (prefixVar X π b) (prefixVar Y π b)
    have h2 := p.Hf_pair_ge_snd (C π) (prefixVar d π s)
    rw [p.Hf_pair_comm] at h2
    dsimp [C] at *
    unfold cHf
    linarith
  have hav := Finset.expect_le_expect (s := Finset.univ) (fun π _ => hlow π)
  simp only [Finset.expect_sub_distrib] at hav
  exact hav.trans hblock

end FinLaw

end GaussianMoat

end OAI