lean/OAI/Computability/Scheduling/SeparatorWalk.lean

import OAI.Computability.Scheduling.Model

namespace OAI

section

namespace ThreeMachine
namespace Structure

abbrev Layout (J : Type) [Fintype J] := J ≃ Fin (Fintype.card J)

def Layout.time {J : Type} [Fintype J] (p : Layout J) (x : J) : ℕ :=
  (p x).val / 3 + 1

def Layout.Respects {J : Type} [Fintype J] (p : Layout J)
    (r : J → J → Prop) : Prop :=
  ∀ x y, r x y → p.time x < p.time y

def Layout.Full {J : Type} [Fintype J] (p : Layout J)
    (r : J → J → Prop) : Prop :=
  3 ∣ Fintype.card J ∧ p.Respects r

def Layout.signature {J : Type} [Fintype J] (p : Layout J)
    (priority : J → ℕ) : List ℕ :=
  List.ofFn (fun i => priority (p.symm i))

def Layout.Normalized {J : Type} [Fintype J] (p : Layout J)
    (r : J → J → Prop) (priority : J → ℕ) : Prop :=
  p.Respects r ∧ ∀ q : Layout J, q.Respects r →
    p.signature priority ≤ q.signature priority

theorem exists_normalized {J : Type} [Fintype J] (r : J → J → Prop)
    (priority : J → ℕ) (p : Layout J) (hp : p.Respects r) :
    ∃ q : Layout J, q.Normalized r priority := by
  classical
  let candidates : Finset (Layout J) := Finset.univ.filter (fun q => q.Respects r)
  have hc : candidates.Nonempty := ⟨p, by simp [candidates, hp]⟩
  obtain ⟨q, hq, hmin⟩ := candidates.exists_min_image
    (fun q => q.signature priority) hc
  refine ⟨q, ?_, ?_⟩
  · simpa [candidates] using hq
  · intro q' hq'
    exact hmin q' (by simp [candidates, hq'])

theorem ofFn_lt_of_first_difference {n : ℕ} (f g : Fin n → ℕ)
    (i : Fin n) (hbefore : ∀ j, j < i → f j = g j) (hi : f i < g i) :
    List.ofFn f < List.ofFn g := by
  induction n with
  | zero => exact Fin.elim0 i
  | succ n ih =>
    rw [List.ofFn_succ, List.ofFn_succ]
    by_cases h0 : i.val = 0
    · have e : i = 0 := Fin.ext h0
      exact List.Lex.rel (by simpa [e] using hi)
    · let j : Fin n := ⟨i.val - 1, by omega⟩
      have ei : j.succ = i := Fin.ext (by dsimp [j]; omega)
      have he : f 0 = g 0 := hbefore 0 (by change 0 < i.val; omega)
      rw [he]
      apply List.Lex.cons
      apply ih (fun k => f k.succ) (fun k => g k.succ) j
      · intro k hk
        apply hbefore k.succ
        rw [← ei]
        exact Fin.succ_lt_succ_iff.mpr hk
      · simpa [ei] using hi

theorem normalized_no_improvement {J : Type} [Fintype J]
    {p q : Layout J} {r : J → J → Prop} {priority : J → ℕ}
    (hp : p.Normalized r priority) (hq : q.Respects r)
    (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)) hlt

def Layout.exchange {J : Type} [Fintype J] [DecidableEq J]
    (p : Layout J) (x y : J) : Layout J :=
  (Equiv.swap x y).trans p

@[simp] theorem exchange_time_left {J : Type} [Fintype J] [DecidableEq J]
    (p : Layout J) (x y : J) : (p.exchange x y).time x = p.time y := by
  simp [Layout.time, Layout.exchange]

@[simp] theorem exchange_time_right {J : Type} [Fintype J] [DecidableEq J]
    (p : Layout J) (x y : J) : (p.exchange x y).time y = p.time x := by
  simp [Layout.time, Layout.exchange]

theorem exchange_time_other {J : Type} [Fintype J] [DecidableEq J]
    (p : Layout J) (x y z : J) (hx : z ≠ x) (hy : z ≠ y) :
    (p.exchange x y).time z = p.time z := by
  simp [Layout.time, Layout.exchange, Equiv.swap_apply_of_ne_of_ne hx hy]

