import OAI.Combinatorics.DiscreteConvexity.CoveringBasic
import OAI.Combinatorics.DiscreteConvexity.CoveringBinomialBounds
import Mathlib.Combinatorics.Enumerative.DoubleCounting

namespace OAI

/-!
# Weighted-degree regularization

The initial family is the actual family of high weighted-degree subsets.
Double counting bounds its cost. An edge surviving this deletion has bounded
weighted degree at every one of its subsets. Grouping surviving edges by their
intersection with `B` gives the extension estimates used for pair sampling and
for residual tuples. No regularity property is assumed separately.
-/

namespace TalagrandDiscreteConvexity.Covering

open scoped BigOperators

variable {V : Type*} [Fintype V] [DecidableEq V]

/-- Count incidences between edges and subsets of cardinality at most `r`. -/
theorem incidence_count (H : Family V) (r : ℕ)
    (hH : ∀ e ∈ H, e.card = r) :
    (∑ I ∈ Finset.univ.filter (fun I : Finset V => I.card ≤ r),
      (H.filter (fun e => I ⊆ e)).card) = H.card * 2 ^ r := by
  classical
  let K : Finset (Finset V) := Finset.univ.filter (fun I => I.card ≤ r)
  have hbelow (e : Finset V) (he : e ∈ H) :
      K.filter (fun I => I ⊆ e) = e.powerset := by
    apply Finset.ext
    intro I
    simp only [K, Finset.mem_filter, Finset.mem_univ, true_and, Finset.mem_powerset]
    constructor
    · exact fun h => h.2
    · intro hIe
      exact ⟨(Finset.card_le_card hIe).trans_eq (hH e he), hIe⟩
  calc
    (∑ I ∈ K, (H.filter (fun e => I ⊆ e)).card) =
        ∑ e ∈ H, (K.filter (fun I => I ⊆ e)).card := by
      exact Finset.sum_card_bipartiteAbove_eq_sum_card_bipartiteBelow
        (fun I e : Finset V => I ⊆ e)
    _ = ∑ _e ∈ H, 2 ^ r := by
      apply Finset.sum_congr rfl
      intro e he
      rw [hbelow e he, Finset.card_powerset, hH e he]
    _ = H.card * 2 ^ r := by simp

omit [Fintype V] in
theorem weightedDegree_nonneg {H : Family V} {rho : ℝ} {r : ℕ} {I : Finset V}
    (hρ : 0 ≤ rho) : 0 ≤ weightedDegree H rho r I := by
  classical
  exact mul_nonneg (Nat.cast_nonneg _) (pow_nonneg hρ _)

/-- The weighted incidence identity is valid even at `rho = 0`. -/
theorem weighted_incidence_count (H : Family V) (rho : ℝ) (r : ℕ)
    (hH : ∀ e ∈ H, e.card = r) :
    (∑ I ∈ Finset.univ.filter (fun I : Finset V => I.card ≤ r),
      weightedDegree H rho r I * rho ^ I.card) =
      (2 : ℝ) ^ r * (H.card : ℝ) * rho ^ r := by
  classical
  let K : Finset (Finset V) := Finset.univ.filter (fun I => I.card ≤ r)
  have hcast : (∑ I ∈ K, ((H.filter (fun e => I ⊆ e)).card : ℝ)) =
      (H.card : ℝ) * (2 : ℝ) ^ r := by
    simpa only [Nat.cast_sum, Nat.cast_mul, Nat.cast_pow, Nat.cast_ofNat] using
      congrArg (fun n : ℕ => (n : ℝ)) (incidence_count H r hH)
  calc
    (∑ I ∈ K, weightedDegree H rho r I * rho ^ I.card) =
        (∑ I ∈ K, ((H.filter (fun e => I ⊆ e)).card : ℝ)) * rho ^ r := by
      rw [Finset.sum_mul]
      apply Finset.sum_congr rfl
      intro I hI
      have hIr : I.card ≤ r := (Finset.mem_filter.mp hI).2
      rw [weightedDegree, mul_assoc, ← pow_add, Nat.sub_add_cancel hIr]
    _ = ((H.card : ℝ) * (2 : ℝ) ^ r) * rho ^ r := by rw [hcast]
    _ = (2 : ℝ) ^ r * (H.card : ℝ) * rho ^ r := by
      rw [mul_comm (H.card : ℝ) ((2 : ℝ) ^ r)]

