import OAI.NumberTheory.GaussianMoat.GroupCoverage

namespace OAI

universe uOmega uAlpha uBeta uIota uCapitalGamma uGroup

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

lemma short_list_probability_deficit (p : FinLaw Ω) (X : Ω → α) (C : Ω → β)
    (L : β → Finset α) {b : ℝ} (hb : 1 ≤ b) :
    let a := p.prob (fun ω => X ω ∈ L (C ω) ∧ ((L (C ω)).card:ℝ) ≤ b)
    a*(Real.log (Fintype.card α)-Real.log b)-Real.binEntropy a ≤
      Real.log (Fintype.card α)-p.cHf X C := by
  dsimp only
  have hh := p.short_list_deficit X C L
    (fun ω => decide (X ω ∈ L (C ω) ∧ ((L (C ω)).card:ℝ) ≤ b)) hb
    (fun ω _ he => of_decide_eq_true he)
  have ha : (p.map (fun ω => decide (X ω ∈ L (C ω) ∧ ((L (C ω)).card:ℝ) ≤ b))) true =
      p.prob (fun ω => X ω ∈ L (C ω) ∧ ((L (C ω)).card:ℝ) ≤ b) := by
    simp only [map_mass,decide_eq_true_eq,prob]
    apply Finset.sum_congr rfl
    intro ω _
    split_ifs <;> rfl
  rw [ha] at hh
  simpa only [condH,← Hf_eq_H,cHf] using hh

lemma average_deficit_lower {ι : Type uIota} [Fintype ι] (w : FinLaw ι)
    (a d : ι → ℝ) {a₀ v : ℝ} (ha : ∀ i, a i ∈ Set.Icc (0:ℝ) 1)
    (ha₀ : 0 < a₀) (hav : a₀ ≤ ∑ i, w i*a i)
    (hv : 2*(1-Real.log a₀) ≤ v)
    (hdef : ∀ i, a i*v-Real.binEntropy (a i) ≤ d i) :
    a₀*v/2 ≤ ∑ i, w i*d i := by
  let A := ∑ i, w i*a i
  have hA : 0 < A := lt_of_lt_of_le ha₀ hav
  have hA1 : A ≤ 1 := by
    have hh := Finset.sum_le_sum (s := Finset.univ) (fun i _ =>
      mul_le_mul_of_nonneg_left (ha i).2 (w.nonneg i))
    simpa only [mul_one,w.sum_one] using hh
  have ha₀1 : a₀ ≤ 1 := hav.trans hA1
  have hl : Real.log a₀ ≤ Real.log A := Real.log_le_log ha₀ hav
  have hl0 : Real.log a₀ ≤ 0 := Real.log_nonpos ha₀.le ha₀1
  have hv0 : 0 ≤ v := by linarith only [hv,hl0]
  have hh := w.binEntropy_sum_le a ha
  have hp := binEntropy_le_log_inverse hA hA1
  have hdl := Finset.sum_le_sum (s := Finset.univ) (fun i _ =>
    mul_le_mul_of_nonneg_left (hdef i) (w.nonneg i))
  rw [show (∑ i, w i*(a i*v-Real.binEntropy (a i))) =
      A*v-∑ i, w i*Real.binEntropy (a i) by
        simp only [mul_sub,Finset.sum_sub_distrib,← mul_assoc,← Finset.sum_mul,A]] at hdl
  have hlog := mul_le_mul_of_nonneg_left hl hA.le
  have hmult := mul_le_mul_of_nonneg_left hv hA.le
  have ham := mul_le_mul_of_nonneg_right hav hv0
  change (∑ i, w i*Real.binEntropy (a i)) ≤ Real.binEntropy A at hh
  nlinarith only [hdl,hh,hp,hlog,hmult,ham]

