import OAI.Computability.Superstring.LayerBridge

namespace OAI

namespace Superstring.LayerArray
open BitCode Hierarchical WalkCode
variable {α : Type} [Inhabited α] [DecidableEq α]

def exits (D : GroupData α) (j : ℕ) : List ℕ := D.2[j]?.getD []
def covered (D : GroupData α) (js : List ℕ) (P : Walk α) : Bool :=
  js.all (fun j => (content D.1 (exits D j)).all (fun w => member w P))
def collective (D : GroupData α) (js : List ℕ) (hi : ℕ) (a b : ℤ) : Walk α :=
  saturate D js (GeoCode.collective (PeriodWord.text D.1) (GeoCode.exit (exits D hi))
    D.1.length js.length a b)
def band (D : GroupData α) (js : List ℕ) (lo hi k : ℕ) (t : ℤ) : Walk α :=
  saturate D js (GeoCode.band (PeriodWord.text D.1) (GeoCode.exit (exits D lo))
    (GeoCode.exit (exits D hi)) D.1.length k t)
def shortSweep (D : GroupData α) (js : List ℕ) (hi : ℕ) (a b t : ℤ) : Walk α :=
  saturate D js (GeoCode.shortSweep (PeriodWord.text D.1) (GeoCode.exit (exits D hi))
    D.1.length js.length a b t)
def individual (D : GroupData α) (i : ℕ) (a b : ℤ) : Walk α :=
  saturate D [i] (GeoCode.individual (PeriodWord.text D.1) (GeoCode.exit (exits D i))
    D.1.length a b)

theorem covered_eq {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {js : List ℕ}
    (h : ∀ j ∈ js, Represents D.1 (exits D j) (L j))
    (hp : 0 < p) (per : Function.Periodic A (p : ℤ)) (P : Walk α) :
    covered D js P = true ↔ ∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ P := by
  simp only [covered,List.all_eq_true,member,decide_eq_true_eq]
  constructor
  · intro hc j hj w hw
    exact hc j hj w ((mem_content (h j hj) hp per w).mpr hw)
  · intro hc j hj w hw
    exact hc j hj w ((mem_content (h j hj) hp per w).mp hw)

theorem filled_realized {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {js : List ℕ}
    (h : ∀ j ∈ js, Represents D.1 (exits D j) (L j))
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ))
    {s : List α} {P : Hierarchical.Path V s s} {W : Walk α}
    (he : WalkCode.Path.points P = W) (ht : ∀ j ∈ js, (L j).TouchedBy P) :
    Runs V s s (saturate D js W) ∧
      cost (saturate D js W) = P.cost+js.length*p ∧
      (∀ w, P.Visits w → w ∈ saturate D js W) ∧
      ∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ saturate D js W := by
  have hs := WalkCode.points_spec P
  obtain ⟨hr,hc,hv,hw⟩ := saturate_spec L h closed hp per
    (s:=s) (t:=s) (P:=W) (by rw [← he]; exact ⟨hs.1,hs.2.1,hs.2.2.1⟩)
    (by intro j hj; obtain ⟨x,e,hf,hl,hv⟩ := ht j hj
        exact ⟨_,⟨x,e,hf,hl,rfl⟩,he ▸ (hs.2.2.2.2 _).mpr hv⟩)
  refine ⟨hr,?_,fun w hw => hv w (he ▸ (hs.2.2.2.2 w).mpr hw),hw⟩
  rw [← he,hs.2.2.2.1] at hc
  simpa only [he] using hc

