import Mathlib.Data.Finset.Card
import Mathlib.Data.Finset.Max
import Mathlib.Data.Int.Interval
import Mathlib.Algebra.BigOperators.Group.Finset.Basic
import Mathlib.Tactic.Linarith
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Set.Pairwise.Basic

namespace OAI

namespace FiniteFactor
open Finset

/-- Finite greedy packing, with the precise loss supplied by forbidden neighbors. -/
theorem finite_greedy_packing {α : Type*} [DecidableEq α] (bad : α → α → Prop)
    [DecidableRel bad] (symm : ∀ a b, bad a b → bad b a)
    (refl : ∀ a, bad a a) (S : Finset α) (D : ℕ)
    (bound : ∀ a ∈ S, (S.filter (bad a)).card ≤ D) :
    ∃ N ⊆ S, (N : Set α).Pairwise (fun a b => ¬bad a b) ∧ S.card ≤ D*N.card := by
  classical
  induction S using Finset.strongInductionOn with
  | _ S ih =>
    by_cases hs : S = ∅
    · subst S; exact ⟨∅, by simp, by simp, by simp⟩
    obtain ⟨a, ha⟩ := Finset.nonempty_iff_ne_empty.mpr hs
    let T := S.filter (fun b => ¬bad a b)
    have hTa : a ∉ T := by simp [T, refl]
    have hTS : T ⊂ S := Finset.ssubset_iff_subset_ne.mpr
      ⟨filter_subset _ _, fun h => hTa (h.symm ▸ ha)⟩
    obtain ⟨N,hNT,hN,hcard⟩ := ih T hTS (fun b hb =>
      (card_le_card (filter_subset_filter _ (filter_subset _ _))).trans (bound b (mem_of_mem_filter b hb)))
    have haN : a ∉ N := fun h => hTa (hNT h)
    refine ⟨insert a N, insert_subset ha (hNT.trans (filter_subset _ _)), ?_, ?_⟩
    · rw [coe_insert, Set.pairwise_insert_of_notMem haN]
      refine ⟨hN, ?_⟩
      intro b hb
      constructor
      · exact (mem_filter.mp (hNT hb)).2
      · intro h; exact (mem_filter.mp (hNT hb)).2 (symm b a h)
    · have hsplit : (S.filter (bad a)).card + T.card = S.card := by
        exact card_filter_add_card_filter_not (s := S) (bad a)
      rw [card_insert_of_notMem haN]
      have := bound a ha
      rw [Nat.mul_add, Nat.mul_one]
      omega

