import OAI.Computability.Superstring.RequestAttachment

namespace OAI

namespace Superstring.HostCode
open Hierarchical WalkCode WindowCode BitCode
variable {α ι κ : Type} [Inhabited α] [DecidableEq α] {V : Set (List α)}

theorem filter_sum_reserve (I : List κ) (P : κ → Bool) (weight : κ → ℕ) (i : κ)
    (hi : i ∈ I) (hp : P i = false) :
    weight i + ((I.filter P).map weight).sum ≤ (I.map weight).sum := by
  have hb (L : List κ) : ((L.filter P).map weight).sum ≤ (L.map weight).sum := by
    induction L with
    | nil => simp
    | cons j L ih =>
      cases h : P j <;> simp only [List.filter_cons,h,Bool.false_eq_true,↓reduceIte,
        List.map_cons,List.sum_cons] <;> omega
  induction I with
  | nil => simp at hi
  | cons j I ih =>
    rcases List.mem_cons.mp hi with rfl | hi
    · simp only [List.filter_cons,hp,Bool.false_eq_true,↓reduceIte,List.map_cons,List.sum_cons]
      exact Nat.add_le_add_left (hb I) _
    · have hh := ih hi
      cases h : P j <;> simp only [List.filter_cons,h,Bool.false_eq_true,↓reduceIte,
        List.map_cons,List.sum_cons] <;> omega

omit [DecidableEq α] in
def entryOf {A : ℤ → α} {q : ℕ} {D : Layer V A q} (H : ι → HostedGroup D)
    (g : κ → ι) (R : ∀ i, (H (g i)).Request) (W : ι → List α) (tag : ι → ℕ) (i : κ) : Entry α :=
  (tag (g i),W (g i),(H (g i)).start,(H (g i)).stop,(R i).stop)

