import OAI.Computability.Scheduling.SeparatorWalk

namespace OAI

section

namespace ThreeMachine.Structure

def GlobalUpset {J : Type} (r : J → J → Prop) (A : Set J) : Prop :=
  ∀ ⦃x y⦄, r x y → x ∈ A → y ∈ A

def GlobalDownset {J : Type} (r : J → J → Prop) (A : Set J) : Prop :=
  ∀ ⦃x y⦄, r x y → y ∈ A → x ∈ A

theorem GlobalUpset.inter {J : Type} {r : J → J → Prop} {A B : Set J}
    (hA : GlobalUpset r A) (hB : GlobalUpset r B) : GlobalUpset r (A ∩ B) := by
  intro x y hxy hx
  exact ⟨hA hxy hx.1, hB hxy hx.2⟩

theorem GlobalUpset.union {J : Type} {r : J → J → Prop} {A B : Set J}
    (hA : GlobalUpset r A) (hB : GlobalUpset r B) : GlobalUpset r (A ∪ B) := by
  intro x y hxy hx
  exact hx.elim (fun h => Or.inl (hA hxy h)) (fun h => Or.inr (hB hxy h))

theorem GlobalDownset.compl {J : Type} {r : J → J → Prop} {A : Set J}
    (hA : GlobalDownset r A) : GlobalUpset r Aᶜ := by
  intro x y hxy hx hy
  exact hx (hA hxy hy)

structure GlobalList (J : Type) where
  indices : Finset ℕ
  entry : ℕ → Set J

namespace GlobalList
variable {J : Type}

def Qual (K : GlobalList J) : Set J := {x | ∃ i ∈ K.indices, x ∈ K.entry i}

def Upsets (K : GlobalList J) (r : J → J → Prop) : Prop :=
  ∀ i ∈ K.indices, GlobalUpset r (K.entry i)

noncomputable def memberships (K : GlobalList J) (x : J) : Finset ℕ := by
  classical
  exact K.indices.filter (fun i => x ∈ K.entry i)

noncomputable def lastIndex (K : GlobalList J) (x : J) : ℕ :=
  (K.memberships x).sup id

def KeyLT (K : GlobalList J) (rank : J → ℕ) (x y : J) : Prop :=
  K.lastIndex x < K.lastIndex y ∨
    K.lastIndex x = K.lastIndex y ∧ rank x < rank y

@[simp] theorem mem_memberships (K : GlobalList J) (x : J) (i : ℕ) :
    i ∈ K.memberships x ↔ i ∈ K.indices ∧ x ∈ K.entry i := by
  classical
  simp [memberships]

theorem le_lastIndex {K : GlobalList J} {x : J} {i : ℕ}
    (hi : i ∈ K.indices) (hx : x ∈ K.entry i) : i ≤ K.lastIndex x := by
  exact Finset.le_sup (f := id) ((mem_memberships K x i).mpr ⟨hi, hx⟩)

theorem lastIndex_mem {K : GlobalList J} {x : J} (hx : x ∈ K.Qual) :
    K.lastIndex x ∈ K.indices ∧ x ∈ K.entry (K.lastIndex x) := by
  obtain ⟨i, hi, hxi⟩ := hx
  have hne : (K.memberships x).Nonempty := ⟨i, (mem_memberships K x i).mpr ⟨hi, hxi⟩⟩
  have := Finset.sup_mem_of_nonempty (f := id) hne
  obtain ⟨j, hj, e⟩ := this
  change j = K.lastIndex x at e
  apply (mem_memberships K x (K.lastIndex x)).mp
  rw [← e]
  exact hj

theorem qual_upset {K : GlobalList J} {r : J → J → Prop}
    (hK : K.Upsets r) : GlobalUpset r K.Qual := by
  rintro x y hxy ⟨i, hi, hx⟩
  exact ⟨i, hi, hK i hi hxy hx⟩

theorem key_extends {K : GlobalList J} {r : J → J → Prop} {rank : J → ℕ}
    (hK : K.Upsets r) (hrank : ∀ x y, r x y → rank x < rank y)
    {x y : J} (hx : x ∈ K.Qual) (hxy : r x y) : K.KeyLT rank x y := by
  obtain ⟨hi, hxlast⟩ := lastIndex_mem hx
  have hle : K.lastIndex x ≤ K.lastIndex y := le_lastIndex hi (hK _ hi hxy hxlast)
  rcases hle.lt_or_eq with h | h
  · exact Or.inl h
  · exact Or.inr ⟨h, hrank x y hxy⟩

