lean/OAI/Computability/Superstring/UpperController.lean

import OAI.Computability.Superstring.HostComplete

namespace OAI

namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode UpperCode
variable {α G : Type} [Inhabited α] [LinearOrder α] {V : Set (List α)}
def complete (X : Env α) (g cut M : ℕ) (P : Walk α) : Plan α :=
  let D := data X g
  let m := D.2.length
  let p := D.1.length
  let t := phase X g
  let H := GeoCode.first (exits D (m-1)) t
  let I := upper m cut
  if m ≤ cut then (P,[],[])
  else if H-t ≤ ((m-cut)*p : ℕ) then
    (join P (rootUpper D I (m-1) t),[],[])
  else if 0 < cut ∧ H-GeoCode.exit (exits D (cut-1)) t ≤ ((m-cut)*p : ℕ) then
    (attachBand D I (cut-1) (m-1) P t,[],[])
  else
    let v := choose D (book X) (ids X) cut M t (foreign D (book X))
    let o := hardPlan X g cut v
    (join P o.1,o.2.1,o.2.2)
namespace Model
variable {X : Env α} {C : LayerCollection V G} (h : Model X C)
theorem first_eq (g : G) {i : ℕ} (hi : i < C.size g) (t : ℤ) :
    GeoCode.first (exits (data X (h.group g)) i) t = (h.natLayer g i).first t := by
  simp only [GeoCode.first,(h.nat_rep g hi).exit_eq,Layer.first]
theorem last_eq (g : G) {i : ℕ} (hi : i < C.size g) (t : ℤ) :
    GeoCode.exit (exits (data X (h.group g)) i) t = (h.natLayer g i).last t :=
  congrFun (h.nat_rep g hi).exit_eq t

