import Std

namespace OAI

section

namespace UniqueGamesTheorem.Reduction.WeightRounding

def floorMass (D q : Nat) (ps : List Nat) : Nat :=
  (ps.map (fun p => D * p / q)).sum

/-- Increment the first `r` floors, in the original occurrence order. -/
def roundCounts (D q : Nat) : Nat → List Nat → List Nat
  | _, [] => []
  | 0, p :: ps => (D * p / q) :: roundCounts D q 0 ps
  | r + 1, p :: ps => (D * p / q + 1) :: roundCounts D q r ps

def deficit (D q : Nat) (ps : List Nat) : Nat := D - floorMass D q ps

def rounded (D q : Nat) (ps : List Nat) : List Nat :=
  roundCounts D q (deficit D q ps) ps

theorem length_roundCounts (D q r : Nat) (ps : List Nat) :
    (roundCounts D q r ps).length = ps.length := by
  induction ps generalizing r with
  | nil => simp [roundCounts]
  | cons p ps ih => cases r <;> simp [roundCounts, ih]

theorem sum_roundCounts (D q r : Nat) (ps : List Nat) (hr : r ≤ ps.length) :
    (roundCounts D q r ps).sum = floorMass D q ps + r := by
  induction ps generalizing r with
  | nil =>
    have : r = 0 := by simpa using hr
    subst r
    simp [roundCounts, floorMass]
  | cons p ps ih =>
    cases r with
    | zero => simp [roundCounts, floorMass, ih 0 (Nat.zero_le _)]
    | succ r =>
      have hr' : r ≤ ps.length := by simpa using hr
      simp only [roundCounts, List.sum_cons, ih r hr', floorMass,
        List.map_cons, List.sum_cons]
      omega

theorem floorMass_mul_le (D q : Nat) (ps : List Nat) :
    floorMass D q ps * q ≤ D * ps.sum := by
  induction ps with
  | nil => simp [floorMass]
  | cons p ps ih =>
    have hp := Nat.div_mul_le_self (D * p) q
    simp only [floorMass, List.map_cons, List.sum_cons, Nat.add_mul,
      Nat.mul_add] at *
    omega

theorem scaled_sum_lt (D q : Nat) (ps : List Nat) (hq : 0 < q)
    (hne : ps ≠ []) :
    D * ps.sum < (floorMass D q ps + ps.length) * q := by
  induction ps with
  | nil => contradiction
  | cons p ps ih =>
    have hp : D * p < (D * p / q + 1) * q :=
      (Nat.div_lt_iff_lt_mul hq).mp (Nat.lt_succ_self _)
    cases ps with
    | nil => simpa [floorMass] using hp
    | cons t ts =>
      have ht := ih (by simp)
      simp only [floorMass, List.map_cons, List.sum_cons, List.length_cons,
        Nat.add_mul, Nat.mul_add, Nat.one_mul] at *
      omega

theorem floorMass_le_target (D q : Nat) (ps : List Nat) (hq : 0 < q)
    (hmass : ps.sum = q) : floorMass D q ps ≤ D := by
  apply Nat.le_of_mul_le_mul_right (c := q) _ hq
  simpa [hmass] using floorMass_mul_le D q ps

theorem deficit_lt_length (D q : Nat) (ps : List Nat) (hq : 0 < q)
    (hmass : ps.sum = q) : deficit D q ps < ps.length := by
  have hne : ps ≠ [] := by intro h; subst ps; simp at hmass; omega
  have hlt := scaled_sum_lt D q ps hq hne
  rw [hmass] at hlt
  have ht := Nat.lt_of_mul_lt_mul_right hlt
  have hlo := floorMass_le_target D q ps hq hmass
  unfold deficit
  omega

/-- Equation (4.7), total mass: the output has exactly the chosen denominator. -/
theorem sum_rounded (D q : Nat) (ps : List Nat) (hq : 0 < q)
    (hmass : ps.sum = q) : (rounded D q ps).sum = D := by
  have hr := deficit_lt_length D q ps hq hmass
  have hl := floorMass_le_target D q ps hq hmass
  rw [rounded, sum_roundCounts D q _ ps (Nat.le_of_lt hr)]
  unfold deficit
  omega

