import OAI.NumberTheory.GaussianMoat.BackwardCoverage

namespace OAI

universe uOmega uAlpha uCapitalGamma uGroup uIota uBeta uGamma

namespace GaussianMoat

namespace FinLaw
open scoped BigOperators Classical
variable {Ω : Type uOmega} {α : Type uAlpha} {Γ : Type uCapitalGamma} {G : Type uGroup} [Fintype Ω] [Fintype α] [Fintype Γ] [Fintype G]

lemma prob_and_split (p : FinLaw Ω) (A B : Ω → Prop) :
    p.prob (fun ω => A ω ∧ B ω)+p.prob (fun ω => A ω ∧ ¬B ω)=p.prob A := by
  simp only [prob,← Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro ω _
  by_cases ha : A ω <;> by_cases hb : B ω <;> simp [ha,hb]

lemma prob_mix (p : FinLaw Ω) (q : Ω → FinLaw Γ) (E : Γ → Prop) :
    (p.mix q).prob E = ∑ ω, p ω*(q ω).prob E := by
  rw [← joint_map_snd,prob_map,prob_joint]

lemma posterior_unfavorable (p : FinLaw Ω) (C : Ω → α) (Bad : Ω → Prop) :
    (p.map C).prob (fun a => (1/2:ℝ)<(p.conditionOn C a).prob Bad) ≤ 2*p.prob Bad := by
  have h := (p.map C).prob_le_expect_div (fun a => (p.conditionOn C a).prob Bad)
    (fun a => (p.conditionOn C a).prob_nonneg _) (by norm_num : (0:ℝ)<1/2)
  rw [p.conditionOn_prob] at h
  linarith only [h]

lemma mixed_exception_card (p : FinLaw Ω) (Good : Ω → Prop) (E : Ω → Finset G)
    {e : ℝ} (he : 0≤e) (hE : ∀ ω, Good ω → ((E ω).card:ℝ)≤e)
    (hG : (1/2:ℝ)≤p.prob Good) :
    ((Finset.univ.filter (fun x : G =>
      p.prob (fun ω => Good ω ∧ x∉E ω)<1/4)).card:ℝ) ≤ 4*e := by
  let u := fun x => p.prob (fun ω => Good ω ∧ x∉E ω)
  let f := fun x => p.prob (fun ω => Good ω ∧ x∈E ω)
  let K := Finset.univ.filter (fun x : G => u x<1/4)
  have hsum : (∑ x : G, f x) ≤ e := by
    simp only [f,prob]
    rw [Finset.sum_comm]
    have hh (ω : Ω) : (∑ x : G, if Good ω ∧ x∈E ω then p ω else 0) ≤ p ω*e := by
      by_cases hg : Good ω
      · have hc : (∑ x : G, if Good ω ∧ x∈E ω then p ω else 0) = p ω*(E ω).card := by
          simp only [hg,true_and]
          calc
            _ = ∑ x : G, p ω*(if x∈E ω then (1:ℝ) else 0) := by
              apply Finset.sum_congr rfl
              intro x _
              split_ifs <;> simp
            _ = _ := by rw [← Finset.mul_sum]; simp
        rw [hc]
        exact mul_le_mul_of_nonneg_left (hE ω hg) (p.nonneg ω)
      · simp only [hg,false_and,ite_false,Finset.sum_const_zero]
        exact mul_nonneg (p.nonneg ω) he
    have ht := Finset.sum_le_sum (s := Finset.univ) (fun ω _ => hh ω)
    simp only [← Finset.sum_mul,p.sum_one,one_mul] at ht
    convert ht using 1
    apply Finset.sum_congr rfl
    intro ω _
    apply Finset.sum_congr rfl
    intro x _
    split_ifs <;> rfl
  have hk (x : G) (hx : x∈K) : (1/4:ℝ)≤f x := by
    have h := p.prob_and_split Good (fun ω => x∈E ω)
    have hu : u x<1/4 := (Finset.mem_filter.mp hx).2
    change f x+u x=p.prob Good at h
    linarith only [hu,h,hG]
  have hl : (K.card:ℝ)/4 ≤ ∑ x∈K, f x := by
    have h := Finset.sum_le_sum (s := K) (fun x hx => hk x hx)
    simpa only [Finset.sum_const,nsmul_eq_mul,div_eq_mul_inv,one_mul] using h
  have hr : (∑ x∈K, f x) ≤ ∑ x:G, f x :=
    Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ K)
      (fun x _ _ => p.prob_nonneg _)
  change (K.card:ℝ)≤4*e
  linarith only [hl,hr,hsum]

