import OAI.Computability.Superstring.SchedulerCode

namespace OAI

namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode UpperCode
variable {α : Type} [Coded α] [Inhabited α] [LinearOrder α]
@[fun_prop] theorem poly_foreign : Poly (fun q : GroupData α × Book α × Param => foreign q.1 q.2.1 q.2.2) := by
  unfold foreign RecordCode.offset
  fun_prop
abbrev ChooseInput (α : Type) := (GroupData α × Book α × List ℕ) × ℕ × ℕ × ℤ
@[fun_prop] theorem poly_choose : Poly (fun q : ChooseInput α =>
    choose q.1.1 q.1.2.1 q.1.2.2 q.2.1 q.2.2.1 q.2.2.2 (foreign q.1.1 q.1.2.1)) := by
  unfold choose
  have hf : Poly (fun q : ChooseInput α =>
      (params q.1.2.1 q.1.2.2 q.1.1.2.length q.2.2.1 q.2.2.2).filter
        (fun v => test q.1.1 q.1.2.1 q.2.1 q.2.2.2 v && foreign q.1.1 q.1.2.1 v)) :=
    BitCode.Poly.filterFn (p := fun q : ChooseInput α × Param =>
      test q.1.1.1 q.1.1.2.1 q.1.2.1 q.1.2.2.2 q.2 && foreign q.1.1.1 q.1.1.2.1 q.2)
      (by fun_prop) (by fun_prop)
  fun_prop
@[fun_prop] theorem poly_hard (hlt : Poly (fun q : α × α => decide (q.1<q.2))) :
    Poly (fun q : Env α × ℕ × ℕ × UpperCode.Param => hard q.1 q.2.1 q.2.2.1 q.2.2.2) := by
  have ph := poly_phase hlt
  unfold hard stride RecordCode.start RecordCode.stop
  exact DistributeCode.poly_record.comp
    (f := fun q : Env α × ℕ × ℕ × UpperCode.Param =>
      ((data q.1 q.2.1,q.2.1,q.2.2.2.2.1,q.2.1*q.1.2),
       (upper (data q.1 q.2.1).2.length q.2.2.1,(data q.1 q.2.1).2.length-q.2.2.2.1,(data q.1 q.2.1).2.length-1),
       (q.2.2.2.2.2.2.1,q.2.2.2.2.2.2.2,phase q.1 q.2.1))) (by fun_prop)
@[fun_prop] theorem poly_hardPlan (hlt : Poly (fun q : α × α => decide (q.1<q.2))) :
    Poly (fun q : Env α × ℕ × ℕ × UpperCode.Param => hardPlan q.1 q.2.1 q.2.2.1 q.2.2.2) := by
  have ph := poly_hard hlt
  unfold hardPlan
  fun_prop
abbrev CompleteInput (α : Type) := Env α × ℕ × ℕ × ℕ × Walk α
@[fun_prop] theorem poly_cond {δ ε : Type} [Coded δ] [Coded ε] {p : δ → Prop} [DecidablePred p]
    {f g : δ → ε} (hp : Poly (fun x => decide (p x))) (hf : Poly f) (hg : Poly g) :
    Poly (fun x => if p x then f x else g x) := by
  simpa only [decide_eq_true_eq] using BitCode.Poly.ite hp hf hg
@[fun_prop] theorem poly_decide_and {δ : Type} [Coded δ] {p q : δ → Prop} [DecidablePred p] [DecidablePred q]
    (hp : Poly (fun x => decide (p x))) (hq : Poly (fun x => decide (q x))) :
    Poly (fun x => decide (p x ∧ q x)) := by
  simpa only [Bool.decide_and,Function.comp_def] using BitCode.Poly.and.comp (hp.pair hq)
def completeRoot (q : CompleteInput α) : Walk α := rootUpper (data q.1 q.2.1)
  (upper (data q.1 q.2.1).2.length q.2.2.1) ((data q.1 q.2.1).2.length-1) (phase q.1 q.2.1)