theorem respects_exchange {J : Type} [Fintype J] [DecidableEq J]
    {p : Layout J} {r : J → J → Prop} (hp : p.Respects r)
    (x y : J) (hxy : p.time y < p.time x)
    (hpred : ∀ u, r u x → p.time u < p.time y)
    (hsucc : ∀ v, r y v → p.time x < p.time v) :
    (p.exchange x y).Respects r := by
  intro u v huv
  have htime := hp u v huv
  by_cases hux : u = x
  · subst u
    by_cases hvx : v = x
    · subst v
      omega
    by_cases hvy : v = y
    · subst v
      simp only [exchange_time_left, exchange_time_right]
      exact hxy
    rw [exchange_time_left, exchange_time_other p x y v hvx hvy]
    exact hxy.trans htime
  by_cases huy : u = y
  · subst u
    have hav := hsucc v huv
    by_cases hvx : v = x
    · subst v
      omega
    by_cases hvy : v = y
    · subst v
      omega
    rw [exchange_time_right, exchange_time_other p x y v hvx hvy]
    exact hav
  rw [exchange_time_other p x y u hux huy]
  by_cases hvx : v = x
  · subst v
    rw [exchange_time_left]
    exact hpred u huv
  by_cases hvy : v = y
  · subst v
    rw [exchange_time_right]
    exact htime.trans hxy
  rw [exchange_time_other p x y v hvx hvy]
  exact htime

theorem normalized_no_exchange {J : Type} [Fintype J] [DecidableEq J]
    {p : Layout J} {r : J → J → Prop} {priority : J → ℕ}
    (hp : p.Normalized r priority) (x y : J)
    (ht : p.time y < p.time x) (hbetter : priority x < priority y)
    (hswap : (p.exchange x y).Respects r) : False := by
  have hpos : p y < p x := by
    change (p y).val < (p x).val
    dsimp [Layout.time] at ht
    omega
  apply normalized_no_improvement hp hswap (p y)
  · intro j hj
    have hy : p.symm j ≠ y := by
      intro h
      have : j = p y := by simpa using congrArg p h
      exact (ne_of_lt hj) this
    have hx : p.symm j ≠ x := by
      intro h
      have : j = p x := by simpa using congrArg p h
      rw [this] at hj
      exact (not_lt_of_ge hpos.le) hj
    simp [Layout.exchange, Equiv.swap_apply_of_ne_of_ne hx hy]
  · simpa [Layout.exchange] using hbetter

end Structure
end ThreeMachine

namespace ThreeMachine.Structure

section Walk
variable {J : Type}

def PredAt (r : J → J → Prop) (time : J → ℕ) (s : ℕ) : Set J :=
  {x | ∃ y, time y = s ∧ r x y}

def DescAt (r : J → J → Prop) (time : J → ℕ) (s : ℕ) : Set J :=
  {x | ∃ y, time y = s ∧ r y x}

def IdealOn (W : Finset J) (r : J → J → Prop) (S : Set J) : Prop :=
  ∀ x ∈ W, ∀ y ∈ W, r x y → y ∈ S → x ∈ S

def PrefixOn (W : Finset J) (priority : J → ℕ) (S : Set J) : Prop :=
  ∀ x ∈ W, x ∈ S → ∀ y ∈ W, y ∉ S → priority x < priority y

def EarlierHigh (W : Finset J) (r : J → J → Prop) (time : J → ℕ)
    (S : Set J) (s : ℕ) : Prop :=
  ∀ x ∈ W, time x < s → x ∉ S → x ∈ PredAt r time s

def LaterLow (W : Finset J) (r : J → J → Prop) (time : J → ℕ)
    (S : Set J) (s : ℕ) : Prop :=
  ∀ x ∈ W, s < time x → x ∈ S → x ∈ DescAt r time s

def Separator (W : Finset J) (r : J → J → Prop) (time : J → ℕ)
    (S : Set J) (s : ℕ) : Prop :=
  EarlierHigh W r time S s ∧ LaterLow W r time S s

def SlotClosed (W : Finset J) (time : J → ℕ) : Prop :=
  ∀ x ∈ W, ∀ y, time y = time x → y ∈ W

def AdmissiblePosition (W : Finset J) (time : J → ℕ) (s : ℕ) : Prop :=
  (∃ x ∈ W, time x = s) ∨ (∀ x ∈ W, s < time x)

