import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Coding.TypicalWordCodebook

namespace OAI

section
namespace HyperbolicCoding
open MeasureTheory Set StandardMapEntropy.Entropy
open scoped BigOperators ENNReal
variable {X A B : Type*} [MeasurableSpace X] [Fintype A] [Fintype B]
variable (μ : Measure X) [IsProbabilityMeasure μ]

lemma cond_vector_subadd [MeasurableSpace A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [MeasurableSingletonClass B]
    (N : ℕ) (p : X → Fin N → A) (q : X → Fin N → B)
    (hp : Measurable p) (hq : Measurable q) :
    StandardMapEntropy.Entropy.cond μ p q≤∑ i : Fin N,
      StandardMapEntropy.Entropy.cond μ (fun x => p x i) (fun x => q x i) := by
  induction N with
  | zero =>
    have h1 : p=fun _ => (fun i : Fin 0 => i.elim0 : Fin 0 → A) := by
      funext x i
      exact i.elim0
    have h2 : q=fun _ => (fun i : Fin 0 => i.elim0 : Fin 0 → B) := by
      funext x i
      exact i.elim0
    rw [h1,h2]
    simp [StandardMapEntropy.Entropy.cond,obs_const]
  | succ N ih =>
    let eA : (A×(Fin N → A)) ≃ (Fin (N+1) → A) := Fin.consEquiv (fun _ => A)
    let eB : (B×(Fin N → B)) ≃ (Fin (N+1) → B) := Fin.consEquiv (fun _ => B)
    have h1 : p=eA ∘ (fun x => (p x 0,Fin.tail (p x))) := by
      funext x
      exact (Fin.consEquiv (fun _ => A)).apply_symm_apply (p x) |>.symm
    have h2 : q=eB ∘ (fun x => (q x 0,Fin.tail (q x))) := by
      funext x
      exact (Fin.consEquiv (fun _ => B)).apply_symm_apply (q x) |>.symm
    have hp0 := (measurable_pi_apply 0).comp hp
    have hq0 := (measurable_pi_apply 0).comp hq
    have hpt : Measurable (fun x => Fin.tail (p x)) := Measurable.of_eval
      (fun i => (measurable_pi_apply i.succ).comp hp)
    have hqt : Measurable (fun x => Fin.tail (q x)) := Measurable.of_eval
      (fun i => (measurable_pi_apply i.succ).comp hq)
    have hb := cond_pair_subadd μ (fun x => p x 0) (fun x => q x 0)
      (fun x => Fin.tail (p x)) (fun x => Fin.tail (q x)) hp0 hq0 hpt hqt
    have hi := ih (fun x => Fin.tail (p x)) (fun x => Fin.tail (q x)) hpt hqt
    rw [h1,h2,cond_equiv_left,cond_equiv_right]
    rw [Fin.sum_univ_succ]
    exact hb.trans (add_le_add (le_refl _) hi)

lemma shannon_productVector [MeasurableSpace A] [MeasurableSingletonClass A]
    (N : ℕ) (p : Fin N → A → ℝ) (hs : ∀ i,∑ a,p i a=1) :
    shannon (fun w : Fin N → A => ∏ i,p i (w i))=∑ i,shannon (p i) := by
  induction N with
  | zero => simp [shannon]
  | succ N ih =>
    let e : (A×(Fin N → A)) ≃ (Fin (N+1) → A) := Fin.consEquiv (fun _ => A)
    have he : shannon (fun w : Fin (N+1) → A => ∏ i,p i (w i))=
        shannon (fun aw : A×(Fin N → A) => p 0 aw.1*∏ i,p i.succ (aw.2 i)) := by
      unfold shannon
      rw [←Equiv.sum_comp e]
      apply Finset.sum_congr rfl
      intro aw _
      congr 1
      simp [e,Fin.prod_univ_succ]
    have hm : (∑ w : Fin N → A,∏ i,p i.succ (w i))=1 :=
      productWeights_sum (fun i : Fin N => p i.succ) (fun i => hs i.succ)
    rw [he,shannon_product_weights (p 0) (fun w : Fin N → A => ∏ i,p i.succ (w i))
      (hs 0) hm,ih _ (fun i => hs i.succ),Fin.sum_univ_succ]
end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory Set StandardMapEntropy.Entropy
open scoped BigOperators ENNReal
variable {X A B C : Type*} [MeasurableSpace X] [Fintype A] [Fintype B]
    [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C]
variable (μ : Measure X)

lemma mass_factor_sum [MeasurableSpace A] [MeasurableSingletonClass A]
    [IsProbabilityMeasure μ] [DecidableEq C] (p : X → A) (hp : Measurable p) (c : A → C) (z : C) :
    mass μ (c ∘ p) z=∑ a,if c a=z then mass μ p a else 0 := by
  classical
  have h := sum_mass_factor_mul μ p hp c (fun v => if v=z then 1 else 0)
  simpa only [mul_ite,mul_one,mul_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true] using h.symm

lemma cond_eq_channel_average [MeasurableSpace A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [MeasurableSingletonClass B] [IsProbabilityMeasure μ]
    (p : X → A) (q : X → B)
    (K : A → B → ℝ) (hK : ∀ a,∑ b,K a b=1)
    (hjoint : ∀ a b,mass μ (fun x => (p x,q x)) (a,b)=mass μ p a*K a b) :
    StandardMapEntropy.Entropy.cond μ q p=∑ a,mass μ p a*shannon (K a) := by
  have hs (a : A) : (∑ b,Real.negMulLog (mass μ p a*K a b))=
      mass μ p a*shannon (K a)+Real.negMulLog (mass μ p a) := by
    change shannon (fun b => mass μ p a*K a b)=_
    simpa only [hK,one_mul] using shannon_scale (K a) (mass μ p a)
  rw [StandardMapEntropy.Entropy.cond,obs_pair_swap μ q p]
  simp only [obs,shannon,Fintype.sum_prod_type,hjoint]
  change (∑ a,∑ b,Real.negMulLog (mass μ p a*K a b))-
    (∑ a,Real.negMulLog (mass μ p a))=_
  simp only [hs,Finset.sum_add_distrib,shannon]
  ring

lemma product_channel_coordinate [MeasurableSpace A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [MeasurableSingletonClass B] [IsProbabilityMeasure μ]
    (N : ℕ) (p : X → Fin N → A) (q : X → Fin N → B)
    (hp : Measurable p) (hq : Measurable q) (K : Fin N → A → B → ℝ)
    (hK : ∀ i a,∑ b,K i a b=1)
    (hjoint : ∀ v w,mass μ (fun x => (p x,q x)) (v,w)=
      mass μ p v*∏ i,K i (v i) (w i)) (i : Fin N) (a : A) (b : B) :
    mass μ (fun x => (p x i,q x i)) (a,b)=mass μ (fun x => p x i) a*K i a b := by
  classical
  have he := mass_factor_sum μ (fun x => (p x,q x)) (hp.prodMk hq)
    (fun vw : (Fin N → A)×(Fin N → B) => (vw.1 i,vw.2 i)) (a,b)
  change mass μ (fun x => (p x i,q x i)) (a,b)=_ at he
  rw [he]
  simp only [Fintype.sum_prod_type,hjoint,Prod.mk.injEq]
  have hr (v : Fin N → A) :
      (∑ w : Fin N → B,if v i=a ∧ w i=b then mass μ p v*∏ j,K j (v j) (w j) else 0)=
      (if v i=a then mass μ p v else 0)*K i a b := by
    by_cases hv : v i=a
    · simp only [hv,true_and,ite_true]
      have hec := expectation_coordinate (fun j => K j (v j)) (fun j => hK j (v j)) i
        (fun z => if z=b then 1 else 0)
      simp only [finiteExpectation,productWeights,mul_ite,mul_one,mul_zero,
        Finset.sum_ite_eq',Finset.mem_univ,ite_true] at hec
      calc
        _ = mass μ p v*(∑ w : Fin N → B,if w i=b then ∏ j,K j (v j) (w j) else 0) := by
          rw [Finset.mul_sum]
          apply Finset.sum_congr rfl
          intro w _
          split_ifs <;> simp
        _ = _ := by rw [hec,hv]
    · simp only [hv,false_and,ite_false,Finset.sum_const_zero,zero_mul]
  simp only [hr,←Finset.sum_mul]
  have hm := mass_factor_sum μ p hp (fun v : Fin N → A => v i) a
  exact congrArg (fun t : ℝ => t*K i a b) hm.symm

theorem product_channel_entropy_lower [MeasurableSpace A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [MeasurableSingletonClass B] [IsProbabilityMeasure μ]
    (N : ℕ) (p : X → Fin N → A) (q : X → Fin N → B)
    (hp : Measurable p) (hq : Measurable q) (K : Fin N → A → B → ℝ)
    (hK : ∀ i a,∑ b,K i a b=1)
    (hjoint : ∀ v w,mass μ (fun x => (p x,q x)) (v,w)=
      mass μ p v*∏ i,K i (v i) (w i)) :
    obs μ p+(∑ i : Fin N,(obs μ (fun x => q x i)-obs μ (fun x => p x i)))≤obs μ q := by
  have hfull := cond_eq_channel_average μ p q (fun v w => ∏ i,K i (v i) (w i))
    (fun v => productWeights_sum (fun i => K i (v i)) (fun i => hK i (v i))) hjoint
  have hr : StandardMapEntropy.Entropy.cond μ q p=∑ i : Fin N,
      StandardMapEntropy.Entropy.cond μ (fun x => q x i) (fun x => p x i) := by
    rw [hfull]
    simp_rw [shannon_productVector _ _ (fun i => hK i _),Finset.mul_sum]
    rw [Finset.sum_comm]
    apply Finset.sum_congr rfl
    intro i _
    rw [cond_eq_channel_average μ (fun x => p x i) (fun x => q x i) (K i) (hK i)
      (product_channel_coordinate μ N p q hp hq K hK hjoint i)]
    exact sum_mass_factor_mul μ p hp (fun v : Fin N → A => v i) (fun a => shannon (K i a))
  have hsub := cond_vector_subadd μ N p q hp hq
  have hid : obs μ p-obs μ q=StandardMapEntropy.Entropy.cond μ p q-
      StandardMapEntropy.Entropy.cond μ q p := by
    rw [StandardMapEntropy.Entropy.cond,StandardMapEntropy.Entropy.cond,obs_pair_swap μ q p]
    ring
  have hi (i : Fin N) : obs μ (fun x => q x i)-obs μ (fun x => p x i)=
      StandardMapEntropy.Entropy.cond μ (fun x => q x i) (fun x => p x i)-
        StandardMapEntropy.Entropy.cond μ (fun x => p x i) (fun x => q x i) := by
    unfold StandardMapEntropy.Entropy.cond
    rw [obs_pair_swap μ (fun x => q x i) (fun x => p x i)]
    ring
  simp only [hi,Finset.sum_sub_distrib]
  rw [hr] at hid
  linarith
end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory Set StandardMapEntropy.Entropy
open scoped BigOperators ENNReal
variable {A B : Type*} [MeasurableSpace A] [Fintype A]
    [MeasurableSpace B] [Fintype B]

lemma mass_finiteWeightLaw_id [MeasurableSingletonClass A] (P : A → ℝ) (hP : ∀ a,0≤P a) (a : A) :
    mass (finiteWeightLaw P) id a=P a := by
  simp only [mass,preimage_id,finiteWeightLaw_singleton,ENNReal.toReal_ofReal (hP a)]

noncomputable def finiteChannelLaw (N : ℕ) (P : (Fin N → A) → ℝ)
    (K : Fin N → A → B → ℝ) : Measure ((Fin N → A)×(Fin N → B)) :=
  finiteWeightLaw (fun vw => P vw.1*∏ i,K i (vw.1 i) (vw.2 i))

lemma finiteChannelLaw_probability [MeasurableSingletonClass A] [MeasurableSingletonClass B]
    (N : ℕ) (P : (Fin N → A) → ℝ)
    (hP : ∀ v,0≤P v) (hPs : ∑ v,P v=1) (K : Fin N → A → B → ℝ)
    (hK : ∀ i a b,0≤K i a b) (hKs : ∀ i a,∑ b,K i a b=1) :
    IsProbabilityMeasure (finiteChannelLaw N P K) := by
  apply finiteWeightLaw_probability
  · intro vw
    exact mul_nonneg (hP _) (Finset.prod_nonneg (fun i _ => hK _ _ _))
  · simp only [Fintype.sum_prod_type,←Finset.mul_sum]
    have he (v : Fin N → A) : (∑ w : Fin N → B,∏ i,K i (v i) (w i))=1 :=
      productWeights_sum (fun i => K i (v i)) (fun i => hKs i (v i))
    simp only [he,mul_one,hPs]

lemma finiteChannelLaw_pair_mass [MeasurableSingletonClass A] [MeasurableSingletonClass B]
    (N : ℕ) (P : (Fin N → A) → ℝ)
    (hP : ∀ v,0≤P v) (K : Fin N → A → B → ℝ) (hK : ∀ i a b,0≤K i a b)
    (v : Fin N → A) (w : Fin N → B) :
    mass (finiteChannelLaw N P K) (fun vw => (vw.1,vw.2)) (v,w)=P v*∏ i,K i (v i) (w i) := by
  exact mass_finiteWeightLaw_id _ (fun vw => mul_nonneg (hP _)
    (Finset.prod_nonneg (fun i _ => hK _ _ _))) (v,w)

lemma finiteChannelLaw_input_mass [MeasurableSingletonClass A] [MeasurableSingletonClass B]
    (N : ℕ) (P : (Fin N → A) → ℝ)
    (hP : ∀ v,0≤P v) (K : Fin N → A → B → ℝ) (hK : ∀ i a b,0≤K i a b)
    (hKs : ∀ i a,∑ b,K i a b=1) (v : Fin N → A) :
    mass (finiteChannelLaw N P K) Prod.fst v=P v := by
  have : IsFiniteMeasure (finiteChannelLaw N P K) := finiteWeightLaw_finite _
  rw [mass_joint_row _ Prod.fst Prod.snd measurable_fst measurable_snd]
  simp only [finiteChannelLaw_pair_mass N P hP K hK,←Finset.mul_sum]
  have he : (∑ w : Fin N → B,∏ i,K i (v i) (w i))=1 :=
    productWeights_sum (fun i => K i (v i)) (fun i => hKs i (v i))
  rw [he,mul_one]

theorem finiteChannelLaw_entropy [MeasurableSingletonClass A] [MeasurableSingletonClass B]
    (N : ℕ) (P : (Fin N → A) → ℝ)
    (hP : ∀ v,0≤P v) (hPs : ∑ v,P v=1) (K : Fin N → A → B → ℝ)
    (hK : ∀ i a b,0≤K i a b) (hKs : ∀ i a,∑ b,K i a b=1) :
    shannon P+(∑ i : Fin N,(obs (finiteChannelLaw N P K) (fun vw => vw.2 i)-
      obs (finiteChannelLaw N P K) (fun vw => vw.1 i)))≤
      obs (finiteChannelLaw N P K) Prod.snd := by
  have := finiteChannelLaw_probability N P hP hPs K hK hKs
  have hh := product_channel_entropy_lower (finiteChannelLaw N P K) N Prod.fst Prod.snd
    measurable_fst measurable_snd K hKs (by
      intro v w
      rw [finiteChannelLaw_pair_mass N P hP K hK,finiteChannelLaw_input_mass N P hP K hK hKs])
  have he : obs (finiteChannelLaw N P K) Prod.fst=shannon P := by
    unfold obs
    congr 1
    funext v
    exact finiteChannelLaw_input_mass N P hP K hK hKs v
  rw [he] at hh
  exact hh
end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory Set StandardMapEntropy.Entropy
open scoped ENNReal BigOperators
variable {X Y A B : Type*} [MeasurableSpace X] [MeasurableSpace Y] [Fintype A] [Fintype B]

lemma channel_joint_l1 [MeasurableSpace A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [MeasurableSingletonClass B] (μ : Measure X) (ν : Measure Y)
    [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    (p : X → A) (r : X → B) (q : Y → A) (s : Y → B)
    (K : A → B → ℝ) (hK : ∀ a b,0≤K a b) (hKs : ∀ a,∑ b,K a b=1)
    (hμ : ∀ a b,mass μ (fun x => (p x,r x)) (a,b)=mass μ p a*K a b)
    (hν : ∀ a b,mass ν (fun x => (q x,s x)) (a,b)=mass ν q a*K a b) :
    (∑ ab : A×B,|mass μ (fun x => (p x,r x)) ab-mass ν (fun x => (q x,s x)) ab|)=
      ∑ a,|mass μ p a-mass ν q a| := by
  simp only [Fintype.sum_prod_type,hμ,hν,←sub_mul,abs_mul,abs_of_nonneg (hK _ _),
    ←Finset.mul_sum,hKs,mul_one]

lemma channel_joint_lawClose [MeasurableSpace A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [MeasurableSingletonClass B] (μ : Measure X) (ν : Measure Y)
    [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    (p : X → A) (r : X → B) (q : Y → A) (s : Y → B)
    (hp : Measurable p) (hr : Measurable r) (hq : Measurable q) (hs : Measurable s)
    (K : A → B → ℝ) (hK : ∀ a b,0≤K a b) (hKs : ∀ a,∑ b,K a b=1)
    (hμ : ∀ a b,mass μ (fun x => (p x,r x)) (a,b)=mass μ p a*K a b)
    (hν : ∀ a b,mass ν (fun x => (q x,s x)) (a,b)=mass ν q a*K a b)
    {δ : ℝ} (hlaw : LawClose (μ.map p) (ν.map q) δ) :
    LawClose (μ.map (fun x => (p x,r x))) (ν.map (fun x => (q x,s x))) (2*δ) := by
  have : IsProbabilityMeasure (μ.map p) := inferInstance
  have : IsProbabilityMeasure (ν.map q) := inferInstance
  have : IsProbabilityMeasure (μ.map (fun x => (p x,r x))) := inferInstance
  have : IsProbabilityMeasure (ν.map (fun x => (q x,s x))) := inferInstance
  have hmass (a : A) : (μ.map p).real {a}=mass μ p a :=
    map_measureReal_apply hp (measurableSet_singleton a)
  have hmass' (a : A) : (ν.map q).real {a}=mass ν q a :=
    map_measureReal_apply hq (measurableSet_singleton a)
  have hj (ab : A×B) : (μ.map (fun x => (p x,r x))).real {ab}=
      mass μ (fun x => (p x,r x)) ab := map_measureReal_apply (hp.prodMk hr) (measurableSet_singleton ab)
  have hj' (ab : A×B) : (ν.map (fun x => (q x,s x))).real {ab}=
      mass ν (fun x => (q x,s x)) ab := map_measureReal_apply (hq.prodMk hs) (measurableSet_singleton ab)
  have hh := finite_l1_le_two_of_lawClose _ _ hlaw
  simp only [hmass,hmass'] at hh
  apply lawClose_of_finite_l1
  simp only [hj,hj']
  rw [channel_joint_l1 μ ν p r q s K hK hKs hμ hν]
  exact hh

lemma channel_output_lawClose [MeasurableSpace A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [MeasurableSingletonClass B] (μ : Measure X) (ν : Measure Y)
    [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    (p : X → A) (r : X → B) (q : Y → A) (s : Y → B)
    (hp : Measurable p) (hr : Measurable r) (hq : Measurable q) (hs : Measurable s)
    (K : A → B → ℝ) (hK : ∀ a b,0≤K a b) (hKs : ∀ a,∑ b,K a b=1)
    (hμ : ∀ a b,mass μ (fun x => (p x,r x)) (a,b)=mass μ p a*K a b)
    (hν : ∀ a b,mass ν (fun x => (q x,s x)) (a,b)=mass ν q a*K a b)
    {δ : ℝ} (hlaw : LawClose (μ.map p) (ν.map q) δ) :
    LawClose (μ.map r) (ν.map s) (2*δ) := by
  have hh := (channel_joint_lawClose μ ν p r q s hp hr hq hs K hK hKs hμ hν hlaw).map measurable_snd
  simpa only [Measure.map_map measurable_snd (hp.prodMk hr),
    Measure.map_map measurable_snd (hq.prodMk hs),Function.comp_def] using hh

lemma channel_cost_stability [MeasurableSpace A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [MeasurableSingletonClass B] (μ : Measure X) (ν : Measure Y)
    [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    (p : X → A) (r : X → B) (q : Y → A) (s : Y → B)
    (hp : Measurable p) (hr : Measurable r) (hq : Measurable q) (hs : Measurable s)
    (K : A → B → ℝ) (hK : ∀ a b,0≤K a b) (hKs : ∀ a,∑ b,K a b=1)
    (hμ : ∀ a b,mass μ (fun x => (p x,r x)) (a,b)=mass μ p a*K a b)
    (hν : ∀ a b,mass ν (fun x => (q x,s x)) (a,b)=mass ν q a*K a b)
    {δ M : ℝ} (hM : 0≤M) (hlaw : LawClose (μ.map p) (ν.map q) δ)
    (d : A → B → ℝ) (hd : ∀ a b,|d a b|≤M) :
    (MatrixCoupling.observations ν q s hq hs).cost d≤
      (MatrixCoupling.observations μ p r hp hr).cost d+2*δ*M := by
  have : IsProbabilityMeasure (μ.map p) := inferInstance
  have : IsProbabilityMeasure (ν.map q) := inferInstance
  have hl1 := finite_l1_le_two_of_lawClose _ _ hlaw
  have he (a : A) : (μ.map p).real {a}=mass μ p a := map_measureReal_apply hp (measurableSet_singleton a)
  have he' (a : A) : (ν.map q).real {a}=mass ν q a := map_measureReal_apply hq (measurableSet_singleton a)
  simp only [he,he'] at hl1
  have hdiff : (∑ ab : A×B,(mass ν (fun x => (q x,s x)) ab-mass μ (fun x => (p x,r x)) ab)*d ab.1 ab.2)≤2*δ*M := by
    calc
      _≤∑ ab : A×B,|mass μ (fun x => (p x,r x)) ab-mass ν (fun x => (q x,s x)) ab| * M := by
        apply Finset.sum_le_sum
        intro ab _
        calc
          _≤|(mass ν (fun x => (q x,s x)) ab-mass μ (fun x => (p x,r x)) ab)*d ab.1 ab.2| := le_abs_self _
          _≤_ := by rw [abs_mul,abs_sub_comm]; exact mul_le_mul_of_nonneg_left (hd _ _) (abs_nonneg _)
      _=(∑ a,|mass μ p a-mass ν q a|)*M := by
        rw [←Finset.sum_mul,channel_joint_l1 μ ν p r q s K hK hKs hμ hν]
      _≤_ := mul_le_mul_of_nonneg_right hl1 hM
  simp only [sub_mul,Finset.sum_sub_distrib,Fintype.sum_prod_type] at hdiff
  change (∑ a,∑ b,mass ν (fun x => (q x,s x)) (a,b)*d a b)≤
    (∑ a,∑ b,mass μ (fun x => (p x,r x)) (a,b)*d a b)+2*δ*M
  linarith
end HyperbolicCoding

end
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] [Nonempty B]

noncomputable def recodingKernel (μ : Measure X) [IsProbabilityMeasure μ] (p : X → A) (r : X → B)
    (hp : Measurable p) (hr : Measurable r) : A → B → ℝ := by
  classical
  exact (MatrixCoupling.observations μ r p hr hp).conditionalAssignment

lemma recodingKernel_nonneg (μ : Measure X) [IsProbabilityMeasure μ]
    (p : X → A) (r : X → B) (hp : Measurable p) (hr : Measurable r) (a : A) (b : B) :
    0≤recodingKernel μ p r hp hr a b := by
  classical
  exact (MatrixCoupling.observations μ r p hr hp).conditionalAssignment_nonneg a b

lemma recodingKernel_sum (μ : Measure X) [IsProbabilityMeasure μ]
    (p : X → A) (r : X → B) (hp : Measurable p) (hr : Measurable r) (a : A) :
    ∑ b,recodingKernel μ p r hp hr a b=1 := by
  classical
  exact (MatrixCoupling.observations μ r p hr hp).conditionalAssignment_sum a

lemma recodingKernel_joint (μ : Measure X) [IsProbabilityMeasure μ]
    (p : X → A) (r : X → B) (hp : Measurable p) (hr : Measurable r) (a : A) (b : B) :
    mass μ (fun x => (p x,r x)) (a,b)=mass μ p a*recodingKernel μ p r hp hr a b := by
  classical
  have hh := (MatrixCoupling.observations μ r p hr hp).mul_conditionalAssignment b a
  exact (mass_joint_swap μ p r a b).trans hh.symm

noncomputable def recodingLaw (μ : Measure X) [IsProbabilityMeasure μ] (p : X → A) (r : X → B)
    (hp : Measurable p) (hr : Measurable r) (ν : Measure Y)
    (N : ℕ) (Q : Y → Fin N → A) : Measure ((Fin N → A)×(Fin N → B)) :=
  finiteChannelLaw N (mass ν Q) (fun _ => recodingKernel μ p r hp hr)

lemma recodingLaw_probability (μ : 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) :
    IsProbabilityMeasure (recodingLaw μ p r hp hr ν N Q) := by
  apply finiteChannelLaw_probability N (mass ν Q) (mass_nonneg _ _) (by simpa using mass_sum ν Q hQ)
  · intro i
    exact recodingKernel_nonneg μ p r hp hr
  · intro i
    exact recodingKernel_sum μ p r hp hr

lemma recodingLaw_input_mass (μ : Measure X) [IsProbabilityMeasure μ]
    (p : X → A) (r : X → B) (hp : Measurable p) (hr : Measurable r)
    (ν : Measure Y) [IsProbabilityMeasure ν] (N : ℕ) (Q : Y → Fin N → A) (v : Fin N → A) :
    mass (recodingLaw μ p r hp hr ν N Q) Prod.fst v=mass ν Q v :=
  finiteChannelLaw_input_mass N (mass ν Q) (mass_nonneg _ _)
    (fun _ => recodingKernel μ p r hp hr) (fun _ => recodingKernel_nonneg μ p r hp hr)
    (fun _ => recodingKernel_sum μ p r hp hr) v

lemma recodingLaw_input_coordinate (μ : 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)
    (i : Fin N) (a : A) :
    mass (recodingLaw μ p r hp hr ν N Q) (fun vw => vw.1 i) a=mass ν (fun y => Q y i) a := by
  classical
  have := recodingLaw_probability μ p r hp hr ν N Q hQ
  have hh := mass_factor_sum (recodingLaw μ p r hp hr ν N Q) Prod.fst measurable_fst
    (fun v : Fin N → A => v i) a
  have hh' := mass_factor_sum ν Q hQ (fun v : Fin N → A => v i) a
  simp only [recodingLaw_input_mass] at hh
  exact hh.trans hh'.symm

lemma recodingLaw_joint_coordinate (μ : 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)
    (i : Fin N) (a : A) (b : B) :
    mass (recodingLaw μ p r hp hr ν N Q) (fun vw => (vw.1 i,vw.2 i)) (a,b)=
      mass (recodingLaw μ p r hp hr ν N Q) (fun vw => vw.1 i) a*recodingKernel μ p r hp hr a b := by
  have := recodingLaw_probability μ p r hp hr ν N Q hQ
  apply product_channel_coordinate (recodingLaw μ p r hp hr ν N Q) N Prod.fst Prod.snd
    measurable_fst measurable_snd (fun _ => recodingKernel μ p r hp hr)
    (fun _ => recodingKernel_sum μ p r hp hr) _ i a b
  intro v w
  rw [recodingLaw_input_mass]
  exact finiteChannelLaw_pair_mass N (mass ν Q) (mass_nonneg _ _)
    (fun _ => recodingKernel μ p r hp hr) (fun _ => recodingKernel_nonneg μ p r hp hr) v w

lemma recodingLaw_input_law (μ : 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)
    (i : Fin N) :
    (recodingLaw μ p r hp hr ν N Q).map (fun vw => vw.1 i)=ν.map (fun y => Q y i) := by
  have := recodingLaw_probability μ p r hp hr ν N Q hQ
  apply Measure.ext_of_singleton
  intro a
  have hl : Measurable (fun vw : (Fin N → A)×(Fin N → B) => vw.1 i) :=
    (measurable_pi_apply i).comp measurable_fst
  have hr' : Measurable (fun y => Q y i) := (measurable_pi_apply i).comp hQ
  rw [Measure.map_apply hl (measurableSet_singleton a),Measure.map_apply hr' (measurableSet_singleton a)]
  apply (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mp
  exact recodingLaw_input_coordinate μ p r hp hr ν N Q hQ i a

lemma recodingLaw_output_lawClose (μ : 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)
    (i : Fin N) {δ : ℝ} (hlaw : LawClose (μ.map p) (ν.map (fun y => Q y i)) δ) :
    LawClose (μ.map r) ((recodingLaw μ p r hp hr ν N Q).map (fun vw => vw.2 i)) (2*δ) := by
  have := recodingLaw_probability μ p r hp hr ν N Q hQ
  apply channel_output_lawClose μ (recodingLaw μ p r hp hr ν N Q) 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)
  rw [recodingLaw_input_law μ p r hp hr ν N Q hQ i]
  exact hlaw
end HyperbolicCoding

end

end OAI