theorem shared_coverage_deficit {Γ : Type uCapitalGamma} {G : Type uGroup} [Fintype Γ] [Fintype G] [AddCommGroup G]
    (p : FinLaw Ω) (q : Ω → FinLaw Γ) (Y : Ω → G) (h : Γ → G)
    (K : Finset G) (hK : K.Nonempty) (E : Ω → Finset G) (Bad : Ω → Prop)
    {τ δ ε b : ℝ} {n : ℕ} (hn : 0<n)
    (hτ : 0≤τ) (hτ1 : τ≤3/8) (hδ : 0<δ) (hδ1 : δ≤1/64)
    (hε : 0≤ε) (hb : 1≤b)
    (hp : (p.joint q).prob (fun v => Y v.1+h v.2∈K) ≤ τ*K.card/(Fintype.card G:ℝ))
    (hq : ∀ ω, ¬ Bad ω → ∀ y ∉ E ω, (τ+4*δ)/(Fintype.card G:ℝ) ≤ (q ω).map h y)
    (hE : ∀ ω, ¬ Bad ω → ((E ω).card:ℝ)/δ≤b)
    (herr : (Fintype.card G:ℝ)*Real.exp (-(n:ℝ)*δ^2*K.card/(2*(Fintype.card G:ℝ)))≤ε) :
    let P := p.joint (fun ω => (q ω).iid n)
    let L := fun v : Fin n → Γ => coverageList K n τ δ (fun i => h (v i))
    let a := P.prob (fun v => Y v.1 ∈ L v.2 ∧ ((L v.2).card:ℝ)≤b)
    δ/(τ+δ)-p.prob Bad-ε ≤ a ∧
      a*(Real.log (Fintype.card G)-Real.log b)-Real.binEntropy a ≤
        Real.log (Fintype.card G)-P.cHf (fun v => Y v.1) Prod.snd := by
  dsimp only
  constructor
  · have htrue := p.true_coverageList_probability q Y h K hK hτ hδ hn hp
    have hsize := p.coverageList_size_probability q h K hK E Bad hτ hτ1 hδ hδ1 hε n hq hE herr
    have hi := (p.joint (fun ω => (q ω).iid n)).prob_inter_ge
      (fun v => Y v.1 ∈ coverageList K n τ δ (fun i => h (v.2 i)))
      (fun v => ((coverageList K n τ δ (fun i => h (v.2 i))).card:ℝ)≤b)
    simp only [not_le] at hi
    linarith only [htrue,hsize,hi]
  · exact short_list_probability_deficit (p.joint (fun ω => (q ω).iid n))
      (fun v => Y v.1) Prod.snd
      (fun v => coverageList K n τ δ (fun i => h (v i))) hb

end FinLaw

lemma perm_expect_apply {ι : Type uIota} [Fintype ι] [DecidableEq ι] (f : ι → ℝ) (i : ι) :
    (𝔼 π : Equiv.Perm ι, f (π i)) = 𝔼 j, f j := by
  let : Nonempty ι := ⟨i⟩
  calc
    _ = 𝔼 j : ι, 𝔼 π : Equiv.Perm ι, f (π j) := by
      rw [show (fun j : ι => 𝔼 π : Equiv.Perm ι, f (π j)) =
        (fun _ => 𝔼 π : Equiv.Perm ι, f (π i)) by
          funext j; exact perm_expect_exchange f j i]
      simp only [Fintype.expect_const]
    _ = 𝔼 π : Equiv.Perm ι, 𝔼 j : ι, f (π j) := Finset.expect_comm _ _ _
    _ = _ := by
      have he (π : Equiv.Perm ι) : (𝔼 j, f (π j)) = 𝔼 j, f j :=
        Fintype.expect_equiv π _ _ (fun _ => rfl)
      simp only [he,Fintype.expect_const]

namespace FinLaw
variable {Ω : Type uOmega} {α : Type uAlpha} {β : Type uBeta} [Fintype Ω] {k : ℕ}

