import OAI.Computability.Superstring.BlockClose

namespace OAI

namespace Superstring.BlockFactory
open BitCode Hierarchical WalkCode LayerArray BlockClose
variable {α : Type} [Coded α] [Inhabited α] [DecidableEq α]
abbrev PackInput (α : Type) := (GroupData α × ℕ × ℕ × ℕ) × (List ℕ × ℤ × ℤ) × (Walk α × List (Walk α))
instance codedPackInput : Coded (PackInput α) := codedProd
omit [DecidableEq α] in
@[fun_prop] theorem poly_pack : Poly (fun q : PackInput α =>
    pack q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 q.2.1.1 q.2.1.2.1 q.2.1.2.2 q.2.2.1 q.2.2.2) := by
  unfold pack
  have hm : Poly (fun q : PackInput α => q.2.1.1.map (q.1.2.2.2+·)) :=
    BitCode.Poly.mapFn (f := fun q : PackInput α × ℕ => q.1.1.2.2.2+q.2) (by fun_prop) (by fun_prop)
  fun_prop
abbrev IndividualInput (α : Type) := (GroupData α × ℕ × ℕ × ℕ) × (ℕ × ℤ × ℤ)
instance codedIndividualInput : Coded (IndividualInput α) := codedProd
@[fun_prop] theorem poly_individual : Poly (fun q : IndividualInput α =>
    individual q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 q.2.1 q.2.2.1 q.2.2.2) := by
  unfold individual
  exact poly_pack.comp
    (f := fun q : IndividualInput α => (q.1,([q.2.1],q.2.2),
      (turn q.1.1.1 (exits q.1.1 q.2.1),[LayerArray.individual q.1.1 q.2.1 q.2.2.1 q.2.2.2]))) (by fun_prop)
abbrev CollectiveInput (α : Type) := (GroupData α × ℕ × ℕ × ℕ) × (List ℕ × ℕ × ℕ) × (ℤ × ℤ × ℤ)
instance codedCollectiveInput : Coded (CollectiveInput α) := codedProd
@[fun_prop] theorem poly_collective : Poly (fun q : CollectiveInput α =>
    collective q.1.1 q.1.2.1 q.1.2.2.1 q.1.2.2.2 q.2.1.1 q.2.1.2.1 q.2.1.2.2 q.2.2.1 q.2.2.2.1 q.2.2.2.2) := by
  unfold collective
  exact poly_pack.comp
    (f := fun q : CollectiveInput α => (q.1,(q.2.1.1,q.2.2.1,q.2.2.2.1),
      (band q.1.1 q.2.1.1 q.2.1.2.1 q.2.1.2.2 (q.2.1.1.length-1) q.2.2.2.2,
       [LayerArray.collective q.1.1 q.2.1.1 q.2.1.2.2 q.2.2.1 q.2.2.2.1,
        shortSweep q.1.1 q.2.1.1 q.2.1.2.2 q.2.2.1 q.2.2.2.1 q.2.2.2.2]))) (by fun_prop)
end Superstring.BlockFactory


namespace Superstring.LayerArray
open BitCode Hierarchical WalkCode
variable {α : Type} [Inhabited α] [DecidableEq α]
def shortWords (D : GroupData α) (i : ℕ) : List (List α) :=
  (content D.1 (exits D i)).filter (fun w => lessEq w.length D.1.length)
def hasShort (D : GroupData α) (i : ℕ) : Bool := !(shortWords D i).isEmpty
def shortLoop (D : GroupData α) (i : ℕ) : Walk α :=
  rootContent D [i] ((shortWords D i).headD [])

