import OAI.NumberTheory.GaussianMoat.SignConcentration

namespace OAI

universe uIota

namespace GaussianMoat
open MeasureTheory ProbabilityTheory
open scoped NNReal

@[reducible] def Cube : ℕ → Type
  | 0 => Unit
  | n + 1 => Bool × Cube n
instance cubeFintype : (n : ℕ) → Fintype (Cube n)
  | 0 => inferInstanceAs (Fintype Unit)
  | n + 1 => @instFintypeProd Bool (Cube n) inferInstance (cubeFintype n)
instance cubeDecidableEq : (n : ℕ) → DecidableEq (Cube n)
  | 0 => inferInstanceAs (DecidableEq Unit)
  | n + 1 => @instDecidableEqProd Bool (Cube n) inferInstance (cubeDecidableEq n)
def cubeDist : (n : ℕ) → Cube n → Cube n → ℕ
  | 0, _, _ => 0
  | n + 1, (b,x), (c,y) => (if b = c then 0 else 1) + cubeDist n x y
@[simp] theorem cubeDist_self (n : ℕ) (x : Cube n) : cubeDist n x x = 0 := by
  induction n with
  | zero => rfl
  | succ n ih => obtain ⟨b,x⟩ := x; simp [cubeDist, ih]
@[simp] theorem cubeDist_zero_iff (n : ℕ) (x y : Cube n) : cubeDist n x y = 0 ↔ x = y := by
  induction n with
  | zero => simp only [cubeDist]
  | succ n ih =>
    obtain ⟨b,x⟩ := x
    obtain ⟨c,y⟩ := y
    by_cases h : b = c <;> simp [cubeDist, h, ih, Prod.mk.injEq]
theorem cubeDist_symm (n : ℕ) (x y : Cube n) : cubeDist n x y = cubeDist n y x := by
  induction n with
  | zero => rfl
  | succ n ih =>
    obtain ⟨b,x⟩ := x
    obtain ⟨c,y⟩ := y
    simp [cubeDist, eq_comm (a := b) (b := c), ih x y]
theorem cubeDist_triangle (n : ℕ) (x y z : Cube n) :
    cubeDist n x z ≤ cubeDist n x y + cubeDist n y z := by
  induction n with
  | zero => simp [cubeDist]
  | succ n ih =>
    obtain ⟨b,x⟩ := x
    obtain ⟨c,y⟩ := y
    obtain ⟨d,z⟩ := z
    have h := ih x y z
    cases b <;> cases c <;> cases d <;> simp [cubeDist] <;> omega

noncomputable def cubeSize {n : ℕ} (S : Cube n → Prop) : ℕ := by
  classical
  exact ∑ x, if S x then 1 else 0
noncomputable def cubeBoundary {n : ℕ} (S : Cube n → Prop) : ℕ := by
  classical
  exact ∑ x, ∑ y, if S x ∧ ¬ S y ∧ cubeDist n x y = 1 then 1 else 0
noncomputable def cubeCross {n : ℕ} (A B : Cube n → Prop) : ℕ := by
  classical
  exact ∑ x, if A x ∧ ¬ B x then 1 else 0

theorem cubeSize_succ {n : ℕ} (S : Cube (n+1) → Prop) :
    cubeSize S = cubeSize (fun x => S (false,x)) + cubeSize (fun x => S (true,x)) := by
  classical
  simp only [cubeSize, Fintype.sum_prod_type, Fintype.sum_bool]
  ac_rfl

theorem cubeBoundary_succ {n : ℕ} (S : Cube (n+1) → Prop) :
    cubeBoundary S = cubeBoundary (fun x => S (false,x)) + cubeBoundary (fun x => S (true,x)) +
      cubeCross (fun x => S (false,x)) (fun x => S (true,x)) +
      cubeCross (fun x => S (true,x)) (fun x => S (false,x)) := by
  classical
  simp only [cubeBoundary, cubeCross, Fintype.sum_prod_type, Fintype.sum_bool, cubeDist,
    Bool.false_eq_true, Bool.true_eq_false, ↓reduceIte, zero_add, Nat.add_eq_left,
    cubeDist_zero_iff, Finset.sum_add_distrib]
  simp only [and_assoc, and_left_comm, and_comm, ite_and, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte]
  omega