def LocalObstruction (W : Finset J) (r : J → J → Prop)
    (time priority : J → ℕ) : Prop :=
  ∀ x ∈ W, ∀ y ∈ W, time y < time x → priority x < priority y →
    (∀ u ∈ W, r u x → time u < time y) →
    ∃ v ∈ W, r y v ∧ time v ≤ time x

theorem normalized_local_obstruction [Fintype J] {r : J → J → Prop} {priority : J → ℕ}
    {p : Layout J} (hp : p.Normalized r priority) :
    LocalObstruction Finset.univ r p.time priority := by
  classical
  intro x _ y _ ht hbetter hpred
  by_contra h
  have hsucc : ∀ v, r y v → p.time x < p.time v := by
    intro v hyv
    by_contra hn
    apply h
    exact ⟨v, Finset.mem_univ _, hyv, by omega⟩
  exact normalized_no_exchange hp x y ht hbetter
    (respects_exchange hp.1 x y ht (fun u hu => hpred u (Finset.mem_univ _) hu) hsucc)

structure Exception (W : Finset J) (r : J → J → Prop) (time : J → ℕ)
    (S : Set J) (s : ℕ) (x : J) : Prop where
  mem : x ∈ W
  low : x ∈ S
  later : s < time x
  not_desc : x ∉ DescAt r time s
  earliest : ∀ y ∈ W, y ∈ S → s < time y → time y < time x →
    y ∈ DescAt r time s

theorem exists_exception {W : Finset J} {r : J → J → Prop} {time : J → ℕ}
    {S : Set J} {s : ℕ} (h : ¬LaterLow W r time S s) :
    ∃ x, Exception W r time S s x := by
  classical
  let candidates := W.filter (fun x => s < time x ∧ x ∈ S ∧ x ∉ DescAt r time s)
  have hne : candidates.Nonempty := by
    simp only [LaterLow, not_forall] at h
    obtain ⟨x, hw, ht, hS, hD⟩ := h
    exact ⟨x, by simp [candidates, hw, ht, hS, hD]⟩
  obtain ⟨x, hx, hmin⟩ := candidates.exists_min_image time hne
  have hx' : x ∈ W ∧ s < time x ∧ x ∈ S ∧ x ∉ DescAt r time s := by
    simpa [candidates] using hx
  refine ⟨x, hx'.1, hx'.2.2.1, hx'.2.1, hx'.2.2.2, ?_⟩
  intro y hy hlow hsy hyx
  by_contra hnd
  have hmem : y ∈ candidates := by simp [candidates, hy, hsy, hlow, hnd]
  have := hmin y hmem
  omega

theorem exception_ready {W : Finset J} {r : J → J → Prop} {time : J → ℕ}
    {S : Set J} {s : ℕ} {x : J}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c) (hrespect : ∀ u v, r u v → time u < time v)
    (hideal : IdealOn W r S) (hx : Exception W r time S s x) :
    ∀ u ∈ W, r u x → time u < s := by
  intro u hu hux
  have huxTime := hrespect u x hux
  have huLow := hideal u hu x hx.mem hux hx.low
  by_contra hn
  have hsu : s ≤ time u := by omega
  rcases hsu.eq_or_lt with heq | hlt
  · exact hx.not_desc ⟨u, heq.symm, hux⟩
  · obtain ⟨y, hy, hyu⟩ := hx.earliest u hu huLow hlt huxTime
    exact hx.not_desc ⟨y, hy, htrans hyu hux⟩

