import OAI.Combinatorics.ExpectationThreshold.SelectorDefinitionsLemmas
import Mathlib.Data.Nat.Find
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring

namespace OAI

/-!
# Feasible minima and the actual containment cover

Resetting an original family member to the first color proves existence of
a bounded feasible move. Minimization itself retains the unrestricted
feasibility witness from `Feasible`; the witness need not be that member.
All retained minima contribute their actual changed sets to a cover.
-/

noncomputable section

open scoped BigOperators

namespace TalagrandThreshold.Selector

variable {α : Type*} [Fintype α] [DecidableEq α]
variable {F : Family α} {s : ℕ}

/-- Reset only the specified member to zero, the first color index. -/
def reset (a : Coloring α s) (H₀ : ↥F) : Coloring α s :=
  fun x => if x ∈ H₀.val then 0 else a x

omit [Fintype α] in
theorem reset_earlier (a : Coloring α s) (H₀ : ↥F) :
    Earlier a (reset a H₀) := by
  intro x
  by_cases hx : x ∈ H₀.val
  · simp [reset, hx]
  · simp [reset, hx]

theorem changes_reset_subset (a : Coloring α s) (H₀ : ↥F) :
    changes a (reset a H₀) ⊆ H₀.val := by
  intro x hx
  by_contra hnot
  have hlt := (Finset.mem_filter.mp hx).2
  simp [reset, hnot] at hlt

/-- The reset uses this one member as a witness, with every cutoff zero. -/
theorem reset_feasibleFor (mu : MassFamily F) (a : Coloring α s) (H₀ : ↥F) :
    FeasibleFor mu a (reset a H₀) H₀ := by
  classical
  intro i
  refine ⟨0, le_rfl, zero_le_one, ?_, ?_⟩
  · intro x hpos
    have hx : x ∈ H₀.val := by
      by_contra hnot
      rw [mu.supported H₀ x hnot] at hpos
      exact (lt_irrefl (0 : ℝ)) hpos
    apply Finset.mem_filter.mpr
    refine ⟨Finset.mem_univ x, ?_⟩
    change (if x ∈ H₀.val then (0 : Color s) else a x).val ≤ i.val
    rw [ite_eq_left hx]
    exact Nat.zero_le i.val
  · have hmin : ∀ x, min (mu.weight H₀ x) (0 : ℝ) = 0 :=
      fun x => min_eq_right (mu.nonneg H₀ x)
    simp only [truncatedExcess, hmin, zero_mul, Finset.sum_const_zero, mul_zero, le_refl]

theorem reset_boundedFeasible (mu : MassFamily F) (a : Coloring α s) (H₀ : ↥F) :
    BoundedFeasible mu a H₀ (reset a H₀) :=
  ⟨⟨reset_earlier a H₀, H₀, reset_feasibleFor mu a H₀⟩, changes_reset_subset a H₀⟩

/-- A minimum exists for every member, without restricting its witness. -/
theorem exists_isMinimalMove (mu : MassFamily F) (a : Coloring α s) (H₀ : ↥F) :
    ∃ z, IsMinimalMove mu a H₀ z := by
  classical
  let P : ℕ → Prop := fun k =>
    ∃ z : Coloring α s, BoundedFeasible mu a H₀ z ∧ movement a z = k
  have hex : ∃ k, P k :=
    ⟨movement a (reset a H₀), reset a H₀, reset_boundedFeasible mu a H₀, rfl⟩
  obtain ⟨z, hz, hcost⟩ := Nat.find_spec hex
  refine ⟨z, hz, ?_⟩
  intro w hw
  rw [hcost]
  exact Nat.find_min' hex ⟨w, hw, rfl⟩

theorem Selected.feasible {mu : MassFamily F} {a z : Coloring α s}
    (hz : Selected mu a z) : Feasible mu a z := by
  obtain ⟨H₀, hz⟩ := hz
  exact hz.1.1

theorem Selected.earlier {mu : MassFamily F} {a z : Coloring α s}
    (hz : Selected mu a z) : Earlier a z := hz.feasible.1

@[simp] theorem mem_selectedMoves {mu : MassFamily F} {a z : Coloring α s} :
    z ∈ selectedMoves mu a ↔ Selected mu a z := by
  classical
  simp [selectedMoves]

/-- Remove duplicate changed sets only when forming the containment cover. -/
def selectedChanges (mu : MassFamily F) (a : Coloring α s) : Family α := by
  classical
  exact (selectedMoves mu a).image (changes a)

theorem selectedChanges_covers (mu : MassFamily F) (a : Coloring α s) :
    Covers (selectedChanges mu a) F := by
  classical
  intro H hH
  obtain ⟨z, hz⟩ := exists_isMinimalMove mu a ⟨H, hH⟩
  refine ⟨changes a z, ?_, hz.1.2⟩
  exact Finset.mem_image.mpr
    ⟨z, mem_selectedMoves.mpr ⟨⟨H, hH⟩, hz⟩, rfl⟩