lemma Hf_sub_le_cHf (p : FinLaw Ω) (X : Ω → α) (Y : Ω → β) :
    p.Hf X-p.Hf Y ≤ p.cHf X Y := by
  have h := p.Hf_pair_ge_snd Y X
  rw [p.Hf_pair_comm Y X] at h
  exact sub_le_sub_right h _

lemma orderedEntropy_conditioning (p : FinLaw Ω) (X : Ω → Fin k → α)
    (C : Ω → β) {b : ℕ} (hb : b ≤ k) :
    p.orderedEntropy X b-p.Hf C ≤
      b*(𝔼 i : Fin k, p.cHf (fun ω => X ω i) C) := by
  have hh (π : Equiv.Perm (Fin k)) :
      p.Hf (prefixVar X π b)-p.Hf C ≤
        ∑ i : Fin b, p.cHf (fun ω => X ω (π ⟨i.val,lt_of_lt_of_le i.isLt hb⟩)) C := by
    apply (p.Hf_sub_le_cHf _ C).trans
    apply (p.cHf_le_of_determined _
      (fun ω (i : Fin b) => X ω (π ⟨i.val,lt_of_lt_of_le i.isLt hb⟩)) C ?_).trans
      (p.cHf_fintype_subadd _ C)
    intro ω ν hx _
    funext i
    by_cases hi : i.val<b
    · simpa only [prefixVar,hi,ite_eq_left] using congrArg some (congrFun hx ⟨i.val,hi⟩)
    · simp only [prefixVar,hi,ite_false]
  have hav := Finset.expect_le_expect (s := Finset.univ) (fun π _ => hh π)
  have he (i : Fin b) :
      (𝔼 π : Equiv.Perm (Fin k), p.cHf (fun ω => X ω (π ⟨i.val,lt_of_lt_of_le i.isLt hb⟩)) C) =
        𝔼 j : Fin k, p.cHf (fun ω => X ω j) C :=
    perm_expect_apply (fun j => p.cHf (fun ω => X ω j) C) _
  simpa only [orderedEntropy,Finset.expect_sub_distrib,Fintype.expect_const,
    Finset.expect_sum_comm,he,Finset.sum_const,Finset.card_univ,
    Fintype.card_fin,nsmul_eq_mul] using hav

lemma signedEntropy_conditioning (p : FinLaw Ω) (X : (Fin k → Bool) → Ω → Fin k → α)
    (C : Ω → β) {b : ℕ} (hb : b ≤ k) :
    p.signedEntropy X b-p.Hf C ≤
      b*(𝔼 σ : Fin k → Bool, 𝔼 i : Fin k, p.cHf (fun ω => X σ ω i) C) := by
  have h := Finset.expect_le_expect (s := Finset.univ) (fun σ _ =>
    p.orderedEntropy_conditioning (X σ) C hb)
  simpa only [signedEntropy,Finset.expect_sub_distrib,Fintype.expect_const,
    Finset.mul_expect] using h

end FinLaw

theorem SplitSieve.coverage_conditioning {Ω : Type uOmega} {β : Type uBeta} [Fintype Ω]
    (s : SplitSieve) (p : FinLaw Ω) (Y : Ω → GaussianInt) (C : Ω → β)
    {b : ℕ} (hb : b ≤ s.primes.card) :
    s.pointEntropy p Y b-p.Hf C ≤
      b*(𝔼 σ : Fin s.primes.card → Bool, 𝔼 i : Fin s.primes.card,
        p.cHf (fun ω => s.residueVector σ (Y ω) i) C) :=
  p.signedEntropy_conditioning _ C hb

namespace FinLaw

section