noncomputable def carry (K : GlobalList J) (rank : J → ℕ) (d r : ℕ) : GlobalList J := by
  classical
  exact ⟨K.indices.filter (d ≤ ·), fun i =>
    if i = d then K.entry i ∩ {x | r ≤ rank x} else K.entry i⟩

theorem carry_membership (K : GlobalList J) (rank : J → ℕ) (d r i : ℕ) (x : J) :
    i ∈ (K.carry rank d r).memberships x ↔
      i ∈ K.indices ∧ d ≤ i ∧ x ∈ K.entry i ∧ (i = d → r ≤ rank x) := by
  classical
  rw [mem_memberships]
  change (i ∈ K.indices.filter (d ≤ ·) ∧
    x ∈ (if i = d then K.entry i ∩ {x | r ≤ rank x} else K.entry i)) ↔ _
  rw [Finset.mem_filter]
  by_cases hi : i = d <;> simp [hi, and_assoc]

theorem carry_selection (K : GlobalList J) (rank : J → ℕ) (d r : ℕ) (x : J) :
    x ∈ (K.carry rank d r).Qual ↔ x ∈ K.Qual ∧
      (d < K.lastIndex x ∨ K.lastIndex x = d ∧ r ≤ rank x) := by
  constructor
  · rintro ⟨i, hi, hx⟩
    have hc := (carry_membership K rank d r i x).mp
      ((mem_memberships _ _ _).mpr ⟨hi, hx⟩)
    refine ⟨⟨i, hc.1, hc.2.2.1⟩, ?_⟩
    have hle := le_lastIndex hc.1 hc.2.2.1
    by_cases h : d < K.lastIndex x
    · exact Or.inl h
    · have hid : i = d := by omega
      exact Or.inr ⟨by omega, hc.2.2.2 hid⟩
  · rintro ⟨hq, hmax⟩
    obtain ⟨hi, hx⟩ := lastIndex_mem hq
    refine ⟨K.lastIndex x, ?_⟩
    apply (mem_memberships _ _ _).mp
    apply (carry_membership K rank d r _ x).mpr
    refine ⟨hi, ?_, hx, ?_⟩
    · rcases hmax with h | ⟨h, _⟩ <;> omega
    · intro e
      rcases hmax with h | ⟨_, hr⟩
      · omega
      · exact hr

theorem carry_lastIndex {K : GlobalList J} {rank : J → ℕ} {d r : ℕ} {x : J}
    (hx : x ∈ (K.carry rank d r).Qual) :
    (K.carry rank d r).lastIndex x = K.lastIndex x := by
  have hsel := (carry_selection K rank d r x).mp hx
  apply le_antisymm
  · apply Finset.sup_le
    intro i hi
    have hm := (carry_membership K rank d r i x).mp hi
    exact le_lastIndex hm.1 hm.2.2.1
  · obtain ⟨hi, hxi⟩ := lastIndex_mem hsel.1
    apply Finset.le_sup (f := id) (b := K.lastIndex x)
    apply (carry_membership K rank d r (K.lastIndex x) x).mpr
    refine ⟨hi, ?_, hxi, ?_⟩
    · rcases hsel.2 with h | ⟨h, _⟩ <;> omega
    · intro e
      rcases hsel.2 with h | ⟨_, hr⟩
      · omega
      · exact hr

theorem carry_key {K : GlobalList J} {rank : J → ℕ} {d r : ℕ} {x y : J}
    (hx : x ∈ (K.carry rank d r).Qual) (hy : y ∈ (K.carry rank d r).Qual) :
    (K.carry rank d r).KeyLT rank x y ↔ K.KeyLT rank x y := by
  simp only [KeyLT, carry_lastIndex hx, carry_lastIndex hy]