/-- Sum only the positions selected by an arbitrary predicate. -/
def selectedSum : List Nat → (Nat → Bool) → Nat
  | [], _ => 0
  | p :: ps, keep => (if keep 0 then p else 0) +
      selectedSum ps (fun i => keep (i + 1))

/-- The two inequalities encode `|nᵢ − D pᵢ/q| ≤ 1`. -/
theorem floor_entry_bounds (D q p : Nat) (hq : 0 < q) (b : Bool) :
    let n := D * p / q + if b then 1 else 0
    n * q ≤ D * p + q ∧ D * p ≤ n * q + q := by
  have hlo := Nat.div_mul_le_self (D * p) q
  have hhi : D * p < (D * p / q + 1) * q :=
    (Nat.div_lt_iff_lt_mul hq).mp (Nat.lt_succ_self _)
  cases b <;> simp only [Bool.false_eq_true, ↓reduceIte,
    Nat.add_zero, Nat.add_mul, Nat.one_mul] at * <;> omega

/-- Equation (4.8) for every selection of occurrences, before dividing by `Dq`.
    The selection can be the equations satisfied by any particular assignment. -/
theorem selected_roundCounts_error (D q r : Nat) (ps : List Nat)
    (keep : Nat → Bool) (hq : 0 < q) :
    selectedSum (roundCounts D q r ps) keep * q ≤
        D * selectedSum ps keep + ps.length * q ∧
    D * selectedSum ps keep ≤
        selectedSum (roundCounts D q r ps) keep * q + ps.length * q := by
  induction ps generalizing r keep with
  | nil => simp [roundCounts, selectedSum]
  | cons p ps ih =>
    cases r with
    | zero =>
      have hi := ih 0 (fun i => keep (i + 1))
      have hp := floor_entry_bounds D q p hq false
      cases hk : keep 0 <;>
        simp only [roundCounts, selectedSum, hk, Bool.false_eq_true, ↓reduceIte,
          Nat.add_zero, Nat.zero_add, List.length_cons,
          Nat.add_mul, Nat.mul_add, Nat.one_mul] at * <;> omega
    | succ r =>
      have hi := ih r (fun i => keep (i + 1))
      have hp := floor_entry_bounds D q p hq true
      cases hk : keep 0 <;>
        simp only [roundCounts, selectedSum, hk, Bool.false_eq_true, ↓reduceIte,
          Nat.zero_add, List.length_cons,
          Nat.add_mul, Nat.mul_add, Nat.one_mul] at * <;> omega

theorem selected_rounded_error (D q : Nat) (ps : List Nat)
    (keep : Nat → Bool) (hq : 0 < q) :
    selectedSum (rounded D q ps) keep * q ≤
        D * selectedSum ps keep + ps.length * q ∧
    D * selectedSum ps keep ≤
        selectedSum (rounded D q ps) keep * q + ps.length * q :=
  selected_roundCounts_error D q _ ps keep hq

def replicateOccurrences {α : Type} : List (α × Nat) → List α
  | [] => []
  | (e, n) :: rest => List.replicate n e ++ replicateOccurrences rest

theorem length_replicateOccurrences {α : Type} (es : List (α × Nat)) :
    (replicateOccurrences es).length = (es.map Prod.snd).sum := by
  induction es with
  | nil => simp [replicateOccurrences]
  | cons en es ih =>
    rcases en with ⟨e, n⟩
    simp [replicateOccurrences, ih]

/-- Output occurrence indices; each integer count gives that many separate copies. -/
def copyIndices : List Nat → List Nat
  | [] => []
  | n :: ns => List.replicate n 0 ++ (copyIndices ns).map Nat.succ

theorem length_copyIndices (ns : List Nat) : (copyIndices ns).length = ns.sum := by
  induction ns with
  | nil => simp [copyIndices]
  | cons n ns ih => simp [copyIndices, ih]

theorem mem_copyIndices_lt (ns : List Nat) (i : Nat) (hi : i ∈ copyIndices ns) :
    i < ns.length := by
  induction ns generalizing i with
  | nil => simp [copyIndices] at hi
  | cons n ns ih =>
    simp only [copyIndices, List.mem_append] at hi
    rcases hi with hi | hi
    · have hz := List.eq_of_mem_replicate hi
      subst i
      simp
    · rcases List.mem_map.mp hi with ⟨j, hj, rfl⟩
      have hj' := ih j hj
      simp only [List.length_cons]
      omega