theorem complete_spec (closed : SubstringClosed V) (supply : C.RecordSupply)
    (M : ℕ) (len : ∀ w ∈ V, w.length ≤ M) (g : G) (cut : ℕ) (hcut : cut ≤ C.size g)
    (P : Walk α) (hP : Runs V [] [] P)
    (hp : ∀ i : Fin (C.size g), i.val < cut → ∀ w ∈ (C.layer g i).Content, w ∈ P) :
    let o := complete X (h.group g) cut M P
    GoodPlan h o ∧ planBudget X o ≤ cost P+2*((C.size g-cut)*C.period g) ∧
      (∀ w ∈ P, w ∈ o.1) ∧
      (∀ i : Fin (C.size g), cut ≤ i.val → Covered X o (h.encode ⟨g,i⟩)) ∧
      (∀ r ∈ o.2.2, r.source = h.group g) ∧ o.2.2.length ≤ 1 := by
  let m := C.size g
  let p := C.period g
  let t := C.distinguished g
  let top : Fin (C.size g) := ⟨C.size g-1,by have := C.nonempty g; omega⟩
  have ht : (h.natLayer g (C.size g-1)) = C.layer g top := by
    exact h.natLayer_fin g top
  have htop : C.size g-1 < C.size g := top.isLt
  let I := upper (C.size g) cut
  have hib (i : ℕ) (hi : i ∈ I) : i < C.size g := ((mem_upper ..).mp hi).2
  have hirep := fun i hi => h.nat_rep g (hib i hi)
  have hie : I.length = C.size g-cut := length_upper ..
  have hu (i : ℕ) (hi : i ∈ I) (x : ℤ) : (h.natLayer g i).z x ≤ (h.natLayer g (C.size g-1)).z x :=
    h.nat_order g (by have := hib i hi; omega) x
  have hrefl (Q : Walk α) (hQ : Runs V [] [] Q) : GoodPlan h (Q,[],[]) := ⟨hQ,by simp,by simp⟩
  have heasy (Q : Walk α) (hQ : Runs V [] [] Q)
      (hc : cost Q ≤ cost P+2*((C.size g-cut)*C.period g))
      (hv : ∀ w ∈ P, w ∈ Q)
      (hi : ∀ i : Fin (C.size g), cut ≤ i.val → ∀ w ∈ (C.layer g i).Content, w ∈ Q) :
      GoodPlan h (Q,[],[]) ∧ planBudget X (Q,[],[]) ≤ cost P+2*((C.size g-cut)*C.period g) ∧
        (∀ w ∈ P, w ∈ Q) ∧
        (∀ i : Fin (C.size g), cut ≤ i.val → Covered X (Q,[],[]) (h.encode ⟨g,i⟩)) ∧
        (∀ r ∈ ([] : List Request), r.source = h.group g) ∧ ([] : List Request).length ≤ 1 := by
    refine ⟨hrefl Q hQ,by simpa only [planBudget,List.map_nil,List.sum_nil,Nat.add_zero] using hc,hv,?_,by simp,by simp⟩
    intro i hi' ; exact Or.inl (fun w hw => hi i hi' w ((h.content_iff ⟨g,i⟩ w).mp hw))
  unfold complete
  simp only [h.size,show (data X (h.group g)).1.length = C.period g from h.per_eq g,h.phase_eq]
  by_cases hem : C.size g ≤ cut
  · rw [ite_eq_left hem]
    apply heasy P hP (by omega) (fun _ hw => hw)
    intro i hi; have := i.isLt; omega
  · rw [ite_eq_right hem]
    have hct : cut < C.size g := by omega
    rw [h.first_eq g htop,ht]
    by_cases he : (C.layer g top).first (C.distinguished g)-C.distinguished g ≤ ((C.size g-cut)*C.period g : ℕ)
    · rw [ite_eq_left he]
      obtain ⟨hr,hc,hv⟩ := rootUpper_spec (h.natLayer g) hirep (h.nat_rep g htop) hu
        closed (C.positive g) (C.periodic g) (C.distinguished g) (by simpa only [hie,ht] using he)
      apply heasy _ (runs_join hP hr)
      · rw [cost_join _ _ [] hP.2.2 hr.2.1]
        rw [hie] at hc
        omega
      · exact fun w hw => (mem_join hP.2.2 hr.2.1).mpr (Or.inl hw)
      · intro i hi w hw
        apply (mem_join hP.2.2 hr.2.1).mpr
        exact Or.inr (hv i.val ((mem_upper ..).mpr ⟨hi,i.isLt⟩) w ((h.natLayer_fin g i).symm ▸ hw))
    · rw [ite_eq_right he]
      by_cases hb : 0 < cut ∧ (C.layer g top).first (C.distinguished g) -
          GeoCode.exit (exits (data X (h.group g)) (cut-1)) (C.distinguished g) ≤ ((C.size g-cut)*C.period g : ℕ)
      · rw [ite_eq_left hb]
        have hl : cut-1 < C.size g := by omega
        have hlo (i : ℕ) (hi : i ∈ I) (x : ℤ) :
            (h.natLayer g (cut-1)).z x ≤ (h.natLayer g i).z x :=
          h.nat_order g (by have := ((mem_upper ..).mp hi).1; omega) x
        have hband := hb.2
        rw [h.last_eq g hl] at hband
        obtain ⟨hr,hc,hv,hi⟩ := attachBand_spec (h.natLayer g) hirep (h.nat_rep g hl) (h.nat_rep g htop)
          hlo hu (h.nat_order g (by omega)) closed (C.positive g) (C.periodic g) (C.letters closed g)
          (C.distinguished g) (by simpa only [ht,hie] using hband) hP
          (by simpa only [h.natLayer_fin g (⟨cut-1,hl⟩ : Fin (C.size g))] using hp ⟨cut-1,hl⟩ (by change cut-1<cut; omega))
        apply heasy _ hr (by simpa only [hie] using hc) hv
        intro i hi' w hw
        exact hi i.val ((mem_upper ..).mpr ⟨hi',i.isLt⟩) w ((h.natLayer_fin g i).symm ▸ hw)
      · rw [ite_eq_right hb]
        have hb' : ¬ ∃ base : Fin (C.size g), base.val+1=cut ∧
            (C.layer g top).first (C.distinguished g)-(C.layer g base).last (C.distinguished g) ≤
              ((C.size g-cut)*C.period g : ℕ) := by
          rintro ⟨base,hbase,hbnd⟩
          apply hb
          have heq : cut-1=base.val := by omega
          refine ⟨by omega,?_⟩
          rw [heq,h.last_eq g base.isLt,h.natLayer_fin]
          exact hbnd
        have hex := supply_params C g supply (data X (h.group g)) (book X) (ids X) h.encode
          (h.size g) (h.rep g) (h.book_rep) (h.id_mem) M len cut hct he hb'
        rw [← h.phase_eq g] at hex
        let v := choose (data X (h.group g)) (book X) (ids X) cut M (phase X (h.group g))
          (foreign (data X (h.group g)) (book X))
        obtain ⟨hv,htest,hforeign⟩ := choose_spec _ _ _ _ _ _ _ hex
        have hvid : v.2.1 ∈ ids X := by
          obtain ⟨k,_,hv⟩ := List.mem_flatMap.mp hv
          obtain ⟨j,hj,hv⟩ := List.mem_flatMap.mp hv
          obtain ⟨r,_,heq⟩ := List.mem_map.mp hv
          have heq' : v.2.1 = j := (congrArg (fun x : UpperCode.Param => x.2.1) heq).symm
          exact heq'.symm ▸ hj
        obtain ⟨hg,hc,hv',hs,hn⟩ := h.hardPlan_spec closed g cut v hct hvid htest hforeign
        rw [← h.phase_eq g]
        change GoodPlan h (join P (hardPlan X (h.group g) cut v).1,_,_) ∧ _
        refine ⟨⟨runs_join hP hg.1,hg.2⟩,?_,?_,?_,hs,hn⟩
        · dsimp only [planBudget] at hc ⊢
          rw [cost_join _ _ [] hP.2.2 hg.1.2.1]
          dsimp only [v] at hc ⊢
          omega
        · exact fun w hw => (mem_join hP.2.2 hg.1.2.1).mpr (Or.inl hw)
        · intro i hi
          rcases hv' i hi with hvis|hblock|hreq
          · exact Or.inl (fun w hw => (mem_join hP.2.2 hg.1.2.1).mpr (Or.inr (hvis w hw)))
          · exact Or.inr (Or.inl hblock)
          · exact Or.inr (Or.inr hreq)
end Model
end Superstring.CollectionCode


namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode
variable {α G : Type} [Inhabited α] [LinearOrder α] {V : Set (List α)}
structure RequestAt {X : Env α} {C : LayerCollection V G} (h : Model X C) (d : C.Id) (r : Request) where
  source : G
  source_eq : h.group source = r.source
  record : (C.layerAt d).Record (C.text source)
  offset : record.offset = RecordCode.offset r.code
  start : record.start = RecordCode.start r.code
  stop : record.stop = RecordCode.stop r.code
  foreign : C.text source ≠ fun x => C.text d.1 (x+record.offset)
  nonempty : r.members ≠ []
  nodup : r.members.Nodup
  bound : ∀ i ∈ r.members, i < C.size source
  long : ∀ i ∈ r.members, record.start+C.period source < (h.natLayer source i).first record.start
  margin : ∀ i ∈ r.members, (h.natLayer source i).last record.start < record.stop-C.period source


namespace RequestAt
variable {X : Env α} {C : LayerCollection V G} {h : Model X C} {r : Request} {d : C.Id}
    (w : RequestAt h d r)
def hosted : HostedGroup (C.layerAt d) where
  text := fun x => C.text w.source (x-w.record.offset)
  period := C.period w.source
  positive := C.positive w.source
  periodic := fun x => by simpa only [add_sub_right_comm] using C.periodic w.source (x-w.record.offset)
  start := w.record.start+w.record.offset
  stop := w.record.stop+w.record.offset
  first_le := w.record.first_le
  le_last := w.record.le_last
  agree := by
    intro x hx hy
    have hh := w.record.agree (x-w.record.offset) (by omega) (by omega)
    simpa only [sub_add_cancel] using hh
  foreign := by
    intro he
    apply w.foreign
    funext x
    simpa only [add_sub_cancel_right] using congrFun he (x+w.record.offset)

def request (i : {j // j ∈ r.members}) : w.hosted.Request where
  layer := (h.natLayer w.source i.val).translate w.record.offset
  stop := (h.natLayer w.source i.val).first w.record.start+w.record.offset
  first_le := by simp [hosted]
  le_last := by
    simp only [hosted,Layer.translate_last,add_sub_cancel_right]
    have hh := (h.natLayer w.source i.val).first_le_last w.record.start
    omega
  long := by
    have hh := w.long i.val i.property
    change w.record.start+w.record.offset+C.period w.source < _
    omega
  margin := by
    have hh := w.margin i.val i.property
    have hf := (h.natLayer w.source i.val).first_le_last w.record.start
    change _ ≤ w.record.stop+w.record.offset-C.period w.source
    omega

theorem data_rep (i : {j // j ∈ r.members}) :
    Represents (UpperCode.lookup (book X) (r.source*stride X+i.val)).1
      (UpperCode.lookup (book X) (r.source*stride X+i.val)).2 (h.natLayer w.source i.val) := by
  rw [← w.source_eq,lookup_encode X _ _ (h.bound _) (lt_of_lt_of_le (w.bound i.val i.property) (h.capacity _))]
  exact h.nat_rep w.source (w.bound i.val i.property)

theorem entry_eq (i : {j // j ∈ r.members}) : Request.entry X r i.val =
    (r.source,PeriodWord.shift (data X r.source).1 w.record.offset,
      w.hosted.start,w.hosted.stop,(w.request i).stop) := by
  simp only [Request.entry,← w.source_eq,← w.offset,← w.start,← w.stop,hosted,request]
  simp only [GeoCode.first,(h.nat_rep w.source (w.bound i.val i.property)).exit_eq,Layer.first]
end RequestAt
namespace Model
variable {X : Env α} {C : LayerCollection V G} (h : Model X C)
theorem requestAt {r : Request} (hr : ValidRequest h r) (d : C.Id) (hd : h.encode d = r.target) :
    Nonempty (RequestAt h d r) := by
  obtain ⟨w⟩ := hr
  have he : w.target = d := h.encode_inj (w.target_eq.trans hd.symm)
  cases he
  exact ⟨⟨w.source,w.source_eq,w.record,w.offset,w.start,w.stop,w.foreign,w.nonempty,w.nodup,
    w.bound,w.long,w.margin⟩⟩
end Model
end Superstring.CollectionCode


namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode
variable {α G : Type} [Inhabited α] [LinearOrder α] {V : Set (List α)}
def entries (X : Env α) (R : List Request) : List (HostCode.Entry α) :=
  R.flatMap (fun r => r.members.map (Request.entry X r))
def requestedData (X : Env α) (R : List Request) : List (LayerData α) :=
  R.flatMap (fun r => (r.ids X).map (UpperCode.lookup (book X)))
def fibrePool (X : Env α) (t : ℕ) (R : List Request) : List (Walk α) :=
  let D := UpperCode.lookup (book X) t
  HostCode.completePool D.1 D.2 (entries X R) (requestedData X R)

def SourcesDistinct (R : List Request) : Prop :=
  ∀ r ∈ R, ∀ s ∈ R, r.source = s.source → r = s
namespace Model
variable {X : Env α} {C : LayerCollection V G} (h : Model X C)
theorem fibrePool_complete (closed : SubstringClosed V) (d : C.Id) (R : List Request)
    (hne : R ≠ []) (valid : ∀ r ∈ R, ValidRequest h r)
    (target : ∀ r ∈ R, r.target = h.encode d) (distinct : SourcesDistinct R) :
    ∃ P ∈ fibrePool X (h.encode d) R,
      Runs V [] [] P ∧ cost P ≤ 2*C.period d.1+(R.map (Request.reserve X)).sum ∧
        (∀ w ∈ ls X (h.encode d), w ∈ P) ∧
        ∀ r ∈ R, ∀ i ∈ r.ids X, ∀ w ∈ ls X i, w ∈ P := by
  classical
  let J := {r // r ∈ R}
  let W : ∀ j : J, RequestAt h d j.val := fun j => (h.requestAt (valid j.val j.property) d (target j.val j.property).symm).some
  let K := Σ j : J, {i // i ∈ j.val.members}
  let I : List K := R.attach.flatMap (fun j => j.val.members.attach.map (fun i => ⟨j,i⟩))
  let H := fun j : J => (W j).hosted
  let req := fun i : K => (W i.1).request i.2
  let Ws := fun j : J => PeriodWord.shift (data X j.val.source).1 (W j).record.offset
  let D' := fun i : K => UpperCode.lookup (book X) (i.1.val.source*stride X+i.2.val)
  have htag : Function.Injective (fun j : J => j.val.source) := by
    intro j k he
    exact Subtype.ext (distinct j.val j.property k.val k.property he)
  have hdiff (j k : J) (hjk : j ≠ k) (c : ℤ) : (H j).text ≠ fun x => (H k).text (x+c) := by
    intro he
    have hn : (W j).source ≠ (W k).source := by
      intro hs
      apply hjk
      apply htag
      exact (W j).source_eq.symm.trans ((congrArg h.group hs).trans (W k).source_eq)
    apply C.different _ _ hn ((W j).record.offset+c-(W k).record.offset)
    funext x
    have hh := congrFun he (x+(W j).record.offset)
    change C.text (W j).source (x+(W j).record.offset-(W j).record.offset) =
      C.text (W k).source (x+(W j).record.offset+c-(W k).record.offset) at hh
    simpa only [add_sub_cancel_right,show x+(W j).record.offset+c-(W k).record.offset =
      x+((W j).record.offset+c-(W k).record.offset) by omega] using hh
  have hWs (j : J) : (Ws j).length = (H j).period := by
    simp only [Ws,PeriodWord.length_shift,← (W j).source_eq]
    exact h.per_eq (W j).source
  have hWst (j : J) : PeriodWord.text (Ws j) = (H j).text := by
    dsimp only [Ws]
    rw [PeriodWord.text_shift (by rw [← (W j).source_eq]; change 0 < per X (h.group (W j).source); rw [h.per_eq]; exact C.positive (W j).source)]
    simp only [← (W j).source_eq,h.text_eq,H,RequestAt.hosted]
  have hiMem (j : J) (i : {i // i ∈ j.val.members}) : (⟨j,i⟩ : K) ∈ I :=
    List.mem_flatMap.mpr ⟨j,List.mem_attach R j,List.mem_map.mpr ⟨i,List.mem_attach _ i,rfl⟩⟩
  have hine : I ≠ [] := by
    obtain ⟨r,hr⟩ := List.exists_mem_of_ne_nil R hne
    let j : J := ⟨r,hr⟩
    obtain ⟨i,hi⟩ := List.exists_mem_of_ne_nil r.members (W j).nonempty
    exact List.ne_nil_of_mem (hiMem j ⟨i,hi⟩)
  obtain ⟨P,hP,hr,hb,hd,hi⟩ := HostCode.completePool_complete closed (C.layerAt d)
    (C.positive d.1) (C.periodic d.1) (C.letters closed d.1) H Sigma.fst req Ws (fun j => j.val.source)
    htag (UpperCode.lookup (book X) (h.encode d)).1 (UpperCode.lookup (book X) (h.encode d)).2
    (h.book_rep d) hWs hWst
    (fun j x => C.letters closed (W j).source (x-(W j).record.offset)) hdiff
    (fun i : K => C.text (W i.1).source) (fun i : K => h.natLayer (W i.1).source i.2.val)
    D' I hine (fun i _ => (W i.1).data_rep i.2) (fun i _ => C.periodic (W i.1).source)
    (fun i _ => (Layer.translate_content _ _).symm)
  have hent : I.map (HostCode.entryOf H Sigma.fst req Ws (fun j => j.val.source)) = entries X R := by
    simp only [I,entries,List.map_flatMap,List.map_map]
    rw [List.flatMap_subtype (g := fun r : Request => r.members.map (Request.entry X r))]
    · simp
    · intro r hr
      rw [List.map_subtype (g := Request.entry X r)]
      · simp
      · intro i hi
        exact ((W ⟨r,hr⟩).entry_eq ⟨i,hi⟩).symm
  have hdata : I.map D' = requestedData X R := by
    simp only [I,requestedData,List.map_flatMap,List.map_map,Request.ids,D',Function.comp_def]
    rw [List.flatMap_subtype (g := fun r : Request => r.members.map
      (fun i => UpperCode.lookup (book X) (r.source*stride X+i)))]
    · simp
    · intro r hr
      simp
  have sum_flatMap_nat {β : Type} (L : List β) (f : β → List ℕ) :
      (L.flatMap f).sum = (L.map (fun x => (f x).sum)).sum := by
    induction L with
    | nil => simp
    | cons a l ih => simp [ih]
  have hsum : (I.map (fun i => (H i.1).period)).sum = (R.map (fun r => r.members.length*per X r.source)).sum := by
    simp only [I,List.map_flatMap,List.map_map,sum_flatMap_nat]
    congr 1
    rw [List.map_subtype (g := fun r : Request => r.members.length*per X r.source)]
    · simp
    · intro r hr
      change (r.members.attach.map (fun _ => C.period (W ⟨r,hr⟩).source)).sum = _
      simp only [List.map_const',List.sum_replicate,List.length_attach,nsmul_eq_mul,Nat.cast_id,
        ← (W ⟨r,hr⟩).source_eq,h.per_eq]
  refine ⟨P,?_,hr,?_,fun w hw => hd w ((h.content_iff d w).mp hw),?_⟩
  · simpa only [fibrePool,hent,hdata] using hP
  · rw [hsum] at hb
    have he : (R.map (Request.reserve X)).sum = 2*(R.map (fun r => r.members.length*per X r.source)).sum := by
      exact List.sum_map_mul_left R (fun r => r.members.length*per X r.source) 2
    rw [he]
    nlinarith
  · intro r hr' i hi' w hw
    obtain ⟨j,hj,rfl⟩ := List.mem_map.mp hi'
    let a : J := ⟨r,hr'⟩
    let b : {j // j ∈ a.val.members} := ⟨j,hj⟩
    apply hi ⟨a,b⟩ (hiMem a b) w
    have hbnd := (W a).bound b.val b.property
    change w ∈ ls X (r.source*stride X+j) at hw
    have he : h.group (W a).source = r.source := (W a).source_eq
    rw [← he,ls_encode X _ _ (h.bound _) (lt_of_lt_of_le hbnd (h.capacity _))] at hw
    exact (mem_content (h.nat_rep (W a).source hbnd) (C.positive (W a).source)
      (C.periodic (W a).source) w).mp hw
end Model
end Superstring.CollectionCode

end OAI