import OAI.Computability.StarHeight.Actions

namespace OAI

namespace GeneralizedStarHeight

universe u
universe uΩ uι

namespace FiniteAvoidance

variable {Ω : Type uΩ} {ι : Type uι} [Fintype Ω]

noncomputable def mass (w : Ω → ℝ) (A : Set Ω) : ℝ := by
  classical
  exact ∑ x : Ω, if x ∈ A then w x else 0

lemma mass_nonneg {w : Ω → ℝ} (hw : ∀ x, 0 ≤ w x) (A : Set Ω) :
    0 ≤ mass w A := by
  classical
  exact Finset.sum_nonneg fun x _ => by
    by_cases hx : x ∈ A <;> simp [hx, hw x]

lemma mass_mono {w : Ω → ℝ} (hw : ∀ x, 0 ≤ w x) {A C : Set Ω}
    (hAC : A ⊆ C) : mass w A ≤ mass w C := by
  classical
  apply Finset.sum_le_sum
  intro x _
  by_cases hx : x ∈ A
  · simp [hx, hAC hx]
  · by_cases hc : x ∈ C <;> simp [hx, hc, hw x]

@[simp] lemma mass_empty (w : Ω → ℝ) : mass w ∅ = 0 := by
  classical
  simp [mass]

lemma mass_diff (w : Ω → ℝ) (A C : Set Ω) :
    mass w (A \ C) = mass w A - mass w (C ∩ A) := by
  classical
  simp only [mass, ← Finset.sum_sub_distrib]
  apply Finset.sum_congr rfl
  intro x _
  by_cases hx : x ∈ A <;> by_cases hc : x ∈ C <;> simp [hx, hc]

def avoids (B : ι → Set Ω) (J : Finset ι) : Set Ω :=
  {x | ∀ i ∈ J, x ∉ B i}

omit [Fintype Ω] in
@[simp] lemma avoids_empty (B : ι → Set Ω) : avoids B ∅ = Set.univ := by
  ext x
  simp [avoids]

omit [Fintype Ω] in
lemma avoids_antitone (B : ι → Set Ω) {J K : Finset ι} (hJK : J ⊆ K) :
    avoids B K ⊆ avoids B J := by
  intro x hx i hi
  exact hx i (hJK hi)

omit [Fintype Ω] in
lemma avoids_insert [DecidableEq ι] (B : ι → Set Ω) (J : Finset ι) (i : ι) :
    avoids B (insert i J) = avoids B J \ B i := by
  ext x
  simp only [avoids, Set.mem_ofPred_eq, Finset.mem_insert, forall_eq_or_imp,
    Set.mem_sdiff]
  exact and_comm

lemma mass_avoids_insert [DecidableEq ι] (w : Ω → ℝ) (B : ι → Set Ω)
    (J : Finset ι) (i : ι) :
    mass w (avoids B (insert i J)) =
      mass w (avoids B J) - mass w (B i ∩ avoids B J) := by
  rw [avoids_insert, mass_diff]

lemma avoid_union_lower [DecidableEq ι] (w : Ω → ℝ) (B : ι → Set Ω)
    (s : ℝ) (hs : s ≤ 1) (J K : Finset ι) (hd : Disjoint J K)
    (hb : ∀ U : Finset ι, U ⊆ K → U.card < K.card →
      ∀ i, i ∉ J ∪ U → mass w (B i ∩ avoids B (J ∪ U)) ≤
        s * mass w (avoids B (J ∪ U))) :
    (1 - s) ^ K.card * mass w (avoids B J) ≤ mass w (avoids B (J ∪ K)) := by
  induction K using Finset.induction_on with
  | empty => simp
  | @insert i K hi ih =>
      have hdK : Disjoint J K := hd.mono_right (Finset.subset_insert _ _)
      have hiJ : i ∉ J := by
        intro hm
        exact Finset.disjoint_left.mp hd hm (Finset.mem_insert_self _ _)
      have hbK : ∀ U : Finset ι, U ⊆ K → U.card < K.card →
          ∀ j, j ∉ J ∪ U → mass w (B j ∩ avoids B (J ∪ U)) ≤
            s * mass w (avoids B (J ∪ U)) := by
        intro U hU hcard j hj
        apply hb U (hU.trans (Finset.subset_insert _ _))
        · simpa [Finset.card_insert_of_notMem hi] using hcard.trans_le (Nat.le_succ _)
        · exact hj
      have hstep := hb K (Finset.subset_insert _ _) (by simp [hi]) i
        (by simp [hiJ, hi])
      have hrec := ih hdK hbK
      rw [Finset.card_insert_of_notMem hi, pow_succ,
        mul_comm ((1 - s) ^ K.card) (1 - s), mul_assoc]
      calc
        (1 - s) * ((1 - s) ^ K.card * mass w (avoids B J))
            ≤ (1 - s) * mass w (avoids B (J ∪ K)) :=
              mul_le_mul_of_nonneg_left hrec (sub_nonneg.mpr hs)
        _ ≤ mass w (avoids B (J ∪ insert i K)) := by
          rw [Finset.union_insert, mass_avoids_insert]
          linarith