theorem collective_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {js : List ℕ} {lo hi : ℕ}
    (h : ∀ j ∈ js, Represents D.1 (exits D j) (L j))
    (hlo : lo ∈ js) (hhi : hi ∈ js)
    (lower : ∀ j ∈ js, ∀ x, (L lo).z x ≤ (L j).z x)
    (upper : ∀ j ∈ js, ∀ x, (L j).z x ≤ (L hi).z x)
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ))
    (letters : ∀ x, [A x] ∈ V) {a b : ℤ} (hab : a ≤ b)
    (hR : textWord A a b ∈ V)
    (hH : (L hi).first a ≤ b + (js.length*p : ℕ))
    (hgap : (L hi).first a-(L lo).last a ≤ (js.length*p : ℕ))
    (hB : b ≤ (L lo).last a + (js.length*p : ℕ)) :
    Runs V (textWord A a b) (textWord A a b) (collective D js hi a b) ∧
      cost (collective D js hi a b) = 2*(js.length*p) ∧
      (∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ collective D js hi a b) ∧
      textWord A a b ∈ collective D js hi a b := by
  obtain ⟨P,he,hc,ht⟩ := GeoCode.collective_link_realizes closed A letters p js.length per
    (fun j : {j // j ∈ js} => L j.val) ⟨lo,hlo⟩ ⟨hi,hhi⟩
    (fun j => lower j.val j.property) (fun j => upper j.val j.property) hab hR hH hgap hB
  have he' : WalkCode.Path.points P = GeoCode.collective (PeriodWord.text D.1)
      (GeoCode.exit (exits D hi)) D.1.length js.length a b := by
    rw [(h hi hhi).text_eq,(h hi hhi).exit_eq,(h hi hhi).length_eq]; exact he
  obtain ⟨hr,hc',hv,hw⟩ := filled_realized L h closed hp per he' (fun j hj => ht ⟨j,hj⟩)
  refine ⟨hr,?_,hw,hv _ (Hierarchical.Path.visits_start P)⟩
  change cost (saturate D js _) = _
  rw [hc',hc,two_mul]

theorem band_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {js : List ℕ} {lo hi k : ℕ}
    (h : ∀ j ∈ js, Represents D.1 (exits D j) (L j))
    (hlo : lo ∈ js) (hhi : hi ∈ js)
    (lower : ∀ j ∈ js, ∀ x, (L lo).z x ≤ (L j).z x)
    (upper : ∀ j ∈ js, ∀ x, (L j).z x ≤ (L hi).z x)
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ))
    (letters : ∀ x, [A x] ∈ V) (t : ℤ)
    (hB : (L hi).first t-(L lo).last t ≤ (k*p : ℕ)) :
    Runs V (textWord A t ((L lo).last t)) (textWord A t ((L lo).last t)) (band D js lo hi k t) ∧
      cost (band D js lo hi k t) ≤ (k+js.length)*p ∧
      ∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ band D js lo hi k t := by
  obtain ⟨P,he,hc,ht⟩ := GeoCode.join_band_realizes closed A letters p k per
    (fun j : {j // j ∈ js} => L j.val) ⟨lo,hlo⟩ ⟨hi,hhi⟩
    (fun j => lower j.val j.property) (fun j => upper j.val j.property) t hB
  have he' : WalkCode.Path.points P = GeoCode.band (PeriodWord.text D.1)
      (GeoCode.exit (exits D lo)) (GeoCode.exit (exits D hi)) D.1.length k t := by
    rw [(h hi hhi).text_eq,(h hi hhi).exit_eq,(h lo hlo).exit_eq,(h hi hhi).length_eq]; exact he
  obtain ⟨hr,hc',_,hw⟩ := filled_realized L h closed hp per he' (fun j hj => ht ⟨j,hj⟩)
  refine ⟨hr,?_,hw⟩
  change cost (saturate D js _) ≤ _
  rw [hc',Nat.add_mul]
  omega

variable [Coded α]
omit [Inhabited α] [DecidableEq α] in
@[fun_prop] theorem poly_exits : Poly (fun q : GroupData α × ℕ => exits q.1 q.2) := by
  unfold exits
  exact (BitCode.Poly.getD ([] : List ℕ)).comp (f := fun q : GroupData α × ℕ => (q.1.2,q.2)) (by fun_prop)
@[fun_prop] theorem poly_covered : Poly (fun q : GroupData α × List ℕ × Walk α => covered q.1 q.2.1 q.2.2) := by
  unfold covered
  apply BitCode.Poly.allFn (p := fun q : (GroupData α × List ℕ × Walk α) × ℕ =>
    (content q.1.1.1 (exits q.1.1 q.2)).all (fun w => member w q.1.2.2))
  · exact BitCode.Poly.allFn (p := fun q : ((GroupData α × List ℕ × Walk α) × ℕ) × List α =>
      member q.2 q.1.1.2.2) (by fun_prop) (by fun_prop)
  · fun_prop
@[fun_prop] theorem saturate_fn {β : Type} [Coded β]
    {D : β → GroupData α} {js : β → List ℕ} {P : β → Walk α}
    (hD : Poly D) (hjs : Poly js) (hP : Poly P) :
    Poly (fun q => saturate (D q) (js q) (P q)) :=
  poly_saturate.comp (hD.pair (hjs.pair hP))
@[fun_prop] theorem poly_collective : Poly (fun q : GroupData α × List ℕ × ℕ × ℤ × ℤ =>
    collective q.1 q.2.1 q.2.2.1 q.2.2.2.1 q.2.2.2.2) := by
  unfold collective
  apply saturate_fn (by fun_prop) (by fun_prop)
  exact GeoCode.poly_collective.comp
    (f := fun q : GroupData α × List ℕ × ℕ × ℤ × ℤ =>
      (q.1.1,exits q.1 q.2.2.1,q.1.1.length,q.2.1.length,q.2.2.2.1,q.2.2.2.2)) (by fun_prop)
@[fun_prop] theorem poly_band : Poly (fun q : GroupData α × List ℕ × ℕ × ℕ × ℕ × ℤ =>
    band q.1 q.2.1 q.2.2.1 q.2.2.2.1 q.2.2.2.2.1 q.2.2.2.2.2) := by
  unfold band
  apply saturate_fn (by fun_prop) (by fun_prop)
  exact GeoCode.poly_band.comp
    (f := fun q : GroupData α × List ℕ × ℕ × ℕ × ℕ × ℤ =>
      (q.1.1,exits q.1 q.2.2.1,exits q.1 q.2.2.2.1,q.1.1.length,q.2.2.2.2.1,q.2.2.2.2.2)) (by fun_prop)
@[fun_prop] theorem poly_shortSweep : Poly (fun q : GroupData α × List ℕ × ℕ × ℤ × ℤ × ℤ =>
    shortSweep q.1 q.2.1 q.2.2.1 q.2.2.2.1 q.2.2.2.2.1 q.2.2.2.2.2) := by
  unfold shortSweep
  apply saturate_fn (by fun_prop) (by fun_prop)
  exact GeoCode.poly_shortSweep.comp
    (f := fun q : GroupData α × List ℕ × ℕ × ℤ × ℤ × ℤ =>
      (q.1.1,exits q.1 q.2.2.1,q.1.1.length,q.2.1.length,q.2.2.2.1,q.2.2.2.2.1,q.2.2.2.2.2)) (by fun_prop)
@[fun_prop] theorem poly_individual : Poly (fun q : GroupData α × ℕ × ℤ × ℤ =>
    individual q.1 q.2.1 q.2.2.1 q.2.2.2) := by
  unfold individual
  apply saturate_fn (by fun_prop) (by fun_prop)
  exact GeoCode.poly_individual.comp
    (f := fun q : GroupData α × ℕ × ℤ × ℤ =>
      (q.1.1,exits q.1 q.2.1,q.1.1.length,q.2.2.1,q.2.2.2)) (by fun_prop)
end Superstring.LayerArray


namespace Superstring.LayerArray
open BitCode Hierarchical WalkCode
variable {α : Type} [Inhabited α] [DecidableEq α]

theorem individual_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {i : ℕ}
    (h : Represents D.1 (exits D i) (L i))
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ))
    (letters : ∀ x, [A x] ∈ V) (q : ℕ) {a b : ℤ} (hab : a ≤ b)
    (hR : textWord A a b ∈ V) (hf : (L i).first a ≤ b) (hl : b ≤ (L i).last a+p)
    (hlen : b-a < p+q) :
    Runs V (textWord A a b) (textWord A a b) (individual D i a b) ∧
      cost (individual D i a b) = 2*p ∧
      (∀ w ∈ (L i).Content, w ∈ individual D i a b) ∧
      textWord A a b ∈ individual D i a b ∧
      ∃ w ∈ individual D i a b, w.length ≤ q := by
  obtain ⟨P,he,hc,ht,w,hw,hwlen⟩ := GeoCode.individual_link_realizes closed A letters p q per
    (L i) hab hR hf hl hlen
  have he' : WalkCode.Path.points P = GeoCode.individual (PeriodWord.text D.1)
      (GeoCode.exit (exits D i)) D.1.length a b := by
    rw [h.text_eq,h.exit_eq,h.length_eq]; exact he
  obtain ⟨hr,hc',hv,hcover⟩ := filled_realized L
    (D:=D) (js:=[i]) (by intro j hj; have := List.mem_singleton.mp hj; subst j; exact h)
    closed hp per he' (by intro j hj; simpa only [List.mem_singleton.mp hj] using ht)
  refine ⟨hr,?_,hcover i (by simp),hv _ (Hierarchical.Path.visits_start P),w,hv w hw,hwlen⟩
  change cost (saturate D [i] _) = _
  rw [hc',hc]
  simp only [List.length_singleton,one_mul,two_mul]

theorem shortSweep_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {js : List ℕ} {hi : ℕ}
    (h : ∀ j ∈ js, Represents D.1 (exits D j) (L j)) (hhi : hi ∈ js)
    (upper : ∀ j ∈ js, ∀ x, (L j).z x ≤ (L hi).z x)
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ))
    (letters : ∀ x, [A x] ∈ V) (q : ℕ)
    (hlong : ∀ j ∈ js, ¬(L j).HasShort q) {a b t : ℤ} (hat : a ≤ t) (htb : t < b)
    (hR : textWord A a b ∈ V) (hH : (L hi).first t ≤ b+(js.length*p : ℕ))
    (hlen : b-a < p+q) (hagr : b-t < q) :
    Runs V (textWord A a b) (textWord A a b) (shortSweep D js hi a b t) ∧
      cost (shortSweep D js hi a b t) = 2*(js.length*p) ∧
      (∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ shortSweep D js hi a b t) ∧
      textWord A a b ∈ shortSweep D js hi a b t ∧
      ∃ w ∈ shortSweep D js hi a b t, w.length ≤ q := by
  have hk : 1 ≤ js.length := by have := List.length_pos_of_mem hhi; omega
  obtain ⟨P,he,hc,ht,w,hw,hwlen⟩ := GeoCode.collective_short_sweep_realizes closed A letters p js.length q hk per
    (fun j : {j // j ∈ js} => L j.val) ⟨hi,hhi⟩
    (fun j => upper j.val j.property) (fun j => hlong j.val j.property) hat htb hR hH hlen hagr
  have he' : WalkCode.Path.points P = GeoCode.shortSweep (PeriodWord.text D.1)
      (GeoCode.exit (exits D hi)) D.1.length js.length a b t := by
    rw [(h hi hhi).text_eq,(h hi hhi).exit_eq,(h hi hhi).length_eq]; exact he
  obtain ⟨hr,hc',hv,hcover⟩ := filled_realized L h closed hp per he' (fun j hj => ht ⟨j,hj⟩)
  refine ⟨hr,?_,hcover,hv _ (Hierarchical.Path.visits_start P),w,hv w hw,hwlen⟩
  change cost (saturate D js _) = _
  rw [hc',hc,two_mul]

theorem collective_contact [LinearOrder α] {V : Set (List α)} {A B : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {js : List ℕ} {lo hi : ℕ}
    (h : ∀ j ∈ js, Represents D.1 (exits D j) (L j)) (hlo : lo ∈ js) (hhi : hi ∈ js)
    (lower : ∀ j ∈ js, ∀ x, (L lo).z x ≤ (L j).z x)
    (upper : ∀ j ∈ js, ∀ x, (L j).z x ≤ (L hi).z x)
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ))
    (letters : ∀ x, [A x] ∈ V) (q : ℕ) (hq : 0 < q) (perB : Function.Periodic B (q : ℤ))
    {a b t : ℤ} (hat : a ≤ t) (htb : t < b)
    (hR : textWord A a b ∈ V) (hag : AgreeOn A B a b) (hne : A ≠ B)
    (hmax : ∀ x, forward A x ≤ forward A t) (hbelow : ∀ x, forward B x ≤ forward A t)
    (hH : (L hi).first t ≤ b+(js.length*p : ℕ))
    (hgap : (L hi).first a-(L lo).last a ≤ (js.length*p : ℕ))
    (hB : b ≤ (L lo).last a+(js.length*p : ℕ)) :
    ∃ P ∈ [collective D js hi a b,shortSweep D js hi a b t],
      Runs V (textWord A a b) (textWord A a b) P ∧ cost P = 2*(js.length*p) ∧
      (∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ P) ∧ textWord A a b ∈ P ∧
      ∃ w ∈ P, w.length ≤ q := by
  classical
  by_cases hs : ∃ j ∈ js, (L j).HasShort q
  · obtain ⟨hr,hc,hcover,hR'⟩ := collective_spec L h hlo hhi lower upper closed hp per letters
      (by omega) hR (le_trans ((L hi).first_mono hat) hH) hgap hB
    obtain ⟨j,hj,x,e,hf,hl,hshort⟩ := hs
    exact ⟨_,by simp,hr,hc,hcover,hR',_,hcover j hj _ ⟨x,e,hf,hl,rfl⟩,hshort⟩
  · have hlen := agreement_bound A B p q hp hq per perB hne a b hag
    have hagr : b-t < q := by
      obtain ⟨n,hn,hd⟩ := maximal_rotation A B p q hp hq per perB t hmax hbelow hne
      by_contra hh
      exact hd (hag (t+n) (by omega) (by omega))
    obtain ⟨hr,hc,hcover,hR',hw⟩ := shortSweep_spec L h hhi upper closed hp per letters q
      (by intro j hj hh; exact hs ⟨j,hj,hh⟩) hat htb hR hH hlen hagr
    exact ⟨_,by simp,hr,hc,hcover,hR',hw⟩
end Superstring.LayerArray


namespace Superstring.WalkCode
open BitCode Hierarchical
variable {α : Type}
theorem root_prefix {V : Set (List α)} (closed : SubstringClosed V) {w v : List α}
    (hw : w ∈ V) (hv : v <+: w) : v ∈ root w := by
  obtain ⟨u,rfl⟩ := hv
  have ha := append_spec closed [] (v++u) (by simpa using hw)
  have hd := delete_spec closed (v++u) [] (by simpa using hw)
  rw [root,mem_join ha.2.2.1 (by simpa only [List.nil_append,List.append_nil] using hd.2.1)]
  apply Or.inl
  simpa using mem_append ([] : List α) (v++u) v.length (by simp)
end Superstring.WalkCode

namespace Superstring.LayerArray
open BitCode Hierarchical WalkCode
variable {α : Type} [Inhabited α] [DecidableEq α]
def rootContent (D : GroupData α) (js : List ℕ) (w : List α) : Walk α :=
  saturate D js (WalkCode.root w)
def shortPool (D : GroupData α) (i : ℕ) : List (Walk α) :=
  (content D.1 (exits D i)).map (rootContent D [i])
def rootUpper (D : GroupData α) (js : List ℕ) (hi : ℕ) (t : ℤ) : Walk α :=
  rootContent D js (PeriodWord.window D.1 t (GeoCode.first (exits D hi) t))

theorem rootContent_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {js : List ℕ} {w : List α}
    (h : ∀ j ∈ js, Represents D.1 (exits D j) (L j))
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ))
    (hw : w ∈ V) (htouch : ∀ j ∈ js, ∃ v ∈ (L j).Content, v <+: w) :
    Runs V [] [] (rootContent D js w) ∧ cost (rootContent D js w) = w.length+js.length*p ∧
      ∀ j ∈ js, ∀ v ∈ (L j).Content, v ∈ rootContent D js w := by
  have hr := WalkCode.root_spec closed hw
  obtain ⟨hR,hc,_,hv⟩ := saturate_spec L h closed hp per hr.1 (by
    intro j hj
    obtain ⟨v,hv,hpre⟩ := htouch j hj
    exact ⟨v,hv,WalkCode.root_prefix closed hw hpre⟩)
  exact ⟨hR,by simpa only [rootContent,hr.2.1] using hc,hv⟩

theorem shortPool_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {i : ℕ}
    (h : Represents D.1 (exits D i) (L i))
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ))
    (hs : (L i).HasShort p) :
    ∃ P ∈ shortPool D i, Runs V [] [] P ∧ cost P ≤ 2*p ∧
      ∀ w ∈ (L i).Content, w ∈ P := by
  obtain ⟨x,e,hf,hl,hlen⟩ := hs
  let w := textWord A x e
  have hw : w ∈ (L i).Content := ⟨x,e,hf,hl,rfl⟩
  refine ⟨rootContent D [i] w,List.mem_map.mpr ⟨w,(mem_content h hp per w).mpr hw,rfl⟩,?_⟩
  obtain ⟨hr,hc,hv⟩ := rootContent_spec L (D:=D) (js:=[i])
    (by intro j hj; have := List.mem_singleton.mp hj; subst j; exact h)
    closed hp per ((L i).actual x e hf hl)
    (by intro j hj; have := List.mem_singleton.mp hj; subst j; exact ⟨w,hw,List.prefix_refl _⟩)
  exact ⟨hr,by simp only [List.length_singleton,one_mul] at hc; dsimp only [w]; omega,hv i (by simp)⟩

