import OAI.Computability.Scheduling.FrameInvariants

namespace OAI

section

namespace ThreeMachine.Structure
section RunCertificates
variable {J A : Type}

def RankTail (rank : J → ℕ) (k : ℕ) : Set J := {x | k ≤ rank x}

theorem rankTail_upset {r : J → J → Prop} {rank : J → ℕ}
    (hrank : ∀ x y, r x y → rank x < rank y) (k : ℕ) :
    GlobalUpset r (RankTail rank k) := by
  intro x y hxy hx
  exact hx.trans (hrank x y hxy).le

structure RunData (K : GlobalList J) (rank : J → ℕ) (atoms : A → Set J)
    (W : Set J) where
  base : ℕ → Set J
  threshold : ℕ → ℕ
  second : Set J
  entry_eq : ∀ i ∈ K.indices, K.entry i = base i ∩ RankTail rank (threshold i)
  simple : ∀ i ∈ K.indices, i ≠ 0 → Described atoms (base i) 2
  first_small : Described atoms (base 0) 24
  second_small : Described atoms second 1
  second_eq : base 1 = second
  cover : ∀ x ∈ W, x ∉ second → x ∈ base 0
  pair : 0 ∈ K.indices → ∀ x ∈ W, x ∈ second → 1 ∈ K.indices ∧ x ∈ K.entry 1

