import OAI.Computability.Scheduling.SplitPaths

namespace OAI

section

namespace ThreeMachine.Structure
section SamePaths
variable {J A : Type} [Fintype J] [DecidableEq J]
    {r : J → J → Prop} {rank : J → ℕ} {atoms : A → Set J}
    {p : Layout J} {W : Set J} {P : Set J → Prop}

theorem EdgeData.child_ssubset {a b v ap bp : ℕ} {B V A' B' : Boundary J}
    (D : EdgeData r rank atoms p W a b v ap bp B V A' B') :
    Window p.time ap bp ⊂ W := by
  have hsub : Window p.time ap bp ⊆ W := by
    intro x hx
    rw [D.parent]
    exact ⟨D.start_le.trans_lt hx.1, (hx.2.trans_le D.target_le).trans D.center_lt⟩
  have hv : 1 ≤ v ∧ v ≤ Fintype.card J / 3 := by
    have := Boundary.at_bounds D.endAt
    have := D.start_le
    have := D.strict
    have := D.target_le
    have := D.center_lt
    omega
  have hc := p.card_slot D.full.1 v hv.1 hv.2
  obtain ⟨x, hx⟩ := Finset.card_pos.mp (show 0 < (p.slot v).card by omega)
  have ht := (p.mem_slot v x).mp hx
  have hxW : x ∈ W := by
    rw [D.parent]
    exact ⟨by have := D.start_le; have := D.strict; have := D.target_le; omega,
      ht ▸ D.center_lt⟩
  refine Set.ssubset_iff_subset_ne.mpr ⟨hsub, ?_⟩
  intro he
  have hh : ap < p.time x ∧ p.time x < bp :=
    show x ∈ Window p.time ap bp from he.symm ▸ hxW
  have := D.target_le
  omega

omit [Fintype J] [DecidableEq J] in
theorem GlobalList.samePriority_final {K : GlobalList J} {B : ℕ} {Q : Set J}
    (hrank : ∀ x, rank x < B) (hhigh : ∀ x ∈ W, x ∈ K.Qual → x ∈ Q) :
    ∀ x ∈ W, x ∈ PriorityCut (K.samePriority rank B Q)
      (B + (K.indices.sup id + 1)*B) ↔ x ∈ Q := by
  classical
  intro x hx
  have hr := hrank x
  have hk := K.keyValue_bound hrank x
  change K.samePriority rank B Q x < B + (K.indices.sup id + 1)*B ↔ x ∈ Q
  by_cases hq : x ∈ K.Qual
  · have hQ := hhigh x hx hq
    simp only [samePriority, ite_eq_left hq, hQ, iff_true]
    omega
  · by_cases hQ : x ∈ Q <;>
      simp only [samePriority, ite_eq_right hq, hQ, ite_true, ite_false, iff_true, iff_false] <;> omega

