import OAI.Computability.Superstring.GroupBridge

namespace OAI

namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode
variable {α : Type} [Inhabited α] [DecidableEq α]
abbrev Env (α : Type) := (List (GroupData α) × List ℕ) × ℕ
def data (X : Env α) (g : ℕ) : GroupData α := X.1.1[g]?.getD ([],[])
def gs (X : Env α) : List ℕ := X.1.2
def stride (X : Env α) : ℕ := X.2
def owner (X : Env α) (i : ℕ) : ℕ := i / stride X
def idx (X : Env α) (i : ℕ) : ℕ := i % stride X
def layer (X : Env α) (i : ℕ) : List α × List ℕ :=
  ((data X (owner X i)).1,exits (data X (owner X i)) (idx X i))
def book (X : Env α) : UpperCode.Book α := (List.range (X.1.1.length*stride X)).map (layer X)
def ids (X : Env α) : List ℕ := (gs X).flatMap (fun g =>
  (List.range (data X g).2.length).map (fun i => g*stride X+i))
def per (X : Env α) (g : ℕ) : ℕ := (data X g).1.length
def phase [LinearOrder α] (X : Env α) (g : ℕ) : ℤ := RotationCode.phase (data X g).1
def contents (X : Env α) : List (Walk α) := (book X).map (fun d => content d.1 d.2)
def ls (X : Env α) : ℕ → Walk α := BlockClose.lookup (contents X)

omit [Inhabited α] [DecidableEq α] in
theorem owner_encode (X : Env α) (g i : ℕ) (hi : i < stride X) : owner X (g*stride X+i) = g := by
  have hp : 0 < stride X := by omega
  simp only [owner,Nat.add_mul_div_right i g hp,add_comm (g*stride X) i]
  rw [Nat.div_eq_of_lt hi,zero_add]
omit [Inhabited α] [DecidableEq α] in
theorem idx_encode (X : Env α) (g i : ℕ) (hi : i < stride X) : idx X (g*stride X+i) = i := by
  unfold idx
  rw [Nat.add_mod,Nat.mul_mod_left,zero_add,Nat.mod_eq_of_lt hi,Nat.mod_eq_of_lt hi]

omit [Inhabited α] [DecidableEq α] in
theorem lookup_encode (X : Env α) (g i : ℕ) (hg : g < X.1.1.length) (hi : i < stride X) :
    UpperCode.lookup (book X) (g*stride X+i) = ((data X g).1,exits (data X g) i) := by
  have hb : g*stride X+i < X.1.1.length*stride X := by nlinarith
  simp only [UpperCode.lookup,book,List.getElem?_map,List.getElem?_range hb,
    Option.map_some,Option.getD_some,layer,owner_encode X g i hi,idx_encode X g i hi]

omit [DecidableEq α] in
theorem ls_encode (X : Env α) (g i : ℕ) (hg : g < X.1.1.length) (hi : i < stride X) :
    ls X (g*stride X+i) = content (data X g).1 (exits (data X g) i) := by
  have hb : g*stride X+i < X.1.1.length*stride X := by nlinarith
  simp only [ls,BlockClose.lookup,contents,book,List.getElem?_map,List.getElem?_range hb,
    Option.map_some,Option.getD_some,layer,owner_encode X g i hi,idx_encode X g i hi]

omit [Inhabited α] [DecidableEq α] in
theorem encode_injective (X : Env α) {g h i j : ℕ} (hi : i < stride X) (hj : j < stride X)
    (he : g*stride X+i = h*stride X+j) : g = h ∧ i = j := by
  exact ⟨by have := congrArg (owner X) he; simpa only [owner_encode X g i hi,owner_encode X h j hj] using this,
    by have := congrArg (idx X) he; simpa only [idx_encode X g i hi,idx_encode X h j hj] using this⟩