namespace RunData
variable {K : GlobalList J} {rank : J → ℕ} {atoms : A → Set J} {W W' : Set J}

def narrow (D : RunData K rank atoms W) (hsub : W' ⊆ W) : RunData K rank atoms W' :=
  { D with
    cover := fun x hx hn => D.cover x (hsub hx) hn
    pair := fun hi x hx hD => D.pair hi x (hsub hx) hD }

noncomputable def carry (D : RunData K rank atoms W) (d k : ℕ) :
    RunData (K.carry rank d k) rank atoms W := by
  classical
  refine { base := D.base
           threshold := fun i => if i = d then max (D.threshold i) k else D.threshold i
           second := D.second
           entry_eq := ?_
           simple := ?_
           first_small := D.first_small
           second_small := D.second_small
           second_eq := D.second_eq
           cover := D.cover
           pair := ?_ }
  · intro i hi
    have hi' : i ∈ K.indices ∧ d ≤ i := Finset.mem_filter.mp hi
    change (if i = d then K.entry i ∩ {x | k ≤ rank x} else K.entry i) = _
    rw [D.entry_eq i hi'.1]
    by_cases hid : i = d
    · simp only [hid, ite_eq_left]
      ext x
      simp only [Set.mem_inter_iff, RankTail, Set.mem_ofPred_eq, max_le_iff]
      tauto
    · simp only [hid, ite_false]
  · intro i hi hn
    exact D.simple i (Finset.mem_filter.mp hi).1 hn
  · intro hzero x hx hxD
    have hd : d = 0 := by have := (Finset.mem_filter.mp hzero).2; omega
    have hz : 0 ∈ K.indices := (Finset.mem_filter.mp hzero).1
    obtain ⟨h1, hx1⟩ := D.pair hz x hx hxD
    refine ⟨Finset.mem_filter.mpr ⟨h1, by omega⟩, ?_⟩
    change x ∈ if 1 = d then _ else _
    simpa [hd] using hx1

noncomputable def prune (D : RunData K rank atoms W) (hsub : W' ⊆ W) :
    RunData (K.prune W') rank atoms W' := by
  classical
  refine { base := D.base, threshold := D.threshold, second := D.second
           entry_eq := ?_, simple := ?_, first_small := D.first_small
           second_small := D.second_small, second_eq := D.second_eq
           cover := fun x hx hn => D.cover x (hsub hx) hn
           pair := ?_ }
  · intro i hi
    exact D.entry_eq i (Finset.mem_filter.mp hi).1
  · intro i hi hn
    exact D.simple i (Finset.mem_filter.mp hi).1 hn
  · intro hzero x hx hxD
    obtain ⟨h1, hx1⟩ := D.pair (Finset.mem_filter.mp hzero).1 x (hsub hx) hxD
    exact ⟨Finset.mem_filter.mpr ⟨h1, ⟨x, hx1, hx⟩⟩, hx1⟩

noncomputable def append (D : RunData K rank atoms W) (I : Set J)
    (hI : Described atoms I 2) : RunData (K.append I) rank atoms W := by
  classical
  have hnext : 2 ≤ K.nextIndex := by dsimp [GlobalList.nextIndex]; omega
  refine { base := fun i => if i = K.nextIndex then I else D.base i
           threshold := fun i => if i = K.nextIndex then 0 else D.threshold i
           second := D.second
           entry_eq := ?_, simple := ?_, first_small := ?_
           second_small := D.second_small, second_eq := ?_
           cover := ?_, pair := ?_ }
  · intro i hi
    change i ∈ insert K.nextIndex K.indices at hi
    change (if i = K.nextIndex then I else K.entry i) = _
    by_cases he : i = K.nextIndex
    · simp only [he, ite_eq_left]
      ext x
      simp [RankTail]
    · have hiK : i ∈ K.indices := (Finset.mem_insert.mp hi).resolve_left he
      simpa only [he, ite_false] using D.entry_eq i hiK
  · intro i hi hn
    change i ∈ insert K.nextIndex K.indices at hi
    by_cases he : i = K.nextIndex
    · simpa only [he, ite_eq_left] using hI
    · simpa only [he, ite_false] using D.simple i ((Finset.mem_insert.mp hi).resolve_left he) hn
  · simpa only [show 0 ≠ K.nextIndex by omega, ite_false] using D.first_small
  · simpa only [show 1 ≠ K.nextIndex by omega, ite_false] using D.second_eq
  · intro x hx hn
    simpa only [show 0 ≠ K.nextIndex by omega, ite_false] using D.cover x hx hn
  · intro hz x hx hxD
    change 0 ∈ insert K.nextIndex K.indices at hz
    have hzK : 0 ∈ K.indices := (Finset.mem_insert.mp hz).resolve_left (by omega)
    obtain ⟨h1, hx1⟩ := D.pair hzK x hx hxD
    refine ⟨Finset.mem_insert_of_mem h1, ?_⟩
    change x ∈ if 1 = K.nextIndex then I else K.entry 1
    simpa only [show 1 ≠ K.nextIndex by omega, ite_false] using hx1

theorem entry_small (D : RunData K rank atoms W)
    (hrank : ∀ k, Described atoms (RankTail rank k) 1) {i : ℕ} (hi : i ∈ K.indices) :
    Described atoms (K.entry i) 25 := by
  rw [D.entry_eq i hi]
  by_cases he : i = 0
  · subst i
    exact D.first_small.inter (hrank _)
  · exact ((D.simple i hi he).inter (hrank _)).mono (by omega)

noncomputable def flatEntry (D : RunData K rank atoms W) (i : ℕ) : Set J :=
  if i = 0 then D.second ∪ RankTail rank (D.threshold 0) else K.entry i

theorem flat_union_agrees (D : RunData K rank atoms W) :
    ∀ x ∈ W, (∃ i ∈ K.indices, x ∈ D.flatEntry i) ↔ x ∈ K.Qual := by
  classical
  intro x hx
  constructor
  · rintro ⟨i, hi, hxi⟩
    by_cases he : i = 0
    · subst i
      change x ∈ if 0 = 0 then _ else _ at hxi
      rcases hxi with hD | htail
      · obtain ⟨h1, hx1⟩ := D.pair hi x hx hD
        exact ⟨1, h1, hx1⟩
      · by_cases hD : x ∈ D.second
        · obtain ⟨h1, hx1⟩ := D.pair hi x hx hD
          exact ⟨1, h1, hx1⟩
        · refine ⟨0, hi, ?_⟩
          rw [D.entry_eq 0 hi]
          exact ⟨D.cover x hx hD, htail⟩
    · exact ⟨i, hi, by simpa only [flatEntry, he, ite_false] using hxi⟩
  · rintro ⟨i, hi, hxi⟩
    refine ⟨i, hi, ?_⟩
    by_cases he : i = 0
    · subst i
      dsimp only [flatEntry]
      exact Or.inr ((D.entry_eq 0 hi) ▸ hxi).2
    · simpa only [flatEntry, he, ite_false] using hxi

theorem short_upset_extension (D : RunData K rank atoms W) {r : J → J → Prop}
    (hK : K.Upsets r) (hD : GlobalUpset r D.second)
    (hstrict : ∀ x y, r x y → rank x < rank y)
    (hrank : ∀ k, Described atoms (RankTail rank k) 1)
    (hfalse : Described atoms ∅ 1) (hcard : K.indices.card ≤ 5) :
    ∃ H : Set J, GlobalUpset r H ∧ Described atoms H 20 ∧
      ∀ x ∈ W, x ∈ H ↔ x ∈ K.Qual := by
  classical
  let H : Set J := {x | ∃ i ∈ K.indices, x ∈ D.flatEntry i}
  refine ⟨H, ?_, ?_, D.flat_union_agrees⟩
  · intro x y hxy hx
    obtain ⟨i, hi, hxi⟩ := hx
    refine ⟨i, hi, ?_⟩
    by_cases he : i = 0
    · subst i
      exact (hD.union (rankTail_upset hstrict _)) hxy hxi
    · simp only [flatEntry, he, ite_false] at hxi ⊢
      exact hK i hi hxy hxi
  · by_cases hne : K.indices.Nonempty
    · have hsmall : ∀ i ∈ K.indices, Described atoms (D.flatEntry i) 4 := by
        intro i hi
        by_cases he : i = 0
        · subst i
          exact (D.second_small.union (hrank _)).mono (by omega)
        · simp only [flatEntry, he, ite_false]
          rw [D.entry_eq i hi]
          exact ((D.simple i hi he).inter (hrank _)).mono (by omega)
      have hh := Described.finite_union K.indices D.flatEntry (fun _ => 4) hne hsmall
      apply hh.mono
      simp only [Finset.sum_const, smul_eq_mul]
      omega
    · have he : K.indices = ∅ := Finset.not_nonempty_iff_eq_empty.mp hne
      have hH : H = ∅ := by ext x; simp [H, he]
      rw [hH]
      exact hfalse.mono (by omega)

end RunData
end RunCertificates
end ThreeMachine.Structure

namespace ThreeMachine.Structure
namespace GlobalList
variable {J : Type}

def empty : GlobalList J := ⟨∅, fun _ => ∅⟩

def one (A : Set J) : GlobalList J := ⟨{1}, fun _ => A⟩

def pair (A B : Set J) : GlobalList J := ⟨{0, 1}, fun i => if i = 0 then A else B⟩

@[simp] theorem qual_empty : (empty : GlobalList J).Qual = ∅ := by
  ext x
  simp [Qual, empty]

@[simp] theorem qual_one (A : Set J) : (one A).Qual = A := by
  ext x
  simp [Qual, one]

@[simp] theorem qual_pair (A B : Set J) : (pair A B).Qual = A ∪ B := by
  ext x
  simp [Qual, pair]

theorem empty_upsets (r : J → J → Prop) : (empty : GlobalList J).Upsets r := by
  intro i hi
  have hf : i ∈ (∅ : Finset ℕ) := hi
  simp at hf

theorem pair_upsets {r : J → J → Prop} {A B : Set J}
    (hA : GlobalUpset r A) (hB : GlobalUpset r B) : (pair A B).Upsets r := by
  intro i _
  dsimp [pair]
  split <;> assumption

def InjectionDisjoint (K : GlobalList J) (W : Set J) : Prop :=
  ∀ i ∈ K.indices, 2 ≤ i → ∀ j ∈ K.indices, 2 ≤ j → i ≠ j →
    ∀ x ∈ W, x ∈ K.entry i → x ∉ K.entry j

theorem InjectionDisjoint.narrow {K : GlobalList J} {W W' : Set J}
    (h : K.InjectionDisjoint W) (hsub : W' ⊆ W) : K.InjectionDisjoint W' := by
  intro i hi h2i j hj h2j hn x hx hxi hxj
  exact h i hi h2i j hj h2j hn x (hsub hx) hxi hxj

theorem InjectionDisjoint.carry {K : GlobalList J} {W : Set J} {rank : J → ℕ}
    (h : K.InjectionDisjoint W) (d k : ℕ) : (K.carry rank d k).InjectionDisjoint W := by
  intro i hi h2i j hj h2j hn x hx hxi hxj
  have hmi := (carry_membership K rank d k i x).mp
    ((mem_memberships _ x i).mpr ⟨hi, hxi⟩)
  have hmj := (carry_membership K rank d k j x).mp
    ((mem_memberships _ x j).mpr ⟨hj, hxj⟩)
  exact h i hmi.1 h2i j hmj.1 h2j hn x hx hmi.2.2.1 hmj.2.2.1

theorem InjectionDisjoint.prune {K : GlobalList J} {W W' : Set J}
    (h : K.InjectionDisjoint W) (hsub : W' ⊆ W) : (K.prune W').InjectionDisjoint W' := by
  classical
  intro i hi h2i j hj h2j hn x hx hxi hxj
  exact h i (Finset.mem_filter.mp hi).1 h2i j (Finset.mem_filter.mp hj).1 h2j hn
    x (hsub hx) hxi hxj

theorem InjectionDisjoint.append {K : GlobalList J} {W I : Set J}
    (h : K.InjectionDisjoint W) (hdisj : ∀ x ∈ W, x ∈ I → x ∉ K.Qual) :
    (K.append I).InjectionDisjoint W := by
  classical
  intro i hi h2i j hj h2j hn x hx hxi hxj
  have hmi := (append_membership K I i x).mp ((mem_memberships _ x i).mpr ⟨hi, hxi⟩)
  have hmj := (append_membership K I j x).mp ((mem_memberships _ x j).mpr ⟨hj, hxj⟩)
  rcases hmi with ⟨hi, hxi⟩ | ⟨hi, hxi⟩ <;>
    rcases hmj with ⟨hj, hxj⟩ | ⟨hj, hxj⟩
  · exact hn (hi.trans hj.symm)
  · exact hdisj x hx hxi ⟨j, hj, hxj⟩
  · exact hdisj x hx hxj ⟨i, hi, hxi⟩
  · exact h i hi h2i j hj h2j hn x hx hxi hxj

theorem pruned_length {K : GlobalList J} {r : J → J → Prop}
    {W W' : Set J} {B : Triple J}
    (hup : K.Upsets r) (hdisj : K.InjectionDisjoint W)
    (hB : ∀ z ∈ B.val, z ∈ W)
    (hhigh : ∀ x ∈ W', x ∈ K.Qual → ∃ z ∈ B.val, r x z) :
    (K.prune W').indices.card ≤ 5 := by
  classical
  let P := K.prune W'
  let I := P.indices.filter (2 ≤ ·)
  have hI : ∀ i ∈ I, i ∈ K.indices := by
    intro i hi
    exact (Finset.mem_filter.mp (Finset.mem_filter.mp hi).1).1
  have hactive : ∀ i ∈ I, ∃ x ∈ W', x ∈ K.entry i := by
    intro i hi
    obtain ⟨x, hxK, hxW⟩ := (Finset.mem_filter.mp (Finset.mem_filter.mp hi).1).2
    exact ⟨x, hxW, hxK⟩
  have hcap : I.card ≤ B.val.card := injection_card_bound (fun _ hi => hI _ hi) hup
    (fun _ hz => hB _ hz)
    (fun i hi j hj hn x hx hxi hxj => hdisj i (hI i hi) (Finset.mem_filter.mp hi).2
      j (hI j hj) (Finset.mem_filter.mp hj).2 hn x hx hxi hxj)
    (fun i hi => by obtain ⟨x, hxW, hxi⟩ := hactive i hi; exact ⟨x, hxi, hxW⟩)
    (fun x hx hxq => hhigh x hx hxq)
  have hsmall : (P.indices.filter (fun i => i < 2)).card ≤ 2 := by
    apply le_trans (Finset.card_le_card (t := {0, 1}) ?_) (by decide)
    intro i hi
    have hi2 := (Finset.mem_filter.mp hi).2
    simp only [Finset.mem_insert, Finset.mem_singleton]
    omega
  have hsum := Finset.card_filter_add_card_filter_not (s := P.indices) (p := fun i => 2 ≤ i)
  have hnot : P.indices.filter (fun i => ¬2 ≤ i) = P.indices.filter (fun i => i < 2) := by
    simp only [not_le]
  rw [hnot] at hsum
  change I.card + _ = P.indices.card at hsum
  have hthree := B.property
  change (K.prune W').indices.card ≤ 5
  dsimp only [P] at hsum hsmall
  omega

end GlobalList

namespace RunData
variable {J A : Type} {rank : J → ℕ} {atoms : A → Set J} {W : Set J}

noncomputable def root (htrue : Described atoms Set.univ 1) :
    RunData (GlobalList.one Set.univ) rank atoms W := by
  refine { base := fun _ => Set.univ, threshold := fun _ => 0, second := Set.univ
           entry_eq := ?_, simple := ?_, first_small := htrue.mono (by omega)
           second_small := htrue, second_eq := rfl, cover := ?_, pair := ?_ }
  · intro i _
    ext x
    simp [GlobalList.one, RankTail]
  · intro i _ _
    exact htrue.mono (by omega)
  · intro x _ _
    trivial
  · intro hz
    simp [GlobalList.one] at hz

noncomputable def switched {G D : Set J} (hG : Described atoms G 24)
    (hD : Described atoms D 1) (hcover : ∀ x ∈ W, x ∉ D → x ∈ G) (k : ℕ) :
    RunData (GlobalList.pair (G ∩ RankTail rank k) D) rank atoms W := by
  refine { base := fun i => if i = 0 then G else D
           threshold := fun i => if i = 0 then k else 0
           second := D
           entry_eq := ?_, simple := ?_, first_small := ?_
           second_small := hD, second_eq := ?_, cover := ?_, pair := ?_ }
  · intro i _
    by_cases he : i = 0
    · simp [GlobalList.pair, he]
    · ext x
      simp [GlobalList.pair, he, RankTail]
  · intro i _ hn
    simpa only [hn, ite_false] using hD.mono (show 1 ≤ 2 by omega)
  · simpa using hG
  · simp
  · simpa using hcover
  · intro _ x _ hx
    exact ⟨by simp [GlobalList.pair], by simpa [GlobalList.pair] using hx⟩

end RunData
end ThreeMachine.Structure

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

def PriorityCut (priority : J → ℕ) (k : ℕ) : Set J := {x | priority x < k}

theorem priorityCut_prefix (W : Finset J) (priority : J → ℕ) (k : ℕ) :
    PrefixOn W priority (PriorityCut priority k) := by
  intro x _ hx y _ hy
  change priority x < k at hx
  change ¬priority y < k at hy
  omega

theorem priorityCut_ideal {W : Finset J} {r : J → J → Prop} {priority : J → ℕ}
    (hstrict : ∀ x ∈ W, ∀ y ∈ W, r x y → priority x < priority y) (k : ℕ) :
    IdealOn W r (PriorityCut priority k) := by
  intro x hx y hy hxy hlow
  exact (hstrict x hx y hy hxy).trans hlow

theorem numeric_shared_cutoff {W : Finset J} {r : J → J → Prop}
    {time priority : J → ℕ} {s k : ℕ}
    (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)
    (hinj : Set.InjOn priority W)
    (hstrict : ∀ x ∈ W, ∀ y ∈ W, r x y → priority x < priority y)
    (hnorm : LocalObstruction W r time priority)
    (hsep : Separator W r time (PriorityCut priority k) s) :
    ∃ t, s ≤ t ∧ AdvancePath W r time (PriorityCut priority (k+1)) s t ∧
      Separator W r time (PriorityCut priority k) t ∧
      Separator W r time (PriorityCut priority (k+1)) t := by
  classical
  by_cases hex : ∃ x ∈ W, priority x = k
  · obtain ⟨x, hx, hxk⟩ := hex
    apply shared_cutoff (a := x) htrans hrespect hclosed hpos
      (priorityCut_ideal hstrict k) (priorityCut_ideal hstrict (k+1))
      (priorityCut_prefix W priority k) (priorityCut_prefix W priority (k+1)) ?_ hnorm hsep
    intro z hz
    change priority z < k+1 ↔ priority z < k ∨ z = x
    constructor
    · intro h
      by_cases hzk : priority z < k
      · exact Or.inl hzk
      · exact Or.inr (hinj hz hx (by omega))
    · rintro (h | rfl) <;> omega
  · have heq : ∀ z ∈ W, z ∈ PriorityCut priority k ↔ z ∈ PriorityCut priority (k+1) := by
      intro z hz
      have hne : priority z ≠ k := fun h => hex ⟨z, hz, h⟩
      change priority z < k ↔ priority z < k+1
      omega
    exact ⟨s, le_rfl, .refl s, hsep, (separator_congr heq).mp hsep⟩

structure NumericWalkData (E : Finset J) (r : J → J → Prop)
    (time priority : J → ℕ) (a lo count : ℕ) where
  position : Fin (count+1) → ℕ
  first : position 0 = a
  endpoint : ∀ i, position i = a ∨ ∃ x ∈ E, time x = position i
  separator : ∀ i, Separator E r time (PriorityCut priority (lo+i.val)) (position i)
  history : ∀ i, CutoffWalk E r time priority (PriorityCut priority (lo+i.val)) a (position i)
  steps : ∀ i : Fin count,
    AdvancePath E r time (PriorityCut priority (lo+i.val+1))
      (position i.castSucc) (position i.succ) ∧
    Separator E r time (PriorityCut priority (lo+i.val)) (position i.succ)

theorem exists_numeric_walk {E : Finset J} {r : J → J → Prop}
    {time priority : J → ℕ} {a lo : ℕ}
    (htrans : ∀ ⦃u v w⦄, r u v → r v w → r u w)
    (hrespect : ∀ u v, r u v → time u < time v)
    (hclosed : SlotClosed E time) (hpos : AdmissiblePosition E time a)
    (hinj : Set.InjOn priority E)
    (hstrict : ∀ x ∈ E, ∀ y ∈ E, r x y → priority x < priority y)
    (hnorm : LocalObstruction E r time priority)
    (hstart : Separator E r time (PriorityCut priority lo) a) (count : ℕ) :
    Nonempty (NumericWalkData E r time priority a lo count) := by
  classical
  induction count with
  | zero =>
    refine ⟨⟨fun _ => a, rfl, fun _ => Or.inl rfl, ?_, ?_, fun i => Fin.elim0 i⟩⟩
    · intro i
      have he : i.val = 0 := by omega
      simpa only [he, Nat.add_zero] using hstart
    · intro _
      exact .refl
  | succ n ih =>
    obtain ⟨ih⟩ := ih
    let last : Fin (n+1) := Fin.last n
    have hlastpos : AdmissiblePosition E time (ih.position last) := by
      rcases ih.endpoint last with he | hm
      · simpa only [he] using hpos
      · exact Or.inl hm
    obtain ⟨t, _ht, hpath, hsep, hnext⟩ := numeric_shared_cutoff htrans hrespect hclosed
      hlastpos hinj hstrict hnorm (ih.separator last)
    let pos : Fin (n+2) → ℕ := Fin.lastCases t ih.position
    have hcast (i : Fin (n+1)) : pos i.castSucc = ih.position i := by simp [pos]
    have hend : pos (Fin.last (n+1)) = t := by simp [pos]
    refine ⟨{ position := pos, first := ?_, endpoint := ?_, separator := ?_, history := ?_, steps := ?_ }⟩
    · change pos (0 : Fin (n+1)).castSucc = a
      rw [hcast, ih.first]
    · intro i
      refine Fin.lastCases ?_ (fun j => ?_) i
      · rw [hend]
        rcases hpath.endpoint with he | hm
        · rw [he]
          exact ih.endpoint last
        · exact Or.inr hm
      · rw [hcast]
        exact ih.endpoint j
    · intro i
      refine Fin.lastCases ?_ (fun j => ?_) i
      · rw [hend]
        simpa only [last, Fin.val_last, Nat.add_assoc] using hnext
      · rw [hcast]
        exact ih.separator j
    · intro i
      refine Fin.lastCases ?_ (fun j => ?_) i
      · rw [hend]
        apply CutoffWalk.trans_advance
          ((ih.history last).mono (fun z _ hz => show priority z < lo + (n+1) from by
            have : priority z < lo + n := hz; omega)) hpath
          (priorityCut_ideal hstrict _) (priorityCut_prefix E priority _) (fun _ _ hz => hz)
      · rw [hcast]
        exact ih.history j
    · intro i
      refine Fin.lastCases ?_ (fun j => ?_) i
      · change AdvancePath E r time (PriorityCut priority (lo+n+1))
          (pos (Fin.last n).castSucc) (pos (Fin.last (n+1))) ∧ _
        rw [hcast, hend]
        constructor
        · exact hpath
        · simpa only [Fin.succ_last, hend] using hsep
      · have hleft : pos j.castSucc.castSucc = ih.position j.castSucc := hcast _
        have hright : pos j.castSucc.succ = ih.position j.succ := by
          rw [Fin.succ_castSucc, hcast]
        simpa only [Fin.val_castSucc, hleft, hright] using ih.steps j

end NumericWalk
end ThreeMachine.Structure

end

end OAI