def completeBand (q : CompleteInput α) : Walk α := attachBand (data q.1 q.2.1)
  (upper (data q.1 q.2.1).2.length q.2.2.1) (q.2.2.1-1) ((data q.1 q.2.1).2.length-1) q.2.2.2.2 (phase q.1 q.2.1)
def completePick (q : CompleteInput α) : UpperCode.Param := choose (data q.1 q.2.1) (book q.1) (ids q.1)
  q.2.2.1 q.2.2.2.1 (phase q.1 q.2.1) (foreign (data q.1 q.2.1) (book q.1))
def completeHard (q : CompleteInput α) : Plan α := hardPlan q.1 q.2.1 q.2.2.1 (completePick q)
def completeM (q : CompleteInput α) : ℕ := (data q.1 q.2.1).2.length
def completeP (q : CompleteInput α) : ℕ := (data q.1 q.2.1).1.length
def completeT (q : CompleteInput α) : ℤ := phase q.1 q.2.1
def completeH (q : CompleteInput α) : ℤ := GeoCode.first (exits (data q.1 q.2.1) (completeM q-1)) (completeT q)
def completeExit (q : CompleteInput α) : ℤ := GeoCode.exit (exits (data q.1 q.2.1) (q.2.2.1-1)) (completeT q)
@[fun_prop] theorem poly_completeRoot (hlt : Poly (fun q : α × α => decide (q.1<q.2))) : Poly (completeRoot (α:=α)) := by
  have ph := poly_phase hlt
  exact poly_rootUpper.comp
    (f := fun q : CompleteInput α => (data q.1 q.2.1,upper (data q.1 q.2.1).2.length q.2.2.1,
      (data q.1 q.2.1).2.length-1,phase q.1 q.2.1)) (by fun_prop)
@[fun_prop] theorem poly_completeBand (hlt : Poly (fun q : α × α => decide (q.1<q.2))) : Poly (completeBand (α:=α)) := by
  have ph := poly_phase hlt
  exact poly_attachBand.comp
    (f := fun q : CompleteInput α => ((data q.1 q.2.1,upper (data q.1 q.2.1).2.length q.2.2.1),
      (q.2.2.1-1,(data q.1 q.2.1).2.length-1),q.2.2.2.2,phase q.1 q.2.1)) (by fun_prop)
@[fun_prop] theorem poly_completePick (hlt : Poly (fun q : α × α => decide (q.1<q.2))) : Poly (completePick (α:=α)) := by
  have ph := poly_phase hlt
  exact poly_choose.comp
    (f := fun q : CompleteInput α => ((data q.1 q.2.1,book q.1,ids q.1),q.2.2.1,q.2.2.2.1,phase q.1 q.2.1)) (by fun_prop)
@[fun_prop] theorem poly_completeHard (hlt : Poly (fun q : α × α => decide (q.1<q.2))) : Poly (completeHard (α:=α)) := by
  have hc := poly_completePick hlt
  exact (poly_hardPlan hlt).comp (f := fun q : CompleteInput α => (q.1,q.2.1,q.2.2.1,completePick q)) (by fun_prop)
omit [Inhabited α] [LinearOrder α] in
@[fun_prop] theorem poly_completeM : Poly (completeM (α:=α)) := by unfold completeM; fun_prop
omit [Inhabited α] [LinearOrder α] in
@[fun_prop] theorem poly_completeP : Poly (completeP (α:=α)) := by unfold completeP; fun_prop
@[fun_prop] theorem poly_completeT (hlt : Poly (fun q : α × α => decide (q.1<q.2))) : Poly (completeT (α:=α)) :=
  (poly_phase hlt).comp (f := fun q : CompleteInput α => (q.1,q.2.1)) (by fun_prop)
@[fun_prop] theorem poly_completeH (hlt : Poly (fun q : α × α => decide (q.1<q.2))) : Poly (completeH (α:=α)) := by
  have ht := poly_completeT hlt
  unfold completeH
  fun_prop
