import OAI.Computability.Superstring.LocalCode

namespace OAI

namespace Superstring.BlockClose
open BitCode Hierarchical WalkCode
variable {α β : Type}
abbrev Block (α : Type) := ((ℕ × ℕ) × (List ℕ × List α)) × ((ℕ × ℕ) × (Walk α × List (Walk α)))
instance [DecidableEq α] : DecidableEq (Block α) := by
  letI : DecidableEq ((ℕ × ℕ) × (List ℕ × List α)) := inferInstance
  letI : DecidableEq ((ℕ × ℕ) × (Walk α × List (Walk α))) := inferInstance
  exact instDecidableEqProd
instance [Coded α] : Coded (Block α) := by
  letI : Coded ((ℕ × ℕ) × (List ℕ × List α)) := inferInstance
  letI : Coded ((ℕ × ℕ) × (Walk α × List (Walk α))) := inferInstance
  exact codedProd
namespace Block
abbrev source (b : Block α) := b.1.1.1
abbrev target (b : Block α) := b.1.1.2
abbrev members (b : Block α) := b.1.2.1
abbrev word (b : Block α) := b.1.2.2
abbrev period (b : Block α) := b.2.1.1
abbrev reserve (b : Block α) := b.2.1.2
abbrev internal (b : Block α) := b.2.2.1
abbrev links (b : Block α) := b.2.2.2
end Block
abbrev Action (α : Type) := List (Block α) × Walk α

def Covers (L : ℕ → List (List α)) (I : List ℕ) (P : Walk α) : Prop :=
  ∀ i ∈ I, ∀ w ∈ L i, w ∈ P

def Good (V : Set (List α)) (L : ℕ → List (List α)) (P : Walk α) (a : Action α) : Prop :=
  Runs V [] [] a.2 ∧ cost a.2 ≤ cost P+(a.1.map Block.reserve).sum ∧
    (∀ w ∈ P, w ∈ a.2) ∧ ∀ b ∈ a.1, Covers L b.members a.2

structure ValidBlock [LinearOrder β] (V : Set (List α)) (ids : List ℕ)
    (L : ℕ → List (List α)) (owner per : ℕ → ℕ) (rank : ℕ → β) (b : Block α) : Prop where
  period_eq : b.period = per b.source
  target_mem : b.target ∈ ids
  same : ∀ i ∈ b.members, owner i = b.source
  word_mem : b.word ∈ L b.target
  same_short : owner b.target = b.source → b.word.length ≤ b.period
  internal : ∃ s, Runs V s s b.internal ∧ cost b.internal+b.period ≤ b.reserve ∧ Covers L b.members b.internal
  link : ∃ Q ∈ b.links, ∃ s, Runs V s s Q ∧ cost Q ≤ b.reserve ∧ Covers L b.members Q ∧ b.word ∈ Q
  short : rank (owner b.target) ≤ rank b.source →
    ∃ Q ∈ b.links, ∃ s, Runs V s s Q ∧ cost Q ≤ b.reserve ∧ Covers L b.members Q ∧ b.word ∈ Q ∧
      ∃ w ∈ Q, w.length ≤ per (owner b.target)

variable [DecidableEq α]
def singles (P : Walk α) (b : Block α) : List (Action α) :=
  ([b],join P (rootShort b.internal b.period)) :: b.links.map (fun Q => ([b],splice P Q))
def doubles (P : Walk α) (b c : Block α) : List (Action α) :=
  b.links.map (fun Q => ([b,c],join P (rootShort (splice Q c.internal) c.period)))
def pool (P : Walk α) (B : List (Block α)) : List (Action α) :=
  B.flatMap (fun b => singles P b ++ (B.filter (fun c => !(equal c b))).flatMap (doubles P b))

omit [DecidableEq α] in
theorem covers_mono {L : ℕ → List (List α)} {I : List ℕ} {P Q : Walk α}
    (hc : Covers L I P) (h : ∀ w ∈ P, w ∈ Q) : Covers L I Q := fun i hi w hw => h w (hc i hi w hw)

theorem pool_single (P : Walk α) {B : List (Block α)} {b : Block α} (hb : b ∈ B) :
    ([b],join P (rootShort b.internal b.period)) ∈ pool P B := by
  exact List.mem_flatMap.mpr ⟨b,hb,List.mem_append_left _ (List.mem_cons_self ..)⟩
theorem pool_link (P : Walk α) {B : List (Block α)} {b : Block α} (hb : b ∈ B)
    {Q : Walk α} (hq : Q ∈ b.links) : ([b],splice P Q) ∈ pool P B := by
  exact List.mem_flatMap.mpr ⟨b,hb,List.mem_append_left _ (List.mem_cons_of_mem _ (List.mem_map.mpr ⟨Q,hq,rfl⟩))⟩
