import OAI.Probability.Localization.ConditionalLaws

namespace OAI

open MeasureTheory ProbabilityTheory Set
open scoped BigOperators ENNReal

namespace RepeatedLocalization

namespace FiniteEntropy

noncomputable def complementMass {n : ℕ} (P : Measure (Coordinate n)) (s : State n) : ℝ :=
  ((ProbabilityTheory.cond P s.event) (residual (ProbabilityTheory.cond P s.event) s.cell)).toReal

noncomputable def complementReward {n : ℕ} (P : Measure (Coordinate n)) (s : State n) (a : Letter n) : ℝ :=
  if s.stopped then 0 else if a = none then -Real.log (complementMass P s) else 0

noncomputable def continuingReward {n : ℕ} (P : Measure (Coordinate n)) (s : State n) (a : Letter n) : ℝ :=
  if s.stopped then 0 else if a = none ∧ complementMass P s < 1/2 then 1 else 0

noncomputable def accumulate {n : ℕ} (P : Measure (Coordinate n)) (r : State n → Letter n → ℝ) :
    State n → Log n → ℝ
  | _,[] => 0
  | s,a::h => r s a + accumulate P r (update P s a) h

noncomputable def rewardLog {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n)
    (r : State n → Letter n → ℝ) (h : Log n) : ℝ := accumulate P r ⟨Q,cellSet Q,false⟩ h

noncomputable def complementTotal {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n) (N : ℕ) (z : Coordinate n) : ℝ :=
  rewardLog P Q (complementReward P) (run P Q N z)

noncomputable def continuingTotal {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n) (N : ℕ) (z : Coordinate n) : ℝ :=
  rewardLog P Q (continuingReward P) (run P Q N z)

noncomputable def truncatedDepth {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n) (N : ℕ) (z : Coordinate n) : ℕ :=
  (state P Q (run P Q N z)).cell.1-Q.1

noncomputable def truncatedAttempts {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n) (N : ℕ) (z : Coordinate n) : ℕ :=
  (run P Q N z).length

noncomputable def activeIndicator {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n) (N : ℕ) (z : Coordinate n) : ℝ :=
  if (state P Q (run P Q N z)).stopped then 0 else 1

lemma accumulate_append {n : ℕ} (P : Measure (Coordinate n)) (r : State n → Letter n → ℝ)
    (s : State n) (h k : Log n) :
    accumulate P r s (h++k) = accumulate P r s h + accumulate P r (h.foldl (update P) s) k := by
  induction h generalizing s with
  | nil => simp [accumulate]
  | cons a h ih => simp only [List.cons_append,accumulate,List.foldl_cons,ih]; ring

lemma rewardLog_append {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n)
    (r : State n → Letter n → ℝ) (h : Log n) (a : Letter n) :
    rewardLog P Q r (h++[a]) = rewardLog P Q r h + r (state P Q h) a := by
  simp only [rewardLog,accumulate_append,accumulate,add_zero,state]

lemma complementMass_nonneg {n : ℕ} (P : Measure (Coordinate n)) (s : State n) :
    0 ≤ complementMass P s := ENNReal.toReal_nonneg

lemma complementMass_le_one {n : ℕ} (P : Measure (Coordinate n)) [IsFiniteMeasure P] (s : State n) :
    complementMass P s ≤ 1 := by
  by_cases hp : P s.event = 0
  · simp [complementMass,ProbabilityTheory.cond_eq_zero_of_meas_eq_zero hp]
  · let := ProbabilityTheory.cond_isProbabilityMeasure (μ := P) hp
    exact (ENNReal.toReal_mono ENNReal.one_ne_top prob_le_one).trans_eq ENNReal.toReal_one

lemma complementReward_nonneg {n : ℕ} (P : Measure (Coordinate n)) [IsFiniteMeasure P]
    (s : State n) (a : Letter n) : 0 ≤ complementReward P s a := by
  unfold complementReward
  split
  · exact le_rfl
  · split
    · exact neg_nonneg.mpr (Real.log_nonpos (complementMass_nonneg P s) (complementMass_le_one P s))
    · exact le_rfl

lemma continuingReward_nonneg {n : ℕ} (P : Measure (Coordinate n)) (s : State n) (a : Letter n) :
    0 ≤ continuingReward P s a := by unfold continuingReward; split_ifs <;> norm_num

lemma accumulate_nonneg {n : ℕ} (P : Measure (Coordinate n)) (r : State n → Letter n → ℝ)
    (hr : ∀ s a,0 ≤ r s a) (s : State n) (h : Log n) : 0 ≤ accumulate P r s h := by
  induction h generalizing s with
  | nil => exact le_rfl
  | cons a h ih => exact add_nonneg (hr s a) (ih _)

lemma rewardLog_nonneg {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n)
    (r : State n → Letter n → ℝ) (hr : ∀ s a,0 ≤ r s a) (h : Log n) : 0 ≤ rewardLog P Q r h :=
  accumulate_nonneg P r hr _ h