variable [Coded α]
omit [Inhabited α] [DecidableEq α] in
@[fun_prop] theorem poly_data : Poly (fun q : Env α × ℕ => data q.1 q.2) := by
  unfold data
  exact (BitCode.Poly.getD ([],[])).comp (f := fun q : Env α × ℕ => (q.1.1.1,q.2)) (by fun_prop)
omit [Inhabited α] [DecidableEq α] in
@[fun_prop] theorem poly_owner : Poly (fun q : Env α × ℕ => owner q.1 q.2) := by unfold owner stride; fun_prop
omit [Inhabited α] [DecidableEq α] in
@[fun_prop] theorem poly_idx : Poly (fun q : Env α × ℕ => idx q.1 q.2) := by unfold idx stride; fun_prop
omit [Inhabited α] [DecidableEq α] in
@[fun_prop] theorem poly_layer : Poly (fun q : Env α × ℕ => layer q.1 q.2) := by unfold layer; fun_prop
omit [Inhabited α] [DecidableEq α] in
@[fun_prop] theorem poly_book : Poly (fun X : Env α => book X) := by
  unfold book stride
  exact BitCode.Poly.mapFn poly_layer (by fun_prop)
omit [Inhabited α] [DecidableEq α] in
@[fun_prop] theorem poly_ids : Poly (fun X : Env α => ids X) := by
  unfold ids gs stride
  apply BitCode.Poly.flatMapFn (f := fun q : Env α × ℕ =>
    (List.range (data q.1 q.2).2.length).map (fun i => q.2*q.1.2+i))
  · exact BitCode.Poly.mapFn (f := fun q : (Env α × ℕ) × ℕ => q.1.2*q.1.1.2+q.2) (by fun_prop) (by fun_prop)
  · fun_prop
omit [Inhabited α] [DecidableEq α] in
@[fun_prop] theorem poly_per : Poly (fun q : Env α × ℕ => per q.1 q.2) := by unfold per; fun_prop
omit [DecidableEq α] in
@[fun_prop] theorem poly_contents : Poly (fun X : Env α => contents X) := by
  unfold contents
  exact BitCode.Poly.mapFn (f := fun q : Env α × (List α × List ℕ) => content q.2.1 q.2.2) (by fun_prop) poly_book
variable [LinearOrder α]
omit [DecidableEq α] in
@[fun_prop] theorem poly_phase (hlt : Poly (fun q : α × α => decide (q.1<q.2))) :
    Poly (fun q : Env α × ℕ => phase q.1 q.2) := by
  unfold phase
  exact BitCode.Poly.natCastInt.comp ((RotationCode.poly_phase hlt).comp (by fun_prop))
end Superstring.CollectionCode


namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode
variable {α G : Type} [Inhabited α] [LinearOrder α] {V : Set (List α)}

noncomputable def rank (X : Env α) (g : ℕ) : Lex (ℕ → α) :=
  forward (PeriodWord.text (data X g).1) (phase X g)


structure Model (X : Env α) (C : LayerCollection V G) where
  group : G → ℕ
  group_inj : Function.Injective group
  groups : ∀ j, j ∈ gs X ↔ ∃ g, group g = j
  nodup : (gs X).Nodup
  bound : ∀ g, group g < X.1.1.length
  size : ∀ g, (data X (group g)).2.length = C.size g
  capacity : ∀ g, C.size g ≤ stride X
  rep : ∀ (g) (i : Fin (C.size g)), Represents (data X (group g)).1
    (exits (data X (group g)) i.val) (C.layer g i)
  phase_eq : ∀ g, phase X (group g) = C.distinguished g

namespace Model
variable {X : Env α} {C : LayerCollection V G} (h : Model X C)
def encode (i : C.Id) : ℕ := h.group i.1*stride X+i.2.val

include h
theorem local_lt (g : G) (i : Fin (C.size g)) : i.val < stride X := lt_of_lt_of_le i.isLt (h.capacity g)
@[simp] theorem owner_eq (i : C.Id) : owner X (h.encode i) = h.group i.1 :=
  owner_encode X _ _ (h.local_lt ..)