theorem cubeCross_card_le {n : ℕ} (A B : Cube n → Prop) : cubeSize A ≤ cubeSize B + cubeCross A B := by
  classical
  rw [cubeSize, cubeSize, cubeCross, ← Finset.sum_add_distrib]
  apply Finset.sum_le_sum
  intro x _
  by_cases ha : A x <;> by_cases hb : B x <;> simp [ha, hb]

theorem cube_degree (n : ℕ) (x : Cube n) : (∑ y, if cubeDist n x y = 1 then 1 else 0) = n := by
  classical
  induction n with
  | zero => simp [cubeDist]
  | succ n ih =>
    obtain ⟨b,x⟩ := x
    cases b <;> simp only [Fintype.sum_prod_type, Fintype.sum_bool, cubeDist,
      Bool.false_eq_true, Bool.true_eq_false, ↓reduceIte, zero_add, Nat.add_eq_left,
      cubeDist_zero_iff, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte, ih]
    omega

theorem binEntropy_ge_two_mul {p : ℝ} (hp0 : 0 ≤ p) (hp2 : p ≤ 1/2) :
    2 * p * Real.log 2 ≤ Real.binEntropy p := by
  have hc : ConcaveOn ℝ (Set.Icc 0 1) Real.binEntropy := Real.strictConcave_binEntropy.concaveOn
  have h := hc.2 (show (0 : ℝ) ∈ Set.Icc 0 1 by norm_num)
    (show (2 : ℝ)⁻¹ ∈ Set.Icc 0 1 by norm_num)
    (show 0 ≤ 1 - 2*p by linarith) (show 0 ≤ 2*p by positivity) (by ring)
  simpa only [smul_eq_mul, Real.binEntropy_zero, Real.binEntropy_two_inv,
    mul_zero, zero_add, show 2*p*(2:ℝ)⁻¹ = p by ring] using h