/-- The sum over selected colorings dominates the cost with duplicates removed. -/
theorem half_lt_selectedMoves_cost (mu : MassFamily F) (a : Coloring α s)
    {p : ℝ} (hp : 0 ≤ p) (hF : ¬ Small p F) :
    (1 / 2 : ℝ) < ∑ z ∈ selectedMoves mu a, p ^ (changes a z).card := by
  classical
  exact (cost_gt_of_not_small hF (selectedChanges_covers mu a)).trans_le
    (cost_image_le hp (selectedMoves mu a) (changes a))

omit [DecidableEq α] in
/-- An earlier move with no changed vertex is the unchanged coloring. -/
theorem eq_of_changes_eq_empty {a z : Coloring α s} (hz : Earlier a z)
    (hempty : changes a z = ∅) : z = a := by
  funext x
  apply le_antisymm (hz x)
  apply le_of_not_gt
  intro hlt
  have hx : x ∈ changes a z := Finset.mem_filter.mpr ⟨Finset.mem_univ x, hlt⟩
  rw [hempty] at hx
  exact Finset.notMem_empty x hx

/-- Restoring weights increases the excess: only heavy points change, and
their coefficient is the nonnegative value `d`. -/
theorem truncatedExcess_le_original (w : α → ℝ) (A : Finset α) (d u : ℝ)
    (hd : 0 ≤ d) (hheavy : ∀ x, u < w x → x ∈ A) :
    truncatedExcess w A d u ≤
      ∑ x, w x * ((if x ∈ A then 1 else 0) - (1 - d)) := by
  classical
  unfold truncatedExcess
  apply Finset.sum_le_sum
  intro x _
  by_cases hx : x ∈ A
  · have hcoef : ((if x ∈ A then (1 : ℝ) else 0) - (1 - d)) = d := by
      rw [ite_eq_left hx]
      ring
    rw [hcoef]
    exact mul_le_mul_of_nonneg_right (min_le_left (w x) u) hd
  · have hxu : w x ≤ u := le_of_not_gt (fun h => hx (hheavy x h))
    rw [min_eq_left hxu]

theorem originalExcess_eq_mass_sub (w : α → ℝ) (A : Finset α) (d : ℝ)
    (htotal : ∑ x, w x = 1) :
    (∑ x, w x * ((if x ∈ A then 1 else 0) - (1 - d))) =
      (∑ x ∈ A, w x) - (1 - d) := by
  classical
  calc
    (∑ x, w x * ((if x ∈ A then 1 else 0) - (1 - d))) =
        (∑ x, if x ∈ A then w x else 0) - (∑ x, w x) * (1 - d) := by
      rw [Finset.sum_mul, ← Finset.sum_sub_distrib]
      apply Finset.sum_congr rfl
      intro x _
      split_ifs <;> ring
    _ = (∑ x ∈ A, w x) - (1 - d) := by
      rw [Finset.sum_ite_mem_eq, htotal, one_mul]

/-- The actual feasibility witness is chosen once, before the scale index. -/
theorem captured_of_feasible_self {mu : MassFamily F} {a : Coloring α s}
    (h : Feasible mu a a) : Captured mu a := by
  classical
  obtain ⟨H, hH⟩ := h.2
  refine ⟨H, ?_⟩
  intro i
  obtain ⟨u, hu⟩ := hH i
  have htest : 0 ≤ truncatedExcess (mu.weight H) (prefixSet a i) (dscale i) u := by
    simpa [crossings] using hu.2.2.2
  have hfull : 0 ≤ (∑ x ∈ prefixSet a i, mu.weight H x) - (1 - dscale i) := by
    calc
      0 ≤ truncatedExcess (mu.weight H) (prefixSet a i) (dscale i) u := htest
      _ ≤ ∑ x, mu.weight H x *
          ((if x ∈ prefixSet a i then 1 else 0) - (1 - dscale i)) :=
        truncatedExcess_le_original (mu.weight H) (prefixSet a i) (dscale i) u
          (dscale_nonneg i) hu.2.2.1
      _ = (∑ x ∈ prefixSet a i, mu.weight H x) - (1 - dscale i) :=
        originalExcess_eq_mass_sub (mu.weight H) (prefixSet a i) (dscale i) (mu.total H)
  exact sub_nonneg.mp hfull

theorem Selected.changes_nonempty {mu : MassFamily F} {a z : Coloring α s}
    (hz : Selected mu a z) (ha : Bad mu a) : (changes a z).Nonempty := by
  apply Finset.nonempty_iff_ne_empty.mpr
  intro hempty
  have hza : z = a := eq_of_changes_eq_empty hz.earlier hempty
  have hself : Feasible mu a a := by simpa only [hza] using hz.feasible
  exact ha (captured_of_feasible_self hself)

end TalagrandThreshold.Selector

end

end OAI