lemma neg_log_mul_le {q : ℝ} (hq : 0 ≤ q) : q * (-Real.log q) ≤ 1/Real.exp 1 := by
  rcases hq.eq_or_lt with rfl | hq
  · simp only [Real.log_zero,neg_zero,mul_zero]; positivity
  · have hl := Real.log_le_sub_one_of_pos (div_pos (Real.exp_pos (-1)) hq)
    rw [Real.log_div (Real.exp_ne_zero _) hq.ne',Real.log_exp] at hl
    have hh := mul_le_mul_of_nonneg_left hl hq.le
    have he : q * (Real.exp (-1) / q - 1) = Real.exp (-1)-q := by field_simp
    rw [he,Real.exp_neg,← one_div] at hh
    nlinarith

lemma threshold_pos (n h : ℕ) : 0 < threshold n h := Real.rpow_pos_of_pos (by norm_num) _

lemma log_threshold (n h : ℕ) : Real.log (threshold n h) = -(n:ℝ)*(h:ℝ)/2*Real.log 2 := by
  exact Real.log_rpow (by norm_num) _

lemma positive_event_descendant {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n) (h : Log n)
    (hp : P (state P Q h).event ≠ 0) : Descendant Q (state P Q h).cell := by
  obtain ⟨z,hz⟩ := nonempty_of_measure_ne_zero hp
  exact state_descendant_of_mem P Q h hz

lemma state_event_append_subset {n : ℕ} (P : Measure (Coordinate n)) (Q : Cell n) (h : Log n) (a : Letter n) :
    (state P Q (h++[a])).event ⊆ (state P Q h).event := by
  rw [state_append]
  unfold update
  split
  · exact Subset.rfl
  · exact Set.inter_subset_left

lemma cond_event_mul {α : Type*} [MeasurableSpace α] (P : Measure α) [IsFiniteMeasure P]
    {E B : Set α} (hE : MeasurableSet E) (hp : P E ≠ 0) :
    (P (E∩B)).toReal = (P E).toReal * ((ProbabilityTheory.cond P E) B).toReal := by
  rw [ProbabilityTheory.cond_apply hE,ENNReal.toReal_mul,ENNReal.toReal_inv]
  have hp' : (P E).toReal ≠ 0 := ENNReal.toReal_ne_zero.mpr ⟨hp,measure_ne_top _ _⟩
  exact (mul_inv_cancel_left₀ hp' _).symm

lemma path_label_surprisal {n : ℕ} (P : Measure (Coordinate n)) [IsProbabilityMeasure P]
    (Q : Cell n) (hroot : P (cellSet Q) = 1) (h : Log n) (hp : P (state P Q h).event ≠ 0) :
    -Real.log (P (state P Q h).event).toReal ≤
      ((n:ℝ)*Real.log 2/2)*((state P Q h).cell.1-Q.1 : ℕ) + rewardLog P Q (complementReward P) h := by
  classical
  induction h using List.reverseRecOn with
  | nil => simp only [state_nil,hroot,ENNReal.toReal_one,Real.log_one,neg_zero,Nat.sub_self,
      Nat.cast_zero,mul_zero,rewardLog,accumulate,add_zero,le_refl]
  | append_singleton h a ih =>
    have hp0 : P (state P Q h).event ≠ 0 := by
      intro he
      exact hp (measure_mono_null (state_event_append_subset P Q h a) he)
    have hih := ih hp0
    have ppos : 0 < (P (state P Q h).event).toReal := ENNReal.toReal_pos hp0 (measure_ne_top _ _)
    have hdesc := positive_event_descendant P Q h hp0
    rw [state_append,rewardLog_append]
    by_cases hs : (state P Q h).stopped = true
    · simpa only [update,hs,ite_true,complementReward,add_zero] using hih
    · cases a with
      | none =>
        have he : (P (update P (state P Q h) none).event).toReal =
            (P (state P Q h).event).toReal * complementMass P (state P Q h) := by
          simp only [update,hs,branch,complementMass]
          exact cond_event_mul P (state_event_measurable P Q h) hp0
        have hepos : 0 < (P (update P (state P Q h) none).event).toReal :=
          ENNReal.toReal_pos (by simpa only [state_append] using hp) (measure_ne_top _ _)
        have hqpos : 0 < complementMass P (state P Q h) := by rw [he] at hepos; nlinarith [complementMass_nonneg P (state P Q h)]
        rw [he,Real.log_mul ppos.ne' hqpos.ne']
        simp only [update,hs,Bool.false_eq_true,ite_false,Option.getD_none,complementReward,ite_true]
        linarith
      | some R =>
        have hR : FirstHeavy (ProbabilityTheory.cond P (state P Q h).event) (state P Q h).cell R := by
          by_contra hR
          simp [state_append,update,hs,branch,hR] at hp
        have he : (P (update P (state P Q h) (some R)).event).toReal =
            (P (state P Q h).event).toReal * ((ProbabilityTheory.cond P (state P Q h).event) (cellSet R)).toReal := by
          simp only [update,hs,branch,ite_eq_left hR]
          exact cond_event_mul P (state_event_measurable P Q h) hp0
        have hmpos := (threshold_pos n (R.1-(state P Q h).cell.1)).trans hR.1.2.2
        have hl := Real.log_le_log (threshold_pos n (R.1-(state P Q h).cell.1)) hR.1.2.2.le
        rw [log_threshold] at hl
        have hdepth : R.1-Q.1 = ((state P Q h).cell.1-Q.1)+(R.1-(state P Q h).cell.1) := by
          have := hdesc.1
          have := hR.1.1.1
          omega
        rw [he,Real.log_mul ppos.ne' hmpos.ne']
        simp only [update,hs,Bool.false_eq_true,ite_false,Option.getD_some,complementReward,reduceCtorEq,add_zero]
        rw [hdepth,Nat.cast_add]
        nlinarith

end FiniteEntropy

end RepeatedLocalization

end OAI