import OAI.Computability.MeanPayoff.Probability

namespace OAI

section
namespace MeanPayoff

abbrev Vec (V : Type) := V → ℤ

def shift {V : Type} (p : Vec V) (c : ℤ) : Vec V := fun i => p i + c

def clip {V : Type} (a b p : Vec V) : Vec V :=
  fun i => min (b i) (max (a i) (p i))

def InBox {V : Type} (a b p : Vec V) : Prop := a ≤ p ∧ p ≤ b

def Subsolution {V : Type} (F : Vec V → Vec V) (a b y : Vec V) : Prop :=
  InBox a b y ∧ ∀ i, a i < y i → y i ≤ F y i

def Supersolution {V : Type} (F : Vec V → Vec V) (a b z : Vec V) : Prop :=
  InBox a b z ∧ ∀ i, z i < b i → F z i ≤ z i

def subSupport {V : Type} (a y : Vec V) : Set V := {i | a i < y i}
def superSupport {V : Type} (b z : Vec V) : Set V := {i | z i < b i}

structure OperatorLaws {V : Type} (F : Vec V → Vec V) : Prop where
  mono : Monotone F
  translation : ∀ p c, F (shift p c) = shift (F p) c

def transformed (G : Game) (e : Fin G.m) : ℤ := (G.n + 1 : ℤ) * G.weight e + 1

def outgoing (G : Game) (v : Fin G.n) : Finset (Fin G.m) :=
  Finset.univ.filter (fun e => G.tail e = v)

theorem outgoing_nonempty (G : Game) (v : Fin G.n) : (outgoing G v).Nonempty := by
  obtain ⟨e, he⟩ := G.total v
  exact ⟨e, by simp [outgoing, he]⟩

def operator (G : Game) (p : Vec (Fin G.n)) : Vec (Fin G.n) := fun i =>
  if G.maxOwner i then
    (outgoing G i).sup' (outgoing_nonempty G i) (fun e => transformed G e + p (G.head e))
  else
    (outgoing G i).inf' (outgoing_nonempty G i) (fun e => transformed G e + p (G.head e))