theorem trace_to_slot {W : Finset J} {r : J → J → Prop} {time : J → ℕ}
    {S : Set J} {s t : ℕ}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c) (hrespect : ∀ u v, r u v → time u < time v)
    (hideal : IdealOn W r S)
    (hforce : ∀ y ∈ W, y ∉ S → s ≤ time y → time y < t →
      ∃ z ∈ W, r y z ∧ time z ≤ t)
    (y : J) (hy : y ∈ W) (hyHigh : y ∉ S) (hsy : s ≤ time y)
    (hyt : time y ≤ t) :
    ∃ z ∈ W, time z = t ∧ (y = z ∨ r y z) ∧ z ∉ S := by
  classical
  let candidates := W.filter (fun z => (y = z ∨ r y z) ∧ time z ≤ t)
  have hne : candidates.Nonempty := ⟨y, by simp [candidates, hy, hyt]⟩
  obtain ⟨z, hz, hmax⟩ := candidates.exists_max_image time hne
  have hz' : z ∈ W ∧ (y = z ∨ r y z) ∧ time z ≤ t := by
    simpa [candidates] using hz
  have hzHigh : z ∉ S := by
    intro hlow
    rcases hz'.2.1 with e | hrel
    · exact hyHigh (e ▸ hlow)
    · exact hyHigh (hideal y hy z hz'.1 hrel hlow)
  have hsz : s ≤ time z := by
    rcases hz'.2.1 with e | hrel
    · simpa [← e] using hsy
    · exact hsy.trans (hrespect y z hrel).le
  have hzt : time z = t := by
    by_contra hn
    have hlt : time z < t := by omega
    obtain ⟨v, hv, hzv, hvt⟩ := hforce z hz'.1 hzHigh hsz hlt
    have hyv : r y v := by
      rcases hz'.2.1 with e | hrel
      · simpa [e] using hzv
      · exact htrans hrel hzv
    have hv' : v ∈ candidates := by simp [candidates, hv, hyv, hvt]
    have := hmax v hv'
    have := hrespect z v hzv
    omega
  exact ⟨z, hz'.1, hzt, hz'.2.1, hzHigh⟩

theorem advance_earlier_high {W : Finset J} {r : J → J → Prop}
    {time priority : J → ℕ} {S : Set J} {s : ℕ} {x : J}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c) (hrespect : ∀ u v, r u v → time u < time v)
    (hclosed : SlotClosed W time) (hpos : AdmissiblePosition W time s)
    (hideal : IdealOn W r S) (hprefix : PrefixOn W priority S)
    (hnorm : LocalObstruction W r time priority)
    (hbefore : EarlierHigh W r time S s) (hx : Exception W r time S s x) :
    EarlierHigh W r time S (time x) := by
  have hready := exception_ready htrans hrespect hideal hx
  have hforce : ∀ y ∈ W, y ∉ S → s ≤ time y → time y < time x →
      ∃ z ∈ W, r y z ∧ time z ≤ time x := by
    intro y hy hyHigh hsy hyt
    exact hnorm x hx.mem y hy hyt (hprefix x hx.mem hx.low y hy hyHigh)
      (fun u hu hur => (hready u hu hur).trans_le hsy)
  intro z hz hzt hzHigh
  by_cases hzs : time z < s
  · obtain ⟨y, hys, hzy⟩ := hbefore z hz hzs hzHigh
    have hy : y ∈ W := by
      rcases hpos with ⟨a, ha, has⟩ | hleft
      · exact hclosed a ha y (hys.trans has.symm)
      · have := hleft z hz
        omega
    have hyHigh : y ∉ S := by
      intro hylow
      exact hzHigh (hideal z hz y hy hzy hylow)
    obtain ⟨v, _hv, hvt, hyv, _hvHigh⟩ := trace_to_slot htrans hrespect hideal
      hforce y hy hyHigh (by omega) (by have := hx.later; omega)
    refine ⟨v, hvt, ?_⟩
    rcases hyv with e | hrel
    · simpa [e] using hzy
    · exact htrans hzy hrel
  · have hsz : s ≤ time z := by omega
    obtain ⟨v, _hv, hvt, hzv, _hvHigh⟩ := trace_to_slot htrans hrespect hideal
      hforce z hz hzHigh hsz hzt.le
    refine ⟨v, hvt, ?_⟩
    rcases hzv with e | hrel
    · subst v
      omega
    · exact hrel