theorem rootUpper_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (L : ℕ → Layer V A p) {D : GroupData α} {js : List ℕ} {hi : ℕ}
    (h : ∀ j ∈ js, Represents D.1 (exits D j) (L j)) (hh : Represents D.1 (exits D hi) (L hi))
    (upper : ∀ j ∈ js, ∀ x, (L j).z x ≤ (L hi).z x)
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ)) (t : ℤ)
    (hlen : (L hi).first t-t ≤ (js.length*p : ℕ)) :
    Runs V [] [] (rootUpper D js hi t) ∧ cost (rootUpper D js hi t) ≤ 2*(js.length*p) ∧
      ∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ rootUpper D js hi t := by
  have he : PeriodWord.window D.1 t (GeoCode.first (exits D hi) t) =
      textWord A t ((L hi).first t) := by
    simp only [PeriodWord.window_eq,hh.text_eq,GeoCode.first,hh.exit_eq,Layer.first]
  unfold rootUpper
  rw [he]
  obtain ⟨hr,hc,hv⟩ := rootContent_spec L h closed hp per ((L hi).first_actual t) (by
    intro j hj
    refine ⟨textWord A t ((L j).first t),⟨t,_,le_rfl,(L j).first_le_last t,rfl⟩,?_⟩
    exact ⟨textWord A ((L j).first t) ((L hi).first t),
      textWord_append A ((L j).start_le_first t) (upper j hj (t-1))⟩)
  refine ⟨hr,?_,hv⟩
  rw [hc,length_textWord]
  have ht := (L hi).start_le_first t
  omega