theorem same_path_normalized (D : NodeData r rank atoms p W)
    (htrans : ∀ ⦃x y z⦄, r x y → r y z → r x z)
    (hA : AtomSupport atoms r rank) {B v : ℕ} {V : Boundary J}
    (hB : 0 < B) (hrank : ∀ x, rank x < B) (hinj : Function.Injective rank)
    (hstrict : ∀ x y, r x y → rank x < rank y)
    (hv : D.a < v ∧ v < D.b)
    (hV : V.At p.time (Fintype.card J / 3) v)
    (hcenter : V.Separates r p.time W (D.right.pred r) v)
    (hnorm : p.NormalizedOn (Window p.time D.a v) r
      (D.list.samePriority rank B (D.right.pred r)))
    (hchild : ∀ U, U ⊂ W → Nonempty (NodeData r rank atoms p U) → P U) :
    Reached P r atoms W p.time D.a v := by
  classical
  let E := (Window p.time D.a v).toFinset
  have hE : ∀ x, x ∈ E ↔ x ∈ Window p.time D.a v := by intro x; simp [E]
  have hEeq : (↑E : Set J) = Window p.time D.a v := Set.ext hE
  have hsub : Window p.time D.a v ⊆ W := by
    intro x hx
    exact (D.window x).mpr ⟨hx.1, hx.2.trans hv.2⟩
  let priority := D.list.samePriority rank B (D.right.pred r)
  let count := (D.list.indices.sup id + 1) * B
  have hfinalAgree : ∀ x ∈ Window p.time D.a v,
      x ∈ PriorityCut priority (B+count) ↔ x ∈ D.right.pred r := by
    intro x hx
    exact GlobalList.samePriority_final hrank D.high x (hsub hx)
  have hfinalSep : V.Separates r p.time (Window p.time D.a v)
      (PriorityCut priority (B+count)) v :=
    (Boundary.separates_congr (fun x hx => (hfinalAgree x hx).symm)).mp
      (hcenter.mono_domain hsub)
  have hvbounds : 1 ≤ v ∧ v ≤ Fintype.card J / 3 := by
    have := Boundary.at_bounds D.rightAt
    omega
  have hVactual := Boundary.actual_of_interior hV hvbounds
  have hedge {ap bp t : ℕ} {A' B' : Boundary J}
      (hap : D.a ≤ ap) (hab : ap < bp) (hbp : bp ≤ v)
      (hAA : A'.At p.time (Fintype.card J / 3) ap)
      (hBB : B'.At p.time (Fintype.card J / 3) bp)
      (hact : ∃ Z, B' = Boundary.actual Z) (ht : t ≤ count)
      (hstart : A'.Separates r p.time (Window p.time D.a v)
        (PriorityCut priority (B+t)) ap)
      (hend : B'.Separates r p.time (Window p.time D.a v)
        (PriorityCut priority (B+t)) bp)
      (hwalk : CutoffWalk E r p.time priority (PriorityCut priority (B+t)) D.a ap)
      (hprev : Reached P r atoms W p.time D.a ap) :
      Reached P r atoms W p.time D.a bp := by
    obtain ⟨F⟩ := exists_same_edge D htrans hA hB hrank hstrict hv hV hcenter
      hap hab hbp hAA hBB hact ht hnorm hstart hend E hE hwalk
    exact F.reached hA F.finalSmall hprev
      (hchild _ F.child_ssubset ⟨F.toNode htrans hA⟩)
  by_cases ha : D.a = 0
  · have hL : D.left = Boundary.left := Boundary.at_unique D.leftAt ha
    apply hedge le_rfl hv.1 le_rfl D.leftAt hV hVactual le_rfl _ hfinalSep .refl (Or.inl rfl)
    rw [hL, ha]
    exact Boundary.left_separates
  · have habounds : 1 ≤ D.a ∧ D.a ≤ Fintype.card J / 3 := by omega
    obtain ⟨Z, hZ⟩ := Boundary.actual_of_interior D.leftAt habounds
    have hstartBoundary : D.left.Separates r p.time (Window p.time D.a v)
        (PriorityCut priority B) D.a := by
      constructor
      · intro x hx ht _
        have := hx.1
        omega
      · intro x hx _ hs
        apply D.low x (hsub hx)
        intro hq
        have hs' : priority x < B := hs
        dsimp only [priority, GlobalList.samePriority] at hs'
        rw [ite_eq_left hq] at hs'
        omega
    have hstart : Separator E r p.time (PriorityCut priority B) D.a := by
      apply (Boundary.actual_separates (hZ ▸ D.leftAt)).mp
      simpa only [hEeq, ← hZ] using hstartBoundary
    have hclosed : SlotClosed E p.time := by
      intro x hx y hy
      apply (hE y).mpr
      have hh := (hE x).mp hx
      simpa only [Window, Set.mem_ofPred, hy] using hh
    have hpriority := GlobalList.samePriority_extends hrank hstrict D.upsets
      (fun _ _ hxy hy => Boundary.pred_downset htrans D.right hxy hy) D.high
    have hnormE : LocalObstruction E r p.time priority :=
      normalizedOn_local_obstruction (hEeq.symm ▸ hnorm) hE
    obtain ⟨walk⟩ := exists_numeric_walk htrans D.full.2 hclosed
      (Or.inr fun x hx => ((hE x).mp hx).1)
      (GlobalList.samePriority_injective hrank hinj).injOn
      (fun x hx y hy hxy => hpriority x (hsub ((hE x).mp hx)) y (hsub ((hE y).mp hy)) hxy)
      hnormE hstart count
    have hpos : ∀ i, walk.position i < v := by
      intro i
      rcases walk.endpoint i with he | ⟨x, hx, ht⟩
      · simpa only [he] using hv.1
      · exact ht ▸ ((hE x).mp hx).2
    apply walk.reached hpos
    · intro i bp hab hbp hsep hprev
      have hap := (walk.history i).le
      have haps : 1 ≤ walk.position i ∧ walk.position i ≤ Fintype.card J / 3 := by
        have := hpos i
        omega
      have hbps : 1 ≤ bp ∧ bp ≤ Fintype.card J / 3 := by omega
      exact hedge hap hab hbp (p.triple_at D.full.1 _ haps.1 haps.2)
        (p.triple_at D.full.1 _ hbps.1 hbps.2) ⟨_, rfl⟩ (by have := i.isLt; omega)
        (separator_at D.full hE haps (walk.separator i))
        (separator_at D.full hE hbps hsep) (walk.history i) hprev
    · obtain ⟨Q, hQ⟩ := hVactual
      apply (Boundary.actual_separates (hQ ▸ hV)).mp
      simpa only [hEeq, ← hQ] using hfinalSep

end SamePaths
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section SwitchPaths
variable {J A : Type} [Fintype J] [DecidableEq J]
    {r : J → J → Prop} {rank : J → ℕ} {atoms : A → Set J}
    {p q : Layout J} {W : Set J} {P : Set J → Prop}

omit [DecidableEq J] in
def SwitchSeed.reorder {L : Boundary J} {a b : ℕ}
    (G : SwitchSeed r p.time atoms W L a)
    (hW : ∀ x, x ∈ W ↔ x ∈ Window p.time a b) (hfix : p.FixedOutside q W) :
    SwitchSeed r q.time atoms W L a := by
  refine { G with later := ?_ }
  intro x hx
  by_cases hxW : x ∈ W
  · exact ((hfix.window hW x).mp hxW).1
  · rw [hfix.time hxW]
    exact G.later x hx

omit [Fintype J] [DecidableEq J] in
theorem switchPriority_final {B : ℕ} {D : Set J} (hrank : ∀ x, rank x < B) :
    PriorityCut (switchPriority rank B D) B = Dᶜ := by
  classical
  ext x
  have := hrank x
  change (if x ∈ D then B+rank x else rank x) < B ↔ x ∉ D
  split_ifs <;> simp_all

theorem switch_path_normalized {a b v B : ℕ} {L R V : Boundary J}
    (hp : p.Full r) (htrans : ∀ ⦃x y z⦄, r x y → r y z → r x z)
    (hA : AtomSupport atoms r rank) (hrank : ∀ x, rank x < B)
    (hinj : Function.Injective rank) (hstrict : ∀ x y, r x y → rank x < rank y)
    (hW : ∀ x, x ∈ W ↔ x ∈ Window p.time a b)
    (hL : L.At p.time (Fintype.card J / 3) a)
    (hR : R.At p.time (Fintype.card J / 3) b)
    (hcover : ∀ x ∈ W, x ∈ L.desc r ∨ x ∈ R.pred r)
    (G : SwitchSeed r p.time atoms W L a)
    (hv : a < v ∧ v < b) (hV : V.At p.time (Fintype.card J / 3) v)
    (hcenter : V.Separates r p.time W (L.desc r)ᶜ v)
    (hnorm : p.NormalizedOn (Window p.time a v) r (switchPriority rank B (L.desc r)))
    (hchild : ∀ U, U ⊂ W → Nonempty (NodeData r rank atoms p U) → P U) :
    Reached P r atoms W p.time a v := by
  classical
  let E := (Window p.time a v).toFinset
  have hE : ∀ x, x ∈ E ↔ x ∈ Window p.time a v := by intro x; simp [E]
  have hEeq : (↑E : Set J) = Window p.time a v := Set.ext hE
  have hsub : Window p.time a v ⊆ W := by
    intro x hx
    exact (hW x).mpr ⟨hx.1, hx.2.trans hv.2⟩
  let priority := switchPriority rank B (L.desc r)
  have hfinalSep : V.Separates r p.time (Window p.time a v)
      (PriorityCut priority B) v := by
    rw [show PriorityCut priority B = (L.desc r)ᶜ from switchPriority_final hrank]
    exact hcenter.mono_domain hsub
  have hvbounds : 1 ≤ v ∧ v ≤ Fintype.card J / 3 := by
    have := Boundary.at_bounds hR
    omega
  have hVactual := Boundary.actual_of_interior hV hvbounds
  have hedge {ap bp t : ℕ} {A' B' : Boundary J}
      (hap : a ≤ ap) (hab : ap < bp) (hbp : bp ≤ v)
      (hAA : A'.At p.time (Fintype.card J / 3) ap)
      (hBB : B'.At p.time (Fintype.card J / 3) bp)
      (hact : ∃ Z, B' = Boundary.actual Z) (ht : t ≤ B)
      (hstart : A'.Separates r p.time (Window p.time a v) (PriorityCut priority t) ap)
      (hend : B'.Separates r p.time (Window p.time a v) (PriorityCut priority t) bp)
      (hprev : Reached P r atoms W p.time a ap) :
      Reached P r atoms W p.time a bp := by
    obtain ⟨F⟩ := exists_switch_edge hp htrans hA hrank hstrict hW hL hR hcover G
      hv hV hcenter hap hab hbp hAA hBB hact ht hnorm hstart hend
    exact F.reached hA F.finalSmall hprev
      (hchild _ F.child_ssubset ⟨F.toNode htrans hA⟩)
  by_cases ha : a = 0
  · have hLL : L = Boundary.left := Boundary.at_unique hL ha
    apply hedge le_rfl hv.1 le_rfl hL hV hVactual le_rfl _ hfinalSep (Or.inl rfl)
    rw [hLL, ha]
    exact Boundary.left_separates
  · have habounds : 1 ≤ a ∧ a ≤ Fintype.card J / 3 := by omega
    have hstart : Separator E r p.time (PriorityCut priority 0) a := by
      constructor
      · intro x hx ht _
        have := ((hE x).mp hx).1
        omega
      · intro x _ _ hs
        exact (Nat.not_lt_zero _ hs).elim
    have hclosed : SlotClosed E p.time := by
      intro x hx y hy
      apply (hE y).mpr
      have hh := (hE x).mp hx
      simpa only [Window, Set.mem_ofPred, hy] using hh
    have hpriority := switchPriority_extends hrank hstrict (Boundary.desc_upset htrans L)
    have hnormE : LocalObstruction E r p.time priority :=
      normalizedOn_local_obstruction (hEeq.symm ▸ hnorm) hE
    obtain ⟨walk⟩ := exists_numeric_walk htrans hp.2 hclosed
      (Or.inr fun x hx => ((hE x).mp hx).1)
      (switchPriority_injective hrank hinj).injOn
      (fun x _ y _ hxy => hpriority x y hxy) hnormE hstart B
    have hpos : ∀ i, walk.position i < v := by
      intro i
      rcases walk.endpoint i with he | ⟨x, hx, ht⟩
      · simpa only [he] using hv.1
      · exact ht ▸ ((hE x).mp hx).2
    apply walk.reached hpos
    · intro i bp hab hbp hsep hprev
      have hap := (walk.history i).le
      have haps : 1 ≤ walk.position i ∧ walk.position i ≤ Fintype.card J / 3 := by
        have := hpos i
        omega
      have hbps : 1 ≤ bp ∧ bp ≤ Fintype.card J / 3 := by omega
      exact hedge (t := i.val) hap hab hbp (p.triple_at hp.1 _ haps.1 haps.2)
        (p.triple_at hp.1 _ hbps.1 hbps.2) ⟨_, rfl⟩ (by have := i.isLt; omega)
        (separator_at hp hE haps (by simpa only [Nat.zero_add] using walk.separator i))
        (separator_at hp hE hbps (by simpa only [Nat.zero_add] using hsep)) hprev
    · obtain ⟨Q, hQ⟩ := hVactual
      apply (Boundary.actual_separates (hQ ▸ hV)).mp
      simpa only [Nat.zero_add, hEeq, ← hQ] using hfinalSep

end SwitchPaths
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section SideNormalization
variable {J A : Type} [Fintype J] [DecidableEq J]
    {r : J → J → Prop} {rank : J → ℕ} {atoms : A → Set J}
    {p : Layout J} {W : Set J} {P : Set J → Prop}

theorem same_path (D : NodeData r rank atoms p W)
    (htrans : ∀ ⦃x y z⦄, r x y → r y z → r x z)
    (hA : AtomSupport atoms r rank) {B v : ℕ} {V : Boundary J}
    (hB : 0 < B) (hrank : ∀ x, rank x < B) (hinj : Function.Injective rank)
    (hstrict : ∀ x y, r x y → rank x < rank y)
    (hv : D.a < v ∧ v < D.b)
    (hV : V.At p.time (Fintype.card J / 3) v)
    (hcenter : V.Separates r p.time W (D.right.pred r) v)
    (hchild : ∀ q U, U ⊂ W → Nonempty (NodeData r rank atoms q U) → P U) :
    Reached P r atoms W p.time D.a v := by
  let E := Window p.time D.a v
  have hsub : E ⊆ W := fun x hx => (D.window x).mpr ⟨hx.1, hx.2.trans hv.2⟩
  obtain ⟨q, hfix, hnorm⟩ := exists_normalizedOn p E r
    (D.list.samePriority rank B (D.right.pred r)) D.full.2
  let Dq := D.reorder (hfix.mono hsub) hnorm.1
  have hE : E = Window q.time D.a v := Set.ext (hfix.window (fun _ => Iff.rfl))
  have hVq := hfix.boundary (fun _ => Iff.rfl) (Or.inr le_rfl) hV
  have hcenterq := hcenter.reorder hfix (fun _ => Iff.rfl) (Or.inr le_rfl)
  have hnormq : q.NormalizedOn (Window q.time Dq.a v) r
      (Dq.list.samePriority rank B (Dq.right.pred r)) := by
    change q.NormalizedOn (Window q.time D.a v) r
      (D.list.samePriority rank B (D.right.pred r))
    exact hE ▸ hnorm
  have hreach := same_path_normalized Dq htrans hA hB hrank hinj hstrict hv hVq
    hcenterq hnormq (hchild q)
  exact hreach.congr_time
    (fun x => (hfix.before_iff (fun _ => Iff.rfl) (Or.inr le_rfl) x).symm)
    (fun x => (hfix.after_iff (fun _ => Iff.rfl) (Or.inr le_rfl) x).symm)

theorem switch_path {a b v B : ℕ} {L R V : Boundary J}
    (hp : p.Full r) (htrans : ∀ ⦃x y z⦄, r x y → r y z → r x z)
    (hA : AtomSupport atoms r rank) (hrank : ∀ x, rank x < B)
    (hinj : Function.Injective rank) (hstrict : ∀ x y, r x y → rank x < rank y)
    (hW : ∀ x, x ∈ W ↔ x ∈ Window p.time a b)
    (hL : L.At p.time (Fintype.card J / 3) a)
    (hR : R.At p.time (Fintype.card J / 3) b)
    (hcover : ∀ x ∈ W, x ∈ L.desc r ∨ x ∈ R.pred r)
    (G : SwitchSeed r p.time atoms W L a)
    (hv : a < v ∧ v < b) (hV : V.At p.time (Fintype.card J / 3) v)
    (hcenter : V.Separates r p.time W (L.desc r)ᶜ v)
    (hchild : ∀ q U, U ⊂ W → Nonempty (NodeData r rank atoms q U) → P U) :
    Reached P r atoms W p.time a v := by
  let E := Window p.time a v
  have hsub : E ⊆ W := fun x hx => (hW x).mpr ⟨hx.1, hx.2.trans hv.2⟩
  obtain ⟨q, hfix, hnorm⟩ := exists_normalizedOn p E r
    (switchPriority rank B (L.desc r)) hp.2
  have hE : E = Window q.time a v := Set.ext (hfix.window (fun _ => Iff.rfl))
  have hfixW := hfix.mono hsub
  have hWq := hfixW.window hW
  have hLq := hfixW.boundary hW (Or.inl le_rfl) hL
  have hRq := hfixW.boundary hW (Or.inr le_rfl) hR
  have hVq := hfix.boundary (fun _ => Iff.rfl) (Or.inr le_rfl) hV
  have hcenterq := hcenter.reorder hfix (fun _ => Iff.rfl) (Or.inr le_rfl)
  have hnormq : q.NormalizedOn (Window q.time a v) r
      (switchPriority rank B (L.desc r)) := by simpa only [hE] using hnorm
  have hreach := switch_path_normalized ⟨hp.1, hnorm.1⟩ htrans hA hrank hinj hstrict
    hWq hLq hRq hcover (G.reorder hW hfixW) hv hVq hcenterq hnormq (hchild q)
  exact hreach.congr_time
    (fun x => (hfix.before_iff (fun _ => Iff.rfl) (Or.inr le_rfl) x).symm)
    (fun x => (hfix.after_iff (fun _ => Iff.rfl) (Or.inr le_rfl) x).symm)

end SideNormalization
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section ReversePaths
variable {J A : Type} [Fintype J] {r : J → J → Prop}
    {atoms : A → Set J} {p : Layout J} {W S : Set J}

theorem Boundary.Separates.reverse {B : Boundary J} {s : ℕ}
    (hfull : 3 ∣ Fintype.card J) (hs : s ≤ Fintype.card J / 3 + 1)
    (h : B.Separates r p.time W S s) :
    B.reverse.Separates (fun x y => r y x) p.reverse.time W Sᶜ
      (Fintype.card J / 3 + 1 - s) := by
  constructor
  · intro x hx ht hn
    have hxbound := p.time_bounds hfull x
    rw [p.reverse_time hfull] at ht
    have hl : s < p.time x := by omega
    have hxS : x ∈ S := by simpa only [Set.mem_compl_iff, not_not] using hn
    simpa only [Boundary.pred_reverse] using h.2 x hx hl hxS
  · intro x hx ht hn
    have hxbound := p.time_bounds hfull x
    rw [p.reverse_time hfull] at ht
    have hl : p.time x < s := by omega
    simpa only [Boundary.desc_reverse] using h.1 x hx hl hn

theorem SplitVertex.AtTime.reverse {u : SplitVertex r atoms W} {s : ℕ}
    (hfull : 3 ∣ Fintype.card J) (hs : s ≤ Fintype.card J / 3 + 1)
    (h : u.AtTime p.time s) :
    u.reverse.AtTime p.reverse.time (Fintype.card J / 3 + 1 - s) := by
  constructor
  · intro x
    change x ∈ u.right ↔ _
    rw [h.2.2 x, p.reverse_time hfull]
    have := p.time_bounds hfull x
    apply and_congr_right
    intro _
    omega
  · constructor
    · intro x
      change x ∈ u.middle.val ↔ _
      rw [h.2.1 x, p.reverse_time hfull]
      have := p.time_bounds hfull x
      apply and_congr_right
      intro _
      omega
    · intro x
      change x ∈ u.left ↔ _
      rw [h.1 x, p.reverse_time hfull]
      have := p.time_bounds hfull x
      apply and_congr_right
      intro _
      omega

theorem window_reverse {a b : ℕ} (hfull : 3 ∣ Fintype.card J)
    (ha : a ≤ Fintype.card J / 3 + 1) (hb : b ≤ Fintype.card J / 3 + 1) :
    Window p.reverse.time (Fintype.card J / 3 + 1 - b) (Fintype.card J / 3 + 1 - a) =
      Window p.time a b := by
  ext x
  change (_ < p.reverse.time x ∧ p.reverse.time x < _) ↔ _ < p.time x ∧ p.time x < _
  rw [p.reverse_time hfull]
  have := p.time_bounds hfull x
  omega

end ReversePaths
end ThreeMachine.Structure

namespace ThreeMachine.Structure
section Completeness
variable {J A : Type} [Fintype J] [DecidableEq J] {atoms : A → Set J}

theorem node_complete (n : ℕ) :
    ∀ (r : J → J → Prop) (rank reverseRank : J → ℕ) (p : Layout J) (W : Set J) (B : ℕ),
    (∀ ⦃x y z⦄, r x y → r y z → r x z) →
    AtomSupport atoms r rank → AtomSupport atoms (fun x y => r y x) reverseRank →
    0 < B → (∀ x, rank x < B) → (∀ x, reverseRank x < B) →
    Function.Injective rank → Function.Injective reverseRank →
    (∀ x y, r x y → rank x < rank y) →
    (∀ x y, r y x → reverseRank x < reverseRank y) →
    NodeData r rank atoms p W → W.ncard ≤ n → AcceptedAt r atoms n W := by
  induction n with
  | zero =>
    intro r rank reverseRank p W B _ _ _ _ _ _ _ _ _ _ D hcard
    have hW : W = ∅ := (Set.ncard_eq_zero (Set.toFinite W)).mp (Nat.eq_zero_of_le_zero hcard)
    exact ⟨D.small.mono (by omega), hW⟩
  | succ n ih =>
    intro r rank reverseRank p W B htrans hA hAR hB hrank hrankR hinj hinjR hstrict hstrictR D hcard
    have hsmall : Described atoms W 10000 := D.small.mono (by omega)
    by_cases hWempty : W = ∅
    · exact ⟨hsmall, Or.inl hWempty⟩
    have hne : W.Nonempty := Set.nonempty_iff_ne_empty.mpr hWempty
    obtain ⟨q, hfix, hq, v, V, hav, hvb, hV, hcenter⟩ := exists_node_center D htrans hne
    let Dq := D.reorder hfix hq
    have hchild : ∀ q U, U ⊂ W → Nonempty (NodeData r rank atoms q U) →
        AcceptedAt r atoms n U := by
      intro q U hU hDU
      obtain ⟨DU⟩ := hDU
      have hlt := Set.ncard_lt_ncard hU
      exact ih r rank reverseRank q U B htrans hA hAR hB hrank hrankR
        hinj hinjR hstrict hstrictR DU (by omega)
    have hchildR : ∀ q U, U ⊂ W →
        Nonempty (NodeData (fun x y => r y x) reverseRank atoms q U) →
        AcceptedAt (fun x y => r y x) atoms n U := by
      intro q U hU hDU
      obtain ⟨DU⟩ := hDU
      have hlt := Set.ncard_lt_ncard hU
      exact ih (fun x y => r y x) reverseRank rank q U B
        (fun {_ _ _} hxy hyz => htrans hyz hxy) hAR hA hB hrankR hrank
        hinjR hinj hstrictR hstrict DU (by omega)
    have hleft := same_path Dq htrans hA hB hrank hinj hstrict ⟨hav, hvb⟩ hV hcenter hchild
    let T := Fintype.card J / 3
    have ha : D.a ≤ T+1 := Boundary.at_bounds D.leftAt
    have hb : D.b ≤ T+1 := Boundary.at_bounds D.rightAt
    have hv : v ≤ T+1 := by omega
    have hfrom : T+1-D.b < T+1-v := by omega
    have hto : T+1-v < T+1-D.a := by omega
    have hWr : ∀ x, x ∈ W ↔ x ∈ Window q.reverse.time (T+1-D.b) (T+1-D.a) := by
      rw [window_reverse D.full.1 ha hb]
      exact Dq.window
    have hcoverr : ∀ x ∈ W, x ∈ Dq.right.reverse.desc (fun x y => r y x) ∨
        x ∈ Dq.left.reverse.pred (fun x y => r y x) := by
      intro x hx
      simpa only [Boundary.desc_reverse, Boundary.pred_reverse, or_comm] using Dq.cover x hx
    have hcenterr : V.reverse.Separates (fun x y => r y x) q.reverse.time W
        (Dq.right.reverse.desc (fun x y => r y x))ᶜ (T+1-v) := by
      rw [Boundary.desc_reverse]
      exact hcenter.reverse D.full.1 hv
    have hright := switch_path (Layout.reverse_full Dq.full) (fun {_ _ _} hxy hyz => htrans hyz hxy)
      hAR hrankR hinjR hstrictR hWr (Boundary.at_reverse D.full.1 Dq.rightAt)
      (Boundary.at_reverse D.full.1 Dq.leftAt) hcoverr
      (Dq.reverseSeed.toSwitch D.full.1 hb) ⟨hfrom, hto⟩
      (Boundary.at_reverse D.full.1 hV) hcenterr hchildR
    rcases hleft with he | ⟨ul, vl, hul, hpl, hvl⟩
    · change v = D.a at he
      omega
    rcases hright with he | ⟨ur, vr, hur, hpr, hvr⟩
    · change T+1-v = T+1-D.b at he
      omega
    have hvback : T+1-(T+1-v) = v := by omega
    have hvr' : vr.reverse.AtTime q.time v := by
      have hh := hvr.reverse D.full.1 (Nat.sub_le (T+1) v)
      change vr.reverse.AtTime q.reverse.reverse.time (T+1-(T+1-v)) at hh
      rw [hvback] at hh
      simpa only [Layout.reverse_reverse] using hh
    have hsame : vl = vr.reverse := hvl.unique hvr'
    have hpr' := SplitVertex.path_reverse (fun _ h => AcceptedAt.reverse h) hpr
    refine ⟨hsmall, Or.inr ⟨ul, ur.reverse, hul, ?_, AcceptedAt.reverse hur⟩⟩
    exact hpl.trans (hsame.symm ▸ hpr')

end Completeness
end ThreeMachine.Structure

end

end OAI