theorem advance_shared_earlier {W : Finset J} {r : J → J → Prop}
    {time priority : J → ℕ} {S Splus : Set J} {s : ℕ} {x a : J}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c) (hrespect : ∀ u v, r u v → time u < time v)
    (hclosed : SlotClosed W time) (hpos : AdmissiblePosition W time s)
    (hideal : IdealOn W r S) (hidealPlus : IdealOn W r Splus)
    (hprefix : PrefixOn W priority S) (hprefixPlus : PrefixOn W priority Splus)
    (hpromotion : ∀ z ∈ W, z ∈ Splus ↔ z ∈ S ∨ z = a)
    (hnorm : LocalObstruction W r time priority)
    (hbefore : EarlierHigh W r time S s)
    (hx : Exception W r time Splus s x) :
    EarlierHigh W r time S (time x) := by
  by_cases hxOld : x ∈ S
  · apply advance_earlier_high htrans hrespect hclosed hpos hideal hprefix hnorm hbefore
    exact ⟨hx.mem, hxOld, hx.later, hx.not_desc, fun y hy hlow hsy hyx =>
      hx.earliest y hy ((hpromotion y hy).mpr (Or.inl hlow)) hsy hyx⟩
  · have hxa : x = a := ((hpromotion x hx.mem).mp hx.low).resolve_left hxOld
    have hbeforePlus : EarlierHigh W r time Splus s := by
      intro z hz hzs hzHigh
      exact hbefore z hz hzs (fun h => hzHigh ((hpromotion z hz).mpr (Or.inl h)))
    have hnew := advance_earlier_high htrans hrespect hclosed hpos hidealPlus
      hprefixPlus hnorm hbeforePlus hx
    intro z hz hzx hzHigh
    apply hnew z hz hzx
    intro hlow
    rcases (hpromotion z hz).mp hlow with h | e
    · exact hzHigh h
    · have : z = x := e.trans hxa.symm
      have heq : time z = time x := congrArg time this
      omega

end Walk
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section SharedWalk
variable {J : Type}

inductive AdvancePath (W : Finset J) (r : J → J → Prop) (time : J → ℕ)
    (S : Set J) : ℕ → ℕ → Prop
  | refl (s) : AdvancePath W r time S s s
  | step {s t x} : AdvancePath W r time S s t →
      Exception W r time S t x → AdvancePath W r time S s (time x)

theorem AdvancePath.le {W : Finset J} {r : J → J → Prop} {time : J → ℕ}
    {S : Set J} {s t : ℕ} (h : AdvancePath W r time S s t) : s ≤ t := by
  induction h with
  | refl => exact le_rfl
  | step _ hx ih => exact ih.trans hx.later.le

theorem AdvancePath.endpoint {W : Finset J} {r : J → J → Prop} {time : J → ℕ}
    {S : Set J} {s t : ℕ} (h : AdvancePath W r time S s t) :
    t = s ∨ ∃ x ∈ W, time x = t := by
  cases h with
  | refl => exact Or.inl rfl
  | step _ hx => exact Or.inr ⟨_, hx.mem, rfl⟩

theorem AdvancePath.admissible {W : Finset J} {r : J → J → Prop} {time : J → ℕ}
    {S : Set J} {s t : ℕ} (h : AdvancePath W r time S s t)
    (hpos : AdmissiblePosition W time s) : AdmissiblePosition W time t := by
  rcases h.endpoint with e | hmem
  · simpa [e] using hpos
  · exact Or.inl hmem

theorem AdvancePath.shared_earlier {W : Finset J} {r : J → J → Prop}
    {time priority : J → ℕ} {S Splus : Set J} {s t : ℕ} {a : J}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c)
    (hrespect : ∀ u v, r u v → time u < time v)
    (hclosed : SlotClosed W time) (hpos : AdmissiblePosition W time s)
    (hideal : IdealOn W r S) (hidealPlus : IdealOn W r Splus)
    (hprefix : PrefixOn W priority S) (hprefixPlus : PrefixOn W priority Splus)
    (hpromotion : ∀ z ∈ W, z ∈ Splus ↔ z ∈ S ∨ z = a)
    (hnorm : LocalObstruction W r time priority)
    (hbefore : EarlierHigh W r time S s)
    (h : AdvancePath W r time Splus s t) : EarlierHigh W r time S t := by
  induction h with
  | refl => exact hbefore
  | step h hx ih =>
      exact advance_shared_earlier htrans hrespect hclosed (h.admissible hpos)
        hideal hidealPlus hprefix hprefixPlus hpromotion hnorm ih hx