variable [Coded α]
@[fun_prop] theorem poly_rootContent : Poly (fun q : GroupData α × List ℕ × List α =>
    rootContent q.1 q.2.1 q.2.2) := by unfold rootContent; fun_prop
@[fun_prop] theorem poly_shortPool : Poly (fun q : GroupData α × ℕ => shortPool q.1 q.2) := by
  unfold shortPool
  exact BitCode.Poly.mapFn
    (f := fun q : (GroupData α × ℕ) × List α => rootContent q.1.1 [q.1.2] q.2)
    (by fun_prop) (by fun_prop)
@[fun_prop] theorem poly_rootUpper : Poly (fun q : GroupData α × List ℕ × ℕ × ℤ =>
    rootUpper q.1 q.2.1 q.2.2.1 q.2.2.2) := by
  unfold rootUpper
  exact poly_rootContent.comp
    (f := fun q : GroupData α × List ℕ × ℕ × ℤ =>
      (q.1,q.2.1,PeriodWord.window q.1.1 q.2.2.2 (GeoCode.first (exits q.1 q.2.2.1) q.2.2.2))) (by fun_prop)
end Superstring.LayerArray


namespace Superstring.WalkCode
open BitCode Hierarchical
variable {α : Type}
def rootShort (P : Walk α) (p : ℕ) : Walk α :=
  rootAt P (ThreadArray.first P.length (fun i => lessEq (P[i]?.getD []).length p))