omit [Fintype G] in
lemma mixed_floor (p : FinLaw Ω) (q : Ω → FinLaw Γ) (Good : Ω → Prop)
    (E : Ω → Finset G) (hit : Γ → G → Prop) {τ : ℝ} (hτ : 0≤τ)
    (hq : ∀ ω, Good ω → ∀ x∉E ω, τ≤(q ω).prob (fun v => hit v x))
    (x : G) (hx : (1/4:ℝ)≤p.prob (fun ω => Good ω ∧ x∉E ω)) :
    τ/4 ≤ (p.mix q).prob (fun v => hit v x) := by
  rw [prob_mix]
  have h (ω : Ω) : τ*(if Good ω ∧ x∉E ω then (1:ℝ) else 0) ≤ (q ω).prob (fun v => hit v x) := by
    by_cases hg : Good ω ∧ x∉E ω
    · rw [ite_eq_left hg,mul_one]
      exact hq ω hg.1 x hg.2
    · rw [ite_eq_right hg,mul_zero]
      exact (q ω).prob_nonneg _
  have hh := Finset.sum_le_sum (s := Finset.univ) (fun ω _ =>
    mul_le_mul_of_nonneg_left (h ω) (p.nonneg ω))
  have he : (∑ ω, p ω*(τ*(if Good ω ∧ x∉E ω then (1:ℝ) else 0))) =
      τ*p.prob (fun ω => Good ω ∧ x∉E ω) := by
    rw [prob,Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro ω _
    split_ifs <;> ring
  rw [he] at hh
  have hm := mul_le_mul_of_nonneg_left hx hτ
  linarith only [hh,hm]

lemma prob_exists_eq_sum_disjoint {ι : Type uIota} [Fintype ι]
    (p : FinLaw Ω) (E : ι → Ω → Prop)
    (h : ∀ ω i j, E i ω → E j ω → i=j) :
    p.prob (fun ω => ∃ i, E i ω) = ∑ i, p.prob (E i) := by
  simp only [prob]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro ω _
  by_cases he : ∃ i, E i ω
  · obtain ⟨i,hi⟩ := he
    rw [ite_eq_left ⟨i,hi⟩,Finset.sum_eq_single i]
    · simp [hi]
    · intro j _ hji
      exact ite_eq_right (fun hj => hji (h ω j i hj hi))
    · simp
  · simp only [ite_eq_right he]
    symm
    apply Finset.sum_eq_zero
    intro i _
    exact ite_eq_right (fun hi => he ⟨i,hi⟩)

end FinLaw

section
namespace FinLaw
open scoped BigOperators Classical
variable {Ω : Type uOmega} {ι : Type uIota} {α : Type uAlpha} {β : Type uBeta} {γ : Type uGamma} [Fintype Ω] [Fintype ι] [Fintype α] [Fintype β]

lemma Hf_id (p : FinLaw Ω) : p.Hf id = p.entropy := by rw [Hf_eq_H,H,map_id]

lemma cHf_joint_fst (p : FinLaw ι) (q : ι → FinLaw Ω) (X : ι → Ω → γ) :
    (p.joint q).cHf (fun v => X v.1 v.2) Prod.fst = ∑ i, p i*(q i).Hf (X i) := by
  unfold cHf
  rw [Hf_pair_comm,Hf_joint_pair_vary]
  have h := (p.joint q).Hf_map Prod.fst id
  rw [joint_map_fst,Hf_id] at h
  change p.entropy = (p.joint q).Hf Prod.fst at h
  rw [← h]
  ring

lemma joint_iid_eval (p : FinLaw ι) (q : ι → FinLaw Ω) (n : ℕ) (i : Fin n) :
    (p.joint (fun a => (q a).iid n)).map (fun v => (v.1,v.2 i)) = p.joint q := by
  calc
    _ = p.joint (fun a => ((q a).iid n).map (fun x : Fin n → Ω => x i)) :=
      joint_map_second p (fun a => (q a).iid n) (fun x : Fin n → Ω => x i)
    _ = _ := by simp only [iid_map_eval]

theorem conditional_iid_information (p : FinLaw (α × β)) (q : α × β → FinLaw Ω) (n : ℕ) :
    (p.joint (fun a => (q a).iid n)).cIf (fun v => v.1.2) Prod.snd (fun v => v.1.1) ≤
      (n:ℝ)*(p.joint q).cIf (fun v => v.1.2) Prod.snd (fun v => v.1.1) := by
  let P := p.joint (fun a => (q a).iid n)
  let Q := p.joint q
  have hsub := P.cHf_fintype_subadd Prod.snd (fun v => v.1.1)
  have hmarg (i : Fin n) : P.cHf (fun v => v.2 i) (fun v => v.1.1) =
      Q.cHf Prod.snd (fun v => v.1.1) := by
    have h := P.cHf_map (fun v => (v.1,v.2 i)) Prod.snd (fun v => v.1.1)
    rw [joint_iid_eval] at h
    exact h.symm
  simp only [hmarg,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] at hsub
  have hcond : P.cHf Prod.snd (fun v => (v.1.1,v.1.2)) =
      (n:ℝ)*Q.cHf Prod.snd (fun v => (v.1.1,v.1.2)) := by
    change P.cHf Prod.snd Prod.fst = (n:ℝ)*Q.cHf Prod.snd Prod.fst
    rw [cHf_joint_fst p (fun a => (q a).iid n) (fun _ x => x),
      cHf_joint_fst p q (fun _ x => x)]
    rw [Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro a _
    change p a*((q a).iid n).Hf id = (n:ℝ)*(p a*(q a).Hf id)
    rw [Hf_id,Hf_id,entropy_iid]
    ring
  change P.cIf _ _ _ ≤ (n:ℝ)*Q.cIf _ _ _
  rw [P.cIf_comm,Q.cIf_comm]
  unfold cIf
  rw [hcond]
  nlinarith only [hsub]

end FinLaw

open scoped BigOperators Classical
namespace FinLaw
variable {Ω : Type uOmega} {α : Type uAlpha} {Γ : Type uCapitalGamma} {G : Type uGroup} [Fintype Ω] [Fintype α] [Fintype Γ] [Fintype G]

noncomputable def passingList (hit : Γ → G → Prop) (n : ℕ) (v : Fin n → Γ) : Finset G :=
  Finset.univ.filter (fun x => ∀ i, ¬ hit (v i) x)

lemma expect_card_passingList (q : FinLaw Γ) (hit : Γ → G → Prop)
    (E : Finset G) {c : ℝ} (hhit : ∀ x ∉ E, c≤q.prob (fun v => hit v x)) (n : ℕ) :
    (∑ v, q.iid n v*((passingList hit n v).card:ℝ)) ≤
      (E.card:ℝ)+(Fintype.card G:ℝ)*Real.exp (-(n:ℝ)*c) := by
  have hprob (x : G) (hx : x ∉ E) :
      (q.iid n).prob (fun v => x∈passingList hit n v) ≤ Real.exp (-(n:ℝ)*c) := by
    have hh := q.iid_survival_exp (fun v => ¬hit v x) n (c := c) (by
      rw [q.prob_compl]; linarith only [hhit x hx])
    simpa only [passingList,Finset.mem_filter,Finset.mem_univ,true_and] using hh
  have he : (∑ v, q.iid n v*((passingList hit n v).card:ℝ)) =
      ∑ x : G, (q.iid n).prob (fun v => x∈passingList hit n v) := by
    have hc (v : Fin n → Γ) : ((passingList hit n v).card:ℝ) =
        ∑ x : G, if x∈passingList hit n v then (1:ℝ) else 0 := by simp
    simp only [hc,Finset.mul_sum,prob]
    rw [Finset.sum_comm]
    apply Finset.sum_congr rfl
    intro x _
    apply Finset.sum_congr rfl
    intro v _
    by_cases hx : x∈passingList hit n v <;> simp only [hx,ite_true,ite_false,mul_one,mul_zero]
  rw [he]
  have hh (x : G) : (q.iid n).prob (fun v => x∈passingList hit n v) ≤
      (if x∈E then (1:ℝ) else 0)+Real.exp (-(n:ℝ)*c) := by
    by_cases hx : x∈E
    · simp only [hx,ite_true]
      exact ((q.iid n).prob_le_one _).trans (le_add_of_nonneg_right (Real.exp_nonneg _))
    · simp only [hx,ite_false,zero_add]
      exact hprob x hx
  have hs := Finset.sum_le_sum (s := Finset.univ) (fun x _ => hh x)
  simpa only [Finset.sum_add_distrib,Finset.sum_boole,Finset.filter_mem_eq_inter,
    Finset.univ_inter,Finset.sum_const,Finset.card_univ,nsmul_eq_mul] using hs

lemma passingList_true (q : FinLaw Γ) (hit : Γ → G → Prop) (x : G)
    (h : ∀ v, q v≠0 → ¬hit v x) (n : ℕ) :
    ∀ v, q.iid n v≠0 → x∈passingList hit n v := by
  intro v hv
  simp only [passingList,Finset.mem_filter,Finset.mem_univ,true_and]
  intro i
  apply h
  intro hz
  apply hv
  change (∏ j : Fin n, q (v j)) = 0
  exact Finset.prod_eq_zero (Finset.mem_univ i) hz

lemma expect_log_le_log_expect (p : FinLaw Ω) (f : Ω → ℝ)
    (hf : ∀ ω, p ω≠0 → 0<f ω) :
    (∑ ω, p ω*Real.log (f ω)) ≤ Real.log (∑ ω, p ω*f ω) := by
  let f' := fun ω => if p ω=0 then (1:ℝ) else f ω
  have hh := strictConcaveOn_log_Ioi.concaveOn.le_map_sum
    (fun ω _ => p.nonneg ω) p.sum_one (fun ω _ => show 0<f' ω from by
      dsimp only [f']; split_ifs with hz; norm_num; exact hf ω hz)
  have he (ω : Ω) : p ω*f' ω=p ω*f ω := by
    dsimp only [f']; split_ifs with hz; simp [hz]; rfl
  have hl (ω : Ω) : p ω*Real.log (f' ω)=p ω*Real.log (f ω) := by
    dsimp only [f']; split_ifs with hz; simp [hz]; rfl
  simpa only [smul_eq_mul,he,hl] using hh

lemma expected_log_card_passingList (q : FinLaw Γ) (hit : Γ → G → Prop)
    (x : G) (htrue : ∀ v, q v≠0 → ¬hit v x)
    (E : Finset G) {c : ℝ} (hhit : ∀ y ∉ E, c≤q.prob (fun v => hit v y)) (n : ℕ) :
    (∑ v, q.iid n v*Real.log (passingList hit n v).card) ≤
      Real.log ((E.card:ℝ)+(Fintype.card G:ℝ)*Real.exp (-(n:ℝ)*c)) := by
  have hp (v : Fin n → Γ) (hv : q.iid n v≠0) : (0:ℝ)<(passingList hit n v).card := by
    exact_mod_cast Finset.card_pos.mpr ⟨x,q.passingList_true hit x htrue n v hv⟩
  apply ((q.iid n).expect_log_le_log_expect (fun v => ((passingList hit n v).card:ℝ)) hp).trans
  apply Real.log_le_log ?_ (q.expect_card_passingList hit E hhit n)
  have hex : ∃ v, 0 < q.iid n v := by
    by_contra hh
    push Not at hh
    have hz : ∀ v, q.iid n v=0 := fun v => le_antisymm (hh v) ((q.iid n).nonneg v)
    have hs := (q.iid n).sum_one
    simp only [hz,Finset.sum_const_zero] at hs
    norm_num at hs
  obtain ⟨v,hv⟩ := hex
  exact Finset.sum_pos' (fun v _ => mul_nonneg ((q.iid n).nonneg v) (Nat.cast_nonneg _))
    ⟨v,Finset.mem_univ v,mul_pos hv (hp v hv.ne')⟩

lemma conditional_passing_support (p : FinLaw Ω) (X : Ω → G) (C : Ω → α)
    (hit : α → G → Prop) (hs : ∀ ω, p ω≠0 → ¬hit (C ω) (X ω)) :
    p.cHf X C ≤ ∑ a, p.map C a*Real.log ((Finset.univ.filter (fun x => ¬hit a x)).card) := by
  have h := p.condH_le_support X C (fun a => Finset.univ.filter (fun x => ¬hit a x)) (by
    intro ω hw
    simp only [Finset.mem_filter,Finset.mem_univ,true_and]
    exact hs ω hw)
  simpa only [condH,← Hf_eq_H,cHf] using h

end FinLaw
end

namespace FinLaw
open scoped BigOperators Classical
variable {Ω : Type uOmega} {α : Type uAlpha} {β : Type uBeta} {γ : Type uGamma} [Fintype Ω]

lemma cHf_prefix_step (p : FinLaw Ω) {n k : ℕ} (X : Ω → Fin n → α)
    (C : Ω → β) (hk : k<n) :
    p.cHf (prefixVar X (Equiv.refl _) (k+1)) C =
      p.cHf (prefixVar X (Equiv.refl _) k) C+
        p.cHf (fun ω => X ω ⟨k,hk⟩) (fun ω => (prefixVar X (Equiv.refl _) k ω,C ω)) := by
  have he : p.cHf (prefixVar X (Equiv.refl _) (k+1)) C =
      p.cHf (fun ω => (prefixVar X (Equiv.refl _) k ω,X ω ⟨k,hk⟩)) C := by
    apply p.cHf_eq_of_fibers
    intro ω ν _
    constructor
    · intro h
      refine Prod.ext ?_ ?_
      · funext i
        by_cases hi : i.val<k
        · simpa only [prefixVar,hi,ite_eq_left,show i.val<k+1 by omega] using congrFun h i
        · simp [prefixVar,hi]
      · simpa [prefixVar] using congrFun h ⟨k,hk⟩
    · intro h
      funext i
      by_cases hi : i.val<k
      · simpa only [prefixVar,hi,ite_eq_left,show i.val<k+1 by omega] using
          congrFun (congrArg Prod.fst h) i
      · by_cases hie : i.val=k
        · have hi' : i=⟨k,hk⟩ := Fin.ext hie
          subst i
          simpa [prefixVar] using congrArg some (congrArg Prod.snd h)
        · simp [prefixVar,show ¬i.val<k+1 by omega]
  rw [he,p.cHf_chain]

lemma cHf_blocks_le (p : FinLaw Ω) {n : ℕ} (X : Ω → Fin n → α)
    (C : Ω → β) (S : Fin n → Ω → γ)
    (hS : ∀ i ω ν, prefixVar X (Equiv.refl _) i.val ω=prefixVar X (Equiv.refl _) i.val ν →
      C ω=C ν → S i ω=S i ν) :
    p.cHf X C ≤ ∑ i : Fin n, p.cHf (fun ω => X ω i) (S i) := by
  have h (k : ℕ) (hk : k≤n) : p.cHf (prefixVar X (Equiv.refl _) k) C ≤
      ∑ i : Fin k, p.cHf (fun ω => X ω ⟨i.val,by omega⟩) (S ⟨i.val,by omega⟩) := by
    induction k with
    | zero =>
      have he : p.cHf (prefixVar X (Equiv.refl _) 0) C = 0 := by
        unfold cHf
        have hh : p.Hf (fun ω => (prefixVar X (Equiv.refl _) 0 ω,C ω)) = p.Hf C := by
          apply p.Hf_eq_of_fibers
          intro ω ν
          simp only [prefixVar_zero,Prod.mk.injEq,true_and]
        rw [hh,sub_self]
      simp only [he,Finset.univ_eq_empty,Finset.sum_empty,le_refl]
    | succ k ih =>
      rw [p.cHf_prefix_step X C (by omega),Fin.sum_univ_castSucc]
      have hm := p.cHf_mono_of_refines (fun ω => X ω ⟨k,by omega⟩)
        (fun ω => (prefixVar X (Equiv.refl _) k ω,C ω)) (S ⟨k,by omega⟩)
        (fun ω ν hh => hS ⟨k,by omega⟩ ω ν (congrArg Prod.fst hh) (congrArg Prod.snd hh))
      exact add_le_add (ih (by omega)) hm
  have he : p.cHf (prefixVar X (Equiv.refl _) n) C=p.cHf X C := by
    apply p.cHf_eq_of_fibers
    intro ω ν _
    constructor
    · intro h
      funext i
      simpa [prefixVar,i.isLt] using congrFun h i
    · intro h
      funext i
      simp only [prefixVar,i.isLt,ite_eq_left,Equiv.refl_apply]
      exact congrArg some (congrFun h i)
  simpa only [he] using h n le_rfl

end FinLaw
end GaussianMoat

end OAI