theorem pool_double (P : Walk α) {B : List (Block α)} {b c : Block α} (hb : b ∈ B) (hc : c ∈ B)
    (hne : c ≠ b) {Q : Walk α} (hq : Q ∈ b.links) :
    ([b,c],join P (rootShort (splice Q c.internal) c.period)) ∈ pool P B := by
  apply List.mem_flatMap.mpr
  refine ⟨b,hb,List.mem_append_right _ (List.mem_flatMap.mpr ⟨c,?_,List.mem_map.mpr ⟨Q,hq,rfl⟩⟩)⟩
  simpa only [List.mem_filter,Bool.not_eq_true',equal,decide_eq_false_iff_not] using And.intro hc hne

theorem pool_sane (P : Walk α) (B : List (Block α)) {a : Action α} (ha : a ∈ pool P B) :
    a.1 ≠ [] ∧ a.1.Nodup ∧ ∀ b ∈ a.1, b ∈ B := by
  obtain ⟨b,hb,ha⟩ := List.mem_flatMap.mp ha
  rcases List.mem_append.mp ha with ha | ha
  · rcases List.mem_cons.mp ha with rfl | ha
    · exact ⟨by simp,by simp,by intro c hc; simpa only [List.mem_singleton.mp hc] using hb⟩
    · obtain ⟨Q,_,rfl⟩ := List.mem_map.mp ha
      exact ⟨by simp,by simp,by intro c hc; simpa only [List.mem_singleton.mp hc] using hb⟩
  · obtain ⟨c,hc,ha⟩ := List.mem_flatMap.mp ha
    have hc' : c ∈ B ∧ c ≠ b := by
      simpa only [List.mem_filter,Bool.not_eq_true',equal,decide_eq_false_iff_not] using hc
    obtain ⟨Q,_,rfl⟩ := List.mem_map.mp ha
    exact ⟨by simp,by simp [Ne.symm hc'.2],by
      intro d hd; rcases List.mem_cons.mp hd with rfl|hd
      · exact hb
      · exact List.mem_singleton.mp hd ▸ hc'.1⟩

variable [LinearOrder β]
theorem pool_complete {V : Set (List α)} (closed : SubstringClosed V)
    (ids : List ℕ) (L : ℕ → List (List α)) (owner per : ℕ → ℕ) (rank : ℕ → β)
    (P : Walk α) (B : List (Block α)) (hP : Runs V [] [] P) (hne : B ≠ [])
    (valid : ∀ b ∈ B, ValidBlock V ids L owner per rank b)
    (ready : ∀ i ∈ ids, (∀ w ∈ L i, w ∈ P) ∨ ∃ b ∈ B, i ∈ b.members) :
    ∃ a ∈ pool P B, Good V L P a := by
  classical
  obtain ⟨b,hb,hmax⟩ := Finset.exists_max_image B.toFinset (fun b => rank b.source)
    (by obtain ⟨b,hb⟩ := List.exists_mem_of_ne_nil B hne; exact ⟨b,List.mem_toFinset.mpr hb⟩)
  have hb : b ∈ B := List.mem_toFinset.mp hb
  have vb := valid b hb
  rcases ready b.target vb.target_mem with hroot | ⟨c,hc,ht⟩
  · obtain ⟨Q,hq,s,hQ,hQc,hcov,hw⟩ := vb.link
    obtain ⟨hS,hSc,hSv⟩ := splice_spec hP hQ ⟨b.word,hroot _ vb.word_mem,hw⟩
    refine ⟨_,pool_link P hb hq,hS,?_,?_,?_⟩
    · simpa only [List.map_singleton,List.sum_singleton,hSc] using Nat.add_le_add_left hQc (cost P)
    · intro w hw; exact (hSv w).mpr (Or.inl hw)
    · intro d hd; have he := List.mem_singleton.mp hd; subst d
      exact covers_mono hcov (fun w hw => (hSv w).mpr (Or.inr hw))
  · by_cases hown : b.target ∈ b.members
    · obtain ⟨s,hI,hIc,hcover⟩ := vb.internal
      obtain ⟨hR,hRc,hRv⟩ := rootShort_spec closed hI b.period
        ⟨b.word,hcover _ hown _ vb.word_mem,vb.same_short (vb.same _ hown)⟩
      have hJ := runs_join hP hR
      have hJc := cost_join P _ _ hP.2.2 hR.2.1
      have hJv (w : List α) := mem_join (w:=w) hP.2.2 hR.2.1
      refine ⟨_,pool_single P hb,hJ,?_,?_,?_⟩
      · simp only [List.map_singleton,List.sum_singleton]; omega
      · intro w hw; exact (hJv w).mpr (Or.inl hw)
      · intro d hd; have he := List.mem_singleton.mp hd; subst d
        exact covers_mono hcover (fun w hw => (hJv w).mpr (Or.inr (hRv w hw)))
    · have hcb : c ≠ b := by intro he; subst c; exact hown ht
      have vc := valid c hc
      have ho := vc.same _ ht
      have hrank : rank (owner b.target) ≤ rank b.source := by
        rw [ho]; exact hmax c (List.mem_toFinset.mpr hc)
      obtain ⟨Q,hq,s,hQ,hQc,hcov,hw,x,hx,hxl⟩ := vb.short hrank
      obtain ⟨t,hI,hIc,hcover⟩ := vc.internal
      obtain ⟨hS,hSc,hSv⟩ := splice_spec hQ hI ⟨b.word,hw,hcover _ ht _ vb.word_mem⟩
      have hlen : x.length ≤ c.period := by simpa only [vc.period_eq,ho] using hxl
      obtain ⟨hR,hRc,hRv⟩ := rootShort_spec closed hS c.period
        ⟨x,(hSv x).mpr (Or.inl hx),hlen⟩
      have hJ := runs_join hP hR
      have hJc := cost_join P _ _ hP.2.2 hR.2.1
      have hJv (w : List α) := mem_join (w:=w) hP.2.2 hR.2.1
      refine ⟨_,pool_double P hb hc hcb hq,hJ,?_,?_,?_⟩
      · simp only [List.map_cons,List.map_nil,List.sum_cons,List.sum_nil]; omega
      · intro w hw; exact (hJv w).mpr (Or.inl hw)
      · intro d hd
        rcases List.mem_cons.mp hd with rfl|hd
        · exact covers_mono hcov (fun w hw => (hJv w).mpr (Or.inr (hRv w ((hSv w).mpr (Or.inl hw)))))
        · have he := List.mem_singleton.mp hd; subst d
          exact covers_mono hcover (fun w hw => (hJv w).mpr (Or.inr (hRv w ((hSv w).mpr (Or.inr hw)))))
end Superstring.BlockClose


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

def rootedCheck (vs P : Walk α) : Bool :=
  check vs P && equal (P.take 1) [[]] && equal (P.reverse.take 1) [[]]

theorem rootedCheck_eq (vs P : Walk α) : rootedCheck vs P = true ↔ Runs {w | w ∈ vs} [] [] P := by
  have h (Q : Walk α) : Q.take 1 = [[]] ↔ Q.head? = some [] := by
    cases Q <;> simp
  simp only [rootedCheck,Bool.and_eq_true,check_eq,equal,decide_eq_true_eq,h,List.head?_reverse,Runs]
  tauto

def lookup (L : List (Walk α)) (i : ℕ) : Walk α := L[i]?.getD []
def coversCheck (L : List (Walk α)) (I : List ℕ) (P : Walk α) : Bool :=
  I.all (fun i => (lookup L i).all (fun w => member w P))
omit [Inhabited α] in
theorem coversCheck_eq (L : List (Walk α)) (I : List ℕ) (P : Walk α) :
    coversCheck L I P = true ↔ Covers (lookup L) I P := by
  simp only [coversCheck,List.all_eq_true,member,decide_eq_true_eq,Covers]

def goodCheck (vs : Walk α) (L : List (Walk α)) (P : Walk α) (a : Action α) : Bool :=
  rootedCheck vs a.2 && lessEq (cost a.2) (cost P+(a.1.map Block.reserve).sum) &&
    P.all (fun w => member w a.2) && a.1.all (fun b => coversCheck L b.members a.2)
theorem goodCheck_eq (vs : Walk α) (L : List (Walk α)) (P : Walk α) (a : Action α) :
    goodCheck vs L P a = true ↔ Good {w | w ∈ vs} (lookup L) P a := by
  simp only [goodCheck,Bool.and_eq_true,rootedCheck_eq,lessEq,decide_eq_true_eq,List.all_eq_true,
    member,coversCheck_eq,Good]
  tauto

def select (vs : Walk α) (L : List (Walk α)) (P : Walk α) (B : List (Block α)) : Action α :=
  ((pool P B).filter (goodCheck vs L P)).headD ([],P)
def remaining (B D : List (Block α)) : List (Block α) :=
  B.filter (fun b => !(member b D))

theorem select_spec (vs : Walk α) (L : List (Walk α)) (P : Walk α) (B : List (Block α))
    (hex : ∃ a ∈ pool P B, Good {w | w ∈ vs} (lookup L) P a) :
    select vs L P B ∈ pool P B ∧ Good {w | w ∈ vs} (lookup L) P (select vs L P B) := by
  have hn : (pool P B).filter (goodCheck vs L P) ≠ [] := by
    obtain ⟨a,ha,hg⟩ := hex
    have hm := List.mem_filter.mpr ⟨ha,(goodCheck_eq ..).mpr hg⟩
    intro he; rw [he] at hm; exact List.not_mem_nil hm
  have hm : select vs L P B ∈ (pool P B).filter (goodCheck vs L P) := by
    unfold select
    generalize (pool P B).filter (goodCheck vs L P) = X at hn ⊢
    cases X with
    | nil => exact False.elim (hn rfl)
    | cons a X => exact List.mem_cons_self ..
  have hs := List.mem_filter.mp hm
  exact ⟨hs.1,(goodCheck_eq ..).mp hs.2⟩

omit [Inhabited α] in
theorem mem_remaining (B D : List (Block α)) (b : Block α) :
    b ∈ remaining B D ↔ b ∈ B ∧ b ∉ D := by
  simp only [remaining,List.mem_filter,Bool.not_eq_true',member,decide_eq_false_iff_not]

omit [Inhabited α] in
theorem remaining_budget (B D : List (Block α)) (hd : D.Nodup) (hsub : D ⊆ B) :
    (D.map Block.reserve).sum+((remaining B D).map Block.reserve).sum ≤ (B.map Block.reserve).sum := by
  let E := B.filter (fun b => member b D)
  have hDE : D ⊆ E := fun b hb => List.mem_filter.mpr ⟨hsub hb,(member_eq ..).mpr hb⟩
  obtain ⟨F,hperm,hsub⟩ := hd.subperm hDE
  have hsum := (hsub.map Block.reserve).sum_le_sum (fun _ _ => Nat.zero_le _)
  rw [(hperm.map Block.reserve).sum_eq] at hsum
  have hp := ((List.filter_append_perm (fun b => member b D) B).map Block.reserve).sum_eq
  simp only [List.map_append,List.sum_append] at hp
  change (E.map Block.reserve).sum+((remaining B D).map Block.reserve).sum = _ at hp
  omega

omit [Inhabited α] in
theorem remaining_length (B D : List (Block α)) (hne : D ≠ []) (hsub : D ⊆ B) :
    (remaining B D).length < B.length := by
  have hh : (remaining B D).Sublist B := List.filter_sublist
  by_contra hn
  have he : remaining B D = B := hh.eq_of_length (by have := hh.length_le; omega)
  obtain ⟨b,hb⟩ := List.exists_mem_of_ne_nil D hne
  have hm : b ∈ remaining B D := by rw [he]; exact hsub hb
  exact ((mem_remaining B D b).mp hm).2 hb

abbrev State (α : Type) := Walk α × List (Block α)
def step (vs : Walk α) (L : List (Walk α)) (s : State α) : State α :=
  let a := select vs L s.1 s.2
  (a.2,remaining s.2 a.1)

variable {β : Type} [LinearOrder β]
theorem step_spec (vs : Walk α) (closed : SubstringClosed {w | w ∈ vs}) (L : List (Walk α))
    (ids : List ℕ) (owner per : ℕ → ℕ) (rank : ℕ → β) (s : State α)
    (hP : Runs {w | w ∈ vs} [] [] s.1) (hne : s.2 ≠ [])
    (valid : ∀ b ∈ s.2, ValidBlock {w | w ∈ vs} ids (lookup L) owner per rank b)
    (ready : ∀ i ∈ ids, (∀ w ∈ lookup L i, w ∈ s.1) ∨ ∃ b ∈ s.2, i ∈ b.members) :
    Runs {w | w ∈ vs} [] [] (step vs L s).1 ∧
      cost (step vs L s).1+((step vs L s).2.map Block.reserve).sum ≤ cost s.1+(s.2.map Block.reserve).sum ∧
      (∀ w ∈ s.1, w ∈ (step vs L s).1) ∧
      (step vs L s).2.Sublist s.2 ∧ (step vs L s).2.length < s.2.length ∧
      ∀ i ∈ ids, (∀ w ∈ lookup L i, w ∈ (step vs L s).1) ∨ ∃ b ∈ (step vs L s).2, i ∈ b.members := by
  obtain ⟨ha,hgood⟩ := select_spec vs L s.1 s.2
    (pool_complete closed ids (lookup L) owner per rank s.1 s.2 hP hne valid ready)
  obtain ⟨hn,hd,hsub⟩ := pool_sane s.1 s.2 ha
  obtain ⟨hQ,hQc,hQv,hQb⟩ := hgood
  have hbudget := remaining_budget s.2 (select vs L s.1 s.2).1 hd hsub
  refine ⟨hQ,by dsimp only [step]; omega,hQv,List.filter_sublist,remaining_length _ _ hn hsub,?_⟩
  intro i hi
  rcases ready i hi with h | ⟨b,hb,hm⟩
  · exact Or.inl (fun w hw => hQv w (h w hw))
  · by_cases hd : b ∈ (select vs L s.1 s.2).1
    · exact Or.inl (hQb b hd i hm)
    · exact Or.inr ⟨b,(mem_remaining _ _ _).mpr ⟨hb,hd⟩,hm⟩
end Superstring.BlockClose


namespace Superstring.BitCode.Poly
@[fun_prop] theorem flatMapFn {α β γ : Type} [Coded α] [Coded β] [Coded γ]
    {f : γ × α → List β} {xs : γ → List α} (hf : Poly f) (hxs : Poly xs) :
    Poly (fun c => (xs c).flatMap (fun a => f (c,a))) := by
  simpa only [List.flatMap, Function.comp_def] using flatten.comp (mapFn hf hxs)
end Superstring.BitCode.Poly
namespace Superstring.BlockClose
open BitCode WalkCode
variable {α : Type} [Coded α] [DecidableEq α] [Inhabited α]
instance codedState : Coded (State α) := codedProd
instance codedAction : Coded (Action α) := codedProd
instance codedContextState : Coded ((Walk α × List (Walk α)) × State α) := codedProd
instance codedContextAction : Coded ((Walk α × List (Walk α)) × (Walk α × Action α)) := codedProd
omit [Inhabited α] in
@[fun_prop] theorem poly_singles : Poly (fun q : Walk α × Block α => singles q.1 q.2) := by
  unfold singles
  have hm : Poly (fun q : Walk α × Block α => q.2.links.map (fun Q => ([q.2],splice q.1 Q))) := by
    apply BitCode.Poly.mapFn (f := fun q : (Walk α × Block α) × Walk α => ([q.1.2],splice q.1.1 q.2))
    · fun_prop
    · fun_prop
  fun_prop
omit [Inhabited α] in
@[fun_prop] theorem poly_doubles : Poly (fun q : Walk α × Block α × Block α => doubles q.1 q.2.1 q.2.2) := by
  unfold doubles
  apply BitCode.Poly.mapFn (f := fun q : (Walk α × Block α × Block α) × Walk α =>
    ([q.1.2.1,q.1.2.2],join q.1.1 (rootShort (splice q.2 q.1.2.2.internal) q.1.2.2.period)))
  · fun_prop
  · fun_prop
omit [Inhabited α] in
@[fun_prop] theorem poly_pool : Poly (fun q : Walk α × List (Block α) => pool q.1 q.2) := by
  unfold pool
  apply BitCode.Poly.flatMapFn (f := fun q : (Walk α × List (Block α)) × Block α =>
    singles q.1.1 q.2 ++ (q.1.2.filter (fun c => !(equal c q.2))).flatMap (doubles q.1.1 q.2))
  · apply BitCode.Poly.append.comp (f := fun q : (Walk α × List (Block α)) × Block α =>
      (singles q.1.1 q.2, (q.1.2.filter (fun c => !(equal c q.2))).flatMap (doubles q.1.1 q.2)))
    apply BitCode.Poly.pair (by fun_prop)
    apply BitCode.Poly.flatMapFn
      (f := fun q : ((Walk α × List (Block α)) × Block α) × Block α => doubles q.1.1.1 q.1.2 q.2)
    · fun_prop
    · exact BitCode.Poly.filterFn
        (p := fun q : ((Walk α × List (Block α)) × Block α) × Block α => !(equal q.2 q.1.2))
        (by fun_prop) (by fun_prop)
  · fun_prop
@[fun_prop] theorem poly_rootedCheck : Poly (fun q : Walk α × Walk α => rootedCheck q.1 q.2) := by
  unfold rootedCheck
  fun_prop
omit [DecidableEq α] [Inhabited α] in
@[fun_prop] theorem poly_lookup : Poly (fun q : List (Walk α) × ℕ => lookup q.1 q.2) := by
  exact BitCode.Poly.getD []
omit [Inhabited α] in
@[fun_prop] theorem poly_coversCheck : Poly (fun q : List (Walk α) × List ℕ × Walk α => coversCheck q.1 q.2.1 q.2.2) := by
  unfold coversCheck
  apply BitCode.Poly.allFn
    (p := fun q : (List (Walk α) × List ℕ × Walk α) × ℕ => (lookup q.1.1 q.2).all (fun w => member w q.1.2.2))
  · exact BitCode.Poly.allFn
      (p := fun q : ((List (Walk α) × List ℕ × Walk α) × ℕ) × List α => member q.2 q.1.1.2.2)
      (by fun_prop) (by fun_prop)
  · fun_prop
omit [DecidableEq α] [Inhabited α] in
@[fun_prop] theorem poly_reserves : Poly (fun B : List (Block α) => (B.map Block.reserve).sum) := by
  apply BitCode.Poly.sum.comp
  exact BitCode.Poly.mapFn (f := fun q : List (Block α) × Block α => q.2.reserve) (by fun_prop) (by fun_prop)
@[fun_prop] theorem poly_goodCheck : Poly (fun q : (Walk α × List (Walk α)) × (Walk α × Action α) =>
    goodCheck q.1.1 q.1.2 q.2.1 q.2.2) := by
  have hp : Poly (fun q : (Walk α × List (Walk α)) × (Walk α × Action α) => q.2.1.all (fun w => member w q.2.2.2)) := by
    exact BitCode.Poly.allFn
      (p := fun q : ((Walk α × List (Walk α)) × (Walk α × Action α)) × List α => member q.2 q.1.2.2.2)
      (by fun_prop) (by fun_prop)
  have hb : Poly (fun q : (Walk α × List (Walk α)) × (Walk α × Action α) =>
      q.2.2.1.all (fun b => coversCheck q.1.2 b.members q.2.2.2)) := by
    exact BitCode.Poly.allFn
      (p := fun q : ((Walk α × List (Walk α)) × (Walk α × Action α)) × Block α =>
        coversCheck q.1.1.2 q.2.members q.1.2.2.2) (by fun_prop) (by fun_prop)
  have hs : Poly (fun q : (Walk α × List (Walk α)) × (Walk α × Action α) =>
      (q.2.2.1.map Block.reserve).sum) := poly_reserves.comp (by fun_prop)
  have hc : Poly (fun q : (Walk α × List (Walk α)) × (Walk α × Action α) =>
      lessEq (cost q.2.2.2) (cost q.2.1+(q.2.2.1.map Block.reserve).sum)) := by fun_prop
  unfold goodCheck
  fun_prop
omit [DecidableEq α] [Inhabited α] in
theorem poly_shuffle : Poly (fun q : ((Walk α × List (Walk α)) × State α) × Action α =>
    (q.1.1,(q.1.2.1,q.2))) := by
  exact ((BitCode.Poly.fst.comp BitCode.Poly.fst).pair
    ((BitCode.Poly.fst.comp (BitCode.Poly.snd.comp BitCode.Poly.fst)).pair BitCode.Poly.snd))
theorem poly_goodCheck_context : Poly (fun q : ((Walk α × List (Walk α)) × State α) × Action α =>
    goodCheck q.1.1.1 q.1.1.2 q.1.2.1 q.2) := by
  exact BitCode.Poly.comp
    (f := fun q : ((Walk α × List (Walk α)) × State α) × Action α => (q.1.1,(q.1.2.1,q.2)))
    (g := fun q : (Walk α × List (Walk α)) × (Walk α × Action α) => goodCheck q.1.1 q.1.2 q.2.1 q.2.2)
    (poly_goodCheck (α := α)) (poly_shuffle (α := α))
theorem poly_filteredPool : Poly (fun q : (Walk α × List (Walk α)) × State α =>
    (pool q.2.1 q.2.2).filter (goodCheck q.1.1 q.1.2 q.2.1)) := by
  exact BitCode.Poly.filterFn poly_goodCheck_context (poly_pool.comp BitCode.Poly.snd)
@[fun_prop] theorem poly_select : Poly (fun q : (Walk α × List (Walk α)) × State α => select q.1.1 q.1.2 q.2.1 q.2.2) := by
  exact BitCode.Poly.headDWith.comp (poly_filteredPool.pair
    ((BitCode.Poly.const []).pair (BitCode.Poly.fst.comp BitCode.Poly.snd)))
omit [Inhabited α] in
@[fun_prop] theorem poly_remaining : Poly (fun q : List (Block α) × List (Block α) => remaining q.1 q.2) := by
  unfold remaining
  exact BitCode.Poly.filterFn
    (p := fun q : (List (Block α) × List (Block α)) × Block α => !(member q.2 q.1.2))
    (by fun_prop) (by fun_prop)
@[fun_prop] theorem poly_step : Poly (fun q : (Walk α × List (Walk α)) × State α => step q.1.1 q.1.2 q.2) := by
  unfold step
  dsimp only
  fun_prop
end Superstring.BlockClose


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

def pack (D : GroupData α) (src tar off : ℕ) (js : List ℕ) (a b : ℤ)
    (P : Walk α) (Qs : List (Walk α)) : BlockClose.Block α :=
  (((src,tar),(js.map (off+·),PeriodWord.window D.1 a b)),
    ((D.1.length,2*(js.length*D.1.length)),(P,Qs)))
def individual (D : GroupData α) (src tar off i : ℕ) (a b : ℤ) : BlockClose.Block α :=
  pack D src tar off [i] a b (turn D.1 (exits D i)) [LayerArray.individual D i a b]
def collective (D : GroupData α) (src tar off : ℕ) (js : List ℕ) (lo hi : ℕ) (a b t : ℤ) : BlockClose.Block α :=
  pack D src tar off js a b (band D js lo hi (js.length-1) t)
    [LayerArray.collective D js hi a b,shortSweep D js hi a b t]

omit [DecidableEq α] in
theorem pack_cover {V : Set (List α)} {A : ℤ → α} {p : ℕ} (L : ℕ → Layer V A p)
    {D : GroupData α} {src tar off : ℕ} {js : List ℕ} {a b : ℤ}
    {P Q : Walk α} {Qs : List (Walk α)} {ls : ℕ → Walk α}
    (he : ∀ j ∈ js, ∀ w ∈ ls (off+j), w ∈ (L j).Content)
    (hv : ∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ Q) :
    Covers ls (pack D src tar off js a b P Qs).members Q := by
  intro i hi w hw
  obtain ⟨j,hj,rfl⟩ := List.mem_map.mp hi
  exact hv j hj w (he j hj w hw)

variable [LinearOrder α]
theorem individual_valid {V : Set (List α)} {A B : ℤ → α} {p q : ℕ}
    (L : ℕ → Layer V A p) (T : Layer V B q) {D : GroupData α} {i src tar off : ℕ}
    (h : Represents D.1 (exits D i) (L i)) (closed : SubstringClosed V)
    (hp : 0 < p) (hq : 0 < q) (perA : Function.Periodic A (p : ℤ))
    (perB : Function.Periodic B (q : ℤ)) (letters : ∀ x, [A x] ∈ V)
    (R : T.Record A) (hne : A ≠ fun x => B (x+R.offset))
    (hf : (L i).first R.start ≤ R.stop) (hl : R.stop ≤ (L i).last R.start+p)
    (ids : List ℕ) (ls : ℕ → Walk α) (owner periods : ℕ → ℕ) (rank : ℕ → Lex (ℕ → α))
    (hsrc : periods src = p) (htar : tar ∈ ids) (hown : owner (off+i) = src)
    (htper : periods (owner tar) = q)
    (hself : owner tar = src → p = q)
    (hrec : textWord A R.start R.stop ∈ ls tar)
    (hlayers : ∀ w ∈ ls (off+i), w ∈ (L i).Content) :
    ValidBlock V ids ls owner periods rank (individual D src tar off i R.start R.stop) := by
  have hlen := R.length_lt hp hq perA perB hne
  obtain ⟨hI,hIc,hIv⟩ := turn_spec h closed hp perA
  obtain ⟨hQ,hQc,hQv,hR,w,hw,hs⟩ := LayerArray.individual_spec L h closed hp perA letters q
    R.start_le_stop R.word_mem hf hl hlen
  have hword : (individual D src tar off i R.start R.stop).word = textWord A R.start R.stop := by
    simp only [individual,pack,BlockClose.Block.word,PeriodWord.window_eq,h.text_eq]
  have hcov : ∀ P : Walk α, (∀ w ∈ (L i).Content, w ∈ P) →
      Covers ls (individual D src tar off i R.start R.stop).members P := by
    intro P hv j hj w hw
    have he : j = off+i := by simpa only [individual,pack,BlockClose.Block.members,List.map_singleton,List.mem_singleton] using hj
    subst j
    exact hv w (hlayers w hw)
  refine ⟨?_,htar,?_,by rw [hword]; exact hrec,?_,?_,?_,?_⟩
  · change D.1.length = periods src
    exact h.length_eq.trans hsrc.symm
  · intro j hj
    have he : j = off+i := by simpa only [individual,pack,BlockClose.Block.members,List.map_singleton,List.mem_singleton] using hj
    exact he ▸ hown
  · intro he
    have hlen' := R.same_period_length_lt hp perA (by rw [hself he]; exact perB) hne
    change (PeriodWord.window D.1 R.start R.stop).length ≤ D.1.length
    rw [PeriodWord.window_eq,h.text_eq,h.length_eq,length_textWord]
    have := R.start_le_stop; omega
  · refine ⟨_,hI,?_,hcov _ hIv⟩
    change cost (turn D.1 (exits D i))+D.1.length ≤ 2*([i].length*D.1.length)
    simp only [List.length_singleton,one_mul,h.length_eq,hIc]; omega
  · refine ⟨_,List.mem_singleton_self _,_,hQ,?_,hcov _ hQv,?_⟩
    · change cost (LayerArray.individual D i R.start R.stop) ≤ 2*([i].length*D.1.length)
      simp only [List.length_singleton,one_mul,h.length_eq,hQc]; exact le_rfl
    · rw [hword]; exact hR
  · intro _
    refine ⟨_,List.mem_singleton_self _,_,hQ,?_,hcov _ hQv,?_,w,hw,?_⟩
    · change cost (LayerArray.individual D i R.start R.stop) ≤ 2*([i].length*D.1.length)
      simp only [List.length_singleton,one_mul,h.length_eq,hQc]; exact le_rfl
    · rw [hword]; exact hR
    · change w.length ≤ periods (owner tar)
      rw [htper]; exact hs

theorem collective_valid {V : Set (List α)} {A B : ℤ → α} {p q : ℕ}
    (L : ℕ → Layer V A p) (T : Layer V B q) {D : GroupData α} {js : List ℕ} {lo hi src tar off : ℕ}
    (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) (hq : 0 < q)
    (perA : Function.Periodic A (p : ℤ)) (perB : Function.Periodic B (q : ℤ))
    (letters : ∀ x, [A x] ∈ V) (R : T.Record A) (hne : A ≠ fun x => B (x+R.offset))
    (t : ℤ) (hat : R.start ≤ t) (htb : t < R.stop)
    (hmax : ∀ x, forward A x ≤ forward A t)
    (hH : (L hi).first t ≤ R.stop+(js.length*p : ℕ))
    (hgap : (L hi).first R.start-(L lo).last R.start ≤ (js.length*p : ℕ))
    (hB : R.stop ≤ (L lo).last R.start+(js.length*p : ℕ))
    (hsharp : (L hi).first t-(L lo).last t ≤ ((js.length-1)*p : ℕ))
    (ids : List ℕ) (ls : ℕ → Walk α) (owner periods : ℕ → ℕ) (rank : ℕ → Lex (ℕ → α))
    (hsrc : periods src = p) (htar : tar ∈ ids) (hown : ∀ j ∈ js, owner (off+j) = src)
    (htper : periods (owner tar) = q) (hself : owner tar = src → p = q)
    (hrank : rank (owner tar) ≤ rank src → ∀ x, forward (fun x => B (x+R.offset)) x ≤ forward A t)
    (hrec : textWord A R.start R.stop ∈ ls tar)
    (hlayers : ∀ j ∈ js, ∀ w ∈ ls (off+j), w ∈ (L j).Content) :
    ValidBlock V ids ls owner periods rank (collective D src tar off js lo hi R.start R.stop t) := by
  have hD := h hi hhi
  have hk : 1 ≤ js.length := by have := List.length_pos_of_mem hhi; omega
  obtain ⟨hI,hIc,hIv⟩ := band_spec L h hlo hhi lower upper closed hp perA letters t hsharp
  obtain ⟨hQ,hQc,hQv,hR⟩ := collective_spec L h hlo hhi lower upper closed hp perA letters
    R.start_le_stop R.word_mem ((L hi).first_mono hat |>.trans hH) hgap hB
  have hword : (collective D src tar off js lo hi R.start R.stop t).word = textWord A R.start R.stop := by
    simp only [collective,pack,BlockClose.Block.word,PeriodWord.window_eq,hD.text_eq]
  have hcov : ∀ P : Walk α, (∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ P) →
      Covers ls (collective D src tar off js lo hi R.start R.stop t).members P := by
    intro P hv i hi w hw
    obtain ⟨j,hj,rfl⟩ := List.mem_map.mp hi
    exact hv j hj w (hlayers j hj w hw)
  have hreserve : (collective D src tar off js lo hi R.start R.stop t).reserve = 2*(js.length*p) := by
    change 2*(js.length*D.1.length) = _
    rw [hD.length_eq]
  refine ⟨?_,htar,?_,by rw [hword]; exact hrec,?_,?_,?_,?_⟩
  · change D.1.length = periods src
    exact hD.length_eq.trans hsrc.symm
  · intro i hi
    obtain ⟨j,hj,rfl⟩ := List.mem_map.mp hi
    exact hown j hj
  · intro he
    have hlen := R.same_period_length_lt hp perA (by rw [hself he]; exact perB) hne
    change (PeriodWord.window D.1 R.start R.stop).length ≤ D.1.length
    rw [PeriodWord.window_eq,hD.text_eq,hD.length_eq,length_textWord]
    have := R.start_le_stop; omega
  · refine ⟨_,hI,?_,hcov _ hIv⟩
    rw [hreserve]
    change cost (band D js lo hi (js.length-1) t)+D.1.length ≤ _
    rw [hD.length_eq]
    have he : (js.length-1+js.length)*p+p = 2*(js.length*p) := by
      have : js.length-1+1 = js.length := by omega
      calc (js.length-1+js.length)*p+p = (js.length-1+1+js.length)*p := by ring
           _ = 2*(js.length*p) := by rw [this]; ring
    omega
  · refine ⟨_,List.mem_cons_self ..,_,hQ,?_,hcov _ hQv,?_⟩
    · rw [hreserve]; exact hQc.le
    · rw [hword]; exact hR
  · intro hr
    have perB' : Function.Periodic (fun x => B (x+R.offset)) (q : ℤ) := by
      intro x
      simpa only [add_right_comm] using perB (x+R.offset)
    obtain ⟨P,hmem,hP,hPc,hPv,hPr,w,hw,hwlen⟩ := collective_contact L h hlo hhi lower upper
      closed hp perA letters q hq perB' hat htb R.word_mem R.agree hne hmax (hrank hr) hH hgap hB
    refine ⟨P,hmem,_,hP,?_,hcov _ hPv,?_,w,hw,?_⟩
    · rw [hreserve]; exact hPc.le
    · rw [hword]; exact hPr
    · change w.length ≤ periods (owner tar)
      rw [htper]; exact hwlen

end Superstring.BlockFactory

end OAI