lean/OAI/Computability/Superstring/SchedulerCode.lean

import OAI.Computability.Superstring.FibreSelect

namespace OAI

namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode BlockClose
variable {α G : Type} [Inhabited α] [LinearOrder α] {V : Set (List α)}
def pick (X : Env α) (I : List ℕ) : ℕ := firstGood I (fun g => I.all (fun j => lessEq (per X g) (per X j)))
def without (I : List ℕ) (g : ℕ) : List ℕ := I.filter (fun i => !(equal i g))
def inRequests (X : Env α) (g : ℕ) (R : List Request) : List Request := R.filter (fun r => equal (owner X r.target) g)
def restRequests (X : Env α) (g : ℕ) (R : List Request) : List Request := R.filter (fun r => !(equal (owner X r.target) g))
def charge (X : Env α) (g : ℕ) : ℕ := 2*((data X g).2.length*per X g)
abbrev State (α : Type) := List ℕ × Plan α
def advance (vs : Walk α) (X : Env α) (M : ℕ) (s : State α) : State α :=
  if s.1.isEmpty then s else
  let g := pick X s.1
  let o := process vs X g M (inRequests X g s.2.2.2)
  (without s.1 g,join s.2.1 o.1,s.2.2.1++o.2.1,restRequests X g s.2.2.2++o.2.2)

omit [Inhabited α] [LinearOrder α] in
theorem pick_spec (X : Env α) (I : List ℕ) (hn : I ≠ []) :
    pick X I ∈ I ∧ ∀ j ∈ I, per X (pick X I) ≤ per X j := by
  have hne : I.toFinset.Nonempty := by
    obtain ⟨i,hi⟩ := List.exists_mem_of_ne_nil _ hn
    exact ⟨i,List.mem_toFinset.mpr hi⟩
  obtain ⟨i,hi,hmin⟩ := Finset.exists_min_image I.toFinset (per X) hne
  have hh := firstGood_mem I (fun g => I.all (fun j => lessEq (per X g) (per X j)))
    ⟨i,List.mem_toFinset.mp hi,List.all_eq_true.mpr (fun j hj => by
      simpa only [lessEq,decide_eq_true_eq] using hmin j (List.mem_toFinset.mpr hj))⟩
  exact ⟨hh.1,fun j hj => of_decide_eq_true (List.all_eq_true.mp hh.2 j hj)⟩
omit [Inhabited α] [LinearOrder α] in
@[simp] theorem mem_without (I : List ℕ) (g i : ℕ) : i ∈ without I g ↔ i ∈ I ∧ i ≠ g := by simp [without,equal]
omit [Inhabited α] [LinearOrder α] in
theorem without_lt (I : List ℕ) (g : ℕ) (hg : g ∈ I) : (without I g).length < I.length := by
  exact List.length_filter_lt_length_iff_exists.mpr ⟨g,hg,by simp [equal]⟩
omit [Inhabited α] [LinearOrder α] in
@[simp] theorem mem_inRequests (X : Env α) (g : ℕ) (R : List Request) (r : Request) :
    r ∈ inRequests X g R ↔ r ∈ R ∧ owner X r.target=g := by simp [inRequests,equal]
omit [Inhabited α] [LinearOrder α] in
@[simp] theorem mem_restRequests (X : Env α) (g : ℕ) (R : List Request) (r : Request) :
    r ∈ restRequests X g R ↔ r ∈ R ∧ owner X r.target≠g := by simp [restRequests,equal]
omit [Inhabited α] [LinearOrder α] in
theorem sum_partition {δ : Type} (R : List δ) (p : δ → Bool) (f : δ → ℕ) :
    ((R.filter p).map f).sum+((R.filter (fun r => !(p r))).map f).sum=(R.map f).sum := by
  induction R with
  | nil => simp
  | cons r R ih => cases hp : p r <;> simp only [List.filter_cons,hp,Bool.not_false,Bool.not_true,
      Bool.false_eq_true,↓reduceIte,List.map_cons,List.sum_cons] <;> omega