theorem rootShort_spec {V : Set (List α)} (closed : SubstringClosed V) {P : Walk α} {s : List α}
    (hP : Runs V s s P) (p : ℕ) (hs : ∃ w ∈ P, w.length ≤ p) :
    Runs V [] [] (rootShort P p) ∧ cost (rootShort P p) ≤ cost P+p ∧
      ∀ w ∈ P, w ∈ rootShort P p := by
  obtain ⟨x,hx,hlen⟩ := hs
  obtain ⟨i,hi,hix⟩ := List.mem_iff_getElem.mp hx
  have he : lessEq (P[i]?.getD []).length p = true := by
    simpa only [List.getElem?_eq_getElem hi,Option.getD_some,hix,lessEq,decide_eq_true_eq] using hlen
  obtain ⟨hj,hp',_⟩ := ThreadArray.first_spec (P := fun i => lessEq (P[i]?.getD []).length p) ⟨i,hi,he⟩
  obtain ⟨hR,hc,hv⟩ := rootAt_spec closed hP hj
  have hl : P[ThreadArray.first P.length (fun i => lessEq (P[i]?.getD []).length p)].length ≤ p := by
    have hh := of_decide_eq_true hp'
    simpa only [List.getElem?_eq_getElem hj,Option.getD_some] using hh
  exact ⟨hR,hc.trans_le (Nat.add_le_add_left hl _),hv⟩

variable [Coded α]
@[fun_prop] theorem poly_rootShort : Poly (fun q : Walk α × ℕ => rootShort q.1 q.2) := by
  unfold rootShort ThreadArray.first
  apply poly_rootAt.comp (f := fun q : Walk α × ℕ =>
    (q.1,((List.range q.1.length).filter (fun i => lessEq (q.1[i]?.getD []).length q.2)).headD 0))
  apply Poly.pair (by fun_prop)
  apply (Poly.headD 0).comp (f := fun q : Walk α × ℕ =>
     (List.range q.1.length).filter (fun i => lessEq (q.1[i]?.getD []).length q.2))
  apply Poly.filterFn (p := fun q : (Walk α × ℕ) × ℕ => lessEq (q.1.1[q.2]?.getD []).length q.1.2)
  · have h := (Poly.getD ([] : List α)).comp
      (f := fun q : (Walk α × ℕ) × ℕ => (q.1.1,q.2)) (by fun_prop)
    fun_prop
  · fun_prop
end Superstring.WalkCode

end OAI