theorem backward_coverage_step {Ω : Type uOmega} {Γ : Type uCapitalGamma} {ι : Type uIota} [Fintype Ω] [Fintype Γ] [Fintype ι]
    (G : ι → Type uGroup) [∀ i, Fintype (G i)] [∀ i, AddCommGroup (G i)]
    (w : FinLaw ι) (p : FinLaw Ω) (q : Ω → FinLaw Γ)
    (Y : (i : ι) → Ω → G i) (h : (i : ι) → Γ → G i)
    (Bad₀ : ι → Prop) (Bad₁ : ι → Ω → Prop)
    (K : (i : ι) → Finset (G i)) (E : (i : ι) → Ω → Finset (G i))
    (b : ι → ℝ) {τ δ ε η η' e v : ℝ} {n : ℕ}
    (hn : 0 < n) (hτ : 0 ≤ τ) (hτ1 : τ ≤ 3/8)
    (hδ : 0 < δ) (hδ1 : δ ≤ 1/64) (hε : 0 ≤ ε) (hη : 0 < η)
    (hnext : ∑ i, w i*p.prob (Bad₁ i) ≤ η')
    (hsmall : η'+ε ≤ η*δ/2)
    (hscale : 2*(1-Real.log (η*δ/2)) ≤ v)
    (hgap : e < η*δ*v/4)
    (hdata : (∑ i, w i*(Real.log (Fintype.card (G i))-
      (p.joint (fun ω => (q ω).iid n)).cHf (fun x => Y i x.1) Prod.snd)) ≤ e)
    (hK : ∀ i, Bad₀ i → (K i).Nonempty)
    (hb : ∀ i, Bad₀ i → 1 ≤ b i)
    (hv : ∀ i, Bad₀ i → v ≤ Real.log (Fintype.card (G i))-Real.log (b i))
    (hp : ∀ i, Bad₀ i → (p.joint q).prob (fun x => Y i x.1+h i x.2 ∈ K i) ≤
      τ*(K i).card/(Fintype.card (G i):ℝ))
    (hq : ∀ i, Bad₀ i → ∀ ω, ¬Bad₁ i ω → ∀ y ∉ E i ω,
      (τ+4*δ)/(Fintype.card (G i):ℝ) ≤ (q ω).map (h i) y)
    (hE : ∀ i, Bad₀ i → ∀ ω, ¬Bad₁ i ω → ((E i ω).card:ℝ)/δ ≤ b i)
    (herr : ∀ i, Bad₀ i → (Fintype.card (G i):ℝ)*
      Real.exp (-(n:ℝ)*δ^2*(K i).card/(2*(Fintype.card (G i):ℝ))) ≤ ε) :
    w.prob Bad₀ ≤ η := by
  let P := p.joint (fun ω => (q ω).iid n)
  let L := fun i (x : Fin n → Γ) => coverageList (K i) n τ δ (fun j => h i (x j))
  let a := fun i => if Bad₀ i then P.prob
    (fun x => Y i x.1 ∈ L i x.2 ∧ ((L i x.2).card:ℝ) ≤ b i) else 0
  let d := fun i => Real.log (Fintype.card (G i))-P.cHf (fun x => Y i x.1) Prod.snd
  have hd (i : ι) : 0 ≤ d i := by
    exact sub_nonneg.mpr ((P.cHf_le_Hf _ _).trans (P.Hf_le_log_card_type _))
  have ha (i : ι) : a i ∈ Set.Icc (0:ℝ) 1 := by
    dsimp only [a]
    split_ifs
    · exact ⟨P.prob_nonneg _,P.prob_le_one _⟩
    · norm_num
  have hstep (i : ι) (hi : Bad₀ i) :
      δ-p.prob (Bad₁ i)-ε ≤ a i ∧ a i*v-Real.binEntropy (a i) ≤ d i := by
    have hh := shared_coverage_deficit p q (Y i) (h i) (K i) (hK i hi) (E i) (Bad₁ i)
      hn hτ hτ1 hδ hδ1 hε (hb i hi) (hp i hi) (hq i hi) (hE i hi) (herr i hi)
    dsimp only at hh
    have hh' : δ/(τ+δ)-p.prob (Bad₁ i)-ε ≤ a i ∧
        a i*(Real.log (Fintype.card (G i))-Real.log (b i))-Real.binEntropy (a i) ≤ d i := by
      simpa only [a,hi,ite_eq_left,P,L,d] using hh
    constructor
    · have htd : 0 < τ+δ := by linarith only [hτ,hδ]
      have htd1 : τ+δ ≤ 1 := by linarith only [hτ1,hδ1]
      have hfrac : δ ≤ δ/(τ+δ) := (le_div_iff₀ htd).mpr (by nlinarith only [htd1,hδ])
      linarith only [hh'.1,hfrac]
    · have hm := mul_le_mul_of_nonneg_left (hv i hi) (ha i).1
      linarith only [hh'.2,hm]
  have hl (i : ι) : δ*(if Bad₀ i then (1:ℝ) else 0)-p.prob (Bad₁ i)-ε ≤ a i := by
    by_cases hi : Bad₀ i
    · simpa only [hi,ite_true,mul_one] using (hstep i hi).1
    · simp only [hi,ite_false,mul_zero,a]
      linarith only [p.prob_nonneg (Bad₁ i),hε]
  have hdef (i : ι) : a i*v-Real.binEntropy (a i) ≤ d i := by
    by_cases hi : Bad₀ i
    · exact (hstep i hi).2
    · simpa only [a,hi,ite_false,Real.binEntropy_zero,zero_mul,sub_zero] using hd i
  by_contra hc
  have hθη : η < w.prob Bad₀ := lt_of_not_ge hc
  have hlavg := Finset.sum_le_sum (s := Finset.univ) (fun i _ =>
    mul_le_mul_of_nonneg_left (hl i) (w.nonneg i))
  have heq : (∑ i, w i*(δ*(if Bad₀ i then (1:ℝ) else 0)-p.prob (Bad₁ i)-ε)) =
      δ*w.prob Bad₀-(∑ i, w i*p.prob (Bad₁ i))-ε := by
    simp only [mul_sub,Finset.sum_sub_distrib,← Finset.sum_mul,w.sum_one,one_mul,prob,
      Finset.mul_sum]
    congr 2
    apply Finset.sum_congr rfl
    intro i _
    split_ifs <;> ring
  rw [heq] at hlavg
  have hav : η*δ/2 ≤ ∑ i, w i*a i := by
    have hm := mul_le_mul_of_nonneg_left hθη.le hδ.le
    linarith only [hlavg,hm,hnext,hsmall]
  have hbnd := average_deficit_lower w a d ha (by positivity : 0 < η*δ/2) hav hscale hdef
  change (∑ i, w i*d i) ≤ e at hdata
  nlinarith only [hbnd,hdata,hgap]

variable {Ω : Type uOmega} {G : Type uGroup} [Fintype Ω] [Fintype G]

theorem low_mass_average {ι : Type uIota} [Fintype ι]
    (G : ι → Type uGroup) [∀ i, Fintype (G i)]
    (w : FinLaw ι) (p : (i : ι) → FinLaw (G i))
    (K : (i : ι) → Finset (G i)) (Bad : ι → Prop) {b e : ℝ}
    (hb : 0 < b)
    (hK : ∀ i, ∀ x ∈ K i, p i x ≤ (3/8:ℝ)/(Fintype.card (G i):ℝ))
    (hbad : ∀ i, Bad i → b ≤ ((K i).card:ℝ)/(8*(Fintype.card (G i):ℝ)))
    (hdef : (∑ i, w i*(Real.log (Fintype.card (G i))-(p i).entropy)) ≤ e) :
    w.prob Bad ≤ e/b := by
  have h (i : ι) : b*(if Bad i then (1:ℝ) else 0) ≤
      Real.log (Fintype.card (G i))-(p i).entropy := by
    by_cases hi : Bad i
    · simp only [hi,ite_true,mul_one]
      exact (hbad i hi).trans ((p i).low_mass_deficit (K i) (by
        intro x hx
        convert hK i x hx using 1; ring))
    · simp only [hi,ite_false,mul_zero]
      exact sub_nonneg.mpr (p i).entropy_le_log_card
  have hs := Finset.sum_le_sum (s := Finset.univ) (fun i _ =>
    mul_le_mul_of_nonneg_left (h i) (w.nonneg i))
  have he : (∑ i, w i*(b*(if Bad i then (1:ℝ) else 0)))=b*w.prob Bad := by
    rw [prob,Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro i _
    split_ifs <;> ring
  rw [he] at hs
  apply (le_div_iff₀ hb).mpr
  linarith only [hs,hdef]

end

variable {Ω : Type uOmega} {α : Type uAlpha} {β : Type uBeta} [Fintype Ω] [Fintype α] [Fintype β]

lemma uniform_map_perm [Nonempty Ω] (e : Equiv.Perm Ω) : (uniform Ω).map e = uniform Ω := by
  ext x
  rw [map_equiv_mass]
  rfl

lemma prob_uniform (E : Ω → Prop) [Nonempty Ω] :
    (uniform Ω).prob E = ((Finset.univ.filter E).card:ℝ)/(Fintype.card Ω:ℝ) := by
  simp only [prob,uniform_mass,div_eq_mul_inv]
  rw [← Finset.sum_boole]
  rw [Finset.sum_mul]
  apply Finset.sum_congr rfl
  intro ω _
  split_ifs <;> simp

lemma uniform_no_wrap (n a : ℕ) (ha : a ≤ n+1) :
    (uniform (Fin (n+1))).prob (fun i => i.val+a<n+1) = 1-(a:ℝ)/(n+1) := by
  rw [prob_uniform]
  have he : (Finset.univ.filter (fun i : Fin (n+1) => i.val+a<n+1)) =
      Finset.univ.filter (fun i : Fin (n+1) => i.val<n+1-a) := by
    ext i
    simp only [Finset.mem_filter,Finset.mem_univ,true_and]
    omega
  have hcard : (Finset.univ.filter (fun i : Fin (n+1) => i.val+a<n+1)).card = n+1-a := by
    rw [he,Fin.card_filter_val_lt,Nat.min_eq_right (by omega)]
  calc
    _ = ((n+1-a:ℕ):ℝ)/(n+1) := by
      congr 1
      · convert! congrArg (fun k : ℕ => (k:ℝ)) hcard using 1
        congr 2
        ext i
        simp
      · simp
    _ = _ := by
      rw [Nat.cast_sub ha,Nat.cast_add,Nat.cast_one]
      field_simp

lemma joint_perm_second (p : FinLaw Ω) {Γ : Type uCapitalGamma} [Fintype Γ] [Nonempty Γ]
    (e : Equiv.Perm Γ) :
    (p.joint (fun _ => uniform Γ)).map (fun v => (v.1,e v.2)) = p.joint (fun _ => uniform Γ) := by
  have h := joint_map_fiber p (fun _ => uniform Γ) (fun _ v => e v)
  simpa only [uniform_map_perm] using h

lemma smoothing_prob (p : FinLaw Ω) (t : Ω → ℕ) (n a : ℕ) (ha : a≤n)
    (E : ℕ → Prop) :
    (p.joint (fun _ => uniform (Fin (n+1)))).prob (fun v => E (t v.1+v.2.val)) ≤
      (p.joint (fun _ => uniform (Fin (n+1)))).prob (fun v => E (t v.1+v.2.val+a))+
        (a:ℝ)/(n+1) := by
  let e : Equiv.Perm (Fin (n+1)) := Equiv.addRight ⟨a,by omega⟩
  let P := p.joint (fun _ => uniform (Fin (n+1)))
  have hprob : P.prob (fun v => E (t v.1+(e v.2).val)) =
      P.prob (fun v => E (t v.1+v.2.val)) := by
    have hh := congrArg (fun Q : FinLaw (Ω × Fin (n+1)) => Q.prob
      (fun v => E (t v.1+v.2.val))) (p.joint_perm_second e)
    simpa only [prob_map] using hh
  have hgood : P.prob (fun v => v.2.val+a<n+1) = 1-(a:ℝ)/(n+1) := by
    rw [prob_joint]
    simp only [uniform_no_wrap n a (by omega),← Finset.sum_mul,p.sum_one,one_mul]
  have hE : P.prob (fun v => E (t v.1+(e v.2).val) ∧ v.2.val+a<n+1) ≤
      P.prob (fun v => E (t v.1+v.2.val+a)) := by
    apply P.prob_mono
    intro v hv
    have he : (e v.2).val = v.2.val+a := by
      change (v.2+(⟨a,by omega⟩ : Fin (n+1))).val = _
      exact Fin.val_add_eq_of_add_lt hv.2
    simpa only [he,Nat.add_assoc] using hv.1
  have hh := P.prob_inter_ge (fun v => E (t v.1+(e v.2).val)) (fun v => v.2.val+a<n+1)
  have hc := P.prob_compl (fun v => v.2.val+a<n+1)
  rw [hgood] at hc
  rw [hprob] at hh
  linarith only [hE,hh,hc]

lemma smoothing_condH (p : FinLaw Ω) (t : Ω → ℕ) (n a : ℕ) (ha : a≤n)
    (X : ℕ → α) (C : ℕ → β) :
    (p.joint (fun _ => uniform (Fin (n+1)))).condH
      (fun v => X (t v.1+v.2.val+a)) (fun v => C (t v.1+v.2.val+a)) ≤
    (p.joint (fun _ => uniform (Fin (n+1)))).condH
      (fun v => X (t v.1+v.2.val)) (fun v => C (t v.1+v.2.val)) +
      2*Real.binEntropy ((a:ℝ)/(n+1))+
        ((a:ℝ)/(n+1))*(Real.log (Fintype.card α)+2*Real.log (Fintype.card β)) := by
  let e : Equiv.Perm (Fin (n+1)) := Equiv.addRight ⟨a,by omega⟩
  let P := p.joint (fun _ => uniform (Fin (n+1)))
  let good := fun v : Ω × Fin (n+1) => decide (v.2.val+a<n+1)
  have hm : P.map good true=1-(a:ℝ)/(n+1) := by
    have hh : P.map good true=P.prob (fun v => v.2.val+a<n+1) := by
      simp only [map_mass,good,prob,decide_eq_true_eq]
      apply Finset.sum_congr rfl
      intro v _
      split_ifs <;> rfl
    rw [hh,prob_joint]
    simp only [uniform_no_wrap n a (by omega),
      ← Finset.sum_mul,p.sum_one,one_mul]
  have he : P.condH (fun v => X (t v.1+(e v.2).val)) (fun v => C (t v.1+(e v.2).val)) =
      P.condH (fun v => X (t v.1+v.2.val)) (fun v => C (t v.1+v.2.val)) := by
    have hh := congrArg (fun Q : FinLaw (Ω × Fin (n+1)) =>
      Q.condH (fun v => X (t v.1+v.2.val)) (fun v => C (t v.1+v.2.val))) (p.joint_perm_second e)
    simpa only [condH,H_map,Function.comp_def] using hh
  have h := P.condH_sub_condH_of_agree
    (fun v => X (t v.1+v.2.val+a)) (fun v => X (t v.1+(e v.2).val))
    (fun v => C (t v.1+v.2.val+a)) (fun v => C (t v.1+(e v.2).val)) good (by
      intro v _ hv
      have hlt : v.2.val+a<n+1 := of_decide_eq_true hv
      have hev : (e v.2).val=v.2.val+a := Fin.val_add_eq_of_add_lt hlt
      simp only [hev,Nat.add_assoc,and_self])
  rw [hm,he,Real.binEntropy_one_sub] at h
  linarith only [h]

end FinLaw
end GaussianMoat

end OAI