theorem local_lemma [DecidableEq ι] (w : Ω → ℝ) (hw : ∀ x, 0 ≤ w x)
    (htotal : 0 < mass w Set.univ) (B : ι → Set Ω)
    (neighbors : ι → Finset ι) (D : ℕ) (s : ℝ) (hs0 : 0 < s) (hs1 : s < 1)
    (hdegree : ∀ i, (neighbors i).card ≤ D)
    (hbad : ∀ i, mass w (B i) ≤ s * (1 - s) ^ D * mass w Set.univ)
    (hind : ∀ i (J : Finset ι), i ∉ J → Disjoint J (neighbors i) →
      mass w (B i ∩ avoids B J) * mass w Set.univ =
        mass w (B i) * mass w (avoids B J))
    (J : Finset ι) : 0 < mass w (avoids B J) := by
  have hconditional : ∀ n : ℕ, ∀ K : Finset ι, K.card = n →
      0 < mass w (avoids B K) ∧ ∀ i, i ∉ K →
        mass w (B i ∩ avoids B K) ≤ s * mass w (avoids B K) := by
    intro n
    induction n using Nat.strong_induction_on with
    | h n ih =>
      intro K hK
      have hpos : 0 < mass w (avoids B K) := by
        by_cases he : K = ∅
        · simpa [he] using htotal
        · obtain ⟨i, hi⟩ := Finset.nonempty_iff_ne_empty.mpr he
          have hsmall : (K.erase i).card < n := by
            rw [← hK]
            exact Finset.card_erase_lt_of_mem hi
          have hprev := ih (K.erase i).card hsmall (K.erase i) rfl
          have hb := hprev.2 i (Finset.notMem_erase i K)
          have hins : insert i (K.erase i) = K := Finset.insert_erase hi
          rw [← hins, mass_avoids_insert]
          have hp : 0 < (1 - s) * mass w (avoids B (K.erase i)) :=
            mul_pos (sub_pos.mpr hs1) hprev.1
          linarith
      refine ⟨hpos, ?_⟩
      intro i hi
      let N := K ∩ neighbors i
      let F := K \ neighbors i
      have hFN : Disjoint F N := by
        exact Finset.disjoint_sdiff_inter _ _
      have hUF : F ∪ N = K := by
        exact Finset.sdiff_union_inter _ _
      have hFsub : F ⊆ K := Finset.sdiff_subset
      have hFdisj : Disjoint F (neighbors i) := by
        apply Finset.disjoint_left.mpr
        intro x hx hnx
        exact (Finset.mem_sdiff.mp hx).2 hnx
      have hiF : i ∉ F := fun h => hi (hFsub h)
      have hInd := hind i F hiF hFdisj
      have hBF : mass w (B i ∩ avoids B F) ≤
          s * (1 - s) ^ D * mass w (avoids B F) := by
        apply (mul_le_mul_iff_left₀ htotal).mp
        rw [hInd]
        calc
          mass w (B i) * mass w (avoids B F)
              ≤ (s * (1 - s) ^ D * mass w Set.univ) * mass w (avoids B F) :=
                mul_le_mul_of_nonneg_right (hbad i) (mass_nonneg hw _)
          _ = (s * (1 - s) ^ D * mass w (avoids B F)) * mass w Set.univ := by ring
      have hchain : (1 - s) ^ N.card * mass w (avoids B F) ≤
          mass w (avoids B K) := by
        rw [← hUF]
        apply avoid_union_lower w B s hs1.le F N hFN
        intro U hU hcard j hj
        have hdu : Disjoint F U := hFN.mono_right hU
        have hsmall : (F ∪ U).card < n := by
          rw [Finset.card_union_of_disjoint hdu, ← hK, ← hUF,
            Finset.card_union_of_disjoint hFN]
          exact Nat.add_lt_add_left hcard _
        exact (ih (F ∪ U).card hsmall (F ∪ U) rfl).2 j hj
      have hNcard : N.card ≤ D :=
        (Finset.card_le_card (Finset.inter_subset_right)).trans (hdegree i)
      have hpow : (1 - s) ^ D ≤ (1 - s) ^ N.card :=
        pow_le_pow_of_le_one (sub_nonneg.mpr hs1.le)
          (by linarith) hNcard
      calc
        mass w (B i ∩ avoids B K) ≤ mass w (B i ∩ avoids B F) :=
          mass_mono hw (Set.inter_subset_inter_right _ (avoids_antitone B hFsub))
        _ ≤ s * (1 - s) ^ D * mass w (avoids B F) := hBF
        _ ≤ s * ((1 - s) ^ N.card * mass w (avoids B F)) := by
          have hh := mul_le_mul_of_nonneg_right
            (mul_le_mul_of_nonneg_left hpow hs0.le) (mass_nonneg hw (avoids B F))
          simpa only [mul_assoc] using hh
        _ ≤ s * mass w (avoids B K) := mul_le_mul_of_nonneg_left hchain hs0.le
  exact (hconditional J.card J rfl).1

