import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Coding.FullEntropyCopySequence

namespace OAI

section
namespace HyperbolicCoding
open MeasureTheory Set Filter StandardMapEntropy.Entropy
open scoped BigOperators ENNReal Topology
variable {X A : Type*} [MeasurableSpace X] [MeasurableSpace A]
  [Fintype A] [MeasurableSingletonClass A] [Nonempty A]

lemma weakBernoulli_zero_rate_diagonal (μ : Measure X) [IsProbabilityMeasure μ]
    (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) (p : X → A) (hp : Measurable p)
    (hwb : WeakBernoulliProcess μ e p) (hz : rate μ e p=0) :
    ∀ ε : ℝ,0 < ε → LawClose (μ.map (fun x => (p x,p x))) ((μ.map p).prod (μ.map p)) ε := by
  have hf := tailObservable_self_of_rate_zero μ e he p hp hz
  have hb := hf.reverse μ e he p p hp hp
  intro ε hε
  obtain ⟨n,hn⟩ := (hwb ε hε).exists
  obtain ⟨F,hF,hFeq⟩ := hf n
  obtain ⟨B,hB,hBeq⟩ := hb n
  have hh := hn.map (hB.prodMap hF)
  have hPast : (μ.map (tailName e.symm p 0)).map B=μ.map p := by
    rw [←stationary_tail_law μ (he.symm e) hp n,
      Measure.map_map hB (measurable_tailName e.symm.measurable hp n)]
    exact Measure.map_congr hBeq.symm
  have hFuture : (μ.map (tailName e p 0)).map F=μ.map p := by
    rw [←stationary_tail_law μ he hp n,
      Measure.map_map hF (measurable_tailName e.measurable hp n)]
    exact Measure.map_congr hFeq.symm
  have hJoint : (μ.map (remotePair e e.symm p n)).map (Prod.map B F)=μ.map (fun x => (p x,p x)) := by
    rw [Measure.map_map (hB.prodMap hF) (measurable_remotePair e.measurable e.symm.measurable hp n)]
    apply Measure.map_congr
    filter_upwards [hBeq,hFeq] with x hx hy
    exact Prod.ext hx.symm hy.symm
  rw [hJoint,remoteProductLaw,←Measure.map_prod_map _ _ hB hF,hPast,hFuture] at hh
  exact hh

