lean/OAI/Computability/Superstring/LayerBridge.lean

import OAI.Computability.Superstring.GeoCore

namespace OAI

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

def layerWord (K : Code α) (g : ℕ) : List α := (key K g).take (period K g)
def layerExits (K : Code α) (g j : ℕ) : List ℕ :=
  (List.range (period K g)).map (fun r => rankLength K g j r)

@[fun_prop] theorem poly_layerWord : Poly (fun q : Code α × ℕ => layerWord q.1 q.2) := by
  unfold layerWord; fun_prop
@[fun_prop] theorem poly_layerExits : Poly (fun q : Code α × ℕ × ℕ => layerExits q.1 q.2.1 q.2.2) := by
  unfold layerExits
  exact BitCode.Poly.mapFn
    (f := fun q : (Code α × ℕ × ℕ) × ℕ => rankLength q.1.1 q.1.2.1 q.1.2.2 q.2)
    (by fun_prop) (by fun_prop)

omit [Coded α] in
theorem length_layerWord {K : Code α} {V : Set (List α)}
    {C : Threading V (Fin K.1.length)} (h : Represents K C) (g : Fin K.1.length) :
    (layerWord K g.val).length = period K g.val := by
  have hp := (period_spec h g).2
  simp only [layerWord,List.length_take,key,List.length_map,List.length_range]
  omega