theorem entropy_merge_of_le {a b : ℝ} (ha : 0 ≤ a) (hab : a ≤ b) :
    2 * a * Real.log 2 ≤ (a+b)*Real.log (a+b) - a*Real.log a - b*Real.log b := by
  by_cases ha0 : a = 0
  · simp [ha0]
  have hap : 0 < a := lt_of_le_of_ne ha (Ne.symm ha0)
  have hbp : 0 < b := hap.trans_le hab
  have ht : 0 < a+b := by positivity
  have hp0 : 0 ≤ a/(a+b) := by positivity
  have hp2 : a/(a+b) ≤ 1/2 := (div_le_iff₀ ht).mpr (by linarith)
  have h := mul_le_mul_of_nonneg_left (binEntropy_ge_two_mul hp0 hp2) ht.le
  have heq : (a+b) * Real.binEntropy (a/(a+b)) =
      (a+b)*Real.log (a+b) - a*Real.log a - b*Real.log b := by
    have hsub : 1-a/(a+b) = b/(a+b) := by field_simp; ring
    rw [Real.binEntropy, hsub, Real.log_inv, Real.log_inv,
      Real.log_div hap.ne' ht.ne', Real.log_div hbp.ne' ht.ne']
    field_simp
    ring
  rw [heq] at h
  have heq' : (a+b) * (2 * (a/(a+b)) * Real.log 2) = 2*a*Real.log 2 := by
    field_simp
  rwa [heq'] at h

theorem entropy_merge {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    2 * min a b * Real.log 2 ≤ (a+b)*Real.log (a+b) - a*Real.log a - b*Real.log b := by
  rcases le_total a b with hab | hba
  · simpa [min_eq_left hab] using entropy_merge_of_le ha hab
  · have h := entropy_merge_of_le hb hba
    rw [min_eq_right hba]
    convert h using 1
    rw [add_comm b a]
    ring

theorem cube_edge_isoperimetric (n : ℕ) (S : Cube n → Prop) :
    (cubeSize S : ℝ) * ((n : ℝ) * Real.log 2 - Real.log (cubeSize S)) ≤
      (cubeBoundary S : ℝ) * Real.log 2 := by
  classical
  induction n with
  | zero =>
    by_cases hs : S () <;> simp [cubeSize, cubeBoundary, cubeDist, hs]
  | succ n ih =>
    have h0 := ih (fun x => S (false,x))
    have h1 := ih (fun x => S (true,x))
    have hac := cubeCross_card_le (fun x => S (false,x)) (fun x => S (true,x))
    have hbc := cubeCross_card_le (fun x => S (true,x)) (fun x => S (false,x))
    have hac' : (cubeSize (fun x => S (false,x)) : ℝ) ≤
        cubeSize (fun x => S (true,x)) + cubeCross (fun x => S (false,x)) (fun x => S (true,x)) := by
      exact_mod_cast hac
    have hbc' : (cubeSize (fun x => S (true,x)) : ℝ) ≤
        cubeSize (fun x => S (false,x)) + cubeCross (fun x => S (true,x)) (fun x => S (false,x)) := by
      exact_mod_cast hbc
    have he := entropy_merge (a := (cubeSize (fun x => S (false,x)) : ℝ))
      (b := (cubeSize (fun x => S (true,x)) : ℝ)) (by positivity) (by positivity)
    have hl : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num)
    rw [cubeSize_succ, cubeBoundary_succ]
    push_cast
    rcases le_total (cubeSize (fun x => S (false,x)) : ℝ) (cubeSize (fun x => S (true,x)) : ℝ) with hab | hba
    · rw [min_eq_left hab] at he
      have hn : (0 : ℝ) ≤ cubeCross (fun x => S (false,x)) (fun x => S (true,x)) := by positivity
      nlinarith
    · rw [min_eq_right hba] at he
      have hn : (0 : ℝ) ≤ cubeCross (fun x => S (true,x)) (fun x => S (false,x)) := by positivity
      nlinarith

def cubeExpand {n : ℕ} (S : Cube n → Prop) (y : Cube n) : Prop :=
  S y ∨ ∃ x, S x ∧ cubeDist n x y = 1

def cubeExpandIter {n : ℕ} (S : Cube n → Prop) : ℕ → Cube n → Prop
  | 0 => S
  | h+1 => cubeExpand (cubeExpandIter S h)

theorem cubeSize_mono {n : ℕ} {S T : Cube n → Prop} (h : ∀ x, S x → T x) :
    cubeSize S ≤ cubeSize T := by
  classical
  apply Finset.sum_le_sum
  intro x _
  by_cases hs : S x
  · simp [hs, h x hs]
  · simp [hs]

theorem cube_card (n : ℕ) : Fintype.card (Cube n) = 2^n := by
  induction n with
  | zero => rfl
  | succ n ih =>
    change Fintype.card (Bool × Cube n) = _
    rw [Fintype.card_prod, Fintype.card_bool, ih, pow_succ]
    omega

theorem cubeSize_le (n : ℕ) (S : Cube n → Prop) : cubeSize S ≤ 2^n := by
  classical
  calc
    cubeSize S ≤ ∑ _ : Cube n, 1 := by
      apply Finset.sum_le_sum
      intro x _
      split_ifs <;> omega
    _ = 2^n := by simp [cube_card]

theorem cubeBoundary_expand_bound {n : ℕ} (S : Cube n → Prop) :
    cubeBoundary S + n * cubeSize S ≤ n * cubeSize (cubeExpand S) := by
  classical
  have hdegree (y : Cube n) :
      (∑ x, if S x ∧ ¬ S y ∧ cubeDist n x y = 1 then 1 else 0) ≤
        n * (if ¬S y ∧ (∃ x, S x ∧ cubeDist n x y = 1) then 1 else 0) := by
    by_cases hy : ¬S y ∧ (∃ x, S x ∧ cubeDist n x y = 1)
    · rw [ite_eq_left hy, mul_one]
      calc
        _ ≤ ∑ x, if cubeDist n y x = 1 then 1 else 0 := by
          apply Finset.sum_le_sum
          intro x _
          by_cases h : S x ∧ ¬ S y ∧ cubeDist n x y = 1
          · simp [h, cubeDist_symm n y x]
          · simp [h]
        _ = n := cube_degree n y
    · simp only [hy, ↓reduceIte, mul_zero, Nat.le_zero]
      apply Finset.sum_eq_zero
      intro x _
      have hnot : ¬(S x ∧ ¬S y ∧ cubeDist n x y = 1) := by
        rintro ⟨hs, hns, hd⟩
        exact hy ⟨hns,x,hs,hd⟩
      simp [hnot]
  have hb := Finset.sum_le_sum (s := Finset.univ) (fun y _ => hdegree y)
  rw [← Finset.mul_sum] at hb
  have heq : cubeSize (cubeExpand S) = cubeSize S +
      ∑ y, if ¬S y ∧ (∃ x, S x ∧ cubeDist n x y = 1) then 1 else 0 := by
    rw [cubeSize, cubeSize, ← Finset.sum_add_distrib]
    apply Finset.sum_congr rfl
    intro y _
    by_cases hs : S y <;> simp [cubeExpand, hs]
  unfold cubeBoundary
  rw [Finset.sum_comm, heq, Nat.mul_add]
  omega

theorem cubeExpandIter_witness {n h : ℕ} {S : Cube n → Prop} {x : Cube n}
    (hx : cubeExpandIter S h x) : ∃ y, S y ∧ cubeDist n y x ≤ h := by
  induction h generalizing x with
  | zero => exact ⟨x,hx,by simp⟩
  | succ h ih =>
    rcases hx with hx | ⟨z,hz,hzx⟩
    · obtain ⟨y,hy,hyx⟩ := ih hx
      exact ⟨y,hy,by omega⟩
    · obtain ⟨y,hy,hyz⟩ := ih hz
      exact ⟨y,hy,by have ht := cubeDist_triangle n y z x; omega⟩

theorem cubeExpandIter_disjoint {n h : ℕ} {S T : Cube n → Prop}
    (hsep : ∀ x, S x → ∀ y, T y → 2*h < cubeDist n x y) :
    ∀ x, ¬(cubeExpandIter S h x ∧ cubeExpandIter T h x) := by
  rintro x ⟨hs,ht⟩
  obtain ⟨y,hy,hyx⟩ := cubeExpandIter_witness hs
  obtain ⟨z,hz,hzx⟩ := cubeExpandIter_witness ht
  have h := hsep y hy z hz
  have htri := cubeDist_triangle n y x z
  rw [cubeDist_symm n x z] at htri
  omega

theorem cubeSize_sum_le {n : ℕ} {ι : Type uIota} [Fintype ι] (S : ι → Cube n → Prop)
    (hd : ∀ i j, i ≠ j → ∀ x, ¬(S i x ∧ S j x)) :
    ∑ i, cubeSize (S i) ≤ 2^n := by
  classical
  unfold cubeSize
  rw [Finset.sum_comm]
  calc
    _ ≤ ∑ _ : Cube n, 1 := by
      apply Finset.sum_le_sum
      intro x _
      by_cases he : ∃ i, S i x
      · obtain ⟨i,hi⟩ := he
        rw [Finset.sum_eq_single i]
        · simp [hi]
        · intro j _ hji
          have hnot : ¬S j x := fun hj => hd j i hji x ⟨hj,hi⟩
          simp [hnot]
        · simp
      · have hh : ∀ i, ¬S i x := by simpa only [not_exists] using he
        simp [hh]
    _ = 2^n := by simp [cube_card]

theorem cube_growth {n : ℕ} (hn : 0 < n) (S : Cube n → Prop) {a E : ℝ}
    (hE : 0 < E) (hlogE : Real.log E ≤ (n : ℝ) * Real.log 2 - a)
    (hsize : (cubeSize S : ℝ) ≤ E) :
    (1 + a / ((n : ℝ) * Real.log 2)) * cubeSize S ≤ cubeSize (cubeExpand S) := by
  by_cases hz : cubeSize S = 0
  · simp [hz]
  have hpos : (0 : ℝ) < cubeSize S := by exact_mod_cast Nat.pos_of_ne_zero hz
  have hnpos : (0 : ℝ) < n := by exact_mod_cast hn
  have hlogtwo : 0 < Real.log 2 := Real.log_pos (by norm_num)
  have hden : 0 < (n : ℝ) * Real.log 2 := mul_pos hnpos hlogtwo
  have hl := ((Real.log_le_log_iff hpos hE).mpr hsize).trans hlogE
  have hi := cube_edge_isoperimetric n S
  have hb : (cubeBoundary S : ℝ) + n * cubeSize S ≤ n * cubeSize (cubeExpand S) := by
    exact_mod_cast cubeBoundary_expand_bound S
  apply (mul_le_mul_iff_left₀ hden).mp
  field_simp at ⊢
  nlinarith [mul_le_mul_of_nonneg_left hl hpos.le,
    mul_le_mul_of_nonneg_right hb hlogtwo.le]

theorem cube_iter_growth {n : ℕ} (S : Cube n → Prop) {δ E : ℝ} (hδ : 0 ≤ δ)
    (hgrow : ∀ T : Cube n → Prop, (cubeSize T : ℝ) ≤ E →
      (1+δ)*cubeSize T ≤ cubeSize (cubeExpand T)) (h : ℕ) :
    min E ((1+δ)^h * cubeSize S) ≤ cubeSize (cubeExpandIter S h) := by
  induction h with
  | zero => simpa only [pow_zero, one_mul, cubeExpandIter] using
      (min_le_right E (cubeSize S : ℝ))
  | succ h ih =>
    have hmono : (cubeSize (cubeExpandIter S h) : ℝ) ≤ cubeSize (cubeExpandIter S (h+1)) := by
      exact_mod_cast cubeSize_mono (S := cubeExpandIter S h) (T := cubeExpand (cubeExpandIter S h))
        (fun _ hx => Or.inl hx)
    by_cases hlarge : E ≤ (cubeSize (cubeExpandIter S h) : ℝ)
    · exact (min_le_left _ _).trans (hlarge.trans hmono)
    · have hsmall : (cubeSize (cubeExpandIter S h) : ℝ) ≤ E := le_of_not_ge hlarge
      have hpow : (1+δ)^h * cubeSize S ≤ E := by
        by_contra hnot
        rw [min_eq_left (le_of_not_ge hnot)] at ih
        exact hlarge ih
      rw [min_eq_right hpow] at ih
      have hmul := mul_le_mul_of_nonneg_left ih (by linarith : 0 ≤ 1+δ)
      have hg := hgrow (cubeExpandIter S h) hsmall
      apply (min_le_right _ _).trans
      simpa only [pow_succ, mul_assoc, mul_left_comm, cubeExpandIter] using hmul.trans hg

theorem cube_separated_bound {n h : ℕ} (hn : 0 < n) {ι : Type uIota} [Fintype ι]
    (S : ι → Cube n → Prop) {a E A : ℝ} (ha : 0 ≤ a) (hE : 0 < E)
    (hlogE : Real.log E ≤ (n : ℝ) * Real.log 2 - a)
    (hseed : ∀ i, A * cubeSize (S i) ≤ E)
    (hfactor : A ≤ (1 + a / ((n : ℝ)*Real.log 2))^h)
    (hsep : ∀ i j, i ≠ j → ∀ x, S i x → ∀ y, S j y → 2*h < cubeDist n x y) :
    A * (∑ i, (cubeSize (S i) : ℝ)) ≤ (2 : ℝ)^n := by
  have hδ : 0 ≤ a / ((n : ℝ)*Real.log 2) := by
    apply div_nonneg ha
    exact mul_nonneg (Nat.cast_nonneg _) (Real.log_nonneg (by norm_num))
  have hlarge (i : ι) : A * cubeSize (S i) ≤ cubeSize (cubeExpandIter (S i) h) := by
    apply le_trans (le_min (hseed i) (mul_le_mul_of_nonneg_right hfactor (Nat.cast_nonneg _)))
    exact cube_iter_growth (S i) hδ (fun T ht => cube_growth hn T hE hlogE ht) h
  rw [Finset.mul_sum]
  apply (Finset.sum_le_sum (fun i _ => hlarge i)).trans
  have hd : ∀ i j, i ≠ j → ∀ x, ¬(cubeExpandIter (S i) h x ∧ cubeExpandIter (S j) h x) := by
    intro i j hij
    exact cubeExpandIter_disjoint (hsep i j hij)
  exact_mod_cast cubeSize_sum_le (fun i => cubeExpandIter (S i) h) hd

end GaussianMoat

end OAI