@[fun_prop] theorem poly_completeExit (hlt : Poly (fun q : α × α => decide (q.1<q.2))) : Poly (completeExit (α:=α)) := by
  have ht := poly_completeT hlt
  unfold completeExit
  fun_prop
omit [Inhabited α] [LinearOrder α] in
@[fun_prop] theorem poly_completeTest1 : Poly (fun q : CompleteInput α => decide (completeM q ≤ q.2.2.1)) := by fun_prop
@[fun_prop] theorem poly_completeTest2 (hlt : Poly (fun q : α × α => decide (q.1<q.2))) :
    Poly (fun q : CompleteInput α => decide (completeH q-completeT q ≤ ((completeM q-q.2.2.1)*completeP q : ℕ))) := by
  have hH := poly_completeH hlt
  have ht := poly_completeT hlt
  fun_prop
@[fun_prop] theorem poly_completeTest3 (hlt : Poly (fun q : α × α => decide (q.1<q.2))) :
    Poly (fun q : CompleteInput α => decide (0 < q.2.2.1 ∧
      completeH q-completeExit q ≤ ((completeM q-q.2.2.1)*completeP q : ℕ))) := by
  have hH := poly_completeH hlt
  have he := poly_completeExit hlt
  have h0 : Poly (fun q : CompleteInput α => decide (0 < q.2.2.1)) := by fun_prop
  have hn : Poly (fun q : CompleteInput α => (((completeM q-q.2.2.1)*completeP q : ℕ) : ℤ)) := by fun_prop
  have hs : Poly (fun q : CompleteInput α => completeH q-completeExit q) := BitCode.Poly.subInt.comp (hH.pair he)
  have h1 : Poly (fun q : CompleteInput α => decide (completeH q-completeExit q ≤ ((completeM q-q.2.2.1)*completeP q : ℕ))) :=
    BitCode.Poly.leInt.comp (hs.pair hn)
  exact poly_decide_and h0 h1
@[fun_prop] theorem poly_complete (hlt : Poly (fun q : α × α => decide (q.1<q.2))) :
    Poly (fun q : CompleteInput α => complete q.1 q.2.1 q.2.2.1 q.2.2.2.1 q.2.2.2.2) := by
  have hr := poly_completeRoot hlt
  have hb := poly_completeBand hlt
  have hp := poly_completeHard hlt
  have ha : Poly (fun q : CompleteInput α => (q.2.2.2.2,([] : List (BlockClose.Block α)),([] : List Request))) := by fun_prop
  have hb1 : Poly (fun q : CompleteInput α => (join q.2.2.2.2 (completeRoot q),([] : List (BlockClose.Block α)),([] : List Request))) := by fun_prop
  have hb2 : Poly (fun q : CompleteInput α => (completeBand q,([] : List (BlockClose.Block α)),([] : List Request))) := by fun_prop
  have hb3 : Poly (fun q : CompleteInput α => (join q.2.2.2.2 (completeHard q).1,(completeHard q).2)) := by
    exact (WalkCode.poly_join.comp (BitCode.Poly.pair (by fun_prop) (BitCode.Poly.fst.comp hp))).pair (BitCode.Poly.snd.comp hp)
  exact poly_cond poly_completeTest1 ha (poly_cond (poly_completeTest2 hlt) hb1 (poly_cond (poly_completeTest3 hlt) hb2 hb3))
@[fun_prop] theorem poly_fibre : Poly (fun q : List Request × ℕ => fibre q.1 q.2) := by
  unfold fibre Request.target
  exact BitCode.Poly.filterFn (p := fun q : (List Request × ℕ) × Request => equal q.2.2.1 q.1.2)
    (by fun_prop) (by fun_prop)
omit [Inhabited α] [LinearOrder α] in
@[fun_prop] theorem poly_recipients : Poly (fun q : Env α × ℕ × List Request => recipients q.1 q.2.1 q.2.2) := by
  unfold recipients stride
  exact BitCode.Poly.filterFn (p := fun q : (Env α × ℕ × List Request) × ℕ =>
    !(fibre q.1.2.2 (q.1.2.1*q.1.1.2+q.2)).isEmpty) (by fun_prop) (by fun_prop)