/-- The initial generators cost at most their weighted-incidence budget divided
by the high-degree threshold. -/
theorem initial_cost_le {H : Family V} {rho T : ℝ} {r : ℕ}
    (hρ : 0 ≤ rho) (hT : 0 < T) (hH : ∀ e ∈ H, e.card = r) :
    cost rho (initialFamily H rho r T) ≤
      T⁻¹ * (2 : ℝ) ^ r * (H.card : ℝ) * rho ^ r := by
  classical
  let K : Finset (Finset V) := Finset.univ.filter (fun I => I.card ≤ r)
  have hsub : initialFamily H rho r T ⊆ K := by
    intro I hI
    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, (mem_initialFamily.mp hI).1⟩
  have hbudget : T * cost rho (initialFamily H rho r T) ≤
      (2 : ℝ) ^ r * (H.card : ℝ) * rho ^ r := by
    calc
      T * cost rho (initialFamily H rho r T) =
          ∑ I ∈ initialFamily H rho r T, T * rho ^ I.card := by
        rw [cost, Finset.mul_sum]
      _ ≤ ∑ I ∈ initialFamily H rho r T,
          weightedDegree H rho r I * rho ^ I.card := by
        apply Finset.sum_le_sum
        intro I hI
        exact mul_le_mul_of_nonneg_right (mem_initialFamily.mp hI).2.le
          (pow_nonneg hρ _)
      _ ≤ ∑ I ∈ K, weightedDegree H rho r I * rho ^ I.card := by
        apply Finset.sum_le_sum_of_subset_of_nonneg hsub
        intro I _ _
        exact mul_nonneg (weightedDegree_nonneg hρ) (pow_nonneg hρ _)
      _ = (2 : ℝ) ^ r * (H.card : ℝ) * rho ^ r :=
        weighted_incidence_count H rho r hH
  calc
    cost rho (initialFamily H rho r T) ≤
        ((2 : ℝ) ^ r * (H.card : ℝ) * rho ^ r) / T := by
      apply (le_div_iff₀ hT).mpr
      simpa only [mul_comm] using hbudget
    _ = T⁻¹ * (2 : ℝ) ^ r * (H.card : ℝ) * rho ^ r := by
      rw [div_eq_mul_inv]
      ac_rfl

/-- Actual survival implies the weighted-degree bound at every subset of the
surviving edge. -/
theorem regular_weightedDegree_le {H : Family V} {rho T : ℝ} {r : ℕ}
    (hH : ∀ e ∈ H, e.card = r) {e I : Finset V}
    (he : e ∈ regularEdges H rho r T) (hIe : I ⊆ e) :
    weightedDegree H rho r I ≤ T := by
  have heH : e ∈ H := (mem_regularEdges.mp he).1
  have hIr : I.card ≤ r := (Finset.card_le_card hIe).trans_eq (hH e heH)
  apply le_of_not_gt
  intro hlarge
  exact (mem_regularEdges.mp he).2 I (mem_initialFamily.mpr ⟨hIr, hlarge⟩) hIe

/-- Each nonempty intersection class contributes at most `T`, and the empty
classes contribute zero. -/
private theorem regular_intersection_sum_le {H : Family V} {rho T : ℝ} {r : ℕ}
    (hρ : 0 ≤ rho) (hT : 0 ≤ T) (hH : ∀ e ∈ H, e.card = r)
    (B I : Finset V) :
    (∑ e ∈ (regularEdges H rho r T).filter (fun e => e ∩ B = I),
      rho ^ (e \ B).card) ≤ T := by
  classical
  let F := (regularEdges H rho r T).filter (fun e => e ∩ B = I)
  by_cases hne : F.Nonempty
  · obtain ⟨e₀, he₀⟩ := hne
    have he₀reg := (Finset.mem_filter.mp he₀).1
    have he₀I : e₀ ∩ B = I := (Finset.mem_filter.mp he₀).2
    have hIe₀ : I ⊆ e₀ := by rw [← he₀I]; exact Finset.inter_subset_left
    have hdegree := regular_weightedDegree_le hH he₀reg hIe₀
    have hsub : F ⊆ H.filter (fun e => I ⊆ e) := by
      intro e he
      obtain ⟨hereg, heI⟩ := Finset.mem_filter.mp he
      refine Finset.mem_filter.mpr ⟨(mem_regularEdges.mp hereg).1, ?_⟩
      rw [← heI]
      exact Finset.inter_subset_left
    have hcards : (F.card : ℝ) ≤ ((H.filter (fun e => I ⊆ e)).card : ℝ) :=
      Nat.cast_le.mpr (Finset.card_le_card hsub)
    calc
      (∑ e ∈ F, rho ^ (e \ B).card) = (F.card : ℝ) * rho ^ (r - I.card) := by
        calc
          (∑ e ∈ F, rho ^ (e \ B).card) = ∑ _e ∈ F, rho ^ (r - I.card) := by
            apply Finset.sum_congr rfl
            intro e he
            obtain ⟨hereg, heI⟩ := Finset.mem_filter.mp he
            have hecard := hH e (mem_regularEdges.mp hereg).1
            have hpartition := Finset.card_sdiff_add_card_inter e B
            rw [heI, hecard] at hpartition
            have hdiff : (e \ B).card = r - I.card := by omega
            rw [hdiff]
          _ = (F.card : ℝ) * rho ^ (r - I.card) := by simp
      _ ≤ weightedDegree H rho r I :=
        mul_le_mul_of_nonneg_right hcards (pow_nonneg hρ _)
      _ ≤ T := hdegree
  · have hF : F = ∅ := Finset.not_nonempty_iff_eq_empty.mp hne
    change (∑ e ∈ F, rho ^ (e \ B).card) ≤ T
    rw [hF, Finset.sum_empty]
    exact hT