omit [DecidableEq α] in
theorem hasShort_eq {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    {D : GroupData α} {i : ℕ} {L : Layer V A p}
    (h : Represents D.1 (exits D i) L) (hp : 0 < p) (per : Function.Periodic A (p : ℤ)) :
    hasShort D i = true ↔ L.HasShort p := by
  simp only [hasShort,Bool.not_eq_true',List.isEmpty_eq_false_iff]
  constructor
  · intro hn
    obtain ⟨w,hw⟩ := List.exists_mem_of_ne_nil _ hn
    obtain ⟨hw,hl⟩ := List.mem_filter.mp (show w ∈ (content D.1 (exits D i)).filter (fun w => lessEq w.length D.1.length) from hw)
    obtain ⟨x,e,hf,he,rfl⟩ := (mem_content h hp per w).mp hw
    refine ⟨x,e,hf,he,?_⟩
    simpa only [lessEq,decide_eq_true_eq,h.length_eq,length_textWord] using hl
  · rintro ⟨x,e,hf,he,hl⟩
    have hm : textWord A x e ∈ shortWords D i := by
      apply List.mem_filter.mpr
      exact ⟨(mem_content h hp per _).mpr ⟨x,e,hf,he,rfl⟩,
        by simpa only [lessEq,decide_eq_true_eq,h.length_eq,length_textWord] using hl⟩
    exact fun hn => by rw [hn] at hm; exact List.not_mem_nil hm

theorem shortLoop_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 : hasShort D i = true) :
    Runs V [] [] (shortLoop D i) ∧ cost (shortLoop D i) ≤ 2*p ∧
      ∀ w ∈ (L i).Content, w ∈ shortLoop D i := by
  have hn : shortWords D i ≠ [] := by simpa only [hasShort,Bool.not_eq_true',List.isEmpty_eq_false_iff] using hs
  have hm : (shortWords D i).headD [] ∈ shortWords D i := by
    generalize shortWords D i = X at hn ⊢
    cases X with
    | nil => exact False.elim (hn rfl)
    | cons w X => exact List.mem_cons_self ..
  change (shortWords D i).headD [] ∈ (content D.1 (exits D i)).filter (fun w => lessEq w.length D.1.length) at hm
  obtain ⟨hm,hl⟩ := List.mem_filter.mp hm
  have hw := (mem_content h hp per _).mp hm
  have hlen : ((shortWords D i).headD []).length ≤ p := by
    simpa only [lessEq,decide_eq_true_eq,h.length_eq] using hl
  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).content_mem hw)
    (by intro j hj; have := List.mem_singleton.mp hj; subst j; exact ⟨_,hw,List.prefix_refl _⟩)
  refine ⟨hr,?_,hv i (by simp)⟩
  change cost (rootContent D [i] ((shortWords D i).headD [])) ≤ _
  rw [hc]
  simp only [List.length_singleton,one_mul]
  omega

variable [Coded α]
omit [DecidableEq α] in
@[fun_prop] theorem poly_shortWords : Poly (fun q : GroupData α × ℕ => shortWords q.1 q.2) := by
  unfold shortWords
  exact BitCode.Poly.filterFn
    (p := fun q : (GroupData α × ℕ) × List α => lessEq q.2.length q.1.1.1.length) (by fun_prop) (by fun_prop)
omit [DecidableEq α] in
@[fun_prop] theorem poly_hasShort : Poly (fun q : GroupData α × ℕ => hasShort q.1 q.2) := by
  unfold hasShort
  fun_prop
@[fun_prop] theorem poly_shortLoop : Poly (fun q : GroupData α × ℕ => shortLoop q.1 q.2) := by
  unfold shortLoop
  exact poly_rootContent.comp (f := fun q : GroupData α × ℕ => (q.1,[q.2],(shortWords q.1 q.2).headD [])) (by fun_prop)
end Superstring.LayerArray


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

theorem step_nil (vs : Walk α) (L : List (Walk α)) (P : Walk α) : step vs L (P,[]) = (P,[]) := by
  simp [step,select,pool,remaining]