@[simp] theorem idx_eq (i : C.Id) : idx X (h.encode i) = i.2.val := idx_encode X _ _ (h.local_lt ..)

theorem encode_inj : Function.Injective h.encode := by
  intro i j he
  obtain ⟨i,k⟩ := i
  obtain ⟨j,l⟩ := j
  obtain ⟨hg,hi⟩ := encode_injective X (h.local_lt i k) (h.local_lt j l) he
  have hg' : i = j := h.group_inj hg
  subst j
  exact Sigma.mk.inj_iff.mpr ⟨rfl,heq_of_eq (Fin.ext hi)⟩

theorem id_mem (i : C.Id) : h.encode i ∈ ids X := by
  apply List.mem_flatMap.mpr
  refine ⟨h.group i.1,(h.groups _).mpr ⟨i.1,rfl⟩,List.mem_map.mpr ⟨i.2.val,?_,rfl⟩⟩
  rw [List.mem_range,h.size]
  exact i.2.isLt

theorem mem_ids (j : ℕ) : j ∈ ids X ↔ ∃ i, h.encode i = j := by
  constructor
  · intro hj
    obtain ⟨g,hg,hj⟩ := List.mem_flatMap.mp hj
    obtain ⟨a,rfl⟩ := (h.groups g).mp hg
    obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hj
    have hi' : i < C.size a := by simpa only [List.mem_range,h.size] using hi
    exact ⟨⟨a,⟨i,hi'⟩⟩,rfl⟩
  · rintro ⟨i,rfl⟩
    exact h.id_mem i

theorem book_rep (i : C.Id) : Represents (UpperCode.lookup (book X) (h.encode i)).1
    (UpperCode.lookup (book X) (h.encode i)).2 (C.layerAt i) := by
  rw [encode,lookup_encode X _ _ (h.bound _) (h.local_lt ..)]
  exact h.rep ..

theorem content_iff (i : C.Id) (w : List α) : w ∈ ls X (h.encode i) ↔ w ∈ (C.layerAt i).Content := by
  rw [encode,ls_encode X _ _ (h.bound _) (h.local_lt ..)]
  exact mem_content (h.rep i.1 i.2) (C.positive i.1) (C.periodic i.1) w

@[simp] theorem per_eq (g : G) : per X (h.group g) = C.period g :=
  (h.rep g ⟨0,C.nonempty g⟩).length_eq
@[simp] theorem text_eq (g : G) : PeriodWord.text (data X (h.group g)).1 = C.text g :=
  (h.rep g ⟨0,C.nonempty g⟩).text_eq
@[simp] theorem rank_eq (g : G) : rank X (h.group g) = C.rank g := by
  simp only [rank,h.text_eq,h.phase_eq,LayerCollection.rank]

def natIndex (_h : Model X C) (g : G) (i : ℕ) : Fin (C.size g) :=
  ⟨min i (C.size g-1),by have := C.nonempty g; omega⟩
def natLayer (g : G) (i : ℕ) : Layer V (C.text g) (C.period g) := C.layer g (h.natIndex g i)
@[simp] theorem natIndex_val (g : G) {i : ℕ} (hi : i < C.size g) : (h.natIndex g i).val = i := by
  exact Nat.min_eq_left (by omega)
@[simp] theorem natLayer_fin (g : G) (i : Fin (C.size g)) : h.natLayer g i.val = C.layer g i := by
  unfold natLayer
  congr 1
  exact Fin.ext (h.natIndex_val g i.isLt)
theorem nat_rep (g : G) {i : ℕ} (hi : i < C.size g) :
    Represents (data X (h.group g)).1 (exits (data X (h.group g)) i) (h.natLayer g i) := by
  simpa only [natLayer,h.natIndex_val g hi] using h.rep g (h.natIndex g i)