theorem carry_upsets {K : GlobalList J} {rank : J → ℕ} {d t : ℕ}
    {r : J → J → Prop} (hK : K.Upsets r)
    (hrank : ∀ x y, r x y → rank x < rank y) : (K.carry rank d t).Upsets r := by
  classical
  intro i hi x y hxy hx
  have hi' : i ∈ K.indices ∧ d ≤ i := by simpa [carry] using hi
  by_cases hid : i = d
  · have hx' : x ∈ K.entry i ∧ t ≤ rank x := by simpa [carry, hid] using hx
    have hrankxy := hrank x y hxy
    have hy : y ∈ K.entry i := hK i hi'.1 hxy hx'.1
    simpa [carry, hid] using And.intro hy (show t ≤ rank y by omega)
  · have hx' : x ∈ K.entry i := by simpa [carry, hid] using hx
    simpa [carry, hid] using hK i hi'.1 hxy hx'

noncomputable def prune (K : GlobalList J) (W : Set J) : GlobalList J := by
  classical
  exact ⟨K.indices.filter (fun i => (K.entry i ∩ W).Nonempty), K.entry⟩

theorem prune_membership (K : GlobalList J) (W : Set J) (i : ℕ) (x : J) :
    i ∈ (K.prune W).memberships x ↔
      i ∈ K.indices ∧ (K.entry i ∩ W).Nonempty ∧ x ∈ K.entry i := by
  classical
  rw [mem_memberships]
  change (i ∈ K.indices.filter (fun j => (K.entry j ∩ W).Nonempty) ∧
    x ∈ K.entry i) ↔ _
  rw [Finset.mem_filter]
  exact and_assoc

theorem prune_qual_subset (K : GlobalList J) (W : Set J) : (K.prune W).Qual ⊆ K.Qual := by
  rintro x ⟨i, hi, hx⟩
  have hm := (prune_membership K W i x).mp ((mem_memberships _ _ _).mpr ⟨hi, hx⟩)
  exact ⟨i, hm.1, hm.2.2⟩

theorem prune_qual (K : GlobalList J) {W : Set J} {x : J} (hx : x ∈ W) :
    x ∈ (K.prune W).Qual ↔ x ∈ K.Qual := by
  refine ⟨fun h => prune_qual_subset K W h, ?_⟩
  rintro ⟨i, hi, hxi⟩
  refine ⟨i, ?_⟩
  apply (mem_memberships _ _ _).mp
  exact (prune_membership K W i x).mpr ⟨hi, ⟨x, hxi, hx⟩, hxi⟩

theorem prune_lastIndex_le (K : GlobalList J) (W : Set J) (x : J) :
    (K.prune W).lastIndex x ≤ K.lastIndex x := by
  apply Finset.sup_le
  intro i hi
  have hm := (prune_membership K W i x).mp hi
  exact le_lastIndex hm.1 hm.2.2

theorem prune_lastIndex (K : GlobalList J) {W : Set J} {x : J} (hx : x ∈ W) :
    (K.prune W).lastIndex x = K.lastIndex x := by
  apply le_antisymm (prune_lastIndex_le K W x)
  apply Finset.sup_le
  intro i hi
  have hm := (mem_memberships K x i).mp hi
  apply Finset.le_sup (f := id)
  exact (prune_membership K W i x).mpr ⟨hm.1, ⟨x, hm.2, hx⟩, hm.2⟩

theorem prune_key {K : GlobalList J} {W : Set J} {rank : J → ℕ} {x y : J}
    (hx : x ∈ W) (hkey : (K.prune W).KeyLT rank x y) : K.KeyLT rank x y := by
  have heq := prune_lastIndex K hx
  have hle := prune_lastIndex_le K W y
  rcases hkey with h | ⟨h, hr⟩
  · exact Or.inl (by omega)
  · by_cases hlt : K.lastIndex x < K.lastIndex y
    · exact Or.inl hlt
    · exact Or.inr ⟨by omega, hr⟩

theorem prune_upsets {K : GlobalList J} {W : Set J} {r : J → J → Prop}
    (hK : K.Upsets r) : (K.prune W).Upsets r := by
  classical
  intro i hi
  have hi' : i ∈ K.indices ∧ (K.entry i ∩ W).Nonempty := by simpa [prune] using hi
  exact hK i hi'.1

end GlobalList
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section IntervalNormalization
variable {J : Type} [Fintype J]

def Layout.FixedOutside (p q : Layout J) (W : Set J) : Prop :=
  ∀ x, x ∉ W → q x = p x

theorem Layout.FixedOutside.refl (p : Layout J) (W : Set J) : p.FixedOutside p W :=
  fun _ _ => rfl