theorem normalized_spec {A : ℤ → α} {q : ℕ} (closed : SubstringClosed V)
    (D : Layer V A q) (hq : 0 < q) (per : Function.Periodic A (q : ℤ))
    (letters : ∀ x, [A x] ∈ V) (H : ι → HostedGroup D) (g : κ → ι)
    (R : ∀ i, (H (g i)).Request) (W : ι → List α) (tag : ι → ℕ)
    (htag : Function.Injective tag) (U : List α) (hU : U.length = q) (hUt : PeriodWord.text U = A)
    (hW : ∀ j, (W j).length = (H j).period) (hWt : ∀ j, PeriodWord.text (W j) = (H j).text)
    (child_letters : ∀ j x, [(H j).text x] ∈ V)
    (different : ∀ i j, i ≠ j → ∀ c, (H i).text ≠ fun x => (H j).text (x+c))
    (I : List κ) (i₀ : κ) (hi₀ : i₀ ∈ I)
    (hmin : ∀ i ∈ I, (H (g i₀)).period ≤ (H (g i)).period)
    (hreq : ∀ i ∈ I, g i = g i₀ → (R i₀).stop ≤ (R i).stop)
    (horder : ∀ i ∈ I,
      (H (g i₀)).start ≤ (H (g i)).start ∧ (H (g i)).start ≤ (H (g i₀)).start+q ∧
      (H (g i₀)).stop ≤ (H (g i)).stop ∧ (H (g i)).stop ≤ (H (g i₀)).stop+q) :
    let E := entryOf H g R W tag
    Runs V [] [] (normalized U (E i₀) (I.map E)) ∧
      cost (normalized U (E i₀) (I.map E)) ≤ q+(I.map (fun i => (H (g i)).period)).sum ∧
      textWord A (H (g i₀)).start (H (g i₀)).stop ∈ normalized U (E i₀) (I.map E) ∧
      ∀ i ∈ I, textWord (H (g i)).text (H (g i)).start (R i).stop ∈ normalized U (E i₀) (I.map E) := by
  classical
  let E := entryOf H g R W tag
  let J := I.filter (fun i => decide (g i ≠ g i₀))
  have hJ (i : κ) : i ∈ J ↔ i ∈ I ∧ g i ≠ g i₀ := by simp [J]
  let s := fun i => min ((H (g i)).start+(H (g i)).period) ((H (g i₀)).start+q)
  let h := fun i => max (R i).stop (H (g i₀)).stop
  let F := fun i => (W (g i),((H (g i)).start,(R i).stop),(s i,h i))
  have hmap : (later (E i₀) (I.map E)).map (Entry.target U.length (E i₀)) = J.map F := by
    have hl : later (E i₀) (I.map E) = J.map E := by
      unfold later J
      rw [List.filter_map]
      congr 1
      apply congrArg (fun f => I.filter f)
      funext i
      simp [E,entryOf,Entry.tag,equal,htag.eq_iff]
    rw [hl,List.map_map]
    apply List.map_congr_left
    intro i _
    simp only [Function.comp_apply,E,entryOf,Entry.target,Entry.word,Entry.start,Entry.req,Entry.stop,hU,hW,F,s,h]
  have hb (i : κ) (hi : i ∈ J) :
      (H (g i)).start ≤ s i ∧ s i ≤ (H (g i)).start+(H (g i)).period ∧
      s i ≤ h i ∧ h i ≤ (H (g i)).stop ∧ (R i).stop ≤ h i ∧
      h i ≤ (R i).stop+(H (g i)).period ∧ (H (g i₀)).start ≤ s i ∧
      s i ≤ (H (g i₀)).start+q ∧ (H (g i₀)).stop ≤ h i ∧ h i < (H (g i₀)).start+q+(H (g i₀)).period := by
    obtain ⟨hiI,hne⟩ := (hJ i).mp hi
    exact hosted_target_bounds D hq per _ _ (R i) (hmin i hiI) (horder i hiI)
      (by simpa only [add_zero] using different (g i₀) (g i) (Ne.symm hne) 0)
      (by simpa only [← sub_eq_add_neg] using different (g i) (g i₀) hne (-(q:ℤ)))
  have hv (i : κ) (hi : i ∈ J) : textWord A (s i) (h i) ∈ V :=
    closed (H (g i)).host_mem (textWord_infix A (hb i hi).1 (hb i hi).2.2.1 (hb i hi).2.2.2.1)
  have heq (i : κ) (hi : i ∈ J) : textWord (H (g i)).text (s i) (h i) = textWord A (s i) (h i) :=
    textWord_eq_of_agree (fun x hx hy => (H (g i)).agree x ((hb i hi).1.trans hx) (hy.trans_le (hb i hi).2.2.2.1))
  have hen : (H (g i₀)).start+(H (g i₀)).period < (R i₀).stop := (R i₀).long
  have heb : (R i₀).stop ≤ (H (g i₀)).stop := by have := (R i₀).margin; omega
  have hshort : (H (g i₀)).stop < (H (g i₀)).start+q+(H (g i₀)).period := by
    have hh := (H (g i₀)).length_lt hq per; omega
  obtain ⟨hQ,hQc,hQr,hQv,hQatt⟩ := raw_spec closed U (by simpa only [hUt] using letters)
    (H (g i₀)).period (H (g i₀)).positive (H (g i₀)).start (H (g i₀)).stop (R i₀).stop
    hen heb (by simpa only [PeriodWord.window_eq,hUt] using (H (g i₀)).host_mem)
    (by simpa only [hU] using hshort) (J.map F)
    (by intro r hr t ht; obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hr
        obtain ⟨j,hj,rfl⟩ := List.mem_map.mp ht
        exact hosted_targets_chain D H g R different _ _ i j)
    (by intro r hr; obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hr
        dsimp only [F]; rw [hU]
        exact ⟨(hb i hi).2.2.2.2.2.2.1,(hb i hi).2.2.2.2.2.2.2.1,
          (hb i hi).2.2.1,(hb i hi).2.2.2.2.2.2.2.2.1,(hb i hi).2.2.2.2.2.2.2.2.2⟩)
    (by intro r hr; obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hr
        simpa only [F,PeriodWord.window_eq,hUt] using hv i hi)
    (by intro r hr; obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hr
        dsimp only [F]
        simp only [hW,PeriodWord.window_eq,hWt,hUt]
        refine ⟨child_letters _,?_,(hb i hi).1,(hb i hi).2.1,(hb i hi).2.2.2.2.1,
          (hb i hi).2.2.2.2.2.1,(R i).word_mem,heq i hi⟩
        have := (R i).long; omega)
  have hpath : normalized U (E i₀) (I.map E) =
      raw U (H (g i₀)).period (H (g i₀)).start (H (g i₀)).stop (R i₀).stop (J.map F) := by
    rw [normalized,hmap]
    simp only [E,entryOf,Entry.word,Entry.start,Entry.stop,Entry.req,hW]
  change Runs V [] [] (normalized U (E i₀) (I.map E)) ∧ _
  rw [hpath]
  refine ⟨hQ,?_,?_,?_⟩
  · simp only [hU,List.map_map,Function.comp_def,F,hW] at hQc
    have hh := filter_sum_reserve I (fun i => decide (g i ≠ g i₀))
      (fun i => (H (g i)).period) i₀ hi₀ (by simp)
    dsimp only [J,F] at hQc ⊢
    omega
  · simpa only [PeriodWord.window_eq,hUt] using hQr
  · intro i hi
    by_cases hg : g i = g i₀
    · have heq' : textWord (H (g i)).text (H (g i)).start (R i).stop =
          textWord A (H (g i₀)).start (R i).stop := by
        rw [← hg]
        apply textWord_eq_of_agree
        intro x hx hy
        apply (H (g i)).agree x hx
        have := (R i).margin
        omega
      rw [heq']
      have hb' : (R i).stop ≤ (H (g i₀)).stop := by
        have := (R i).margin
        have hs := congrArg (fun j => (H j).stop) hg
        omega
      simpa only [PeriodWord.window_eq,hUt] using hQv _ (hreq i hi hg) hb'
    · have hh := hQatt _ (List.mem_map.mpr ⟨i,(hJ i).mpr ⟨hi,hg⟩,rfl⟩)
      simpa only [F,PeriodWord.window_eq,hWt] using hh
end Superstring.HostCode


namespace Superstring.HostCode
open Hierarchical WalkCode WindowCode BitCode

def normalDelta (q : ℕ) (a b a₀ b₀ : ℤ) : ℤ :=
  let d := a₀+((a-a₀) % (q:ℤ)).toNat-a
  if decide (b₀ ≤ b+d) then d else d+q

@[simp] theorem normalDelta_self (q : ℕ) (a b : ℤ) : normalDelta q a b a b = 0 := by
  simp [normalDelta]

theorem normalDelta_spec {α : Type} {V : Set (List α)} {A : ℤ → α} {q : ℕ}
    (D : Layer V A q) (hq : 0 < q) {a b a₀ b₀ : ℤ}
    (hf : D.first a ≤ b) (hl : b ≤ D.last a)
    (hf₀ : D.first a₀ ≤ b₀) (hl₀ : b₀ ≤ D.last a₀) :
    ∃ m : ℤ, normalDelta q a b a₀ b₀ = m*q ∧
      a₀ ≤ a+m*q ∧ a+m*q ≤ a₀+q ∧ b₀ ≤ b+m*q ∧ b+m*q ≤ b₀+q := by
  let m : ℤ := -((a-a₀)/q)
  let r : ℤ := a+m*q
  let e : ℤ := b+m*q
  have hr : r = a₀+(a-a₀)%q := by
    have hh := Int.emod_add_ediv_mul (a-a₀) (q:ℤ)
    dsimp only [r,m]
    simp only [neg_mul]
    omega
  have hrlo : a₀ ≤ r := by have := Int.emod_nonneg (a-a₀) (show (q:ℤ) ≠ 0 by omega); omega
  have hrhi : r < a₀+q := by have := Int.emod_lt_of_pos (a-a₀) (show (0:ℤ) < q by omega); omega
  have hfe : D.first r ≤ e := by dsimp only [r,e]; rw [D.first_shift_int]; omega
  have hle : e ≤ D.last r := by
    dsimp only [r,e,Layer.last]
    rw [D.shift_int]
    change b ≤ D.z a at hl
    omega
  have hfnext : D.first (a₀+q) ≤ b₀+q := by rw [D.first_shift]; omega
  have hehi : e ≤ b₀+q := D.window_order hle hfnext hrhi
  have hd : a₀+(((a-a₀)%(q:ℤ)).toNat:ℤ)-a = m*q := by
    rw [Int.toNat_of_nonneg (Int.emod_nonneg _ (by omega))]
    dsimp only [r] at hr
    omega
  by_cases hb : b₀ ≤ e
  · refine ⟨m,?_,hrlo,hrhi.le,hb,hehi⟩
    simp only [normalDelta,hd,show b₀ ≤ b+m*q from hb,decide_true,↓reduceIte]
  · have hre : r = a₀ := by
      by_contra hn
      have hh := D.window_order hl₀ hfe (by omega : a₀ < r)
      omega
    have hfn : D.first (r+q) ≤ e+q := by rw [D.first_shift]; omega
    have helon : b₀ ≤ e+q := D.window_order hl₀ hfn (by omega)
    refine ⟨m+1,?_,?_,?_,?_,?_⟩
    · simp only [normalDelta,hd,show ¬ b₀ ≤ b+m*q from hb,decide_false,Bool.false_eq_true,↓reduceIte]
      ring
    all_goals dsimp only [r,e] at *; nlinarith

@[fun_prop] theorem poly_normalDelta : Poly (fun t : ℕ × ℤ × ℤ × ℤ × ℤ =>
    normalDelta t.1 t.2.1 t.2.2.1 t.2.2.2.1 t.2.2.2.2) := by
  have hr : Poly (fun t : ℕ × ℤ × ℤ × ℤ × ℤ => ((t.2.1-t.2.2.2.1)%(t.1:ℤ)).toNat) :=
    Poly.modIntNat.comp (f := fun t : ℕ × ℤ × ℤ × ℤ × ℤ => (t.2.1-t.2.2.2.1,t.1)) (by fun_prop)
  unfold normalDelta
  dsimp only
  fun_prop

variable {α : Type} [Inhabited α] [DecidableEq α]
def normalizeEntry (q : ℕ) (base e : Entry α) : Entry α :=
  e.shift (normalDelta q e.start e.stop base.start base.stop)
def requestPath (U : List α) (base : Entry α) (E : List (Entry α)) : Walk α :=
  normalized U base (E.map (normalizeEntry U.length base))
def requestPool (U : List α) (E : List (Entry α)) : List (Walk α) :=
  E.map (fun b => requestPath U b E)
variable [Coded α]
omit [DecidableEq α] in
@[fun_prop] theorem poly_normalizeEntry : Poly (fun t : ℕ × Entry α × Entry α => normalizeEntry t.1 t.2.1 t.2.2) := by
  unfold normalizeEntry
  have hd := poly_normalDelta.comp (f := fun t : ℕ × Entry α × Entry α =>
    (t.1,t.2.2.start,t.2.2.stop,t.2.1.start,t.2.1.stop)) (by fun_prop)
  fun_prop
@[fun_prop] theorem poly_requestPath : Poly (fun t : List α × Entry α × List (Entry α) => requestPath t.1 t.2.1 t.2.2) := by
  have hm : Poly (fun t : List α × Entry α × List (Entry α) => t.2.2.map (normalizeEntry t.1.length t.2.1)) := by
    apply BitCode.Poly.mapFn (f := fun t : (List α × Entry α × List (Entry α)) × Entry α => normalizeEntry t.1.1.length t.1.2.1 t.2)
    · exact poly_normalizeEntry.comp (f := fun t : (List α × Entry α × List (Entry α)) × Entry α =>
        (t.1.1.length,t.1.2.1,t.2)) (by fun_prop)
    · fun_prop
  unfold requestPath
  fun_prop
@[fun_prop] theorem poly_requestPool : Poly (fun t : List α × List (Entry α) => requestPool t.1 t.2) := by
  unfold requestPool
  apply BitCode.Poly.mapFn (f := fun t : (List α × List (Entry α)) × Entry α => requestPath t.1.1 t.2 t.1.2)
  · exact poly_requestPath.comp (f := fun t : (List α × List (Entry α)) × Entry α => (t.1.1,t.2,t.1.2)) (by fun_prop)
  · fun_prop
end Superstring.HostCode


namespace Superstring.PeriodWord
variable {α : Type} [Inhabited α]
@[simp] theorem shift_zero (U : List α) : shift U 0 = U := by
  apply List.ext_getElem
  · simp
  · intro i hi hi'
    simp only [shift,window_eq,Hierarchical.textWord,List.getElem_ofFn,neg_zero,zero_add]
    simp only [text,Int.emod_eq_of_lt (by omega : (0:ℤ) ≤ i) (by omega : (i:ℤ) < U.length),Int.toNat_natCast,
      List.getElem?_eq_getElem hi',Option.getD_some]
end Superstring.PeriodWord

namespace Superstring.HostCode
open Hierarchical WalkCode WindowCode BitCode
variable {α ι κ : Type} [Inhabited α] [DecidableEq α] {V : Set (List α)}

theorem requestPath_spec {A : ℤ → α} {q : ℕ} (closed : SubstringClosed V)
    (D : Layer V A q) (hq : 0 < q) (per : Function.Periodic A (q : ℤ))
    (letters : ∀ x, [A x] ∈ V) (H : ι → HostedGroup D) (g : κ → ι)
    (R : ∀ i, (H (g i)).Request) (W : ι → List α) (tag : ι → ℕ)
    (htag : Function.Injective tag) (U : List α) (hU : U.length = q) (hUt : PeriodWord.text U = A)
    (hW : ∀ j, (W j).length = (H j).period) (hWt : ∀ j, PeriodWord.text (W j) = (H j).text)
    (child_letters : ∀ j x, [(H j).text x] ∈ V)
    (different : ∀ i j, i ≠ j → ∀ c, (H i).text ≠ fun x => (H j).text (x+c))
    (I : List κ) (i₀ : κ) (hi₀ : i₀ ∈ I)
    (hmin : ∀ i ∈ I, (H (g i₀)).period ≤ (H (g i)).period)
    (hreq : ∀ i ∈ I, g i = g i₀ → (R i₀).stop ≤ (R i).stop) :
    let E := entryOf H g R W tag
    Runs V [] [] (requestPath U (E i₀) (I.map E)) ∧
      cost (requestPath U (E i₀) (I.map E)) ≤ q+(I.map (fun i => (H (g i)).period)).sum ∧
      textWord A (H (g i₀)).start (H (g i₀)).stop ∈ requestPath U (E i₀) (I.map E) ∧
      ∀ i ∈ I, textWord (H (g i)).text (H (g i)).start (R i).stop ∈ requestPath U (E i₀) (I.map E) := by
  classical
  let E := entryOf H g R W tag
  let z := g i₀
  have shifts (j : ι) : ∃ m : ℤ,
      normalDelta q (H j).start (H j).stop (H z).start (H z).stop = m*q ∧
      (H z).start ≤ (H j).start+m*q ∧ (H j).start+m*q ≤ (H z).start+q ∧
      (H z).stop ≤ (H j).stop+m*q ∧ (H j).stop+m*q ≤ (H z).stop+q :=
    normalDelta_spec D hq (H j).first_le (H j).le_last (H z).first_le (H z).le_last
  choose m hm hb using shifts
  have hmz : m z = 0 := by
    have hz := hm z
    rw [normalDelta_self] at hz
    have : (0:ℤ) < q := by omega
    nlinarith
  let H' := fun j => (H j).translate per (m j)
  let R' := fun i => (R i).translate per (m (g i))
  let W' := fun j => PeriodWord.shift (W j) (m j*q)
  let E' := entryOf H' g R' W' tag
  have hW' (j : ι) : (W' j).length = (H' j).period := by simp [W',H',HostedGroup.translate,hW]
  have hWt' (j : ι) : PeriodWord.text (W' j) = (H' j).text := by
    dsimp only [W']
    rw [PeriodWord.text_shift (by rw [hW]; exact (H j).positive),hWt]
    rfl
  have hbase : E' i₀ = E i₀ := by
    simp only [E',E,entryOf,H',R',W',HostedGroup.translate,HostedGroup.Request.translate,
      show g i₀ = z from rfl,hmz,zero_mul,PeriodWord.shift_zero,add_zero]
  have hmap (i : κ) : normalizeEntry U.length (E i₀) (E i) = E' i := by
    simp only [normalizeEntry,E,E',entryOf,Entry.start,Entry.stop,hU,show g i₀ = z from rfl,hm]
    rfl
  have hd : ∀ i j, i ≠ j → ∀ c, (H' i).text ≠ fun x => (H' j).text (x+c) := by
    intro i j hij c he
    apply different i j hij (m i*q+c-m j*q)
    funext x
    have hh := congrFun he (x+m i*q)
    change (H i).text (x+m i*q-m i*q) = (H j).text (x+m i*q+c-m j*q) at hh
    have hx : x+m i*q+c-m j*q = x+(m i*q+c-m j*q) := by omega
    simpa only [add_sub_cancel_right,hx] using hh
  have ho : ∀ i ∈ I,
      (H' (g i₀)).start ≤ (H' (g i)).start ∧ (H' (g i)).start ≤ (H' (g i₀)).start+q ∧
      (H' (g i₀)).stop ≤ (H' (g i)).stop ∧ (H' (g i)).stop ≤ (H' (g i₀)).stop+q := by
    intro i _
    simpa only [H',HostedGroup.translate,show g i₀ = z from rfl,hmz,zero_mul,add_zero] using hb (g i)
  have hrq : ∀ i ∈ I, g i = g i₀ → (R' i₀).stop ≤ (R' i).stop := by
    intro i hi hg
    have hh := hreq i hi hg
    change (R i₀).stop+m (g i₀)*q ≤ (R i).stop+m (g i)*q
    have hm' := congrArg m hg
    rw [hm']
    exact Int.add_le_add_right hh _
  obtain ⟨hr,hc,hb',hv⟩ := normalized_spec closed D hq per letters H' g R' W' tag htag U hU hUt
    hW' hWt' (fun j x => child_letters j (x-m j*q)) hd I i₀ hi₀ hmin hrq ho
  have hpath : requestPath U (E i₀) (I.map E) = normalized U (E' i₀) (I.map E') := by
    unfold requestPath
    rw [List.map_map,hbase]
    apply congrArg (normalized U (E i₀))
    apply List.map_congr_left
    intro i _
    exact hmap i
  change Runs V [] [] (requestPath U (E i₀) (I.map E)) ∧ _
  rw [hpath]
  refine ⟨hr,hc,?_,?_⟩
  · have ha : (H' (g i₀)).start = (H (g i₀)).start := by
      simp only [H',HostedGroup.translate,show g i₀ = z from rfl,hmz,zero_mul,add_zero]
    have hb₀ : (H' (g i₀)).stop = (H (g i₀)).stop := by
      simp only [H',HostedGroup.translate,show g i₀ = z from rfl,hmz,zero_mul,add_zero]
    change textWord A (H' (g i₀)).start (H' (g i₀)).stop ∈ normalized U (E' i₀) (I.map E') at hb'
    rwa [ha,hb₀] at hb'
  · intro i hi
    have hh := hv i hi
    have he : textWord (H' (g i)).text (H' (g i)).start (R' i).stop =
        textWord (H (g i)).text (H (g i)).start (R i).stop := by
      change textWord (fun x => (H (g i)).text (x-m (g i)*q))
        ((H (g i)).start+m (g i)*q) ((R i).stop+m (g i)*q) = _
      simpa only [sub_eq_add_neg,add_neg_cancel_right] using
        textWord_reindex (H (g i)).text (-(m (g i)*q))
          ((H (g i)).start+m (g i)*q) ((R i).stop+m (g i)*q)
    rwa [he] at hh
theorem requestPool_complete {A : ℤ → α} {q : ℕ} (closed : SubstringClosed V)
    (D : Layer V A q) (hq : 0 < q) (per : Function.Periodic A (q : ℤ))
    (letters : ∀ x, [A x] ∈ V) (H : ι → HostedGroup D) (g : κ → ι)
    (R : ∀ i, (H (g i)).Request) (W : ι → List α) (tag : ι → ℕ)
    (htag : Function.Injective tag) (U : List α) (hU : U.length = q) (hUt : PeriodWord.text U = A)
    (hW : ∀ j, (W j).length = (H j).period) (hWt : ∀ j, PeriodWord.text (W j) = (H j).text)
    (child_letters : ∀ j x, [(H j).text x] ∈ V)
    (different : ∀ i j, i ≠ j → ∀ c, (H i).text ≠ fun x => (H j).text (x+c))
    (I : List κ) (hne : I ≠ []) :
    ∃ P ∈ requestPool U (I.map (entryOf H g R W tag)),
      Runs V [] [] P ∧ cost P ≤ q+(I.map (fun i => (H (g i)).period)).sum ∧
      (∃ w ∈ D.Content, w ∈ P) ∧
      ∀ i ∈ I, ∃ w ∈ (R i).layer.Content, w ∈ P := by
  classical
  have hne' : I.toFinset.Nonempty := by
    obtain ⟨i,hi⟩ := List.exists_mem_of_ne_nil I hne
    exact ⟨i,List.mem_toFinset.mpr hi⟩
  obtain ⟨i₀,hi₀,hmin⟩ := I.toFinset.exists_min_image (fun i => (H (g i)).period) hne'
  let J := I.toFinset.filter (fun i => g i = g i₀)
  have hj₀ : i₀ ∈ J := by simp [J,hi₀]
  obtain ⟨i₁,hi₁,hr⟩ := J.exists_min_image (fun i => (R i).stop) ⟨i₀,hj₀⟩
  have hi₁I : i₁ ∈ I := List.mem_toFinset.mp (Finset.mem_filter.mp hi₁).1
  have he : g i₁ = g i₀ := (Finset.mem_filter.mp hi₁).2
  have hm : ∀ i ∈ I, (H (g i₁)).period ≤ (H (g i)).period := by
    intro i hi
    rw [he]
    exact hmin i (List.mem_toFinset.mpr hi)
  have hr' : ∀ i ∈ I, g i = g i₁ → (R i₁).stop ≤ (R i).stop := by
    intro i hi hg
    exact hr i (Finset.mem_filter.mpr ⟨List.mem_toFinset.mpr hi,hg.trans he⟩)
  obtain ⟨hP,hc,hb,hv⟩ := requestPath_spec closed D hq per letters H g R W tag htag U hU hUt
    hW hWt child_letters different I i₁ hi₁I hm hr'
  refine ⟨_,List.mem_map.mpr ⟨_,List.mem_map.mpr ⟨i₁,hi₁I,rfl⟩,rfl⟩,hP,hc,?_,?_⟩
  · exact ⟨_,⟨_,_,(H (g i₁)).first_le,(H (g i₁)).le_last,rfl⟩,hb⟩
  · intro i hi
    exact ⟨_,⟨_,_,(R i).first_le,(R i).le_last,rfl⟩,hv i hi⟩
end Superstring.HostCode


namespace Superstring.LayerArray
open BitCode Hierarchical WalkCode
variable {α ι : Type} [Inhabited α] [DecidableEq α]
abbrev LayerData (α : Type) := List α × List ℕ

def saturateAll (D : List (LayerData α)) (P : Walk α) : Walk α :=
  fill P (D.map (fun d => turn d.1 d.2))

theorem saturateAll_spec {V : Set (List α)} (closed : SubstringClosed V)
    (A : ι → ℤ → α) (p : ι → ℕ) (L : ∀ i, Layer V (A i) (p i))
    (D : ι → LayerData α) (I : List ι) (rep : ∀ i ∈ I, Represents (D i).1 (D i).2 (L i))
    (pos : ∀ i ∈ I, 0 < p i) (per : ∀ i ∈ I, Function.Periodic (A i) (p i : ℤ))
    {P : Walk α} {s t : List α} (hP : Runs V s t P)
    (touch : ∀ i ∈ I, ∃ w ∈ (L i).Content, w ∈ P) :
    Runs V s t (saturateAll (I.map D) P) ∧
      cost (saturateAll (I.map D) P) = cost P+(I.map p).sum ∧
      (∀ w ∈ P, w ∈ saturateAll (I.map D) P) ∧
      ∀ i ∈ I, ∀ w ∈ (L i).Content, w ∈ saturateAll (I.map D) P := by
  have hturn i hi := turn_spec (rep i hi) closed (pos i hi) (per i hi)
  have hm : (I.map D).map (fun d => turn d.1 d.2) = I.map (fun i => turn (D i).1 (D i).2) := List.map_map ..
  obtain ⟨hF,hFc,hFv⟩ := fill_spec P (I.map (fun i => turn (D i).1 (D i).2)) hP
    (by intro Q hQ; obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hQ; exact ⟨_,(hturn i hi).1⟩)
    (by intro Q hQ; obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hQ
        obtain ⟨w,hw,hwP⟩ := touch i hi
        exact ⟨w,hwP,(hturn i hi).2.2 w hw⟩)
  unfold saturateAll
  rw [hm]
  refine ⟨hF,?_,fun w hw => (hFv w).mpr (Or.inl hw),?_⟩
  · rw [List.map_map] at hFc
    have hh : I.map (fun i => cost (turn (D i).1 (D i).2)) = I.map p :=
      List.map_congr_left (fun i hi => (hturn i hi).2.1)
    exact hFc.trans (congrArg (fun l : List ℕ => cost P+l.sum) hh)
  · intro i hi w hw
    exact (hFv w).mpr (Or.inr ⟨_,List.mem_map.mpr ⟨i,hi,rfl⟩,(hturn i hi).2.2 w hw⟩)

variable [Coded α]
@[fun_prop] theorem poly_saturateAll : Poly (fun q : List (LayerData α) × Walk α => saturateAll q.1 q.2) := by
  unfold saturateAll
  have ht : Poly (fun D : List (LayerData α) => D.map (fun d => turn d.1 d.2)) := BitCode.Poly.map poly_turn
  fun_prop
end Superstring.LayerArray

end OAI