variable {β : Type} [LinearOrder β]
theorem iterate_step (vs : Walk α) (closed : SubstringClosed {w | w ∈ vs}) (L : List (Walk α))
    (ids : List ℕ) (owner per : ℕ → ℕ) (rank : ℕ → β) (s : State α)
    (hP : Runs {w | w ∈ vs} [] [] s.1)
    (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) (n : ℕ) :
    let t := (step vs L)^[n] s
    Runs {w | w ∈ vs} [] [] t.1 ∧
      cost t.1+(t.2.map Block.reserve).sum ≤ cost s.1+(s.2.map Block.reserve).sum ∧
      (∀ w ∈ s.1, w ∈ t.1) ∧ t.2.Sublist s.2 ∧ t.2.length ≤ s.2.length-n ∧
      ∀ i ∈ ids, (∀ w ∈ lookup L i, w ∈ t.1) ∨ ∃ b ∈ t.2, i ∈ b.members := by
  dsimp only
  induction n with
  | zero => exact ⟨hP,le_rfl,fun _ h => h,List.Sublist.refl _,by simp,ready⟩
  | succ n ih =>
    rw [Function.iterate_succ_apply']
    let t := (step vs L)^[n] s
    change Runs _ [] [] t.1 ∧ _ at ih
    by_cases hn : t.2 = []
    · have he : step vs L t = t := by
        rw [← Prod.eta t,hn,step_nil]
      rw [he]
      exact ⟨ih.1,ih.2.1,ih.2.2.1,ih.2.2.2.1,by simp [hn],ih.2.2.2.2.2⟩
    · obtain ⟨hQ,hcost,hvis,hsub,hlen,hr⟩ := step_spec vs closed L ids owner per rank t ih.1 hn
        (fun b hb => valid b (ih.2.2.2.1.subset hb)) ih.2.2.2.2.2
      exact ⟨hQ,hcost.trans ih.2.1,fun w hw => hvis w (ih.2.2.1 w hw),hsub.trans ih.2.2.2.1,
        by change (step vs L t).2.length ≤ _; have hh : t.2.length ≤ s.2.length-n := ih.2.2.2.2.1; omega,hr⟩

omit [DecidableEq α] [Inhabited α] [LinearOrder β] in
theorem rooted_length {V : Set (List α)} {P : Walk α} (hP : Runs V [] [] P) :
    P.length = 2*cost P+1 := by
  cases P with
  | nil => exact False.elim (hP.1.1 rfl)
  | cons a P =>
    have ha : a = [] := by simpa using hP.2.1
    subst a
    have h := length_cost hP.1
    simp only [hP.2.2,Option.getD_some,List.length_nil,Nat.add_zero] at h
    simpa only [List.length_cons] using congrArg (·+1) h

variable [Coded α]
abbrev Input (α : Type) := (Walk α × List (Walk α)) × State α
def iterStep (q : Input α) : Input α := (q.1,step q.1.1 q.1.2 q.2)
def capacity (q : Input α) : ℕ :=
  2*bitSize q + 1 + (2*(cost q.2.1+(q.2.2.map Block.reserve).sum)+1)*(bitSize q+1)
def close (q : Input α) : Walk α :=
  (((cappedStep iterStep)^[q.2.2.length] (capacity q,q)).2).2.1

omit [LinearOrder β] [Coded α] in
theorem iterate_iterStep (q : Input α) (n : ℕ) :
    iterStep^[n] q = (q.1,(step q.1.1 q.1.2)^[n] q.2) := by
  induction n with
  | zero => rfl
  | succ n ih => rw [Function.iterate_succ_apply',ih,Function.iterate_succ_apply']; rfl

omit [LinearOrder β] [DecidableEq α] [Inhabited α] in
theorem state_size (q : Input α) (t : State α)
    (hP : Runs {w | w ∈ q.1.1} [] [] t.1)
    (hcost : cost t.1 ≤ cost q.2.1+(q.2.2.map Block.reserve).sum)
    (hsub : t.2.Sublist q.2.2) : bitSize (q.1,t) ≤ capacity q := by
  have eqQ : bitSize q = bitSize q.1+bitSize q.2 := bitSize_prod q.1 q.2
  have eqCtx : bitSize q.1 = bitSize q.1.1+bitSize q.1.2 := bitSize_prod q.1.1 q.1.2
  have eqS : bitSize q.2 = bitSize q.2.1+bitSize q.2.2 := bitSize_prod q.2.1 q.2.2
  have eqT : bitSize t = bitSize t.1+bitSize t.2 := bitSize_prod t.1 t.2
  have eqOut : bitSize (q.1,t) = bitSize q.1+bitSize t := bitSize_prod q.1 t
  have hv : ∀ w ∈ t.1, bitSize w ≤ bitSize q := by
    intro w hw
    have hm := bitSize_mem (hP.1.2.1 w hw)
    omega
  have hh := bitSize_map_le t.1 (fun w => w) (bitSize q) hv
  have hid : t.1.map (fun w => w) = t.1 := by simp
  rw [hid,rooted_length hP] at hh
  have hb := bitSize_sublist hsub
  unfold capacity
  nlinarith

theorem close_spec (q : Input α) (closed : SubstringClosed {w | w ∈ q.1.1})
    (ids : List ℕ) (owner per : ℕ → ℕ) (rank : ℕ → β)
    (hP : Runs {w | w ∈ q.1.1} [] [] q.2.1)
    (valid : ∀ b ∈ q.2.2, ValidBlock {w | w ∈ q.1.1} ids (lookup q.1.2) owner per rank b)
    (ready : ∀ i ∈ ids, (∀ w ∈ lookup q.1.2 i, w ∈ q.2.1) ∨ ∃ b ∈ q.2.2, i ∈ b.members) :
    Runs {w | w ∈ q.1.1} [] [] (close q) ∧
      cost (close q) ≤ cost q.2.1+(q.2.2.map Block.reserve).sum ∧
      (∀ w ∈ q.2.1, w ∈ close q) ∧ Covers (lookup q.1.2) ids (close q) := by
  have hi := iterate_step q.1.1 closed q.1.2 ids owner per rank q.2 hP valid ready
  have he := iterate_cappedStep_eq iterStep q.2.2.length (capacity q) q (by
    intro n _ _
    rw [iterate_iterStep]
    exact state_size q _ (hi n).1 (by have := (hi n).2.1; omega) (hi n).2.2.2.1)
  unfold close
  rw [he,iterate_iterStep]
  dsimp only
  have hh := hi q.2.2.length
  have hz : ((step q.1.1 q.1.2)^[q.2.2.length] q.2).2 = [] := by
    apply List.length_eq_zero_iff.mp
    have := hh.2.2.2.2.1; omega
  refine ⟨hh.1,by have := hh.2.1; omega,hh.2.2.1,?_⟩
  intro i hi
  rcases hh.2.2.2.2.2 i hi with h | ⟨b,hb,_⟩
  · exact h
  · rw [hz] at hb; exact False.elim (List.not_mem_nil hb)

omit [LinearOrder β] in
@[fun_prop] theorem poly_iterStep : Poly (iterStep : Input α → Input α) := by
  exact BitCode.Poly.fst.pair poly_step
omit [LinearOrder β] [DecidableEq α] [Inhabited α] in
@[fun_prop] theorem poly_capacity : Poly (capacity : Input α → ℕ) := by
  have hr : Poly (fun q : Input α => (q.2.2.map Block.reserve).sum) := poly_reserves.comp (by fun_prop)
  unfold capacity
  fun_prop
omit [LinearOrder β] in
@[fun_prop] theorem poly_close : Poly (close : Input α → Walk α) := by
  have ht : Poly (fun q : Input α => ((cappedStep iterStep)^[q.2.2.length] (capacity q,q)).2) :=
    (BitCode.Poly.cappedIterate poly_iterStep).comp
      (f := fun q : Input α => (q.2.2.length,(capacity q,q))) (by fun_prop)
  exact BitCode.Poly.fst.comp (BitCode.Poly.snd.comp ht)
end Superstring.BlockClose


namespace Superstring.WalkCode
open Hierarchical BitCode
variable {α : Type}
def collect (Ps : List (Walk α)) : Walk α := Ps.foldl join [[]]

theorem fold_join_spec {V : Set (List α)} (Ps : List (Walk α)) (P : Walk α)
    (hP : Runs V [] [] P) (h : ∀ Q ∈ Ps, Runs V [] [] Q) :
    Runs V [] [] (Ps.foldl join P) ∧
      cost (Ps.foldl join P) = cost P+(Ps.map cost).sum ∧
      (∀ w ∈ P, w ∈ Ps.foldl join P) ∧
      ∀ Q ∈ Ps, ∀ w ∈ Q, w ∈ Ps.foldl join P := by
  induction Ps generalizing P with
  | nil => exact ⟨hP,by simp,fun _ hw => hw,by simp⟩
  | cons Q Ps ih =>
    have hQ := h Q (List.mem_cons_self ..)
    obtain ⟨hr,hc,hv,ha⟩ := ih (join P Q) (runs_join hP hQ)
      (fun R hR => h R (List.mem_cons_of_mem _ hR))
    refine ⟨hr,?_,?_,?_⟩
    · simp only [List.foldl_cons,List.map_cons,List.sum_cons,hc,cost_join P Q [] hP.2.2 hQ.2.1]
      omega
    · intro w hw; exact hv w ((mem_join hP.2.2 hQ.2.1).mpr (Or.inl hw))
    · intro R hR w hw
      rcases List.mem_cons.mp hR with rfl|hR
      · exact hv w ((mem_join hP.2.2 hQ.2.1).mpr (Or.inr hw))
      · exact ha R hR w hw

theorem collect_spec {V : Set (List α)} (h0 : ([] : List α) ∈ V)
    (Ps : List (Walk α)) (h : ∀ Q ∈ Ps, Runs V [] [] Q) :
    Runs V [] [] (collect Ps) ∧ cost (collect Ps) = (Ps.map cost).sum ∧
      ∀ Q ∈ Ps, ∀ w ∈ Q, w ∈ collect Ps := by
  have hh := fold_join_spec Ps [[]] ⟨valid_nil [] h0,rfl,rfl⟩ h
  exact ⟨hh.1,by simpa only [collect,cost_singleton,Nat.zero_add] using hh.2.1,hh.2.2.2⟩

variable [Coded α]
@[fun_prop] theorem poly_collect : Poly (collect : List (Walk α) → Walk α) := by
  have hs : ∀ P Q : Walk α, bitSize (join P Q) ≤ bitSize P + (Polynomial.X : Polynomial ℕ).eval (bitSize Q) := by
    intro P Q
    simpa only [Polynomial.eval_X] using size_join P Q
  exact (BitCode.Poly.foldl_additive poly_join Polynomial.X hs).comp
    (f := fun Ps : List (Walk α) => (Ps,[[]])) (by fun_prop)
end Superstring.WalkCode

end OAI