theorem shared_cutoff {W : Finset J} {r : J → J → Prop}
    {time priority : J → ℕ} {S Splus : Set J} {s : ℕ} {a : J}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c)
    (hrespect : ∀ u v, r u v → time u < time v)
    (hclosed : SlotClosed W time) (hpos : AdmissiblePosition W time s)
    (hideal : IdealOn W r S) (hidealPlus : IdealOn W r Splus)
    (hprefix : PrefixOn W priority S) (hprefixPlus : PrefixOn W priority Splus)
    (hpromotion : ∀ z ∈ W, z ∈ Splus ↔ z ∈ S ∨ z = a)
    (hnorm : LocalObstruction W r time priority)
    (hsep : Separator W r time S s) :
    ∃ t, s ≤ t ∧ AdvancePath W r time Splus s t ∧
      Separator W r time S t ∧ Separator W r time Splus t := by
  classical
  let candidates := (insert s (W.image time)).filter (AdvancePath W r time Splus s)
  have hne : candidates.Nonempty := ⟨s, by simp [candidates, AdvancePath.refl]⟩
  obtain ⟨t, ht, hmax⟩ := candidates.exists_max_image id hne
  have hpath : AdvancePath W r time Splus s t := (Finset.mem_filter.mp ht).2
  have hafter : LaterLow W r time Splus t := by
    by_contra hn
    obtain ⟨x, hx⟩ := exists_exception hn
    have hnext : AdvancePath W r time Splus s (time x) := .step hpath hx
    have hmem : time x ∈ candidates := by
      simp only [candidates, Finset.mem_filter, Finset.mem_insert, Finset.mem_image]
      exact ⟨Or.inr ⟨x, hx.mem, rfl⟩, hnext⟩
    have := hmax (time x) hmem
    have := hx.later
    simp only [id_eq] at *
    omega
  have hbefore := hpath.shared_earlier htrans hrespect hclosed hpos hideal hidealPlus
    hprefix hprefixPlus hpromotion hnorm hsep.1
  refine ⟨t, hpath.le, hpath, ⟨hbefore, ?_⟩, ⟨?_, hafter⟩⟩
  · intro x hx htx hlow
    exact hafter x hx htx ((hpromotion x hx).mpr (Or.inl hlow))
  · intro x hx hxt hhigh
    exact hbefore x hx hxt (fun h => hhigh ((hpromotion x hx).mpr (Or.inl h)))

theorem separator_congr {W : Finset J} {r : J → J → Prop} {time : J → ℕ}
    {S Splus : Set J} {s : ℕ} (heq : ∀ z ∈ W, z ∈ S ↔ z ∈ Splus) :
    Separator W r time S s ↔ Separator W r time Splus s := by
  constructor
  · rintro ⟨hbefore, hafter⟩
    constructor
    · intro x hx hxt hhigh
      exact hbefore x hx hxt (fun h => hhigh ((heq x hx).mp h))
    · intro x hx htx hlow
      exact hafter x hx htx ((heq x hx).mpr hlow)
  · rintro ⟨hbefore, hafter⟩
    constructor
    · intro x hx hxt hhigh
      exact hbefore x hx hxt (fun h => hhigh ((heq x hx).mpr h))
    · intro x hx htx hlow
      exact hafter x hx htx ((heq x hx).mp hlow)

end SharedWalk
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section IdealSeparator
variable {J : Type}

theorem AdvancePath.earlier {W : Finset J} {r : J → J → Prop}
    {time priority : J → ℕ} {S : Set J} {s t : ℕ}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c)
    (hrespect : ∀ u v, r u v → time u < time v)
    (hclosed : SlotClosed W time) (hpos : AdmissiblePosition W time s)
    (hideal : IdealOn W r S) (hprefix : PrefixOn W priority S)
    (hnorm : LocalObstruction W r time priority)
    (hbefore : EarlierHigh W r time S s)
    (h : AdvancePath W r time S s t) : EarlierHigh W r time S t := by
  induction h with
  | refl => exact hbefore
  | step h hx ih =>
      exact advance_earlier_high htrans hrespect hclosed
        (h.admissible hpos) hideal hprefix hnorm ih hx