lemma weakBernoulli_zero_rate_constant (μ : Measure X) [IsProbabilityMeasure μ]
    (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) (p : X → A) (hp : Measurable p)
    (hwb : WeakBernoulliProcess μ e p) (hz : rate μ e p=0) :
    ∃ a : A,∀ᵐ x ∂μ,p x=a := by
  classical
  have hmass (a : A) : mass μ p a=0 ∨ mass μ p a=1 := by
    have heq : mass μ p a-mass μ p a*mass μ p a=0 := by
      apply abs_eq_zero.mp
      apply le_antisymm ?_ (abs_nonneg _)
      apply le_of_forall_pos_le_add
      intro ε hε
      simp only [zero_add]
      have hh := weakBernoulli_zero_rate_diagonal μ e he p hp hwb hz (ε/2) (half_pos hε)
        ({a} ×ˢ {a}) ((measurableSet_singleton a).prod (measurableSet_singleton a))
      have hdiag : (fun x => (p x,p x)) ⁻¹' ({a} ×ˢ {a})=p ⁻¹' {a} := by
        ext x
        simp
      rw [Measure.real,Measure.map_apply (hp.prodMk hp)
        ((measurableSet_singleton a).prod (measurableSet_singleton a)),hdiag] at hh
      have hprod : ((μ.map p).prod (μ.map p)).real ({a} ×ˢ {a})=mass μ p a*mass μ p a := by
        simp only [Measure.real,Measure.prod_prod,ENNReal.toReal_mul,
          Measure.map_apply hp (measurableSet_singleton a),mass]
      rw [hprod] at hh
      exact hh.trans (by linarith)
    rcases mul_eq_zero.mp (show mass μ p a*(1-mass μ p a)=0 by nlinarith) with h | h
    · exact Or.inl h
    · exact Or.inr (by linarith)
  have hs : ∑ a,mass μ p a=1 := by
    simpa only [measure_univ,ENNReal.toReal_one] using mass_sum μ p hp
  have hex : ∃ a,mass μ p a=1 := by
    by_contra! h
    have hz : ∀ a,mass μ p a=0 := fun a => (hmass a).resolve_right (h a)
    simp only [hz,Finset.sum_const_zero] at hs
    norm_num at hs
  obtain ⟨a,ha⟩ := hex
  refine ⟨a,?_⟩
  have hm : μ (p ⁻¹' {a})=1 := by
    rw [←ENNReal.ofReal_toReal (measure_ne_top μ _)]
    change ENNReal.ofReal (mass μ p a)=1
    rw [ha,ENNReal.ofReal_one]
  exact (ae_iff_prob_eq_one (measurableSet_setOfPred.mp (measurableSet_eq_fun hp measurable_const))).mpr hm

theorem separating_weakBernoulli_positive_rate (μ : Measure X) [IsProbabilityMeasure μ]
    [NullSingletonClass μ] (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    (α : ℕ → ℕ → 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)) :
    ∃ M : ℕ,0 < rate μ e (joinedBinary α M) := by
  by_contra! h
  have hz (M : ℕ) : rate μ e (joinedBinary α M)=0 :=
    le_antisymm (h M) (rate_nonneg μ e he _ (measurable_joinedBinary hα M))
  choose a ha using fun M => weakBernoulli_zero_rate_constant μ e he
    (joinedBinary α M) (measurable_joinedBinary hα M) (hwb M) (hz M)
  have hall : ∀ᵐ x ∂μ,∀ M,joinedBinary α M x=a M := ae_all_iff.mpr ha
  obtain ⟨x,hx⟩ := hall.exists
  have hone : ∀ᵐ y ∂μ,y=x := by
    filter_upwards [hall] with y hy
    apply hsep
    funext i j
    let M := max i j+1
    have hij : (⟨i,by dsimp [M]; omega⟩,⟨j,by dsimp [M]; omega⟩) ∈
        (Set.univ : Set (Fin M × Fin M)) := mem_univ _
    have hh := congrFun ((hy M).trans (hx M).symm)
      (⟨i,by dsimp [M]; omega⟩,⟨j,by dsimp [M]; omega⟩)
    exact hh
  have hset : ({x} : Set X)=ᵐ[μ]univ := by
    filter_upwards [hone] with y hy
    change (y=x)=True
    simp only [hy,eq_self]
  have hm := measure_congr hset
  exact zero_ne_one (by simpa only [measure_singleton,measure_univ] using hm)
end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory Set Filter StandardMapEntropy.Entropy
open scoped BigOperators ENNReal Topology

lemma weightEntropy_eq_shannon {A : Type*} [Fintype A] (p : A → ℝ) :
    weightEntropy p=shannon p := by
  unfold weightEntropy shannon
  apply Finset.sum_congr rfl
  intro a _
  rw [Real.negMulLog]
  ring

noncomputable def entropyPath (n : ℕ) (t : ℝ) (a : Fin (n+2)) : ℝ :=
  (1-t)*(if a=0 then 1 else 0)+t/(n+2 : ℝ)

lemma entropyPath_nonneg (n : ℕ) {t : ℝ} (ht : t∈Icc (0 : ℝ) 1) (a : Fin (n+2)) :
    0 ≤ entropyPath n t a := by
  unfold entropyPath
  exact add_nonneg (mul_nonneg (sub_nonneg.mpr ht.2) (by split_ifs <;> norm_num))
    (div_nonneg ht.1 (by positivity))

lemma entropyPath_sum (n : ℕ) (t : ℝ) : ∑ a,entropyPath n t a=1 := by
  have hc : (n+2 : ℝ)≠0 := ne_of_gt (by positivity)
  simp only [entropyPath,Finset.sum_add_distrib,←Finset.mul_sum,
    Finset.sum_ite_eq',Finset.mem_univ,ite_true,mul_one,Finset.sum_const,
    Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,Nat.cast_add,Nat.cast_ofNat]
  field_simp
  ring

lemma entropyPath_continuous (n : ℕ) : Continuous (fun t => weightEntropy (entropyPath n t)) := by
  simp_rw [weightEntropy_eq_shannon]
  apply continuous_shannon.comp
  apply continuous_pi
  intro a
  unfold entropyPath
  fun_prop

lemma entropyPath_zero (n : ℕ) : weightEntropy (entropyPath n 0)=0 := by
  unfold weightEntropy entropyPath
  simp only [sub_zero,mul_ite,mul_one,mul_zero,zero_div,add_zero]
  apply Finset.sum_eq_zero
  intro a _
  split_ifs <;> simp

lemma entropyPath_one (n : ℕ) : weightEntropy (entropyPath n 1)=Real.log (n+2 : ℝ) := by
  have hc : (n+2 : ℝ)≠0 := ne_of_gt (by positivity)
  unfold weightEntropy entropyPath
  simp only [sub_self,zero_mul,zero_add,one_div,Real.log_inv,neg_neg,Finset.sum_const,
    Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,Nat.cast_add,Nat.cast_ofNat]
  rw [←mul_assoc,mul_inv_cancel₀ hc,one_mul]

theorem exists_finite_weight_entropy (h : ℝ) (hh : 0 ≤ h) :
    ∃ n : ℕ,∃ β : Fin (n+2) → ℝ,(∀ a,0 ≤ β a) ∧ (∑ a,β a=1) ∧ weightEntropy β=h := by
  obtain ⟨n,hn⟩ := exists_nat_gt (Real.exp h)
  have hn2 : Real.exp h < (n+2 : ℝ) := by linarith
  have hl : h < Real.log (n+2 : ℝ) := by
    simpa only [Real.log_exp] using Real.log_lt_log (Real.exp_pos h) hn2
  have him := intermediate_value_Icc (show (0 : ℝ) ≤ 1 by norm_num)
    (entropyPath_continuous n).continuousOn
  have hmem : h∈Icc (weightEntropy (entropyPath n 0)) (weightEntropy (entropyPath n 1)) := by
    rw [entropyPath_zero,entropyPath_one]
    exact ⟨hh,hl.le⟩
  obtain ⟨t,ht,heq⟩ := him hmem
  exact ⟨n,entropyPath n t,entropyPath_nonneg n ht,entropyPath_sum n t,heq⟩
end HyperbolicCoding

end
section
namespace StandardMapEntropy
open MeasureTheory Set Filter HyperbolicCoding Entropy
open scoped BigOperators ENNReal Topology

lemma normalizedArea_nullSingleton (E : Set Torus) : NullSingletonClass (normalizedArea E) := by
  have : NullSingletonClass area := by unfold area; infer_instance
  constructor
  intro z
  exact normalizedArea_absolutelyContinuous E (measure_singleton z)

theorem actual_return_full_entropy_iid_factor (k : ℝ) (hk : 0 ≤ k) (N : ℕ)
    (E : Set Torus) (hE : 0 < area E)
    (htotal : ∀ m : ℕ,0 < m → Ergodic (((standardMap k)^[N])^[m]) (normalizedArea E))
    (α : ℕ → ℕ → Torus → Bool) (hα : ∀ i j,Measurable (α i j))
    (hsep : Function.Injective (fun z => fun i j => α i j z))
    (hwb : ∀ M : ℕ,WeakBernoulliProcess (normalizedArea E)
      (iterateEquiv (standardMap_measurableEquiv k) N) (joinedBinary α M)) :
    ∃ n : ℕ,∃ β : Fin (n+2) → ℝ,∃ p : Torus → Fin (n+2),
      (∀ a,0 ≤ β a) ∧ (∑ a,β a=1) ∧ 0 < weightEntropy β ∧ Measurable p ∧
      FiniteRateSupremum (normalizedArea E) ((standardMap k)^[N]) (weightEntropy β) ∧
      MeasurePreserving (orbitName (iterateEquiv (standardMap_measurableEquiv k) N) p)
        (normalizedArea E) (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)) ∧
      rate (normalizedArea E) ((standardMap k)^[N]) p=weightEntropy β ∧
      (∀ z,orbitName (iterateEquiv (standardMap_measurableEquiv k) N) p ((standardMap k)^[N] z)=
        fun i => orbitName (iterateEquiv (standardMap_measurableEquiv k) N) p z (i+1)) ∧
      (∀ r : ℕ,∀ γ : Torus → Fin (r+1),Measurable γ →
        rate (normalizedArea E) ((standardMap k)^[N]) (fun z => (p z,γ z))=weightEntropy β) := by
  let := normalizedArea_probability hE
  let := normalizedArea_nullSingleton E
  let e := iterateEquiv (standardMap_measurableEquiv k) N
  have heq : (e : Torus → Torus)=(standardMap k)^[N] := funext (iterateEquiv_apply _ N)
  have he : Ergodic e (normalizedArea E) := by
    rw [heq]
    simpa only [Function.iterate_one] using htotal 1 (by omega)
  have het : ∀ m : ℕ,0 < m → Ergodic (e^[m]) (normalizedArea E) := by
    simpa only [heq] using htotal
  obtain ⟨h,H,_hbound⟩ := exists_finiteRateSupremum (normalizedArea E) ((standardMap k)^[N])
    ((Real.log 1000+(∫ z,Real.log ‖standardDerivativeProduct k z N‖ ∂area))/area.real E)
    (fun r p hp => restricted_finite_rate_upper k hk N E hE
      (by simpa only [heq] using he.toMeasurePreserving) p hp)
  have H' : FiniteRateSupremum (normalizedArea E) e h := by simpa only [heq] using H
  obtain ⟨M,hM⟩ := separating_weakBernoulli_positive_rate (normalizedArea E) e
    he.toMeasurePreserving α hα hsep hwb
  have hh : 0 < h := hM.trans_le (H'.upper _ (measurable_joinedBinary hα M))
  obtain ⟨n,β,hβ,hβsum,hβentropy⟩ := exists_finite_weight_entropy h hh.le
  have hpos : 0 < weightEntropy β := hβentropy.symm ▸ hh
  have Hβ : FiniteRateSupremum (normalizedArea E) e (weightEntropy β) := hβentropy.symm ▸ H'
  obtain ⟨p,hp,hcode,hr,hshift,hjoint⟩ := full_entropy_iid_factor (normalizedArea E) e he het
    β hβ hβsum hpos Hβ (⟨0,by omega⟩ : Fin (n+2)) (⟨1,by omega⟩ : Fin (n+2))
    (by intro h; have hv := congrArg Fin.val h; simp only at hv; omega)
  refine ⟨n,β,p,hβ,hβsum,hpos,hp,?_,hcode,?_,?_,?_⟩
  · simpa only [heq] using Hβ
  · simpa only [heq] using hr
  · simpa only [heq] using hshift
  · simpa only [heq] using hjoint
end StandardMapEntropy

end

end OAI