theorem Layout.FixedOutside.trans {p q u : Layout J} {W : Set J}
    (hpq : p.FixedOutside q W) (hqu : q.FixedOutside u W) : p.FixedOutside u W :=
  fun x hx => (hqu x hx).trans (hpq x hx)

theorem Layout.FixedOutside.mono {p q : Layout J} {W U : Set J}
    (h : p.FixedOutside q W) (hWU : W ⊆ U) : p.FixedOutside q U :=
  fun x hx => h x (fun hW => hx (hWU hW))

theorem Layout.FixedOutside.time {p q : Layout J} {W : Set J}
    (h : p.FixedOutside q W) {x : J} (hx : x ∉ W) : q.time x = p.time x := by
  simp [Layout.time, h x hx]

theorem Layout.FixedOutside.symm_position {p q : Layout J} {W : Set J}
    (h : p.FixedOutside q W) (i : Fin (Fintype.card J)) (hi : p.symm i ∉ W) :
    q.symm i = p.symm i := by
  apply q.injective
  rw [q.apply_symm_apply, h _ hi, p.apply_symm_apply]

theorem Layout.FixedOutside.position_mem {p q : Layout J} {W : Set J}
    (h : p.FixedOutside q W) {x : J} (hx : x ∈ W) : p.symm (q x) ∈ W := by
  by_contra hn
  have he : q (p.symm (q x)) = q x := by rw [h _ hn, p.apply_symm_apply]
  apply hn
  rw [q.injective he]
  exact hx

theorem Layout.FixedOutside.time_range {p q : Layout J} {W : Set J} {a b : ℕ}
    (h : p.FixedOutside q W) (hW : ∀ x ∈ W, a < p.time x ∧ p.time x < b)
    {x : J} (hx : x ∈ W) : a < q.time x ∧ q.time x < b := by
  have hr := hW _ (h.position_mem hx)
  simpa [Layout.time] using hr

theorem reorder_respects {p q : Layout J} {W : Set J} {a b : ℕ}
    {r : J → J → Prop} (hp : p.Respects r) (hfix : p.FixedOutside q W)
    (hW : ∀ x, x ∈ W ↔ a < p.time x ∧ p.time x < b)
    (hq : ∀ x ∈ W, ∀ y ∈ W, r x y → q.time x < q.time y) : q.Respects r := by
  intro x y hxy
  have ht := hp x y hxy
  by_cases hx : x ∈ W
  · by_cases hy : y ∈ W
    · exact hq x hx y hy hxy
    · have hxt := hfix.time_range (fun z hz => (hW z).mp hz) hx
      have hxp := (hW x).mp hx
      have hyp : ¬(a < p.time y ∧ p.time y < b) := fun h => hy ((hW y).mpr h)
      rw [hfix.time hy]
      omega
  · rw [hfix.time hx]
    by_cases hy : y ∈ W
    · have hyt := hfix.time_range (fun z hz => (hW z).mp hz) hy
      have hyp := (hW y).mp hy
      have hxp : ¬(a < p.time x ∧ p.time x < b) := fun h => hx ((hW x).mpr h)
      omega
    · rw [hfix.time hy]
      exact ht

def Layout.NormalizedOn (p : Layout J) (W : Set J)
    (r : J → J → Prop) (priority : J → ℕ) : Prop :=
  p.Respects r ∧ ∀ q : Layout J, q.Respects r → p.FixedOutside q W →
    p.signature priority ≤ q.signature priority