theorem nat_order (g : G) {i j : ℕ} (hij : i ≤ j) (x : ℤ) :
    (h.natLayer g i).z x ≤ (h.natLayer g j).z x := by
  apply C.ordered
  change min i _ ≤ min j _
  omega

theorem rank_shift (g : G) (d : C.Id) (r : ℤ)
    (hr : rank X (owner X (h.encode d)) ≤ rank X (h.group g)) :
    ∀ x, forward (fun x => C.text d.1 (x+r)) x ≤ forward (C.text g) (C.distinguished g) := by
  rw [h.owner_eq,h.rank_eq,h.rank_eq] at hr
  intro x
  rw [forward_shift]
  exact (C.distinguished_max d.1 (x+r)).trans hr
end Model
end Superstring.CollectionCode


namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode BlockClose
variable {α G : Type} [Inhabited α] [LinearOrder α] {V : Set (List α)}

def hard (X : Env α) (g cut : ℕ) (v : UpperCode.Param) : DistributeCode.Result α :=
  let D := data X g
  DistributeCode.record D g v.2.1 (g*stride X) (UpperCode.upper D.2.length cut)
    (D.2.length-v.1) (D.2.length-1) (RecordCode.start v.2.2) (RecordCode.stop v.2.2) (phase X g)

namespace Model
variable {X : Env α} {C : LayerCollection V G} (h : Model X C)