/-- Extension cost for actual regular edges, with the exact number of possible
intersections with `B`. -/
theorem regular_extension_le_card {H : Family V} {rho T : ℝ} {r : ℕ}
    (hρ : 0 ≤ rho) (hT : 0 ≤ T) (hH : ∀ e ∈ H, e.card = r) (B : Finset V) :
    (∑ e ∈ regularEdges H rho r T, rho ^ (e \ B).card) ≤
      T * ((B.powerset.filter (fun I => I.card ≤ r)).card : ℝ) := by
  classical
  let D := B.powerset.filter (fun I => I.card ≤ r)
  have hmap : ∀ e ∈ regularEdges H rho r T, e ∩ B ∈ D := by
    intro e he
    refine Finset.mem_filter.mpr ⟨Finset.mem_powerset.mpr Finset.inter_subset_right, ?_⟩
    exact (Finset.card_le_card Finset.inter_subset_left).trans_eq
      (hH e (mem_regularEdges.mp he).1)
  calc
    (∑ e ∈ regularEdges H rho r T, rho ^ (e \ B).card) =
        ∑ I ∈ D, ∑ e ∈ (regularEdges H rho r T).filter (fun e => e ∩ B = I),
          rho ^ (e \ B).card :=
      (Finset.sum_fiberwise_of_maps_to hmap (fun e => rho ^ (e \ B).card)).symm
    _ ≤ ∑ _I ∈ D, T := by
      apply Finset.sum_le_sum
      intro I _
      exact regular_intersection_sum_le hρ hT hH B I
    _ = T * (D.card : ℝ) := by simp [mul_comm]

/-- The exact binomial extension bound from the covering lemma. -/
theorem regular_extension_le_choose {H : Family V} {rho T : ℝ} {r : ℕ}
    (hρ : 0 ≤ rho) (hT : 0 ≤ T) (hH : ∀ e ∈ H, e.card = r) (B : Finset V) :
    (∑ e ∈ regularEdges H rho r T, rho ^ (e \ B).card) ≤
      T * (∑ i ∈ Finset.range (r + 1), (Nat.choose B.card i : ℝ)) := by
  calc
    _ ≤ T * ((B.powerset.filter (fun I => I.card ≤ r)).card : ℝ) :=
      regular_extension_le_card hρ hT hH B
    _ = _ := by rw [card_subsets_card_le, Nat.cast_sum]

/-- The polynomial version used for extending a residual tuple prefix. -/
theorem regular_extension_le_pow {H : Family V} {rho T : ℝ} {r : ℕ}
    (hρ : 0 ≤ rho) (hT : 0 ≤ T) (hH : ∀ e ∈ H, e.card = r) (B : Finset V) :
    (∑ e ∈ regularEdges H rho r T, rho ^ (e \ B).card) ≤
      T * (1 + (B.card : ℝ)) ^ r := by
  have hc : ((B.powerset.filter (fun I => I.card ≤ r)).card : ℝ) ≤
      (((1 + B.card) ^ r : ℕ) : ℝ) :=
    Nat.cast_le.mpr (card_subsets_card_le_pow B r)
  have hc' : ((B.powerset.filter (fun I => I.card ≤ r)).card : ℝ) ≤
      (1 + (B.card : ℝ)) ^ r := by
    simpa only [Nat.cast_pow, Nat.cast_add, Nat.cast_one] using hc
  exact (regular_extension_le_card hρ hT hH B).trans (mul_le_mul_of_nonneg_left hc' hT)

/-- An `r`-element prefix gives the sharper factor `2^r`, used for pairs. -/
theorem regular_extension_le_two_pow {H : Family V} {rho T : ℝ} {r : ℕ}
    (hρ : 0 ≤ rho) (hT : 0 ≤ T) (hH : ∀ e ∈ H, e.card = r)
    {B : Finset V} (hB : B.card = r) :
    (∑ e ∈ regularEdges H rho r T, rho ^ (e \ B).card) ≤ (2 : ℝ) ^ r * T := by
  have h := regular_extension_le_choose hρ hT hH B
  rw [hB, ← Nat.cast_sum, Nat.sum_range_choose, Nat.cast_pow, Nat.cast_ofNat] at h
  simpa only [mul_comm] using h

end TalagrandDiscreteConvexity.Covering

end OAI