theorem exists_normalizedOn (p : Layout J) (W : Set J) (r : J → J → Prop)
    (priority : J → ℕ) (hp : p.Respects r) :
    ∃ q : Layout J, p.FixedOutside q W ∧ q.NormalizedOn W r priority := by
  classical
  let candidates : Finset (Layout J) := Finset.univ.filter
    (fun q => q.Respects r ∧ p.FixedOutside q W)
  have hne : candidates.Nonempty := ⟨p, by simp [candidates, hp, Layout.FixedOutside.refl]⟩
  obtain ⟨q, hq, hmin⟩ := candidates.exists_min_image (fun q => q.signature priority) hne
  have hq' : q.Respects r ∧ p.FixedOutside q W := by simpa [candidates] using hq
  refine ⟨q, hq'.2, hq'.1, ?_⟩
  intro u hu hqu
  exact hmin u (by simp [candidates, hu, hq'.2.trans hqu])

theorem normalizedOn_no_improvement {p q : Layout J} {W : Set J}
    {r : J → J → Prop} {priority : J → ℕ} (hp : p.NormalizedOn W r priority)
    (hq : q.Respects r) (hfix : p.FixedOutside q W)
    (i : Fin (Fintype.card J))
    (hbefore : ∀ j, j < i → priority (q.symm j) = priority (p.symm j))
    (hi : priority (q.symm i) < priority (p.symm i)) : False := by
  have hlt : q.signature priority < p.signature priority :=
    ofFn_lt_of_first_difference _ _ i hbefore hi
  exact (not_lt_of_ge (hp.2 q hq hfix)) hlt

theorem exchange_fixedOutside [DecidableEq J] {p : Layout J} {W : Set J}
    {x y : J} (hx : x ∈ W) (hy : y ∈ W) : p.FixedOutside (p.exchange x y) W := by
  intro z hz
  have hzx : z ≠ x := fun e => hz (e ▸ hx)
  have hzy : z ≠ y := fun e => hz (e ▸ hy)
  simp [Layout.exchange, Equiv.swap_apply_of_ne_of_ne hzx hzy]

theorem normalizedOn_prefix_no_exchange [DecidableEq J]
    {p q : Layout J} {W : Set J} {r : J → J → Prop} {priority : J → ℕ}
    (hp : p.NormalizedOn W r priority) (hfix : p.FixedOutside q W)
    {x y : J} (hx : x ∈ W) (hy : y ∈ W)
    (hprefix : ∀ j, j ≤ p y → q.symm j = p.symm j)
    (ht : q.time y < q.time x) (hbetter : priority x < priority y)
    (hswap : (q.exchange x y).Respects r) : False := by
  have hqy : q y = p y := by
    have he := hprefix (p y) le_rfl
    simp only [p.symm_apply_apply] at he
    exact (congrArg q he).symm.trans (q.apply_symm_apply _)
  have hpos : p y < q x := by
    change (p y).val < (q x).val
    dsimp [Layout.time] at ht
    rw [hqy] at ht
    omega
  apply normalizedOn_no_improvement hp hswap
    (hfix.trans (exchange_fixedOutside hx hy)) (p y)
  · intro j hj
    have hpy := hprefix j hj.le
    have hny : q.symm j ≠ y := by
      intro e
      have he : j = p y := by simpa [hqy] using congrArg q e
      exact (ne_of_lt hj) he
    have hnx : q.symm j ≠ x := by
      intro e
      have he : j = q x := by simpa using congrArg q e
      rw [he] at hj
      exact (not_lt_of_ge hpos.le) hj
    change priority ((Equiv.swap x y) (q.symm j)) = priority (p.symm j)
    rw [Equiv.swap_apply_of_ne_of_ne hnx hny, hpy]
  · have hpy := hprefix (p y) le_rfl
    simp only [p.symm_apply_apply] at hpy
    simpa [Layout.exchange, hpy] using hbetter

theorem normalizedOn_local_obstruction {p : Layout J} {W : Finset J}
    {a b : ℕ} {r : J → J → Prop} {priority : J → ℕ}
    (hp : p.NormalizedOn (W : Set J) r priority)
    (hW : ∀ z, z ∈ W ↔ a < p.time z ∧ p.time z < b) :
    LocalObstruction W r p.time priority := by
  classical
  intro x hx y hy htyx hbetter hpred
  by_contra hn
  have hsucc : ∀ v, r y v → p.time x < p.time v := by
    intro v hyv
    have hyvTime := hp.1 y v hyv
    by_cases hv : v ∈ W
    · by_contra h
      exact hn ⟨v, hv, hyv, by omega⟩
    · have hnt : ¬(a < p.time v ∧ p.time v < b) := fun h => hv ((hW v).mpr h)
      have hxt := (hW x).mp hx
      have hyt := (hW y).mp hy
      omega
  have hready : ∀ u, r u x → p.time u < p.time y := by
    intro u hux
    by_cases hu : u ∈ W
    · exact hpred u hu hux
    · have huxTime := hp.1 u x hux
      have hnt : ¬(a < p.time u ∧ p.time u < b) := fun h => hu ((hW u).mpr h)
      have hxt := (hW x).mp hx
      have hyt := (hW y).mp hy
      omega
  exact normalizedOn_prefix_no_exchange hp (Layout.FixedOutside.refl p _)
    hx hy (fun _ _ => rfl) htyx hbetter (respects_exchange hp.1 x y htyx hready hsucc)

end IntervalNormalization
end ThreeMachine.Structure

namespace ThreeMachine.Structure

abbrev Triple (J : Type) := {Z : Finset J // Z.card = 3}

inductive Boundary (J : Type)
  | left
  | actual (Z : Triple J)
  | right

namespace Boundary
variable {J : Type}

def pred (r : J → J → Prop) : Boundary J → Set J
  | .left => ∅
  | .actual Z => {x | ∃ y ∈ Z.val, r x y}
  | .right => Set.univ

def desc (r : J → J → Prop) : Boundary J → Set J
  | .left => Set.univ
  | .actual Z => {x | ∃ y ∈ Z.val, r y x}
  | .right => ∅

def weakPred (r : J → J → Prop) : Boundary J → Set J
  | .left => ∅
  | .actual Z => pred r (.actual Z) ∪ (Z.val : Set J)
  | .right => Set.univ

def weakDesc (r : J → J → Prop) : Boundary J → Set J
  | .left => Set.univ
  | .actual Z => desc r (.actual Z) ∪ (Z.val : Set J)
  | .right => ∅

def reverse : Boundary J → Boundary J
  | .left => .right
  | .actual Z => .actual Z
  | .right => .left

@[simp] theorem reverse_reverse (B : Boundary J) : B.reverse.reverse = B := by cases B <;> rfl

@[simp] theorem pred_reverse (r : J → J → Prop) (B : Boundary J) :
    B.reverse.pred (fun x y => r y x) = B.desc r := by cases B <;> rfl

@[simp] theorem desc_reverse (r : J → J → Prop) (B : Boundary J) :
    B.reverse.desc (fun x y => r y x) = B.pred r := by cases B <;> rfl

@[simp] theorem weakPred_reverse (r : J → J → Prop) (B : Boundary J) :
    B.reverse.weakPred (fun x y => r y x) = B.weakDesc r := by cases B <;> rfl

@[simp] theorem weakDesc_reverse (r : J → J → Prop) (B : Boundary J) :
    B.reverse.weakDesc (fun x y => r y x) = B.weakPred r := by cases B <;> rfl

theorem pred_downset {r : J → J → Prop}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c) (B : Boundary J) :
    GlobalDownset r (B.pred r) := by
  intro x y hxy hy
  cases B with
  | left => exact hy.elim
  | right => trivial
  | actual Z =>
      obtain ⟨z, hz, hyz⟩ := hy
      exact ⟨z, hz, htrans hxy hyz⟩

theorem desc_upset {r : J → J → Prop}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c) (B : Boundary J) :
    GlobalUpset r (B.desc r) := by
  intro x y hxy hx
  cases B with
  | left => trivial
  | right => exact hx.elim
  | actual Z =>
      obtain ⟨z, hz, hzx⟩ := hx
      exact ⟨z, hz, htrans hzx hxy⟩

theorem weakPred_downset {r : J → J → Prop}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c) (B : Boundary J) :
    GlobalDownset r (B.weakPred r) := by
  intro x y hxy hy
  cases B with
  | left => exact hy.elim
  | right => trivial
  | actual Z =>
      rcases hy with h | h
      · exact Or.inl (pred_downset htrans (.actual Z) hxy h)
      · exact Or.inl ⟨y, h, hxy⟩