omit [Inhabited α] [LinearOrder α] in
theorem charge_remove (X : Env α) (I : List ℕ) (hn : I.Nodup) (g : ℕ) (hg : g ∈ I) :
    charge X g+((without I g).map (charge X)).sum=(I.map (charge X)).sum := by
  induction I with
  | nil => simp at hg
  | cons a I ih =>
    obtain ⟨ha,hn⟩ := List.nodup_cons.mp hn
    rcases List.mem_cons.mp hg with rfl|hg
    · have he : without I g = I := by
        apply List.filter_eq_self.mpr
        intro j hj
        simpa only [Bool.not_eq_true',equal,decide_eq_false_iff_not] using (show j ≠ g from fun he => ha (he ▸ hj))
      simp only [without,List.filter_cons,equal,decide_true,Bool.not_true,Bool.false_eq_true,↓reduceIte]
      change charge X g+((without I g).map (charge X)).sum=_
      rw [he,List.map_cons,List.sum_cons]
    · have hag : a ≠ g := fun he => ha (he ▸ hg)
      have hh := ih hn hg
      simp only [without,List.filter_cons,equal,decide_eq_false hag,Bool.not_false,↓reduceIte,
        List.map_cons,List.sum_cons]
      change charge X g+(charge X a+((without I g).map (charge X)).sum)=_
      omega

end Superstring.CollectionCode


namespace Superstring.CollectionCode
open BitCode Hierarchical LayerArray WalkCode BlockClose
variable {α G : Type} [Inhabited α] [LinearOrder α] {V : Set (List α)}
structure Invariant {X : Env α} {C : LayerCollection V G} (h : Model X C) (s : State α) : Prop where
  todo : s.1.Sublist (gs X)
  good : GoodPlan h s.2
  upward : ∀ g ∈ s.1, ∀ j ∈ gs X, per X g < per X j → j ∈ s.1
  targets : ∀ r ∈ s.2.2.2, owner X r.target ∈ s.1
  sources : ∀ r ∈ s.2.2.2, r.source ∉ s.1
  distinct : SourcesDistinct s.2.2.2
  ready : ∀ i : C.Id, h.group i.1 ∈ s.1 ∨ Covered X s.2 (h.encode i)

def budget (X : Env α) (s : State α) := planBudget X s.2+(s.1.map (charge X)).sum

omit [Inhabited α] [LinearOrder α] in
theorem length_one_same {δ : Type} {L : List δ} (hh : L.length ≤ 1) {a b : δ} (ha : a ∈ L) (hb : b ∈ L) : a=b := by
  cases L with
  | nil => cases ha
  | cons c L =>
    have he : L=[] := by apply List.length_eq_zero_iff.mp; simp only [List.length_cons] at hh; omega
    subst L
    exact (List.mem_singleton.mp ha).trans (List.mem_singleton.mp hb).symm

namespace Model
variable {X : Env α} (vs : Walk α) {C : LayerCollection {w | w ∈ vs} G} (h : Model X C)
theorem advance_spec (closed : SubstringClosed {w | w ∈ vs}) (supply : C.RecordSupply)
    (M : ℕ) (len : ∀ w ∈ vs, w.length ≤ M) (s : State α) (hs : Invariant h s) (hn : s.1 ≠ []) :
    Invariant h (advance vs X M s) ∧ budget X (advance vs X M s) ≤ budget X s ∧
      (advance vs X M s).1.length < s.1.length := by
  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
  let T := restRequests X j s.2.2.2
  let o := process vs X j M R
  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 s hs' he => hs.distinct r ((mem_inRequests ..).mp hr).1 s ((mem_inRequests ..).mp hs').1 he
  have hh := h.process_spec vs closed supply M len g R hr htar hd
  rw [hg] at hh
  change GoodPlan h o ∧ _ at hh
  obtain ⟨ho,hcost,hcover,hfulfilled,hsource,hsmall⟩ := hh
  let t : State α := (without s.1 j,join s.2.1 o.1,s.2.2.1++o.2.1,T++o.2.2)
  have he : advance vs X M s = t := by simp only [advance,List.isEmpty_iff,hn,↓reduceIte,t,j,R,T,o]
  rw [he]
  have hmemold : ∀ w ∈ s.2.1, w ∈ t.2.1 := fun w hw => (mem_join hs.good.1.2.2 ho.1.2.1).mpr (Or.inl hw)
  have hmemnew : ∀ w ∈ o.1, w ∈ t.2.1 := fun w hw => (mem_join hs.good.1.2.2 ho.1.2.1).mpr (Or.inr hw)
  have hcovnew (i : ℕ) (hi : Covered X o i) : Covered X t.2 i := by
    rcases hi with hv|⟨b,hb,hi⟩|⟨r,hr,hi⟩
    · exact Or.inl (fun w hw => hmemnew w (hv w hw))
    · exact Or.inr (Or.inl ⟨b,List.mem_append_right _ hb,hi⟩)
    · exact Or.inr (Or.inr ⟨r,List.mem_append_right _ hr,hi⟩)
  have hcovold (i : ℕ) (hi : Covered X s.2 i) : Covered X t.2 i := by
    rcases hi with hv|⟨b,hb,hi⟩|⟨r,hr,hi⟩
    · exact Or.inl (fun w hw => hmemold w (hv w hw))
    · exact Or.inr (Or.inl ⟨b,List.mem_append_left _ hb,hi⟩)
    · by_cases ht : owner X r.target=j
      · exact Or.inl (fun w hw => hmemnew w (hfulfilled r ((mem_inRequests ..).mpr ⟨hr,ht⟩) i hi w hw))
      · exact Or.inr (Or.inr ⟨r,List.mem_append_left _ ((mem_restRequests ..).mpr ⟨hr,ht⟩),hi⟩)
  have hnewtarget (r : Request) (hr : r ∈ o.2.2) : owner X r.target ∈ without s.1 j := by
    obtain ⟨w⟩ := ho.2.2 r hr
    have hl := w.later
    rw [hsource r hr] at hl
    have ht : owner X r.target ∈ gs X := by
      rw [← w.target_eq,h.owner_eq]
      exact (h.groups _).mpr ⟨w.target.1,rfl⟩
    exact (mem_without ..).mpr ⟨hs.upward j hj _ ht hl,fun he => (lt_irrefl _ (he ▸ hl))⟩
  refine ⟨?_,?_,without_lt s.1 j hj⟩
  · refine ⟨(List.filter_sublist).trans hs.todo,?_,?_,?_,?_,?_,?_⟩
    · refine ⟨runs_join hs.good.1 ho.1,?_,?_⟩
      · intro b hb
        rcases List.mem_append.mp hb with hb|hb
        · exact hs.good.2.1 b hb
        · exact ho.2.1 b hb
      · intro r hr
        rcases List.mem_append.mp hr with hr|hr
        · exact hs.good.2.2 r ((mem_restRequests ..).mp hr).1
        · exact ho.2.2 r hr
    · intro a ha b hb hab
      obtain ⟨ha,haj⟩ := (mem_without ..).mp ha
      refine (mem_without ..).mpr ⟨hs.upward a ha b hb hab,?_⟩
      intro he
      subst b
      have hh := (pick_spec X s.1 hn).2 a ha
      change per X j ≤ per X a at hh
      omega
    · intro r hr
      rcases List.mem_append.mp hr with hr|hr
      · obtain ⟨hr,ht⟩ := (mem_restRequests ..).mp hr
        exact (mem_without ..).mpr ⟨hs.targets r hr,ht⟩
      · exact hnewtarget r hr
    · intro r hr hh
      rcases List.mem_append.mp hr with hr|hr
      · exact hs.sources r ((mem_restRequests ..).mp hr).1 ((mem_without ..).mp hh).1
      · exact ((mem_without ..).mp hh).2 (hsource r hr)
    · intro r hr u hu he
      rcases List.mem_append.mp hr with hr|hr <;> rcases List.mem_append.mp hu with hu|hu
      · exact hs.distinct r ((mem_restRequests ..).mp hr).1 u ((mem_restRequests ..).mp hu).1 he
      · exact False.elim (hs.sources r ((mem_restRequests ..).mp hr).1 ((he.trans (hsource u hu)).symm ▸ hj))
      · exact False.elim (hs.sources u ((mem_restRequests ..).mp hu).1 ((he.symm.trans (hsource r hr)).symm ▸ hj))
      · exact length_one_same hsmall hr hu
    · intro i
      rcases hs.ready i with hi|hi
      · by_cases hij : h.group i.1=j
        · have heg : i.1=g := h.group_inj (hij.trans hg.symm)
          obtain ⟨a,k⟩ := i
          change a=g at heg
          subst a
          exact Or.inr (hcovnew _ (hcover k))
        · exact Or.inl ((mem_without ..).mpr ⟨hi,hij⟩)
      · exact Or.inr (hcovold _ hi)
  · have hc := cost_join s.2.1 o.1 [] hs.good.1.2.2 ho.1.2.1
    have hp := sum_partition s.2.2.2 (fun r => equal (owner X r.target) j) (Request.reserve X)
    have hrm := charge_remove X s.1 (h.nodup.sublist hs.todo) j hj
    have hcharge : charge X j = 2*(C.size g*C.period g) := by rw [← hg]; simp only [charge,h.size,h.per_eq]
    simp only [budget,planBudget,t,List.map_append,List.sum_append]
    rw [hc]
    change (R.map (Request.reserve X)).sum+(T.map (Request.reserve X)).sum=(s.2.2.2.map (Request.reserve X)).sum at hp
    unfold planBudget at hcost
    rw [hcharge] at hrm
    dsimp only [o] at hc ⊢
    omega
end Model
end Superstring.CollectionCode

end OAI