/-- Copying occurrences preserves the satisfaction test for every assignment. -/
theorem count_copyIndices (ns : List Nat) (keep : Nat → Bool) :
    ((copyIndices ns).filter keep).length = selectedSum ns keep := by
  induction ns generalizing keep with
  | nil => simp [copyIndices, selectedSum]
  | cons n ns ih =>
    simp only [copyIndices, List.filter_append, List.length_append,
      List.filter_map, List.length_map, ih]
    cases hk : keep 0 <;> simp [hk, selectedSum, Function.comp_def]

def uniformSource (D q : Nat) (ps : List Nat) : List Nat := copyIndices (rounded D q ps)

theorem uniformSource_indices_lt (D q : Nat) (ps : List Nat) (i : Nat)
    (hi : i ∈ uniformSource D q ps) : i < ps.length := by
  have h := mem_copyIndices_lt (rounded D q ps) i hi
  simpa only [rounded, length_roundCounts] using h

theorem length_uniformSource (D q : Nat) (ps : List Nat) (hq : 0 < q)
    (hmass : ps.sum = q) : (uniformSource D q ps).length = D := by
  rw [uniformSource, length_copyIndices, sum_rounded D q ps hq hmass]

theorem uniformSource_nonempty (D q : Nat) (ps : List Nat) (hD : 0 < D)
    (hq : 0 < q) (hmass : ps.sum = q) : uniformSource D q ps ≠ [] := by
  intro h
  have hl := length_uniformSource D q ps hq hmass
  rw [h] at hl
  simp at hl
  omega

/-- Full occurrence-list form of (4.8), quantified over all satisfaction tests. -/
theorem uniformSource_error (D q : Nat) (ps : List Nat)
    (keep : Nat → Bool) (hq : 0 < q) :
    ((uniformSource D q ps).filter keep).length * q ≤
        D * selectedSum ps keep + ps.length * q ∧
    D * selectedSum ps keep ≤
        ((uniformSource D q ps).filter keep).length * q + ps.length * q := by
  simpa only [uniformSource, count_copyIndices] using selected_rounded_error D q ps keep hq

/-- Integer ceiling; valid for positive `a`. -/
def ceilQuotient (n a : Nat) : Nat := (n + a - 1) / a

theorem le_ceilQuotient_mul (n a : Nat) (ha : 0 < a) :
    n ≤ ceilQuotient n a * a := by
  have he := Nat.mod_add_div (n + a - 1) a
  have hr := Nat.mod_lt (n + a - 1) ha
  unfold ceilQuotient
  rw [Nat.mul_comm a] at he
  omega

theorem ceilQuotient_le (n a : Nat) (ha : 0 < a) : ceilQuotient n a ≤ n := by
  have hm : n ≤ n * a := by
    simpa using Nat.mul_le_mul_left n ha
  unfold ceilQuotient
  apply (Nat.div_le_iff_le_mul ha).mpr
  omega

def targetDenominator (m a b : Nat) : Nat := ceilQuotient (4 * m * b) a

/-- Cross-multiplied statement `m / D ≤ γ₀ / 4`. -/
theorem targetDenominator_error_budget (m a b : Nat) (ha : 0 < a) :
    4 * m * b ≤ targetDenominator m a b * a :=
  le_ceilQuotient_mul _ a ha

/-- At fixed rational `γ₀`, the number of output occurrences is linear in `m`.
    This is an output-size bound, not a machine-model complexity theorem. -/
theorem targetDenominator_size (m a b : Nat) (ha : 0 < a) :
    targetDenominator m a b ≤ 4 * b * m := by
  have h := ceilQuotient_le (4 * m * b) a ha
  simpa [targetDenominator, Nat.mul_assoc, Nat.mul_comm, Nat.mul_left_comm] using h

theorem targetDenominator_positive (m a b : Nat) (hm : 0 < m)
    (ha : 0 < a) (hb : 0 < b) : 0 < targetDenominator m a b := by
  have h := targetDenominator_error_budget m a b ha
  have hp : 0 < 4 * m * b := Nat.mul_pos (Nat.mul_pos (by decide) hm) hb
  by_cases hz : targetDenominator m a b = 0
  · rw [hz] at h
    simp at h
    omega
  · omega

end UniqueGamesTheorem.Reduction.WeightRounding

end

end OAI