theorem weakDesc_upset {r : J → J → Prop}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c) (B : Boundary J) :
    GlobalUpset r (B.weakDesc r) := by
  intro x y hxy hx
  cases B with
  | left => trivial
  | right => exact hx.elim
  | actual Z =>
      rcases hx with h | h
      · exact Or.inl (desc_upset htrans (.actual Z) hxy h)
      · exact Or.inl ⟨x, h, hxy⟩

def At (time : J → ℕ) (T : ℕ) : Boundary J → ℕ → Prop
  | .left, s => s = 0
  | .actual Z, s => 1 ≤ s ∧ s ≤ T ∧ ∀ x, x ∈ Z.val ↔ time x = s
  | .right, s => s = T + 1

theorem pred_time {r : J → J → Prop} {time : J → ℕ} {T s : ℕ} {B : Boundary J}
    (hrespect : ∀ u v, r u v → time u < time v)
    (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T) (hB : B.At time T s)
    {x : J} (hx : x ∈ B.pred r) : time x < s := by
  cases B with
  | left => exact hx.elim
  | right => have := (hbound x).2; dsimp [At] at hB; omega
  | actual Z =>
      obtain ⟨y, hy, hxy⟩ := hx
      have he := (hB.2.2 y).mp hy
      have := hrespect x y hxy
      omega