@[fun_prop] theorem poly_incoming : Poly (fun q : (Walk α × Env α) × ℕ × List Request => incoming q.1.1 q.1.2 q.2.1 q.2.2) := by
  unfold incoming stride
  have hm : Poly (fun q : (Walk α × Env α) × ℕ × List Request =>
      (recipients q.1.2 q.2.1 q.2.2).map (fun i => fibreSelect q.1.1 q.1.2 (q.2.1*q.1.2.2+i)
        (fibre q.2.2 (q.2.1*q.1.2.2+i)))) :=
    BitCode.Poly.mapFn (f := fun q : ((Walk α × Env α) × ℕ × List Request) × ℕ =>
      fibreSelect q.1.1.1 q.1.1.2 (q.1.2.1*q.1.1.2.2+q.2) (fibre q.1.2.2 (q.1.2.1*q.1.1.2.2+q.2)))
      (by fun_prop) (by fun_prop)
  fun_prop
@[fun_prop] theorem poly_baseIndex : Poly baseIndex := BitCode.Poly.maxFold
@[fun_prop] theorem poly_holes : Poly holes := by
  unfold holes
  exact BitCode.Poly.filterFn (p := fun q : List ℕ × ℕ => !(member q.2 q.1)) (by fun_prop) (by fun_prop)
@[fun_prop] theorem poly_prepare : Poly (fun q : (Walk α × Env α) × ℕ × List Request => prepare q.1.1 q.1.2 q.2.1 q.2.2) := by
  let J := fun q : (Walk α × Env α) × ℕ × List Request => recipients q.1.2 q.2.1 q.2.2
  let r := fun q : (Walk α × Env α) × ℕ × List Request =>
    (fibre q.2.2 (q.2.1*stride q.1.2+baseIndex (J q))).headD (default : Request)
  have hr : Poly r := by unfold r J stride; fun_prop
  have hb : Poly (fun q : (Walk α × Env α) × ℕ × List Request =>
      below (data q.1.2 q.2.1) (holes (J q)) (incoming q.1.1 q.1.2 q.2.1 q.2.2)
        (RecordCode.start (r q).code+RecordCode.offset (r q).code)
        (RecordCode.stop (r q).code+RecordCode.offset (r q).code)) :=
    poly_below.comp (f := fun q : (Walk α × Env α) × ℕ × List Request =>
      ((data q.1.2 q.2.1,holes (J q)),incoming q.1.1 q.1.2 q.2.1 q.2.2,
       RecordCode.start (r q).code+RecordCode.offset (r q).code,
       RecordCode.stop (r q).code+RecordCode.offset (r q).code))
      (by unfold RecordCode.start RecordCode.stop RecordCode.offset Request.code; unfold J; fun_prop)
  unfold prepare
  dsimp only
  fun_prop
abbrev ProcessInput (α : Type) := (Walk α × Env α) × ℕ × ℕ × List Request
@[fun_prop] theorem poly_process (hlt : Poly (fun q : α × α => decide (q.1<q.2))) :
    Poly (fun q : ProcessInput α => process q.1.1 q.1.2 q.2.1 q.2.2.1 q.2.2.2) := by
  have hc := poly_complete hlt
  unfold process
  exact hc.comp (f := fun q : ProcessInput α =>
    (q.1.2,q.2.1,(prepare q.1.1 q.1.2 q.2.1 q.2.2.2).1,q.2.2.1,(prepare q.1.1 q.1.2 q.2.1 q.2.2.2).2)) (by
    have hp := poly_prepare.comp (f := fun q : ProcessInput α => (q.1,q.2.1,q.2.2.2)) (by fun_prop)
    exact (by fun_prop))
end Superstring.CollectionCode


namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode BlockClose
variable {α G : Type} [Inhabited α] [LinearOrder α] {V : Set (List α)}

theorem complete_extras (X : Env α) (g cut M : ℕ) (P Q : Walk α) :
    (complete X g cut M P).2 = (complete X g cut M Q).2 := by
  unfold complete
  dsimp only
  split <;> first | rfl | (split <;> first | rfl | (split <;> rfl))

variable [Coded α]
def extraSizes (X : Env α) (M : ℕ) : List ℕ :=
  (gs X).flatMap (fun g => (List.range ((data X g).2.length+1)).map
    (fun cut => bitSize (complete X g cut M [[]]).2))
def maxExtras (X : Env α) (M : ℕ) : ℕ := (extraSizes X M).foldl max 0

theorem extras_le (X : Env α) (M g cut : ℕ) (hg : g ∈ gs X) (hc : cut ≤ (data X g).2.length) (P : Walk α) :
    bitSize (complete X g cut M P).2 ≤ maxExtras X M := by
  rw [complete_extras X g cut M P [[]]]
  exact le_maxFold _ 0 (List.mem_flatMap.mpr ⟨g,hg,List.mem_map.mpr ⟨cut,List.mem_range.mpr (by omega),rfl⟩⟩)

namespace Model
variable {X : Env α} (vs : Walk α) {C : LayerCollection {w | w ∈ vs} G} (h : Model X C)
theorem process_extra_bound (closed : SubstringClosed {w | w ∈ vs})
    (g : G) (R : List Request) (M : ℕ)
    (valid : ∀ r ∈ R, ValidRequest h r)
    (targets : ∀ r ∈ R, ∃ i : Fin (C.size g), r.target=h.encode ⟨g,i⟩)
    (distinct : SourcesDistinct R) :
    bitSize (process vs X (h.group g) M R).2 ≤ maxExtras X M := by
  have hc := (h.prepare_spec vs closed g R valid targets distinct).1
  unfold process
  apply extras_le
  · exact (h.groups _).mpr ⟨g,rfl⟩
  · rwa [h.size]