theorem hard_spec (closed : SubstringClosed V) (g : G) (cut : ℕ) (v : UpperCode.Param)
    (hcut : cut < C.size g) (hv : v.2.1 ∈ ids X)
    (ht : UpperCode.test (data X (h.group g)) (book X) cut (phase X (h.group g)) v = true)
    (hf : UpperCode.foreign (data X (h.group g)) (book X) v = true) :
    let o := hard X (h.group g) cut v
    Runs V [] [] o.1 ∧ DistributeCode.budget o (C.period g) ≤ 2*((C.size g-cut)*C.period g) ∧
      (∀ b ∈ o.2.1, ValidBlock V (ids X) (ls X) (owner X) (per X) (rank X) b) ∧
      (∀ i : Fin (C.size g), cut ≤ i.val →
        (∀ w ∈ ls X (h.encode ⟨g,i⟩), w ∈ o.1) ∨
        (∃ b ∈ o.2.1, h.encode ⟨g,i⟩ ∈ b.members) ∨ i.val ∈ o.2.2) ∧
      o.2.2.Sublist (UpperCode.upper (C.size g) cut) ∧
      ∃ (d : C.Id) (R : (C.layerAt d).Record (C.text g)), h.encode d = v.2.1 ∧
        R.offset = RecordCode.offset v.2.2 ∧ R.start = RecordCode.start v.2.2 ∧ R.stop = RecordCode.stop v.2.2 ∧
        C.text g ≠ (fun x => C.text d.1 (x+R.offset)) ∧
        ∀ i ∈ o.2.2, R.start+C.period g < (h.natLayer g i).first R.start ∧
          (h.natLayer g i).last R.start < R.stop-C.period g := by
  obtain ⟨d,hd⟩ := (h.mem_ids v.2.1).mp hv
  unfold UpperCode.test at ht
  unfold UpperCode.foreign at hf
  rw [← hd] at ht hf
  simp only [Bool.and_eq_true,less,lessEq,decide_eq_true_eq,
    h.size,h.phase_eq] at ht
  obtain ⟨⟨⟨⟨⟨⟨⟨hk,hkn⟩,hr⟩,hat⟩,htb⟩,hH⟩,hsharp⟩,hfirst⟩ := ht
  let D := data X (h.group g)
  have hp : D.1.length = C.period g := h.per_eq g
  let R := RecordCode.checkedRecord (h.text_eq g) (h.book_rep d) v.2.2 hr
  have hne : C.text g ≠ fun x => C.text d.1 (x+R.offset) := by
    have hh := (PeriodWord.different_iff D.1 (UpperCode.lookup (book X) (h.encode d)).1
      (RecordCode.offset v.2.2) (by rw [hp]; exact C.positive g)
      (by rw [(h.book_rep d).length_eq]; exact C.positive d.1)).mp hf
    simpa only [D,h.text_eq,(h.book_rep d).text_eq,R,RecordCode.checkedRecord] using hh
  let I := UpperCode.upper (C.size g) cut
  let lo := C.size g-v.1
  let hi := C.size g-1
  have hilo : lo ≤ hi := by dsimp [lo,hi]; omega
  have hm (i : ℕ) : i ∈ I ↔ cut ≤ i ∧ i < C.size g := UpperCode.mem_upper _ _ _
  have hlo : lo ∈ I := (hm _).mpr (by dsimp [lo]; omega)
  have hhi : hi ∈ I := (hm _).mpr (by dsimp [hi]; omega)
  have hlen : (I.filter (fun i => lessEq lo i)).length = v.1 := by
    rw [UpperCode.upper_filter (show cut ≤ lo from by dsimp [lo]; omega)]
    simp only [UpperCode.length_upper]
    dsimp only [lo]
    omega
  have hrep : ∀ i ∈ I, Represents D.1 (exits D i) (h.natLayer g i) :=
    fun i hi' => h.nat_rep g ((hm i).mp hi').2
  have hexit (i : ℕ) (hi' : i ∈ I) (x : ℤ) : GeoCode.exit (exits D i) x = (h.natLayer g i).z x :=
    congrFun (hrep i hi').exit_eq x
  have hh := DistributeCode.record_spec (h.natLayer g) (C.layerAt d) hrep closed
    (C.positive g) (C.positive d.1) (C.periodic g) (C.periodic d.1) (C.letters closed g)
    R hne (C.distinguished g) hat htb (C.distinguished_max g) hlo hhi hilo
    (fun i _ hil x => h.nat_order g hil x)
    (fun i hi' x => h.nat_order g (by have := (hm i).mp hi'; dsimp [hi]; omega) x)
    (by
      intro i hi' hil
      have hiF : i ∈ (UpperCode.upper (C.size g) cut).filter (fun i => decide (i < C.size g-v.1)) :=
        List.mem_filter.mpr ⟨hi',by simpa only [decide_eq_true_eq] using hil⟩
      have hh := of_decide_eq_true (List.all_eq_true.mp hfirst i hiF)
      change (h.natLayer g i).z (R.start-1) ≤ R.stop
      rw [← hexit i hi']
      exact hh)
    (by
      change (h.natLayer g hi).z (C.distinguished g-1) ≤ _
      rw [← hexit hi hhi,hlen,← hp]
      exact hH)
    (by
      change (h.natLayer g hi).z (C.distinguished g-1)-(h.natLayer g lo).z (C.distinguished g) ≤ _
      rw [← hexit hi hhi,← hexit lo hlo,hlen,← hp]
      exact hsharp)
    (ids X) (ls X) (owner X) (per X) (rank X) (h.per_eq g) (h.id_mem d)
    (by intro i hi'; exact owner_encode X _ _ (lt_of_lt_of_le ((hm i).mp hi').2 (h.capacity g)))
    (by rw [h.owner_eq,h.per_eq]) (h.rank_shift g d R.offset)
    ((h.content_iff d _).mpr ⟨R.start+R.offset,R.stop+R.offset,R.first_le,R.le_last,R.word_eq⟩)
    (by
      intro i hi' w hw
      let j : Fin (C.size g) := ⟨i,((hm i).mp hi').2⟩
      have hh := (h.content_iff ⟨g,j⟩ w).mp hw
      change w ∈ (C.layer g j).Content at hh
      have he : h.natLayer g i = C.layer g j := h.natLayer_fin g j
      rw [he]
      exact hh)
  dsimp only at hh ⊢
  have he : hard X (h.group g) cut v = DistributeCode.record D (h.group g) (h.encode d)
      (h.group g*stride X) I lo hi R.start R.stop (C.distinguished g) := by
    simp only [hard,h.size,h.phase_eq,hd,D,I,lo,hi,R,RecordCode.checkedRecord]
  rw [he]
  refine ⟨hh.1,?_,hh.2.2.1,?_,hh.2.2.2.2.1,d,R,hd,rfl,rfl,rfl,hne,hh.2.2.2.2.2⟩
  · simpa only [I,UpperCode.length_upper] using hh.2.1
  · intro i hi'
    exact hh.2.2.2.1 i.val ((hm i.val).mpr ⟨hi',i.isLt⟩)
end Model
end Superstring.CollectionCode


namespace Superstring.BitCode.Poly
variable {α β : Type} [Coded α] [Coded β] [Inhabited α] [Inhabited β]
@[fun_prop] theorem zip : Poly (fun p : List α × List β => p.1.zip p.2) := by
  have h : Poly (fun p : List α × List β =>
      (List.range (Min.min p.1.length p.2.length)).map
        (fun i => (p.1[i]?.getD default, p.2[i]?.getD default))) := by
    apply mapFn (f := fun q : (List α × List β) × ℕ =>
      (q.1.1[q.2]?.getD default, q.1.2[q.2]?.getD default))
    · exact ((getD default).comp
          (f := fun q : (List α × List β) × ℕ => (q.1.1,q.2)) (by fun_prop)).pair
        ((getD default).comp
          (f := fun q : (List α × List β) × ℕ => (q.1.2,q.2)) (by fun_prop))
    · fun_prop
  convert h using 1
  funext p
  apply List.ext_getElem
  · simp
  · intro i hi hi'
    have h₁ : i < p.1.length := by simp only [List.length_zip] at hi; omega
    have h₂ : i < p.2.length := by simp only [List.length_zip] at hi; omega
    simp only [List.getElem_zip,List.getElem_map,List.getElem_range,
      List.getElem?_eq_getElem h₁,List.getElem?_eq_getElem h₂,Option.getD_some]
end Superstring.BitCode.Poly
namespace Superstring.WindowCode
open Hierarchical WalkCode BitCode
variable {α : Type}
abbrev Window := ℤ × ℤ
def ordered (u v : Window) : Prop := u.1 ≤ v.1 ∧ u.2 ≤ v.2
def routeList (A : ℤ → α) (u : Window) (W : List Window) : Walk α :=
  [textWord A u.1 u.2] ++ (((u::W).zip W).flatMap fun q =>
    (route A q.1.1 q.1.2 q.2.1 q.2.2).tail)

theorem routeList_nil (A : ℤ → α) (u : Window) : routeList A u [] = [textWord A u.1 u.2] := rfl

theorem routeList_cons (A : ℤ → α) (u v : Window) (W : List Window)
    (hh : (route A u.1 u.2 v.1 v.2).head? = some (textWord A u.1 u.2)) :
    routeList A u (v::W) = join (route A u.1 u.2 v.1 v.2) (routeList A v W) := by
  unfold routeList
  simp only [List.zip_cons_cons,List.flatMap_cons,List.singleton_append,join,List.tail_cons]
  cases he : route A u.1 u.2 v.1 v.2 with
  | nil => simp [he] at hh
  | cons x xs =>
    have hx : x = textWord A u.1 u.2 := by simpa only [he,List.head?_cons,Option.some.injEq] using hh
    simp only [hx,List.tail_cons,List.cons_append]

theorem routeList_realizes {V : Set (List α)} (closed : SubstringClosed V)
    (A : ℤ → α) (letters : ∀ x, [A x] ∈ V) (u : Window) (W : List Window)
    (hchain : (u::W).Pairwise ordered)
    (hvalid : ∀ v ∈ u::W, v.1 ≤ v.2 ∧ textWord A v.1 v.2 ∈ V) :
    ∃ P : Hierarchical.Path V (textWord A u.1 u.2)
      (textWord A (W.getLastD u).1 (W.getLastD u).2),
      Path.points P = routeList A u W ∧ P.cost = ((W.getLastD u).2-u.2).toNat ∧
      ∀ v ∈ u::W, P.Visits (textWord A v.1 v.2) := by
  induction W generalizing u with
  | nil =>
    refine ⟨.nil _ (hvalid u (by simp)).2,rfl,?_,?_⟩
    · simp only [Hierarchical.Path.cost,List.getLastD_nil,sub_self,Int.toNat_zero]
    · intro v hv
      have he : v = u := List.mem_singleton.mp hv
      subst v
      exact Hierarchical.Path.visits_start _
  | cons v W ih =>
    obtain ⟨hfront,hrest⟩ := List.pairwise_cons.mp hchain
    have huv := hfront v (by simp)
    have hu := hvalid u (by simp)
    have hv := hvalid v (by simp)
    obtain ⟨P,hP,hcP,_,_⟩ := route_realizes closed A letters hu.1 hv.1 huv.1 huv.2 hu.2 hv.2
    obtain ⟨Q,hQ,hcQ,hvQ⟩ := ih v hrest (fun x hx => hvalid x (List.mem_cons_of_mem u hx))
    have hhead : (route A u.1 u.2 v.1 v.2).head? = some (textWord A u.1 u.2) := by
      rw [← hP]; exact (points_spec P).2.1
    have hlast : (v::W).getLastD u = W.getLastD v := by cases W <;> rfl
    have hend : v.2 ≤ (W.getLastD v).2 := by
      rcases List.mem_cons.mp (List.getLastD_mem_cons (l:=W) (a:=v)) with he | he
      · rw [he]
      · exact (List.pairwise_cons.mp hrest).1 _ he |>.2
    refine ⟨(P.trans Q).copy rfl (by rw [hlast]),?_,?_,?_⟩
    · rw [points_copy,Path.points,hP,hQ,routeList_cons A u v W hhead]
    · simp only [Hierarchical.Path.cost_copy,Hierarchical.Path.cost_trans,hcP,hcQ,hlast]
      have hh := huv.2
      omega
    · intro x hx
      apply (Hierarchical.Path.visits_copy ..).mpr
      rcases List.mem_cons.mp hx with rfl | hx
      · exact Or.inl (Hierarchical.Path.visits_start P)
      · exact Or.inr (hvQ x hx)

variable [Inhabited α] [Coded α]
@[fun_prop] theorem poly_routeList : Poly (fun q : List α × Window × List Window =>
    routeList (PeriodWord.text q.1) q.2.1 q.2.2) := by
  unfold routeList
  apply Poly.append.comp (f := fun q : List α × Window × List Window =>
    ([textWord (PeriodWord.text q.1) q.2.1.1 q.2.1.2],
      (((q.2.1::q.2.2).zip q.2.2).flatMap fun r =>
        (route (PeriodWord.text q.1) r.1.1 r.1.2 r.2.1 r.2.2).tail)))
  apply Poly.pair
  · simp_rw [← PeriodWord.window_eq]
    fun_prop
  · change Poly (fun q : List α × Window × List Window =>
      ((((q.2.1::q.2.2).zip q.2.2).map (fun r =>
        (route (PeriodWord.text q.1) r.1.1 r.1.2 r.2.1 r.2.2).tail))).flatten)
    apply Poly.flatten.comp
    apply Poly.mapFn (f := fun q : (List α × Window × List Window) × (Window × Window) =>
      (route (PeriodWord.text q.1.1) q.2.1.1 q.2.1.2 q.2.2.1 q.2.2.2).tail)
    · fun_prop
    · exact (BitCode.Poly.zip (α:=Window) (β:=Window)).comp
        (f := fun q : List α × Window × List Window => (q.2.1::q.2.2,q.2.2)) (by fun_prop)
end Superstring.WindowCode

end OAI