theorem desc_time {r : J → J → Prop} {time : J → ℕ} {T s : ℕ} {B : Boundary J}
    (hrespect : ∀ u v, r u v → time u < time v)
    (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T) (hB : B.At time T s)
    {x : J} (hx : x ∈ B.desc r) : s < time x := by
  cases B with
  | left => have := (hbound x).1; dsimp [At] at hB; omega
  | right => exact hx.elim
  | actual Z =>
      obtain ⟨y, hy, hyx⟩ := hx
      have he := (hB.2.2 y).mp hy
      have := hrespect y x hyx
      omega

theorem weakPred_time {r : J → J → Prop} {time : J → ℕ} {T s : ℕ} {B : Boundary J}
    (hrespect : ∀ u v, r u v → time u < time v)
    (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T) (hB : B.At time T s)
    {x : J} (hx : x ∈ B.weakPred r) : time x ≤ s := by
  cases B with
  | left => exact hx.elim
  | right => have := (hbound x).2; dsimp [At] at hB; omega
  | actual Z =>
      rcases hx with h | h
      · exact (pred_time hrespect hbound hB h).le
      · exact ((hB.2.2 x).mp h).le

theorem weakDesc_time {r : J → J → Prop} {time : J → ℕ} {T s : ℕ} {B : Boundary J}
    (hrespect : ∀ u v, r u v → time u < time v)
    (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T) (hB : B.At time T s)
    {x : J} (hx : x ∈ B.weakDesc r) : s ≤ time x := by
  cases B with
  | left => dsimp [At] at hB; omega
  | right => exact hx.elim
  | actual Z =>
      rcases hx with h | h
      · exact (desc_time hrespect hbound hB h).le
      · exact ((hB.2.2 x).mp h).ge

theorem mem_weak_at_time {r : J → J → Prop} {time : J → ℕ} {T s : ℕ} {B : Boundary J}
    (hbound : ∀ x, 1 ≤ time x ∧ time x ≤ T) (hB : B.At time T s)
    {x : J} (hx : time x = s) : x ∈ B.weakPred r ∧ x ∈ B.weakDesc r := by
  cases B with
  | left => have := (hbound x).1; dsimp [At] at hB; omega
  | right => have := (hbound x).2; dsimp [At] at hB; omega
  | actual Z => exact ⟨Or.inr ((hB.2.2 x).mpr hx), Or.inr ((hB.2.2 x).mpr hx)⟩

theorem actual_pred_eq {r : J → J → Prop} {time : J → ℕ} {T s : ℕ} {Z : Triple J}
    (hZ : (Boundary.actual Z).At time T s) :
    (Boundary.actual Z).pred r = PredAt r time s := by
  ext x
  simp only [pred, PredAt, Set.mem_ofPred_eq, hZ.2.2]

theorem actual_desc_eq {r : J → J → Prop} {time : J → ℕ} {T s : ℕ} {Z : Triple J}
    (hZ : (Boundary.actual Z).At time T s) :
    (Boundary.actual Z).desc r = DescAt r time s := by
  ext x
  simp only [desc, DescAt, Set.mem_ofPred_eq, hZ.2.2]

end Boundary

inductive Formula (A : Type)
  | leaf (atom : A) (negative : Bool)
  | conj (p q : Formula A)
  | disj (p q : Formula A)

namespace Formula
variable {A J : Type}

def leaves : Formula A → ℕ
  | .leaf _ _ => 1
  | .conj p q | .disj p q => p.leaves + q.leaves

def eval (atoms : A → Set J) : Formula A → Set J
  | .leaf a false => atoms a
  | .leaf a true => (atoms a)ᶜ
  | .conj p q => p.eval atoms ∩ q.eval atoms
  | .disj p q => p.eval atoms ∪ q.eval atoms