/-- A fixed nonzero second frequency excludes at most 2R+1 integers. -/
theorem forbidden_frequency_card (S : Finset ℤ) (v v' n : ℤ) (R : ℕ) (hv' : v' ≠ 0) :
    (S.filter (fun n' => |v*n+v'*n'| ≤ (R : ℤ))).card ≤ 2*R+1 := by
  have h := card_le_card_of_injOn (fun n' : ℤ => v*n+v'*n')
    (s := S.filter (fun n' => |v*n+v'*n'| ≤ (R : ℤ)))
    (t := Finset.Icc (-(R : ℤ)) (R : ℤ))
    (fun n' hn' => Finset.mem_Icc.mpr (abs_le.mp (mem_filter.mp hn').2))
    (fun a _ b _ he => mul_left_cancel₀ hv' (add_left_cancel he))
  have hc : (Finset.Icc (-(R : ℤ)) (R : ℤ)).card = 2*R+1 := by
    rw [Int.card_Icc]
    omega
  exact h.trans_eq hc

/-- Failure of the full symmetric bounded-frequency separation condition. -/
def SamplingConflict (H R : ℕ) (n n' : ℤ) : Prop :=
  ∃ v ∈ Finset.Icc (-(H : ℤ)) (H : ℤ),
    ∃ v' ∈ Finset.Icc (-(H : ℤ)) (H : ℤ),
      (v ≠ 0 ∨ v' ≠ 0) ∧ |v*n+v'*n'| ≤ (R : ℤ)

instance (H R : ℕ) : DecidableRel (SamplingConflict H R) := fun _ _ =>
  inferInstanceAs (Decidable (∃ v ∈ Finset.Icc (-(H : ℤ)) (H : ℤ),
    ∃ v' ∈ Finset.Icc (-(H : ℤ)) (H : ℤ), _))

theorem samplingConflict_symm (H R : ℕ) (n n' : ℤ) :
    SamplingConflict H R n n' → SamplingConflict H R n' n := by
  rintro ⟨v,hv,v',hv',hne,hb⟩
  exact ⟨v',hv',v,hv,hne.symm,by simpa [add_comm] using hb⟩

theorem samplingConflict_refl (H R : ℕ) (hH : 1 ≤ H) (n : ℤ) :
    SamplingConflict H R n n := by
  refine ⟨1, mem_Icc.mpr ?_, -1, mem_Icc.mpr ?_, Or.inl (by omega), ?_⟩
  · constructor <;> omega
  · constructor <;> omega
  · simp

/-- Total forbidden-neighbor count, with no unspecified asymptotic constant. -/
theorem samplingConflict_card (H R : ℕ) (S : Finset ℤ) (n : ℤ) (hn : (R : ℤ) < n) :
    (S.filter (SamplingConflict H R n)).card ≤ (2*H+1)^2*(2*R+1) := by
  let F := (Finset.Icc (-(H : ℤ)) (H : ℤ)).product
    ((Finset.Icc (-(H : ℤ)) (H : ℤ)).filter (fun v => v ≠ 0))
  let B := fun p : ℤ × ℤ => S.filter (fun n' => |p.1*n+p.2*n'| ≤ (R : ℤ))
  have hsub : S.filter (SamplingConflict H R n) ⊆ F.biUnion B := by
    intro n' hn'
    obtain ⟨hs,v,hv,v',hv',hne,hb⟩ := mem_filter.mp hn'
    have hv'0 : v' ≠ 0 := by
      intro he
      subst v'
      have hv0 := hne.resolve_right (by simp)
      have hv1 : 1 ≤ |v| := by have := abs_pos.mpr hv0; omega
      have hn0 : 0 ≤ n := by omega
      simp only [zero_mul, add_zero, abs_mul, abs_of_nonneg hn0] at hb
      nlinarith
    exact mem_biUnion.mpr ⟨(v,v'), mem_product.mpr ⟨hv,mem_filter.mpr ⟨hv',hv'0⟩⟩,
      mem_filter.mpr ⟨hs,hb⟩⟩
  have hF : F.card ≤ (2*H+1)^2 := by
    have hc : (Finset.Icc (-(H : ℤ)) (H : ℤ)).card = 2*H+1 := by
      rw [Int.card_Icc]; omega
    dsimp [F]
    rw [card_product]
    calc
      _ ≤ (Finset.Icc (-(H : ℤ)) (H : ℤ)).card ^ 2 := by
        rw [pow_two]
        exact Nat.mul_le_mul_left _ (card_filter_le _ _)
      _ = _ := by rw [hc]
  calc
    _ ≤ (F.biUnion B).card := card_le_card hsub
    _ ≤ ∑ p ∈ F, (B p).card := card_biUnion_le
    _ ≤ ∑ _p ∈ F, (2*R+1) := sum_le_sum fun p hp =>
      forbidden_frequency_card S p.1 p.2 n R (mem_filter.mp (mem_product.mp hp).2).2
    _ = F.card*(2*R+1) := by simp
    _ ≤ _ := Nat.mul_le_mul_right _ hF

/-- Deterministic selection from any positive integer interval above R. -/
theorem exists_sampling_separated (H R : ℕ) (hH : 1 ≤ H) (S : Finset ℤ)
    (hS : ∀ n ∈ S, (R : ℤ) < n) :
    ∃ N ⊆ S, (N : Set ℤ).Pairwise (fun n n' => ¬SamplingConflict H R n n') ∧
      S.card ≤ ((2*H+1)^2*(2*R+1))*N.card :=
  finite_greedy_packing (SamplingConflict H R) (samplingConflict_symm H R)
    (samplingConflict_refl H R hH) S _ (fun n hn => samplingConflict_card H R S n (hS n hn))

end FiniteFactor

end OAI