theorem walk_to_separator {W : Finset J} {r : J → J → Prop}
    {time priority : J → ℕ} {S : Set J} {s : ℕ}
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c)
    (hrespect : ∀ u v, r u v → time u < time v)
    (hclosed : SlotClosed W time) (hpos : AdmissiblePosition W time s)
    (hideal : IdealOn W r S) (hprefix : PrefixOn W priority S)
    (hnorm : LocalObstruction W r time priority)
    (hbefore : EarlierHigh W r time S s) :
    ∃ t, s ≤ t ∧ AdvancePath W r time S s t ∧ Separator W r time S t := by
  classical
  let candidates := (insert s (W.image time)).filter (AdvancePath W r time S s)
  have hne : candidates.Nonempty := ⟨s, by simp [candidates, AdvancePath.refl]⟩
  obtain ⟨t, ht, hmax⟩ := candidates.exists_max_image id hne
  have hpath : AdvancePath W r time S s t := (Finset.mem_filter.mp ht).2
  refine ⟨t, hpath.le, hpath, hpath.earlier htrans hrespect hclosed hpos hideal
    hprefix hnorm hbefore, ?_⟩
  by_contra hn
  obtain ⟨x, hx⟩ := exists_exception hn
  have hnext : AdvancePath W r time S s (time x) := .step hpath hx
  have hmem : time x ∈ candidates := by
    simp only [candidates, Finset.mem_filter, Finset.mem_insert, Finset.mem_image]
    exact ⟨Or.inr ⟨x, hx.mem, rfl⟩, hnext⟩
  have := hmax (time x) hmem
  have := hx.later
  simp only [id_eq] at *
  omega

theorem ideal_has_separator [Fintype J] [Nonempty J]
    {r : J → J → Prop} {S : Set J} (p : Layout J) (hp : p.Full r)
    (htrans : ∀ ⦃a b c⦄, r a b → r b c → r a c)
    (hideal : IdealOn Finset.univ r S) :
    ∃ q : Layout J, q.Full r ∧ ∃ t,
      (∃ x, q.time x = t) ∧ Separator Finset.univ r q.time S t := by
  classical
  let priority := fun x : J => if x ∈ S then (p x).val else Fintype.card J + (p x).val
  have hprefix : PrefixOn Finset.univ priority S := by
    intro x _ hx y _ hy
    simp only [priority, ite_eq_left hx, ite_eq_right hy]
    have := (p x).isLt
    omega
  obtain ⟨q, hq⟩ := exists_normalized r priority p hp.2
  have hcard : 0 < Fintype.card J := Fintype.card_pos
  let first := q.symm ⟨0, hcard⟩
  have hfirst : q.time first = 1 := by simp [Layout.time, first]
  have hbefore : EarlierHigh Finset.univ r q.time S 1 := by
    intro x _ hx _
    have : 1 ≤ q.time x := by simp [Layout.time]
    omega
  obtain ⟨t, _hst, hpath, hsep⟩ := walk_to_separator htrans hq.1
    (fun _ _ _ _ => Finset.mem_univ _) (Or.inl ⟨first, Finset.mem_univ _, hfirst⟩)
    hideal hprefix (normalized_local_obstruction hq) hbefore
  refine ⟨q, ⟨hp.1, hq.1⟩, t, ?_, hsep⟩
  rcases hpath.endpoint with e | ⟨x, _, hx⟩
  · exact ⟨first, hfirst.trans e.symm⟩
  · exact ⟨x, hx⟩

def BeforeTest (r : J → J → Prop) (time : J → ℕ) (s : ℕ) (H : Set J) : Set J :=
  PredAt r time s ∪ (H \ (DescAt r time s ∪ {x | time x = s}))

theorem separator_description {W : Finset J} {r : J → J → Prop}
    {time : J → ℕ} {s : ℕ} {S H : Set J}
    (hrespect : ∀ u v, r u v → time u < time v)
    (hsep : Separator W r time S s) (hagree : ∀ x ∈ W, x ∈ H ↔ x ∈ S) :
    ∀ x ∈ W, x ∈ BeforeTest r time s H ↔ time x < s := by
  intro x hx
  constructor
  · rintro (⟨y, hys, hxy⟩ | ⟨hH, hnd⟩)
    · have := hrespect x y hxy
      omega
    · have hS := (hagree x hx).mp hH
      have hne : time x ≠ s := fun he => hnd (Or.inr he)
      by_contra hn
      have hsx : s < time x := by omega
      exact hnd (Or.inl (hsep.2 x hx hsx hS))
  · intro hxs
    by_cases hS : x ∈ S
    · refine Or.inr ⟨(hagree x hx).mpr hS, ?_⟩
      rintro (⟨y, hys, hyx⟩ | he)
      · have := hrespect y x hyx
        omega
      · change time x = s at he
        omega
    · exact Or.inl (hsep.1 x hx hxs hS)

end IdealSeparator
end ThreeMachine.Structure

end

end OAI