def negate : Formula A → Formula A
  | .leaf a b => .leaf a (!b)
  | .conj p q => .disj p.negate q.negate
  | .disj p q => .conj p.negate q.negate

@[simp] theorem leaves_negate (p : Formula A) : p.negate.leaves = p.leaves := by
  induction p with
  | leaf a b => cases b <;> rfl
  | conj p q hp hq | disj p q hp hq => simp [negate, leaves, hp, hq]

@[simp] theorem eval_negate (atoms : A → Set J) (p : Formula A) :
    p.negate.eval atoms = (p.eval atoms)ᶜ := by
  induction p with
  | leaf a b => cases b <;> simp [negate, eval]
  | conj p q hp hq =>
      ext x
      simp only [negate, eval, hp, hq, Set.mem_union, Set.mem_compl_iff, Set.mem_inter_iff]
      tauto
  | disj p q hp hq => simp [negate, eval, hp, hq]

theorem leaves_pos (p : Formula A) : 0 < p.leaves := by
  induction p with
  | leaf => exact Nat.zero_lt_one
  | conj p q hp hq | disj p q hp hq => dsimp [leaves]; omega

end Formula

def Described {A J : Type} (atoms : A → Set J) (W : Set J) (k : ℕ) : Prop :=
  ∃ p : Formula A, p.eval atoms = W ∧ p.leaves ≤ k

namespace Described
variable {A J : Type} {atoms : A → Set J} {W U : Set J} {k l : ℕ}

theorem mono (h : Described atoms W k) (hkl : k ≤ l) : Described atoms W l := by
  obtain ⟨p, hp, hk⟩ := h
  exact ⟨p, hp, hk.trans hkl⟩

theorem atom (a : A) : Described atoms (atoms a) 1 := ⟨.leaf a false, rfl, le_rfl⟩

theorem compl (h : Described atoms W k) : Described atoms Wᶜ k := by
  obtain ⟨p, hp, hk⟩ := h
  exact ⟨p.negate, by simp [hp], by simpa using hk⟩

theorem inter (hW : Described atoms W k) (hU : Described atoms U l) :
    Described atoms (W ∩ U) (k + l) := by
  obtain ⟨p, hp, hk⟩ := hW
  obtain ⟨q, hq, hl⟩ := hU
  exact ⟨.conj p q, by simp [Formula.eval, hp, hq], Nat.add_le_add hk hl⟩

theorem union (hW : Described atoms W k) (hU : Described atoms U l) :
    Described atoms (W ∪ U) (k + l) := by
  obtain ⟨p, hp, hk⟩ := hW
  obtain ⟨q, hq, hl⟩ := hU
  exact ⟨.disj p q, by simp [Formula.eval, hp, hq], Nat.add_le_add hk hl⟩

theorem diff (hW : Described atoms W k) (hU : Described atoms U l) :
    Described atoms (W \ U) (k + l) := hW.inter hU.compl

theorem finite_union {ι : Type} (s : Finset ι) (E : ι → Set J) (b : ι → ℕ)
    (hne : s.Nonempty) (hE : ∀ i ∈ s, Described atoms (E i) (b i)) :
    Described atoms {x | ∃ i ∈ s, x ∈ E i} (∑ i ∈ s, b i) := by
  classical
  induction s using Finset.induction_on with
  | empty => exact (Finset.not_nonempty_empty hne).elim
  | @insert i s hi ih =>
      by_cases hs : s.Nonempty
      · have hrest := ih hs (fun j hj => hE j (Finset.mem_insert_of_mem hj))
        have hfirst := hE i (Finset.mem_insert_self _ _)
        have he : {x | ∃ j ∈ insert i s, x ∈ E j} = E i ∪ {x | ∃ j ∈ s, x ∈ E j} := by
          ext x
          simp only [Set.mem_ofPred_eq, Finset.mem_insert, Set.mem_union]
          aesop
        rw [he, Finset.sum_insert hi]
        exact hfirst.union hrest
      · have es : s = ∅ := Finset.not_nonempty_iff_eq_empty.mp hs
        subst s
        simpa using hE i (Finset.mem_insert_self i ∅)

end Described
end ThreeMachine.Structure

end

end OAI