theorem advance_extra_bound (closed : SubstringClosed {w | w ∈ vs})
    (M : ℕ) (s : State α) (hs : Invariant h s) :
    bitSize (advance vs X M s).2.2 ≤ bitSize s.2.2+maxExtras X M := by
  by_cases hn : s.1=[]
  · simp only [advance,hn,List.isEmpty_nil,↓reduceIte]
    omega
  · let j := pick X s.1
    have hj := (pick_spec X s.1 hn).1
    obtain ⟨g,hg⟩ := (h.groups j).mp (hs.todo.subset hj)
    let R := inRequests X j s.2.2.2
    have hr : ∀ r ∈ R, ValidRequest h r := fun r hr => hs.good.2.2 r ((mem_inRequests ..).mp hr).1
    have htar : ∀ r ∈ R, ∃ i : Fin (C.size g), r.target=h.encode ⟨g,i⟩ := by
      intro r hr'
      obtain ⟨w⟩ := hr r hr'
      have he : h.group w.target.1=h.group g := by
        rw [← h.owner_eq w.target,w.target_eq,hg]
        exact ((mem_inRequests ..).mp hr').2
      have heg := h.group_inj he
      cases hwt : w.target with
      | mk d i =>
        have hdg : d=g := by simpa only [hwt] using heg
        subst d
        exact ⟨i,by rw [← w.target_eq,hwt]⟩
    have hd : SourcesDistinct R := fun r hr u hu he => hs.distinct r ((mem_inRequests ..).mp hr).1 u ((mem_inRequests ..).mp hu).1 he
    have he := h.process_extra_bound vs closed g R M hr htar hd
    rw [hg] at he
    have hB := bitSize_append s.2.2.1 (process vs X j M R).2.1
    have hR := bitSize_append (restRequests X j s.2.2.2) (process vs X j M R).2.2
    have hsR := bitSize_sublist (List.filter_sublist (p := fun r => !(equal (owner X r.target) j)) (l := s.2.2.2))
    change bitSize (restRequests X j s.2.2.2) ≤ bitSize s.2.2.2 at hsR
    have hp := bitSize_prod (process vs X j M R).2.1 (process vs X j M R).2.2
    have hs := bitSize_prod s.2.2.1 s.2.2.2
    simp only [Prod.eta] at hp hs
    simp only [advance,List.isEmpty_iff,hn,↓reduceIte,bitSize_prod]
    change bitSize (s.2.2.1++(process vs X j M R).2.1)+
      bitSize (restRequests X j s.2.2.2++(process vs X j M R).2.2)≤_
    omega
end Model
end Superstring.CollectionCode


namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode BlockClose
variable {α G : Type} [Inhabited α] [LinearOrder α] {V : Set (List α)}
def initial (X : Env α) : State α := (gs X,[[]],[],[])
theorem advance_nil (vs : Walk α) (X : Env α) (M : ℕ) (P : Plan α) : advance vs X M ([],P)=([],P) := by
  simp only [advance,List.isEmpty_nil,↓reduceIte]
namespace Model
variable {X : Env α} (vs : Walk α) {C : LayerCollection {w | w ∈ vs} G} (h : Model X C)
theorem initial_invariant (nil_mem : ([] : List α) ∈ vs) : Invariant h (initial X) := by
  refine { todo := List.Sublist.refl _, good := ?_, upward := ?_, targets := ?_, sources := ?_, distinct := ?_, ready := ?_ }
  · exact ⟨⟨valid_nil [] nil_mem,rfl,rfl⟩,by simp [initial],by simp [initial]⟩
  · intro g hg j hj _; exact hj
  · simp [initial]
  · simp [initial]
  · intro r hr; cases hr
  · intro i; exact Or.inl ((h.groups _).mpr ⟨i.1,rfl⟩)

variable [Coded α]
theorem iterate_advance (closed : SubstringClosed {w | w ∈ vs}) (supply : C.RecordSupply)
    (M : ℕ) (len : ∀ w ∈ vs, w.length ≤ M) (s : State α) (hs : Invariant h s) (n : ℕ) :
    let t := (advance vs X M)^[n] s
    Invariant h t ∧ budget X t ≤ budget X s ∧ t.1.length ≤ s.1.length-n ∧
      bitSize t.2.2 ≤ bitSize s.2.2+n*maxExtras X M := by
  dsimp only
  induction n with
  | zero => exact ⟨hs,le_rfl,by simp,by simp⟩
  | succ n ih =>
    rw [Function.iterate_succ_apply']
    let t := (advance vs X M)^[n] s
    change Invariant h t ∧ budget X t ≤ budget X s ∧ t.1.length ≤ s.1.length-n ∧
      bitSize t.2.2 ≤ bitSize s.2.2+n*maxExtras X M at ih
    change Invariant h (advance vs X M t) ∧ budget X (advance vs X M t) ≤ budget X s ∧
      (advance vs X M t).1.length ≤ s.1.length-(n+1) ∧
      bitSize (advance vs X M t).2.2 ≤ bitSize s.2.2+(n+1)*maxExtras X M
    by_cases hn : t.1=[]
    · have ht : advance vs X M t=t := by rw [← Prod.eta t,hn,advance_nil]
      rw [ht]
      refine ⟨ih.1,ih.2.1,by simp [hn],?_⟩
      have hh := ih.2.2.2
      rw [Nat.succ_mul]
      omega
    · have hh := h.advance_spec vs closed supply M len t ih.1 hn
      have he := h.advance_extra_bound vs closed M t ih.1
      refine ⟨hh.1,hh.2.1.trans ih.2.1,?_,?_⟩
      · have h1 := hh.2.2; have h2 := ih.2.2.1; change (advance vs X M t).1.length ≤ _; omega
      · have h1 := ih.2.2.2; rw [Nat.succ_mul]; omega
end Model
end Superstring.CollectionCode

end OAI