theorem operator_laws (G : Game) : OperatorLaws (operator G) := by
  constructor
  · intro p q hpq i
    simp only [operator]
    split
    · apply (Finset.sup'_le_iff _ _).2
      intro e he
      exact le_trans (add_le_add_right (hpq (G.head e)) _)
        (Finset.le_sup' (fun e => transformed G e + q (G.head e)) he)
    · apply (Finset.le_inf'_iff _ _).2
      intro e he
      exact le_trans (Finset.inf'_le (fun e => transformed G e + p (G.head e)) he)
        (add_le_add_right (hpq (G.head e)) _)
  · intro p c
    funext i
    simp only [operator, shift]
    split
    · simpa only [add_assoc] using
        (Finset.sup'_add (outgoing G i)
          (fun e => transformed G e + p (G.head e)) c (outgoing_nonempty G i)).symm
    · obtain ⟨e, he, heq⟩ := Finset.exists_mem_eq_inf' (outgoing_nonempty G i)
        (fun e => transformed G e + p (G.head e))
      obtain ⟨f, hf, hfq⟩ := Finset.exists_mem_eq_inf' (outgoing_nonempty G i)
        (fun e => transformed G e + (p (G.head e) + c))
      have hlo := Finset.inf'_le (fun e => transformed G e + p (G.head e)) hf
      have hup := Finset.inf'_le (fun e => transformed G e + (p (G.head e) + c)) he
      rw [heq] at hlo ⊢
      rw [hfq] at hup ⊢
      omega

section Projections
variable {V : Type} {F : Vec V → Vec V}

theorem subsolution_raise_floor (laws : OperatorLaws F) {a b a' y : Vec V}
    (hy : Subsolution F a b y) (haa' : a ≤ a') (ha'b : a' ≤ b) :
    Subsolution F a' b (fun i => max (y i) (a' i)) ∧
    subSupport a' (fun i => max (y i) (a' i)) ⊆ subSupport a y := by
  refine ⟨⟨⟨?_, ?_⟩, ?_⟩, ?_⟩
  · intro i; exact le_max_right _ _
  · intro i; exact max_le (hy.1.2 i) (ha'b i)
  · intro i hi
    have hiy : a' i < y i := by simpa using hi
    have heq : max (y i) (a' i) = y i := max_eq_left (le_of_lt hiy)
    dsimp only
    rw [heq]
    exact le_trans (hy.2 i (lt_of_le_of_lt (haa' i) hiy))
      (laws.mono (fun j => le_max_left (y j) (a' j)) i)
  · intro i hi
    have hiy : a' i < y i := by simpa [subSupport] using hi
    exact lt_of_le_of_lt (haa' i) hiy

theorem supersolution_lower_ceiling (laws : OperatorLaws F) {a b b' z : Vec V}
    (hz : Supersolution F a b z) (hab' : a ≤ b') (hb'b : b' ≤ b) :
    Supersolution F a b' (fun i => min (z i) (b' i)) ∧
    superSupport b' (fun i => min (z i) (b' i)) ⊆ superSupport b z := by
  refine ⟨⟨⟨?_, ?_⟩, ?_⟩, ?_⟩
  · intro i; exact le_min (hz.1.1 i) (hab' i)
  · intro i; exact min_le_right _ _
  · intro i hi
    have hiz : z i < b' i := by simpa using hi
    have heq : min (z i) (b' i) = z i := min_eq_left (le_of_lt hiz)
    dsimp only
    rw [heq]
    exact le_trans (laws.mono (fun j => min_le_left (z j) (b' j)) i)
      (hz.2 i (lt_of_lt_of_le hiz (hb'b i)))
  · intro i hi
    have hiz : z i < b' i := by simpa [superSupport] using hi
    exact lt_of_lt_of_le hiz (hb'b i)

def centerSub (y q : Vec V) (d A : ℤ) : Vec V :=
  fun i => max (y i - d + A) (q i - A)

def centerSuper (z q : Vec V) (e A : ℤ) : Vec V :=
  fun i => min (z i + e - A) (q i + A)

theorem centerSub_support (y q : Vec V) (d A : ℤ) :
    subSupport (fun i => q i - A) (centerSub y q d A) =
      {i | d - 2 * A < y i - q i} := by
  ext i
  simp only [subSupport, centerSub, Set.mem_ofPred_eq, lt_max_iff, lt_self_iff_false,
    or_false]
  omega

theorem centerSuper_support (z q : Vec V) (e A : ℤ) :
    superSupport (fun i => q i + A) (centerSuper z q e A) =
      {i | e - 2 * A < q i - z i} := by
  ext i
  simp only [superSupport, centerSuper, Set.mem_ofPred_eq, min_lt_iff,
    lt_self_iff_false, or_false]
  omega

theorem centered_subsolution (laws : OperatorLaws F) {a b y q : Vec V} {d A : ℤ}
    (hy : Subsolution F a b y) (hq : InBox a b q)
    (hA : 0 < A) (hdev : ∀ i, y i - q i ≤ d) (hd : 2 * A ≤ d) :
    Subsolution F (fun i => q i - A) (fun i => q i + A) (centerSub y q d A) ∧
    subSupport (fun i => q i - A) (centerSub y q d A) ⊆ subSupport a y := by
  have hs : subSupport (fun i => q i - A) (centerSub y q d A) ⊆
      subSupport a y := by
    rw [centerSub_support]
    intro i hi
    have hqi : a i ≤ q i := hq.1 i
    change a i < y i
    change d - 2 * A < y i - q i at hi
    omega
  refine ⟨⟨⟨?_, ?_⟩, ?_⟩, hs⟩
  · intro i; exact le_max_right _ _
  · intro i
    change max (y i - d + A) (q i - A) ≤ q i + A
    apply max_le
    · have := hdev i; omega
    · omega
  · intro i hi
    have hiy : y i ≤ F y i := hy.2 i (hs hi)
    have hlarge : q i - A < y i - d + A := by
      simpa only [centerSub, lt_max_iff, lt_self_iff_false, or_false] using hi
    have heq : centerSub y q d A i = y i - d + A :=
      max_eq_left (le_of_lt hlarge)
    rw [heq]
    have hmono : F (shift y (-d + A)) i ≤ F (centerSub y q d A) i := by
      apply laws.mono
      intro j
      have := le_max_left (y j - d + A) (q j - A)
      simp [shift, centerSub, sub_eq_add_neg, add_assoc]
    rw [laws.translation] at hmono
    simp only [shift] at hmono
    omega

theorem centered_supersolution (laws : OperatorLaws F) {a b z q : Vec V} {e A : ℤ}
    (hz : Supersolution F a b z) (hq : InBox a b q)
    (hA : 0 < A) (hdev : ∀ i, q i - z i ≤ e) (he : 2 * A ≤ e) :
    Supersolution F (fun i => q i - A) (fun i => q i + A) (centerSuper z q e A) ∧
    superSupport (fun i => q i + A) (centerSuper z q e A) ⊆ superSupport b z := by
  have hs : superSupport (fun i => q i + A) (centerSuper z q e A) ⊆
      superSupport b z := by
    rw [centerSuper_support]
    intro i hi
    have hqi : q i ≤ b i := hq.2 i
    change z i < b i
    change e - 2 * A < q i - z i at hi
    omega
  refine ⟨⟨⟨?_, ?_⟩, ?_⟩, hs⟩
  · intro i
    change q i - A ≤ min (z i + e - A) (q i + A)
    apply le_min
    · have := hdev i; omega
    · omega
  · intro i; exact min_le_right _ _
  · intro i hi
    have hiz : F z i ≤ z i := hz.2 i (hs hi)
    have hsmall : z i + e - A < q i + A := by
      simpa only [centerSuper, min_lt_iff, lt_self_iff_false, or_false] using hi
    have heq : centerSuper z q e A i = z i + e - A :=
      min_eq_left (le_of_lt hsmall)
    rw [heq]
    have hmono : F (centerSuper z q e A) i ≤ F (shift z (e - A)) i := by
      apply laws.mono
      intro j
      have := min_le_left (z j + e - A) (q j + A)
      simp [shift, centerSuper, sub_eq_add_neg, add_assoc]
    rw [laws.translation] at hmono
    simp only [shift] at hmono
    omega

end Projections

def averageStep {V : Type} (a b r₁ r₂ : Vec V) : Vec V :=
  clip a b (fun i => (r₁ i + r₂ i) / 2)

theorem high_deviation_step {V : Type} {a b y q r₁ r₂ : Vec V} {d D : ℤ}
    (hyb : y ≤ b) (hD : 0 < D) (hd : 2 * D ≤ d)
    (hdev : ∀ i, y i - q i ≤ d)
    (hr₁ : ∀ i, q i - D ≤ r₁ i)
    (hr₂ : centerSub y q d D ≤ r₂) :
    ∀ i, y i - averageStep a b r₁ r₂ i ≤ d := by
  intro i
  have hq := hdev i
  have h1 := hr₁ i
  have h2 := le_trans (le_max_left (y i - d + D) (q i - D)) (hr₂ i)
  have hb : y i ≤ b i := hyb i
  have havg : y i - d ≤ (r₁ i + r₂ i) / 2 := by omega
  have hclip : y i - d ≤ min (b i) (max (a i) ((r₁ i + r₂ i) / 2)) :=
    le_min (by omega) (le_trans havg (le_max_right _ _))
  change y i - min (b i) (max (a i) ((r₁ i + r₂ i) / 2)) ≤ d
  omega

theorem high_bad_step {V : Type} {a b y q r₁ r₂ : Vec V} {d D : ℤ}
    (hyb : y ≤ b) (hD : 0 < D) (hd : 2 * D ≤ d)
    (hr₁ : centerSub y q d D ≤ r₁) (hr₂ : centerSub y q d D ≤ r₂) :
    ∀ i, y i - averageStep a b r₁ r₂ i ≤ d - D := by
  intro i
  have h1 := le_trans (le_max_left (y i - d + D) (q i - D)) (hr₁ i)
  have h2 := le_trans (le_max_left (y i - d + D) (q i - D)) (hr₂ i)
  have hb : y i ≤ b i := hyb i
  have havg : y i - d + D ≤ (r₁ i + r₂ i) / 2 := by omega
  have hclip : y i - d + D ≤ min (b i) (max (a i) ((r₁ i + r₂ i) / 2)) :=
    le_min (by omega) (le_trans havg (le_max_right _ _))
  change y i - min (b i) (max (a i) ((r₁ i + r₂ i) / 2)) ≤ d - D
  omega

theorem low_deviation_step {V : Type} {a b z q r₁ r₂ : Vec V} {e D : ℤ}
    (haz : a ≤ z) (hD : 0 < D) (he : 2 * D ≤ e)
    (hdev : ∀ i, q i - z i ≤ e)
    (hr₁ : r₁ ≤ centerSuper z q e D)
    (hr₂ : ∀ i, r₂ i ≤ q i + D) :
    ∀ i, averageStep a b r₁ r₂ i - z i ≤ e := by
  intro i
  have hq := hdev i
  have h1 : r₁ i ≤ z i + e - D := le_trans (hr₁ i) (min_le_left (z i + e - D) (q i + D))
  have h2 := hr₂ i
  have ha : a i ≤ z i := haz i
  have havg : (r₁ i + r₂ i) / 2 ≤ z i + e := by omega
  have hclip : min (b i) (max (a i) ((r₁ i + r₂ i) / 2)) ≤ z i + e :=
    le_trans (min_le_right _ _) (max_le (by omega) havg)
  change min (b i) (max (a i) ((r₁ i + r₂ i) / 2)) - z i ≤ e
  omega

theorem low_bad_step {V : Type} {a b z q r₁ r₂ : Vec V} {e D : ℤ}
    (haz : a ≤ z) (hD : 0 < D) (he : 2 * D ≤ e)
    (hr₁ : r₁ ≤ centerSuper z q e D) (hr₂ : r₂ ≤ centerSuper z q e D) :
    ∀ i, averageStep a b r₁ r₂ i - z i ≤ e - D := by
  intro i
  have h1 : r₁ i ≤ z i + e - D := le_trans (hr₁ i) (min_le_left (z i + e - D) (q i + D))
  have h2 : r₂ i ≤ z i + e - D := le_trans (hr₂ i) (min_le_left (z i + e - D) (q i + D))
  have ha : a i ≤ z i := haz i
  have havg : (r₁ i + r₂ i) / 2 ≤ z i + e - D := by omega
  have hclip : min (b i) (max (a i) ((r₁ i + r₂ i) / 2)) ≤ z i + e - D :=
    le_trans (min_le_right _ _) (max_le (by omega) havg)
  change min (b i) (max (a i) ((r₁ i + r₂ i) / 2)) - z i ≤ e - D
  omega

theorem no_tight_sequence (G : Game) (p : Vec (Fin G.n))
    (v : ℕ → Fin G.n) (w : ℕ → ℤ)
    (h : ∀ k, p (v k) = (G.n + 1 : ℤ) * w k + 1 + p (v (k + 1))) : False := by
  have hmod : ∀ k : ℕ,
      p (v k) + (k : ℤ) ≡ p (v 0) [ZMOD (G.n + 1 : ℤ)] := by
    intro k
    induction k with
    | zero => simp
    | succ k ih =>
      apply Int.ModEq.trans _ ih
      apply Int.modEq_iff_dvd.mpr
      use w k
      have hk := h k
      push_cast
      linarith
  have hinj : Function.Injective (fun k : Fin (G.n + 1) => v k.val) := by
    intro i j hij
    change v i.val = v j.val at hij
    apply Fin.ext
    have hm := (hmod i.val).trans (hmod j.val).symm
    rw [hij] at hm
    have hc := Int.ModEq.add_left_cancel' (p (v j.val)) hm
    have hn : i.val ≡ j.val [MOD (G.n + 1)] :=
      Int.natCast_modEq_iff.mp (by simpa only [Nat.cast_add, Nat.cast_one] using hc)
    exact hn.eq_of_lt_of_lt i.isLt j.isLt
  have hc := Fintype.card_le_of_injective _ hinj
  simp only [Fintype.card_fin] at hc
  omega

theorem comparison_step (G : Game) {a b y z : Vec (Fin G.n)}
    (hy : Subsolution (operator G) a b y)
    (hz : Supersolution (operator G) a b z)
    {d : ℤ} (hd : 0 < d) (hdev : ∀ j, y j - z j ≤ d)
    (i : Fin G.n) (hi : y i - z i = d) :
    ∃ e : Fin G.m, G.tail e = i ∧
      y (G.head e) - z (G.head e) = d ∧
      y i = transformed G e + y (G.head e) := by
  have hay : a i < y i := by have hzi : a i ≤ z i := hz.1.1 i; omega
  have hzb : z i < b i := by have hyi : y i ≤ b i := hy.1.2 i; omega
  have hys := hy.2 i hay
  have hzs := hz.2 i hzb
  have hmono : operator G y i ≤ operator G z i + d := by
    have hm := (operator_laws G).mono (a := y) (b := shift z d)
      (fun j => by have := hdev j; dsimp [shift]; omega) i
    rw [(operator_laws G).translation] at hm
    exact hm
  have hyeq : y i = operator G y i := by omega
  have hzeq : z i = operator G z i := by omega
  by_cases ho : G.maxOwner i = true
  · obtain ⟨e, he, heq⟩ := Finset.exists_mem_eq_sup' (outgoing_nonempty G i)
      (fun e => transformed G e + y (G.head e))
    have htail : G.tail e = i := (Finset.mem_filter.mp he).2
    have hye : y i = transformed G e + y (G.head e) := by
      rw [hyeq, operator, ite_eq_left ho]; exact heq
    have hzle : transformed G e + z (G.head e) ≤ z i := by
      rw [hzeq, operator, ite_eq_left ho]
      exact Finset.le_sup' (fun e => transformed G e + z (G.head e)) he
    exact ⟨e, htail, by have := hdev (G.head e); omega, hye⟩
  · obtain ⟨e, he, heq⟩ := Finset.exists_mem_eq_inf' (outgoing_nonempty G i)
      (fun e => transformed G e + z (G.head e))
    have htail : G.tail e = i := (Finset.mem_filter.mp he).2
    have hze : z i = transformed G e + z (G.head e) := by
      rw [hzeq, operator, ite_eq_right ho]; exact heq
    have hyle : y i ≤ transformed G e + y (G.head e) := by
      rw [hyeq, operator, ite_eq_right ho]
      exact Finset.inf'_le (fun e => transformed G e + y (G.head e)) he
    have hj := hdev (G.head e)
    exact ⟨e, htail, by omega, by omega⟩

theorem box_comparison (G : Game) {a b y z : Vec (Fin G.n)}
    (hy : Subsolution (operator G) a b y)
    (hz : Supersolution (operator G) a b z) : y ≤ z := by
  classical
  let : Nonempty (Fin G.n) := ⟨⟨0, G.positive⟩⟩
  let d : ℤ := Finset.univ.sup' Finset.univ_nonempty (fun i => y i - z i)
  have hdev : ∀ i, y i - z i ≤ d := fun i =>
    Finset.le_sup' (fun j => y j - z j) (Finset.mem_univ i)
  by_contra h
  change ¬ (∀ i, y i ≤ z i) at h
  obtain ⟨k, hk⟩ := not_forall.mp h
  have hd : 0 < d := by have := hdev k; omega
  obtain ⟨v, _, hv⟩ := Finset.exists_mem_eq_sup' (Finset.univ_nonempty (α := Fin G.n))
    (fun i => y i - z i)
  let S := {i : Fin G.n // y i - z i = d}
  let s₀ : S := ⟨v, hv.symm⟩
  have hs : ∀ s : S, ∃ e : Fin G.m, G.tail e = s.val ∧
      y (G.head e) - z (G.head e) = d ∧
      y s.val = transformed G e + y (G.head e) :=
    fun s => comparison_step G hy hz hd hdev s.val s.property
  choose edge hedge using hs
  let next : S → S := fun s => ⟨G.head (edge s), (hedge s).2.1⟩
  let path : ℕ → S := fun k => next^[k] s₀
  apply no_tight_sequence G y (fun k => (path k).val)
    (fun k => G.weight (edge (path k)))
  intro k
  have heq := (hedge (path k)).2.2
  simpa only [path, Function.iterate_succ_apply', next, transformed] using heq

def boxStep {V : Type} (F : Vec V → Vec V) (a b p : Vec V) : Vec V :=
  clip a b (F p)

theorem boxStep_in_box {V : Type} (F : Vec V → Vec V)
    {a b : Vec V} (hab : a ≤ b) (p : Vec V) : InBox a b (boxStep F a b p) := by
  constructor
  · intro i
    exact le_min (hab i) (le_max_left _ _)
  · intro i; exact min_le_left _ _

theorem boxStep_mono {V : Type} {F : Vec V → Vec V} (hF : Monotone F)
    (a b : Vec V) : Monotone (boxStep F a b) := by
  intro p q hpq i
  exact min_le_min_left _ (max_le_max_left _ (hF hpq i))

theorem fixed_iff_comparisons {V : Type} (F : Vec V → Vec V)
    {a b p : Vec V} (hab : a ≤ b) :
    boxStep F a b p = p ↔ Subsolution F a b p ∧ Supersolution F a b p := by
  constructor
  · intro heq
    have hp := boxStep_in_box F hab p
    rw [heq] at hp
    have hc : ∀ i, min (b i) (max (a i) (F p i)) = p i := congrFun heq
    constructor
    · refine ⟨hp, ?_⟩
      intro i hi
      have := hc i
      omega
    · refine ⟨hp, ?_⟩
      intro i hi
      have := hc i
      omega
  · rintro ⟨hy, hz⟩
    funext i
    have ha : a i ≤ p i := hy.1.1 i
    have hb : p i ≤ b i := hy.1.2 i
    have hs := hy.2 i
    have ht := hz.2 i
    change min (b i) (max (a i) (F p i)) = p i
    omega

def volume {n : ℕ} (b p : Vec (Fin n)) : ℕ := ∑ i, (b i - p i).toNat

theorem volume_decreases {n : ℕ} {b p q : Vec (Fin n)}
    (hpq : p ≤ q) (hqb : q ≤ b) (hne : p ≠ q) : volume b q < volume b p := by
  apply Finset.sum_lt_sum
  · intro i _
    exact Int.toNat_le_toNat (sub_le_sub_left (hpq i) _)
  · have hx : ∃ i, p i ≠ q i := Function.ne_iff.mp hne
    obtain ⟨i, hi⟩ := hx
    have hpi : p i ≤ q i := hpq i
    have hqi : q i ≤ b i := hqb i
    refine ⟨i, Finset.mem_univ i, ?_⟩
    apply (Int.toNat_lt_toNat (by omega)).mpr
    omega

def basicFrom {n : ℕ} (F : Vec (Fin n) → Vec (Fin n)) (hF : Monotone F)
    (a b : Vec (Fin n)) (hab : a ≤ b) (p : Vec (Fin n))
    (hp : InBox a b p) (hinc : p ≤ boxStep F a b p) :
    {r : Vec (Fin n) × ℕ // InBox a b r.1 ∧ boxStep F a b r.1 = r.1 ∧
      r.2 ≤ volume b p + 1} := by
  by_cases heq : boxStep F a b p = p
  · exact ⟨(p, 1), hp, heq, by omega⟩
  · have hq := boxStep_in_box F hab p
    have hnext : boxStep F a b p ≤ boxStep F a b (boxStep F a b p) :=
      boxStep_mono hF a b hinc
    have hvol : volume b (boxStep F a b p) < volume b p :=
      volume_decreases hinc hq.2 (Ne.symm heq)
    let r := basicFrom F hF a b hab (boxStep F a b p) hq hnext
    exact ⟨(r.val.1, r.val.2 + 1), r.property.1, r.property.2.1, by
      have := r.property.2.2; dsimp only; omega⟩
termination_by volume b p

def basic (G : Game) (a b : Vec (Fin G.n)) (hab : a ≤ b) : Vec (Fin G.n) × ℕ :=
  (basicFrom (operator G) (operator_laws G).mono a b hab a
    ⟨le_refl a, hab⟩ (boxStep_in_box (operator G) hab a).1).val

theorem basic_spec (G : Game) (a b : Vec (Fin G.n)) (hab : a ≤ b) :
    Subsolution (operator G) a b (basic G a b hab).1 ∧
    Supersolution (operator G) a b (basic G a b hab).1 ∧
    (basic G a b hab).2 ≤ volume b a + 1 := by
  have h := (basicFrom (operator G) (operator_laws G).mono a b hab a
    ⟨le_refl a, hab⟩ (boxStep_in_box (operator G) hab a).1).property
  have hc := (fixed_iff_comparisons (operator G) hab).mp h.2.1
  exact ⟨hc.1, hc.2, h.2.2⟩

theorem box_solution_exists_unique (G : Game) (a b : Vec (Fin G.n)) (hab : a ≤ b) :
    ∃! x, Subsolution (operator G) a b x ∧ Supersolution (operator G) a b x := by
  refine ⟨(basic G a b hab).1, ⟨(basic_spec G a b hab).1,
    (basic_spec G a b hab).2.1⟩, ?_⟩
  intro y hy
  apply le_antisymm
  · exact box_comparison G hy.1 (basic_spec G a b hab).2.1
  · exact box_comparison G (basic_spec G a b hab).1 hy.2

theorem no_tight_segment (G : Game) (p : Vec (Fin G.n))
    (v : ℕ → Fin G.n) (w : ℕ → ℤ)
    (h : ∀ k < G.n, p (v k) = (G.n + 1 : ℤ) * w k + 1 + p (v (k + 1))) : False := by
  have hmod : ∀ k : ℕ, k ≤ G.n →
      p (v k) + (k : ℤ) ≡ p (v 0) [ZMOD (G.n + 1 : ℤ)] := by
    intro k
    induction k with
    | zero => intro _; simp
    | succ k ih =>
      intro hk
      apply Int.ModEq.trans _ (ih (by omega))
      apply Int.modEq_iff_dvd.mpr
      use w k
      have hstep := h k (by omega)
      push_cast
      linarith
  have hinj : Function.Injective (fun k : Fin (G.n + 1) => v k.val) := by
    intro i j hij
    change v i.val = v j.val at hij
    apply Fin.ext
    have hm := (hmod i.val (by omega)).trans (hmod j.val (by omega)).symm
    rw [hij] at hm
    have hc := Int.ModEq.add_left_cancel' (p (v j.val)) hm
    have hn : i.val ≡ j.val [MOD (G.n + 1)] :=
      Int.natCast_modEq_iff.mp (by simpa only [Nat.cast_add, Nat.cast_one] using hc)
    exact hn.eq_of_lt_of_lt i.isLt j.isLt
  have hc := Fintype.card_le_of_injective _ hinj
  simp only [Fintype.card_fin] at hc
  omega

theorem operator_attained (G : Game) (p : Vec (Fin G.n)) (i : Fin G.n) :
    ∃ e : Fin G.m, G.tail e = i ∧ operator G p i = transformed G e + p (G.head e) := by
  by_cases ho : G.maxOwner i = true
  · obtain ⟨e, he, heq⟩ := Finset.exists_mem_eq_sup' (outgoing_nonempty G i)
      (fun e => transformed G e + p (G.head e))
    exact ⟨e, (Finset.mem_filter.mp he).2, by simpa [operator, ho] using heq⟩
  · obtain ⟨e, he, heq⟩ := Finset.exists_mem_eq_inf' (outgoing_nonempty G i)
      (fun e => transformed G e + p (G.head e))
    exact ⟨e, (Finset.mem_filter.mp he).2, by simpa [operator, ho] using heq⟩

theorem solution_near_boundary (G : Game) {x : Vec (Fin G.n)} {B W : ℤ}
    (hW : 0 ≤ W) (hweights : ∀ e, |transformed G e| ≤ W)
    (hx : Subsolution (operator G) (fun _ => 0) (fun _ => B) x ∧
      Supersolution (operator G) (fun _ => 0) (fun _ => B) x) :
    ∀ i, x i ≤ G.n * W ∨ B - G.n * W ≤ x i := by
  classical
  choose edge hedge using operator_attained G x
  let next : Fin G.n → Fin G.n := fun i =>
    if 0 < x i ∧ x i < B then G.head (edge i) else i
  have hstep : ∀ i, |x (next i) - x i| ≤ W := by
    intro i
    by_cases hi : 0 < x i ∧ x i < B
    · have hsub := hx.1.2 i hi.1
      have hsuper := hx.2.2 i hi.2
      have he := (hedge i).2
      have hw := hweights (edge i)
      simp only [next, ite_eq_left hi]
      rw [show x (G.head (edge i)) - x i = -transformed G (edge i) by omega,
        abs_neg]
      exact hw
    · simp only [next, ite_eq_right hi, sub_self, abs_zero]; exact hW
  intro start
  let path : ℕ → Fin G.n := fun k => next^[k] start
  have hmove : ∀ k, |x (path k) - x start| ≤ k * W := by
    intro k
    induction k with
    | zero => simp [path]
    | succ k ih =>
      have hs := hstep (path k)
      have hp : path (k + 1) = next (path k) := Function.iterate_succ_apply' next k start
      rw [← hp] at hs
      calc
        |x (path (k + 1)) - x start| =
          |(x (path (k + 1)) - x (path k)) + (x (path k) - x start)| := by congr 1; ring
        _ ≤ |x (path (k + 1)) - x (path k)| + |x (path k) - x start| := abs_add_le _ _
        _ ≤ W + k * W := add_le_add hs ih
        _ = (↑(k + 1) : ℤ) * W := by push_cast; ring
  have hboundary : ∃ k < G.n, ¬ (0 < x (path k) ∧ x (path k) < B) := by
    by_contra h
    push Not at h
    apply no_tight_segment G x path (fun k => G.weight (edge (path k)))
    intro k hk
    have hi := h k hk
    have hsub := hx.1.2 (path k) hi.1
    have hsuper := hx.2.2 (path k) hi.2
    have hp : path (k + 1) = G.head (edge (path k)) := by
      change next^[k + 1] start = _
      rw [Function.iterate_succ_apply']
      exact ite_eq_left hi
    rw [hp]
    have he := (hedge (path k)).2
    change x (path k) = transformed G (edge (path k)) + x (G.head (edge (path k)))
    omega
  obtain ⟨k, hk, hbound⟩ := hboundary
  have hlo : 0 ≤ x (path k) := hx.1.1.1 (path k)
  have hhi : x (path k) ≤ B := hx.1.1.2 (path k)
  have hm := hmove k
  have hk' : (k : ℤ) ≤ G.n := by omega
  have hkn := mul_le_mul_of_nonneg_right hk' hW
  have ha := (abs_le.mp hm)
  by_cases he : x (path k) = 0
  · left; omega
  · right; have he' : x (path k) = B := by omega
    omega

theorem exists_rounding_shift {n : ℕ} (p : Vec (Fin n)) :
    ∃ c : ℤ, ∀ i, (p i - c) % (n + 1 : ℤ) ≠ 0 := by
  classical
  have hN : (0 : ℤ) < n + 1 := by omega
  let residue : Fin n → Fin (n + 1) := fun i =>
    ⟨(p i % (n + 1 : ℤ)).toNat,
      (Int.toNat_lt (Int.emod_nonneg _ (ne_of_gt hN))).mpr (by
        simpa only [Nat.cast_add, Nat.cast_one] using Int.emod_lt_of_pos (p i) hN)⟩
  have hns : ¬ Function.Surjective residue := by
    intro hs
    have hc := Fintype.card_le_of_surjective residue hs
    simp only [Fintype.card_fin] at hc
    omega
  have hex : ∃ c : Fin (n + 1), ∀ i, residue i ≠ c := by
    simpa only [Function.Surjective, not_forall, not_exists] using hns
  obtain ⟨c, hc⟩ := hex
  refine ⟨c.val, ?_⟩
  intro i hi
  apply hc i
  apply Fin.ext
  change (p i % (n + 1 : ℤ)).toNat = c.val
  have hm : (c.val : ℤ) ≡ p i [ZMOD (n + 1 : ℤ)] :=
    Int.modEq_iff_dvd.mpr (Int.dvd_of_emod_eq_zero hi)
  have hcmod : (c.val : ℤ) % (n + 1 : ℤ) = c.val :=
    Int.emod_eq_of_lt (by omega) (by exact_mod_cast c.isLt)
  change (c.val : ℤ) % (n + 1 : ℤ) = p i % (n + 1 : ℤ) at hm
  rw [hcmod] at hm
  rw [← hm]
  simp

theorem rounded_high_edge {N a b w c : ℤ} (hN : 0 < N)
    (hgap : (a - c) % N ≠ 0) (h : a ≤ N * w + 1 + b) :
    (a - c) / N ≤ w + (b - c) / N := by
  have ha := Int.ediv_emod_unique (a := a - c) (b := N)
    (r := (a - c) % N) (q := (a - c) / N) hN
  have hb := Int.ediv_emod_unique (a := b - c) (b := N)
    (r := (b - c) % N) (q := (b - c) / N) hN
  have hqa := ha.mp ⟨rfl, rfl⟩
  have hqb := hb.mp ⟨rfl, rfl⟩
  by_contra hn
  have hq : w + (b - c) / N + 1 ≤ (a - c) / N := by omega
  have hp := mul_le_mul_of_nonneg_left hq (le_of_lt hN)
  have hra : 1 ≤ (a - c) % N := by omega
  have hrb : (b - c) % N ≤ N - 1 := by omega
  nlinarith [hqa.1, hqb.1]

def weightBound (G : Game) : ℤ :=
  max 1 ((Finset.univ.sup (fun e : Fin G.m => (transformed G e).natAbs) : ℕ) : ℤ)

def topWidth (G : Game) : ℤ := 8 * G.n * weightBound G

theorem weightBound_positive (G : Game) : 0 < weightBound G := by
  have := le_max_left (1 : ℤ) ((Finset.univ.sup (fun e : Fin G.m => (transformed G e).natAbs) : ℕ) : ℤ)
  change 0 < max 1 _
  omega

theorem transformed_le_bound (G : Game) (e : Fin G.m) : |transformed G e| ≤ weightBound G := by
  have h := Finset.le_sup (f := fun e : Fin G.m => (transformed G e).natAbs) (Finset.mem_univ e)
  have hc : ((transformed G e).natAbs : ℤ) ≤
      ((Finset.univ.sup (fun e : Fin G.m => (transformed G e).natAbs) : ℕ) : ℤ) := by exact_mod_cast h
  rw [Int.natCast_natAbs] at hc
  exact hc.trans (le_max_right _ _)

theorem top_bands (G : Game) {x : Vec (Fin G.n)}
    (hx : Subsolution (operator G) (fun _ => 0) (fun _ => topWidth G) x ∧
      Supersolution (operator G) (fun _ => 0) (fun _ => topWidth G) x) :
    ∀ i, x i ≤ G.n * weightBound G ∨ 7 * G.n * weightBound G ≤ x i := by
  intro i
  have h := solution_near_boundary G (le_of_lt (weightBound_positive G))
    (transformed_le_bound G) hx i
  simpa only [topWidth, show 8 * (G.n : ℤ) * weightBound G - G.n * weightBound G =
    7 * G.n * weightBound G by ring] using h

theorem max_edge_le_operator (G : Game) (p : Vec (Fin G.n))
    {i : Fin G.n} (ho : G.maxOwner i = true) {e : Fin G.m} (he : G.tail e = i) :
    transformed G e + p (G.head e) ≤ operator G p i := by
  rw [operator, ite_eq_left ho]
  exact Finset.le_sup' (fun e => transformed G e + p (G.head e)) (by simp [outgoing, he])

theorem operator_le_min_edge (G : Game) (p : Vec (Fin G.n))
    {i : Fin G.n} (ho : G.maxOwner i ≠ true) {e : Fin G.m} (he : G.tail e = i) :
    operator G p i ≤ transformed G e + p (G.head e) := by
  rw [operator, ite_eq_right ho]
  exact Finset.inf'_le (fun e => transformed G e + p (G.head e)) (by simp [outgoing, he])

theorem move_tail (G : Game) (σ τ : Strategy G) (v : Fin G.n)
    (history : List (Fin G.m)) : G.tail (move G σ τ v history) = v := by
  unfold move
  split
  · exact (σ history v).property
  · exact (τ history v).property

theorem next_position (G : Game) (σ τ : Strategy G) (v : Fin G.n) (t : ℕ) :
    (position G σ τ v (t + 1)).1 = G.head (play G σ τ v t) := rfl

theorem high_edge_stays_high (G : Game) {x : Vec (Fin G.n)}
    (hbands : ∀ i, x i ≤ G.n * weightBound G ∨ 7 * G.n * weightBound G ≤ x i)
    {i : Fin G.n} {e : Fin G.m}
    (hi : 7 * G.n * weightBound G ≤ x i)
    (he : x i ≤ transformed G e + x (G.head e)) :
    7 * G.n * weightBound G ≤ x (G.head e) := by
  rcases hbands (G.head e) with hl | hh
  · have hw := (abs_le.mp (transformed_le_bound G e)).2
    have hn : (1 : ℤ) ≤ G.n := by exact_mod_cast G.positive
    have hW := weightBound_positive G
    have hnW : weightBound G ≤ G.n * weightBound G := by nlinarith
    nlinarith
  · exact hh

theorem low_edge_stays_low (G : Game) {x : Vec (Fin G.n)}
    (hbands : ∀ i, x i ≤ G.n * weightBound G ∨ 7 * G.n * weightBound G ≤ x i)
    {i : Fin G.n} {e : Fin G.m}
    (hi : x i ≤ G.n * weightBound G)
    (he : transformed G e + x (G.head e) ≤ x i) :
    x (G.head e) ≤ G.n * weightBound G := by
  rcases hbands (G.head e) with hl | hh
  · exact hl
  · have hw := (abs_le.mp (transformed_le_bound G e)).1
    have hn : (1 : ℤ) ≤ G.n := by exact_mod_cast G.positive
    have hW := weightBound_positive G
    have hnW : weightBound G ≤ G.n * weightBound G := by nlinarith
    nlinarith

theorem high_strategy (G : Game) {x : Vec (Fin G.n)}
    (hx : Subsolution (operator G) (fun _ => 0) (fun _ => topWidth G) x ∧
      Supersolution (operator G) (fun _ => 0) (fun _ => topWidth G) x) :
    ∃ σ : Strategy G, ∀ τ : Strategy G, ∀ start : Fin G.n,
      7 * G.n * weightBound G ≤ x start → ∀ t : ℕ,
      7 * G.n * weightBound G ≤ x (position G σ τ start t).1 ∧
      x (position G σ τ start t).1 ≤
        transformed G (play G σ τ start t) + x (position G σ τ start (t + 1)).1 := by
  classical
  choose edge hedge using operator_attained G x
  let σ : Strategy G := fun _ i => ⟨edge i, (hedge i).1⟩
  refine ⟨σ, ?_⟩
  intro τ start hstart
  have hlocal (i : Fin G.n) (history : List (Fin G.m))
      (hi : 7 * G.n * weightBound G ≤ x i) :
      x i ≤ transformed G (move G σ τ i history) + x (G.head (move G σ τ i history)) := by
    have hn : (0 : ℤ) < G.n := by exact_mod_cast G.positive
    have hW := weightBound_positive G
    have hpos : 0 < x i := by nlinarith
    have hsub := hx.1.2 i hpos
    by_cases ho : G.maxOwner i = true
    · simpa only [move, ite_eq_left ho, σ] using hsub.trans_eq (hedge i).2
    · exact hsub.trans (operator_le_min_edge G x ho (move_tail G σ τ i history))
  have hstay : ∀ t : ℕ, 7 * G.n * weightBound G ≤ x (position G σ τ start t).1 := by
    intro t
    induction t with
    | zero => exact hstart
    | succ t ih =>
      rw [next_position]
      exact high_edge_stays_high G (top_bands G hx) ih
        (hlocal (position G σ τ start t).1 (position G σ τ start t).2 ih)
  intro t
  refine ⟨hstay t, ?_⟩
  rw [next_position]
  exact hlocal (position G σ τ start t).1 (position G σ τ start t).2 (hstay t)

theorem low_strategy (G : Game) {x : Vec (Fin G.n)}
    (hx : Subsolution (operator G) (fun _ => 0) (fun _ => topWidth G) x ∧
      Supersolution (operator G) (fun _ => 0) (fun _ => topWidth G) x) :
    ∃ τ : Strategy G, ∀ σ : Strategy G, ∀ start : Fin G.n,
      x start ≤ G.n * weightBound G → ∀ t : ℕ,
      x (position G σ τ start t).1 ≤ G.n * weightBound G ∧
      transformed G (play G σ τ start t) + x (position G σ τ start (t + 1)).1 ≤
        x (position G σ τ start t).1 := by
  classical
  choose edge hedge using operator_attained G x
  let τ : Strategy G := fun _ i => ⟨edge i, (hedge i).1⟩
  refine ⟨τ, ?_⟩
  intro σ start hstart
  have hlocal (i : Fin G.n) (history : List (Fin G.m))
      (hi : x i ≤ G.n * weightBound G) :
      transformed G (move G σ τ i history) + x (G.head (move G σ τ i history)) ≤ x i := by
    have hn : (0 : ℤ) < G.n := by exact_mod_cast G.positive
    have hW := weightBound_positive G
    have hlt : x i < topWidth G := by unfold topWidth; nlinarith
    have hsuper := hx.2.2 i hlt
    by_cases ho : G.maxOwner i = true
    · exact (max_edge_le_operator G x ho (move_tail G σ τ i history)).trans hsuper
    · simpa only [move, ite_eq_right ho, τ] using (hedge i).2.symm.trans_le hsuper
  have hstay : ∀ t : ℕ, x (position G σ τ start t).1 ≤ G.n * weightBound G := by
    intro t
    induction t with
    | zero => exact hstart
    | succ t ih =>
      rw [next_position]
      exact low_edge_stays_low G (top_bands G hx) ih
        (hlocal (position G σ τ start t).1 (position G σ τ start t).2 ih)
  intro t
  refine ⟨hstay t, ?_⟩
  rw [next_position]
  exact hlocal (position G σ τ start t).1 (position G σ τ start t).2 (hstay t)

def vectorBound {n : ℕ} (p : Fin n → ℤ) : ℕ :=
  Finset.univ.sup (fun i => (p i).natAbs)

theorem le_vectorBound {n : ℕ} (p : Fin n → ℤ) (i : Fin n) :
    |p i| ≤ (vectorBound p : ℤ) := by
  have h := Finset.le_sup (f := fun i => (p i).natAbs) (Finset.mem_univ i)
  rw [← Int.natCast_natAbs]
  exact_mod_cast h

noncomputable def average (w : ℕ → ℝ) (T : ℕ) : ℝ := (∑ j ∈ Finset.range T, w j) / T

theorem average_bounds {w : ℕ → ℝ} {M : ℝ} (hM : 0 ≤ M)
    (hw : ∀ t, |w t| ≤ M) (T : ℕ) : -M ≤ average w T ∧ average w T ≤ M := by
  by_cases hT : T = 0
  · simp [hT, average, hM, neg_nonpos.mpr hM]
  have ht : (0 : ℝ) < T := by exact_mod_cast Nat.pos_of_ne_zero hT
  constructor
  · apply (le_div_iff₀ ht).2
    calc
      -M * (T : ℝ) = ∑ j ∈ Finset.range T, -M := by simp; ring
      _ ≤ ∑ j ∈ Finset.range T, w j :=
        Finset.sum_le_sum (fun j _ => (abs_le.mp (hw j)).1)
  · apply (div_le_iff₀ ht).2
    calc
      (∑ j ∈ Finset.range T, w j) ≤ ∑ j ∈ Finset.range T, M :=
        Finset.sum_le_sum (fun j _ => (abs_le.mp (hw j)).2)
      _ = M * (T : ℝ) := by simp; ring

theorem payoff_bounded (G : Game) (π : ℕ → Fin G.m) :
    Filter.IsBoundedUnder (· ≤ ·) Filter.atTop
      (average (fun t => (G.weight (π t) : ℝ))) ∧
    Filter.IsBoundedUnder (· ≥ ·) Filter.atTop
      (average (fun t => (G.weight (π t) : ℝ))) := by
  let M : ℝ := vectorBound G.weight
  have hM : 0 ≤ M := by positivity
  have hw (t : ℕ) : |(G.weight (π t) : ℝ)| ≤ M := by
    dsimp [M]
    exact_mod_cast le_vectorBound G.weight (π t)
  exact ⟨Filter.isBoundedUnder_of_eventually_le
      (Filter.Eventually.of_forall fun t => (average_bounds hM hw t).2),
    Filter.isBoundedUnder_of_eventually_ge
      (Filter.Eventually.of_forall fun t => (average_bounds hM hw t).1)⟩

theorem lower_average_from_potential {w p : ℕ → ℝ} {K : ℝ}
    (hp : ∀ t, |p t| ≤ K) (he : ∀ t, p t - p (t + 1) ≤ w t) (T : ℕ) :
    (-2 * K) / (T : ℝ) ≤ average w T := by
  apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg T)
  calc
    -2 * K ≤ p 0 - p T := by
      have h0 := (abs_le.mp (hp 0)).1
      have hT := (abs_le.mp (hp T)).2
      linarith
    _ = ∑ j ∈ Finset.range T, (p j - p (j + 1)) := (Finset.sum_range_sub' p T).symm
    _ ≤ ∑ j ∈ Finset.range T, w j := Finset.sum_le_sum fun j _ => he j

theorem upper_average_from_potential {w p : ℕ → ℝ} {K N δ : ℝ}
    (hN : 0 < N) (hp : ∀ t, |p t| ≤ K)
    (he : ∀ t, N * w t + δ ≤ p t - p (t + 1))
    {T : ℕ} (hT : 0 < T) :
    average w T ≤ (2 * K / N) / (T : ℝ) - δ / N := by
  have ht : (0 : ℝ) < T := by exact_mod_cast hT
  have hs : N * (∑ j ∈ Finset.range T, w j) + (T : ℝ) * δ ≤ 2 * K := by
    calc
      N * (∑ j ∈ Finset.range T, w j) + (T : ℝ) * δ =
          ∑ j ∈ Finset.range T, (N * w j + δ) := by
        simp [Finset.sum_add_distrib, Finset.mul_sum]
      _ ≤ ∑ j ∈ Finset.range T, (p j - p (j + 1)) :=
        Finset.sum_le_sum fun j _ => he j
      _ = p 0 - p T := Finset.sum_range_sub' p T
      _ ≤ 2 * K := by
        have h0 := (abs_le.mp (hp 0)).2
        have hT := (abs_le.mp (hp T)).1
        linarith
  have hd := div_le_div_of_nonneg_right hs (le_of_lt (mul_pos hN ht))
  have hleft : (N * (∑ j ∈ Finset.range T, w j) + (T : ℝ) * δ) / (N * T) =
      average w T + δ / N := by
    unfold average
    field_simp
  have hright : 2 * K / (N * (T : ℝ)) = (2 * K / N) / T := by ring
  rw [hleft, hright] at hd
  linarith

theorem high_payoff (G : Game) {x : Vec (Fin G.n)} (σ τ : Strategy G)
    (start : Fin G.n)
    (he : ∀ t, x (position G σ τ start t).1 ≤
      transformed G (play G σ τ start t) + x (position G σ τ start (t + 1)).1) :
    0 ≤ meanPayoff G (play G σ τ start) := by
  obtain ⟨c, hc⟩ := exists_rounding_shift x
  let q (i : Fin G.n) : ℤ := (x i - c) / (G.n + 1 : ℤ)
  let p (t : ℕ) : ℝ := q (position G σ τ start t).1
  let K : ℝ := vectorBound q
  have hp (t : ℕ) : |p t| ≤ K := by
    dsimp [p, K]
    exact_mod_cast le_vectorBound q (position G σ τ start t).1
  have hedge (t : ℕ) : p t - p (t + 1) ≤ (G.weight (play G σ τ start t) : ℝ) := by
    have hN : (0 : ℤ) < G.n + 1 := by omega
    have h := rounded_high_edge hN (hc (position G σ τ start t).1) (he t)
    change q (position G σ τ start t).1 ≤
      G.weight (play G σ τ start t) + q (position G σ τ start (t + 1)).1 at h
    have hr : p t ≤ (G.weight (play G σ τ start t) : ℝ) + p (t + 1) := by
      dsimp [p]
      exact_mod_cast h
    linarith
  have hl := lower_average_from_potential hp hedge
  have ht := tendsto_const_div_atTop_nhds_zero_nat (-2 * K)
  have hb := (payoff_bounded G (play G σ τ start)).1
  have hcb : Filter.IsCoboundedUnder (· ≥ ·) Filter.atTop
      (average (fun t => (G.weight (play G σ τ start t) : ℝ))) :=
    Filter.IsBounded.isCobounded_flip hb
  have hm := Filter.liminf_le_liminf (Filter.Eventually.of_forall hl)
    ht.isBoundedUnder_ge hcb
  rw [ht.liminf_eq] at hm
  exact hm

theorem low_payoff (G : Game) {x : Vec (Fin G.n)} (σ τ : Strategy G)
    (start : Fin G.n)
    (he : ∀ t, transformed G (play G σ τ start t) +
      x (position G σ τ start (t + 1)).1 ≤ x (position G σ τ start t).1) :
    meanPayoff G (play G σ τ start) ≤ -1 / (G.n + 1 : ℝ) := by
  let p (t : ℕ) : ℝ := x (position G σ τ start t).1
  let K : ℝ := vectorBound x
  have hp (t : ℕ) : |p t| ≤ K := by
    dsimp [p, K]
    exact_mod_cast le_vectorBound x (position G σ τ start t).1
  have hedge (t : ℕ) : (G.n + 1 : ℝ) * G.weight (play G σ τ start t) + 1 ≤
      p t - p (t + 1) := by
    have h := he t
    unfold transformed at h
    have hr : (G.n + 1 : ℝ) * G.weight (play G σ τ start t) + 1 + p (t + 1) ≤ p t := by
      dsimp [p]
      exact_mod_cast h
    linarith
  have hN : (0 : ℝ) < G.n + 1 := by positivity
  have hev : ∀ᶠ T : ℕ in Filter.atTop,
      average (fun t => (G.weight (play G σ τ start t) : ℝ)) T ≤
        (2 * K / (G.n + 1 : ℝ)) / T - 1 / (G.n + 1 : ℝ) := by
    filter_upwards [Filter.eventually_gt_atTop 0] with T hT
    exact upper_average_from_potential hN hp hedge hT
  have ht := (tendsto_const_div_atTop_nhds_zero_nat (2 * K / (G.n + 1 : ℝ))).sub_const
    (1 / (G.n + 1 : ℝ))
  have hcb : Filter.IsCoboundedUnder (· ≥ ·) Filter.atTop
      (fun T : ℕ => (2 * K / (G.n + 1 : ℝ)) / T - 1 / (G.n + 1 : ℝ)) :=
    Filter.IsBounded.isCobounded_flip ht.isBoundedUnder_le
  have hm := Filter.liminf_le_liminf hev (payoff_bounded G (play G σ τ start)).2 hcb
  rw [ht.liminf_eq] at hm
  change meanPayoff G (play G σ τ start) ≤ (0 : ℝ) - 1 / (G.n + 1 : ℝ) at hm
  rw [show (-1 : ℝ) / (G.n + 1 : ℝ) = 0 - 1 / (G.n + 1 : ℝ) by ring]
  exact hm

theorem winning_iff_high (G : Game) {x : Vec (Fin G.n)}
    (hx : Subsolution (operator G) (fun _ => 0) (fun _ => topWidth G) x ∧
      Supersolution (operator G) (fun _ => 0) (fun _ => topWidth G) x) (v : Fin G.n) :
    Winning G v ↔ topWidth G / 2 < x v := by
  have hn : (0 : ℤ) < G.n := by exact_mod_cast G.positive
  have hW := weightBound_positive G
  have hhalf : topWidth G / 2 = 4 * G.n * weightBound G := by
    unfold topWidth
    rw [show 8 * (G.n : ℤ) * weightBound G = (4 * G.n * weightBound G) * 2 by ring]
    omega
  constructor
  · rintro ⟨σ, hσ⟩
    rcases top_bands G hx v with hl | hh
    · obtain ⟨τ, hτ⟩ := low_strategy G hx
      have he := fun t => (hτ σ v hl t).2
      have hp := low_payoff G σ τ v he
      have hneg : (-1 : ℝ) / (G.n + 1 : ℝ) < 0 := div_neg_of_neg_of_pos (by norm_num) (by positivity)
      exact False.elim (not_lt_of_ge ((hσ τ).trans hp) hneg)
    · rw [hhalf]
      nlinarith
  · intro hv
    obtain ⟨σ, hσ⟩ := high_strategy G hx
    refine ⟨σ, fun τ => ?_⟩
    have hh : 7 * G.n * weightBound G ≤ x v := by
      rcases top_bands G hx v with hl | hh
      · rw [hhalf] at hv
        nlinarith
      · exact hh
    exact high_payoff G σ τ v fun t => (hσ τ v hh t).2

def mass {n : ℕ} (a : Fin n → ℚ) (S : Finset (Fin n)) : ℚ := ∑ i ∈ S, a i

def lowerActive {n : ℕ} (a y : Vec (Fin n)) : Finset (Fin n) :=
  Finset.univ.filter (fun i => a i < y i)

def upperActive {n : ℕ} (b z : Vec (Fin n)) : Finset (Fin n) :=
  Finset.univ.filter (fun i => z i < b i)

theorem mass_nonneg {n : ℕ} {a : Fin n → ℚ} (ha : ∀ i, 0 ≤ a i) (S : Finset (Fin n)) :
    0 ≤ mass a S := Finset.sum_nonneg (fun i _ => ha i)

theorem mass_mono {n : ℕ} {a : Fin n → ℚ} (ha : ∀ i, 0 ≤ a i)
    {S T : Finset (Fin n)} (hST : S ⊆ T) : mass a S ≤ mass a T :=
  Finset.sum_le_sum_of_subset_of_nonneg hST (fun i _ _ => ha i)

theorem weight_le_mass {n : ℕ} {a : Fin n → ℚ} (ha : ∀ i, 0 ≤ a i)
    {S : Finset (Fin n)} {i : Fin n} (hi : i ∈ S) : a i ≤ mass a S :=
  Finset.single_le_sum (fun i _ => ha i) hi

end MeanPayoff

end

end OAI