lemma mass_one_eq_card (A : Set Ω) :
    mass (fun _ : Ω => (1 : ℝ)) A = Nat.card A := by
  classical
  simp [mass, Nat.card_eq_fintype_card, Fintype.card_subtype]

@[simp] lemma mass_one_univ :
    mass (fun _ : Ω => (1 : ℝ)) Set.univ = Fintype.card Ω := by
  classical
  simp [mass]

noncomputable def probability (E : Set Ω) : ℝ :=
  mass (fun _ => (1 : ℝ)) E / Fintype.card Ω

@[simp] lemma probability_univ [Nonempty Ω] :
    probability (Set.univ : Set Ω) = 1 := by
  simp [probability, ne_of_gt Fintype.card_pos]

lemma probability_compl [Nonempty Ω] (E : Set Ω) :
    probability Eᶜ = 1 - probability E := by
  have hd := mass_diff (fun _ : Ω => (1 : ℝ)) Set.univ E
  simp only [← Set.compl_eq_univ_sdiff, Set.inter_univ, mass_one_univ] at hd
  unfold probability
  rw [hd, sub_div, div_self (by exact_mod_cast ne_of_gt Fintype.card_pos)]

lemma probability_eq_of_equiv (E F : Set Ω) (e : E ≃ F) :
    probability E = probability F := by
  unfold probability
  rw [mass_one_eq_card, mass_one_eq_card, Nat.card_congr e]

lemma probability_inter_of_independent [Nonempty Ω] (E F : Set Ω)
    (hind : mass (fun _ : Ω => (1 : ℝ)) (E ∩ F) *
        mass (fun _ : Ω => (1 : ℝ)) Set.univ =
      mass (fun _ : Ω => (1 : ℝ)) E * mass (fun _ : Ω => (1 : ℝ)) F) :
    probability (E ∩ F) = probability E * probability F := by
  have hp : (Fintype.card Ω : ℝ) ≠ 0 := by
    exact_mod_cast ne_of_gt Fintype.card_pos
  simp only [mass_one_univ] at hind
  unfold probability
  field_simp
  exact hind

lemma nonempty_of_mass_pos {w : Ω → ℝ} {E : Set Ω} (h : 0 < mass w E) :
    E.Nonempty := by
  by_contra hn
  have he := Set.not_nonempty_iff_eq_empty.mp hn
  simp [he] at h

lemma local_parameter (D : ℕ) (p : ℝ)
    (hp : 4 * ((D : ℝ) + 1) * p ≤ 1) :
    ∃ s : ℝ, 0 < s ∧ s < 1 ∧ p ≤ s * (1 - s) ^ D := by
  let s : ℝ := (2 * ((D : ℝ) + 1))⁻¹
  have hD : (0 : ℝ) ≤ D := Nat.cast_nonneg D
  have hden : 0 < 2 * ((D : ℝ) + 1) := by positivity
  have hs0 : 0 < s := inv_pos.mpr hden
  have heq : s * (2 * ((D : ℝ) + 1)) = 1 := inv_mul_cancel₀ hden.ne'
  have hsD : 0 ≤ s * D := mul_nonneg hs0.le hD
  have hshalf : s ≤ 1 / 2 := by nlinarith
  have hs1 : s < 1 := by linarith
  have hbern : 1 - (D : ℝ) * s ≤ (1 - s) ^ D := by
    simpa only [sub_eq_add_neg, mul_neg] using
      (one_add_mul_le_pow (a := -s) (by linarith) D)
  have hhalf : (1 : ℝ) / 2 ≤ (1 - s) ^ D := by nlinarith
  have hp' : p ≤ s / 2 := by
    apply (mul_le_mul_iff_right₀ (show 0 < 4 * ((D : ℝ) + 1) by positivity)).mp
    nlinarith [heq]
  refine ⟨s, hs0, hs1, hp'.trans ?_⟩
  nlinarith

end FiniteAvoidance

end GeneralizedStarHeight

end OAI