omit [Coded α] in
theorem text_layerWord {K : Code α} {V : Set (List α)}
    {C : Threading V (Fin K.1.length)} (h : Represents K C) (g : Fin K.1.length) :
    PeriodWord.text (layerWord K g.val) = C.text g := by
  apply PeriodWord.eq_of_prefix
  · rw [length_layerWord h g]; exact (period_spec h g).1.positive
  · rw [length_layerWord h g]; exact (period_spec h g).1.periodic
  · intro i hi
    have hir : i < 2 * K.1.length := by
      rw [length_layerWord h g] at hi; have := (period_spec h g).2; omega
    have he := C.finiteKey_get g (by simpa only [Fintype.card_fin] using hir)
    have he' := key_eq h g
    have hi' : i < (key K g.val).length := by simpa only [key,List.length_map,List.length_range] using hir
    have heq : (key K g.val)[i] = C.text g (i : ℤ) := by
      rw [← he'] at he
      exact Option.some.inj (by simpa only [List.getElem?_eq_getElem hi'] using he)
    simpa only [layerWord,List.getElem_take] using heq

theorem exit_layerExits (K : Code α) (g j : ℕ) (hp : 0 < period K g) (x : ℤ) :
    GeoCode.exit (layerExits K g j) x = exit K g j x := by
  unfold GeoCode.exit layerExits exit
  simp only [List.length_map,List.length_range]
  have hi : (x % (period K g : ℤ)).toNat < period K g := by
    have h₀ := Int.emod_nonneg x (show (period K g : ℤ) ≠ 0 by omega)
    have h₁ := Int.emod_lt_of_pos x (show (0 : ℤ) < period K g by omega)
    omega
  simp only [List.getElem?_map,List.getElem?_range hi,Option.map_some,Option.getD_some]

end Superstring.ThreadArray


namespace Superstring.LayerArray
open BitCode Hierarchical WalkCode
variable {α : Type} [Inhabited α]
abbrev GroupData (α : Type) := List α × List (List ℕ)
def turn (U : List α) (Z : List ℕ) : Walk α :=
  GeoCode.segment (PeriodWord.text U) (GeoCode.exit Z) 0 U.length
structure Represents {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    (U : List α) (Z : List ℕ) (L : Layer V A p) : Prop where
  text_eq : PeriodWord.text U = A
  length_eq : U.length = p
  exit_eq : GeoCode.exit Z = L.z

theorem turn_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    {U : List α} {Z : List ℕ} {L : Layer V A p} (h : Represents U Z L)
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ)) :
    Runs V (textWord A 0 (L.first 0)) (textWord A 0 (L.first 0)) (turn U Z) ∧
      cost (turn U Z) = p ∧ ∀ w ∈ L.Content, w ∈ turn U Z := by
  obtain ⟨P,hP,hc,hv⟩ := GeoCode.full_turn_realizes L closed hp per 0
  have he : turn U Z = WalkCode.Path.points P := by
    rw [turn,h.text_eq,h.length_eq,h.exit_eq,hP]
  rw [he]
  have hs := WalkCode.points_spec P
  refine ⟨⟨hs.1,hs.2.1,hs.2.2.1⟩,hs.2.2.2.1.trans hc,?_⟩
  rintro w ⟨x,e,hf,hl,rfl⟩
  exact (hs.2.2.2.2 _).mpr (hv x e hf hl)

variable [DecidableEq α]
def saturate (D : GroupData α) (js : List ℕ) (P : Walk α) : Walk α :=
  fill P (js.map (fun j => turn D.1 (D.2[j]?.getD [])))

theorem saturate_spec {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    {D : GroupData α} {js : List ℕ} {P : Walk α} {s t : List α}
    (L : ℕ → Layer V A p) (h : ∀ j ∈ js, Represents D.1 (D.2[j]?.getD []) (L j))
    (closed : SubstringClosed V) (hp : 0 < p) (per : Function.Periodic A (p : ℤ))
    (hP : Runs V s t P) (htouch : ∀ j ∈ js, ∃ w ∈ (L j).Content, w ∈ P) :
    Runs V s t (saturate D js P) ∧ cost (saturate D js P) = cost P + js.length*p ∧
      (∀ w ∈ P, w ∈ saturate D js P) ∧ ∀ j ∈ js, ∀ w ∈ (L j).Content, w ∈ saturate D js P := by
  have ht (j : ℕ) (hj : j ∈ js) := turn_spec (h j hj) closed hp per
  obtain ⟨hR,hc,hv⟩ := fill_spec P (js.map (fun j => turn D.1 (D.2[j]?.getD []))) hP
    (by rintro Q hQ; obtain ⟨j,hj,rfl⟩ := List.mem_map.mp hQ; exact ⟨_,(ht j hj).1⟩)
    (by rintro Q hQ; obtain ⟨j,hj,rfl⟩ := List.mem_map.mp hQ
        obtain ⟨w,hw,hwP⟩ := htouch j hj
        exact ⟨w,hwP,(ht j hj).2.2 w hw⟩)
  refine ⟨hR,?_,fun w hw => (hv w).mpr (Or.inl hw),?_⟩
  · rw [List.map_map] at hc
    have he : (js.map (fun j => cost (turn D.1 (D.2[j]?.getD [])))).sum = js.length*p := by
      rw [List.map_congr_left (g := fun _ => p) (fun j hj => (ht j hj).2.1)]
      simp only [List.map_const',List.sum_replicate,nsmul_eq_mul,Nat.cast_id]
    exact hc.trans (congrArg (cost P + ·) he)
  · intro j hj w hw
    exact (hv w).mpr (Or.inr ⟨_,List.mem_map.mpr ⟨j,hj,rfl⟩,(ht j hj).2.2 w hw⟩)

variable [Coded α]
omit [DecidableEq α] in
@[fun_prop] theorem poly_turn : Poly (fun q : List α × List ℕ => turn q.1 q.2) := by
  unfold turn
  exact GeoCode.poly_segment.comp (f := fun q : List α × List ℕ => (q.1,q.2,(0 : ℤ),q.1.length)) (by fun_prop)
omit [DecidableEq α] in
@[fun_prop] theorem poly_indexturn : Poly (fun q : GroupData α × ℕ => turn q.1.1 (q.1.2[q.2]?.getD [])) := by
  have hz : Poly (fun q : GroupData α × ℕ => q.1.2[q.2]?.getD []) :=
    (BitCode.Poly.getD ([] : List ℕ)).comp (f := fun q : GroupData α × ℕ => (q.1.2,q.2)) (by fun_prop)
  exact poly_turn.comp (f := fun q : GroupData α × ℕ => (q.1.1,q.1.2[q.2]?.getD []))
    ((show Poly (fun q : GroupData α × ℕ => q.1.1) from by fun_prop).pair hz)
@[fun_prop] theorem poly_saturate : Poly (fun q : GroupData α × List ℕ × Walk α =>
    saturate q.1 q.2.1 q.2.2) := by
  unfold saturate
  have ht : Poly (fun q : (GroupData α × List ℕ × Walk α) × ℕ =>
      turn q.1.1.1 (q.1.1.2[q.2]?.getD [])) :=
    poly_indexturn.comp (f := fun q : (GroupData α × List ℕ × Walk α) × ℕ => (q.1.1,q.2)) (by fun_prop)
  have hm : Poly (fun q : GroupData α × List ℕ × Walk α =>
      q.2.1.map (fun j => turn q.1.1 (q.1.2[j]?.getD []))) :=
    BitCode.Poly.mapFn ht (by fun_prop)
  exact WalkCode.poly_fill.comp ((show Poly (fun q : GroupData α × List ℕ × Walk α => q.2.2) from by fun_prop).pair hm)
end Superstring.LayerArray


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

def phaseContent (U : List α) (Z : List ℕ) (r : ℕ) : List (List α) :=
  let a := GeoCode.first Z r
  (List.range ((GeoCode.exit Z r-a).toNat+1)).map
    (fun i : ℕ => PeriodWord.window U r (a+i))
def content (U : List α) (Z : List ℕ) : List (List α) :=
  (List.range U.length).flatMap (phaseContent U Z)

theorem mem_phaseContent {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    {U : List α} {Z : List ℕ} {L : Layer V A p} (h : Represents U Z L)
    (r : ℕ) (w : List α) : w ∈ phaseContent U Z r ↔
      ∃ e, L.first r ≤ e ∧ e ≤ L.last r ∧ w = textWord A r e := by
  simp only [phaseContent,GeoCode.first,h.exit_eq,PeriodWord.window_eq,h.text_eq,
    List.mem_map,List.mem_range]
  constructor
  · rintro ⟨i,hi,rfl⟩
    refine ⟨L.first r+i,by omega,?_,rfl⟩
    have hh := L.first_le_last r
    change L.z ((r : ℤ)-1)+(i : ℤ) ≤ L.z r
    unfold Layer.first Layer.last at hh
    omega
  · rintro ⟨e,hf,hl,rfl⟩
    refine ⟨(e-L.first r).toNat,?_,?_⟩
    · unfold Layer.first Layer.last at *
      omega
    · congr 1
      change L.first r+((e-L.first r).toNat : ℤ) = e
      omega

theorem mem_content {V : Set (List α)} {A : ℤ → α} {p : ℕ}
    {U : List α} {Z : List ℕ} {L : Layer V A p} (h : Represents U Z L)
    (hp : 0 < p) (per : Function.Periodic A (p : ℤ)) (w : List α) :
    w ∈ content U Z ↔ w ∈ L.Content := by
  simp only [content,List.mem_flatMap,List.mem_range,h.length_eq,mem_phaseContent h]
  constructor
  · rintro ⟨r,_,e,hf,hl,he⟩
    exact ⟨r,e,hf,hl,he⟩
  · rintro ⟨x,e,hf,hl,rfl⟩
    let r := x % (p : ℤ)
    let m := x / (p : ℤ)
    have hr0 : 0 ≤ r := Int.emod_nonneg x (by omega)
    have hrp : r < p := Int.emod_lt_of_pos x (by omega)
    have hrx : r+m*p = x := Int.emod_add_ediv_mul x p
    have hfr := L.first_shift_int m r
    have hlr := L.shift_int m r
    rw [hrx] at hfr hlr
    have hrn : (r.toNat : ℤ) = r := Int.toNat_of_nonneg hr0
    refine ⟨r.toNat,by omega,e-m*p,?_,?_,?_⟩
    · rw [hrn]; omega
    · rw [hrn]
      change _ ≤ L.z r
      change e ≤ L.z x at hl
      omega
    · rw [hrn]
      have he := textWord_translate A (m*p) (per.int_mul m) r (e-m*p)
      rw [hrx,sub_add_cancel] at he
      exact he

variable [Coded α]
@[fun_prop] theorem poly_phaseContent : Poly (fun q : List α × List ℕ × ℕ =>
    phaseContent q.1 q.2.1 q.2.2) := by
  unfold phaseContent
  exact BitCode.Poly.mapFn
    (f := fun q : (List α × List ℕ × ℕ) × ℕ =>
      PeriodWord.window q.1.1 q.1.2.2 (GeoCode.first q.1.2.1 q.1.2.2+q.2))
    (by fun_prop) (by fun_prop)
@[fun_prop] theorem poly_content : Poly (fun q : List α × List ℕ => content q.1 q.2) := by
  unfold content
  exact BitCode.Poly.flatten.comp (BitCode.Poly.mapFn
    (f := fun q : (List α × List ℕ) × ℕ => phaseContent q.1.1 q.1.2 q.2)
    (by fun_prop) (by fun_prop))
end Superstring.LayerArray

end OAI