lean/OAI/Computability/Scheduling/SchedulingAlgorithm.lean

import OAI.Computability.Scheduling.DynamicProgram

namespace OAI

section

namespace ThreeMachine.Algorithm
section Closure
variable {n : ℕ}

def closureStep (E R : Finset (Fin n × Fin n)) : Finset (Fin n × Fin n) :=
  R ∪ Finset.univ.filter (fun p => ∃ v : Fin n, (p.1,v) ∈ R ∧ (v,p.2) ∈ E)

def closureTable (G : Instance n) (k : ℕ) : Finset (Fin n × Fin n) :=
  (closureStep G.edges.toFinset)^[k] G.edges.toFinset

def reachable (G : Instance n) (x y : Fin n) : Prop := (x,y) ∈ closureTable G n

instance (G : Instance n) : DecidableRel (reachable G) := fun x y =>
  inferInstanceAs (Decidable ((x,y) ∈ closureTable G n))

@[simp] theorem closureTable_zero (G : Instance n) : closureTable G 0 = G.edges.toFinset := rfl
@[simp] theorem closureTable_succ (G : Instance n) (k : ℕ) :
    closureTable G (k+1) = closureStep G.edges.toFinset (closureTable G k) :=
  Function.iterate_succ_apply' _ _ _

theorem closureStep_mono (E R : Finset (Fin n × Fin n)) : R ⊆ closureStep E R :=
  Finset.subset_union_left

theorem closureTable_mono (G : Instance n) {k l : ℕ} (h : k ≤ l) :
    closureTable G k ⊆ closureTable G l := by
  obtain ⟨d,rfl⟩ := Nat.exists_eq_add_of_le h
  clear h
  induction d with
  | zero => exact Finset.Subset.refl _
  | succ d ih =>
    change closureTable G k ⊆ closureTable G ((k+d)+1)
    rw [closureTable_succ]
    exact ih.trans (closureStep_mono G.edges.toFinset (closureTable G (k+d)))

theorem closureTable_sound (G : Instance n) (k : ℕ) {x y : Fin n}
    (h : (x,y) ∈ closureTable G k) : G.order x y := by
  induction k generalizing x y with
  | zero => exact .single (by simpa [Instance.edge] using h)
  | succ k ih =>
    rw [closureTable_succ, closureStep, Finset.mem_union] at h
    rcases h with h | h
    · exact ih h
    · obtain ⟨v,hv,he⟩ := (Finset.mem_filter.mp h).2
      exact (ih hv).tail (by simpa [Instance.edge] using he)

theorem walk_closure (G : Instance n) {k : ℕ} {x y : Fin n}
    (h : Walk G.edge (k+1) x y) : (x,y) ∈ closureTable G k := by
  generalize he : k+1 = l at h
  induction h generalizing k with
  | refl => omega
  | @tail m x y z hp hz ih =>
    cases k with
    | zero =>
      have hm : m = 0 := by omega
      subst m
      cases hp
      simpa [Instance.edge] using hz
    | succ k =>
      have hm : k+1 = m := by omega
      have hh := ih hm
      rw [closureTable_succ, closureStep]
      apply Finset.mem_union_right
      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,y,hh,by simpa [Instance.edge] using hz⟩

theorem transGen_walk (G : Instance n) {x y : Fin n} (h : G.order x y) :
    ∃ k, Walk G.edge (k+1) x y := by
  induction h with
  | single he => exact ⟨0,.tail (.refl _) he⟩
  | tail _ he ih => obtain ⟨k,hk⟩ := ih; exact ⟨k+1,.tail hk he⟩

theorem reachable_iff (G : Instance n) (hG : G.acyclic) (x y : Fin n) :
    reachable G x y ↔ G.order x y := by
  classical
  constructor
  · exact closureTable_sound G n
  · intro h
    obtain ⟨k,hk⟩ := transGen_walk G h
    have hr : ∀ a b, G.edge a b → Structure.jobRank G.order a < Structure.jobRank G.order b :=
      fun _ _ he => Structure.jobRank_strict G.order hG
        (fun {_ _ _} h₁ h₂ => h₁.trans h₂) (.single he)
    have hb := hk.rank_bound hr
    have hy := Structure.jobRank_bounds G.order y
    apply closureTable_mono G (show k ≤ n by omega)
    exact walk_closure G hk

end Closure
end ThreeMachine.Algorithm

namespace ThreeMachine.Structure
section EffectiveFamily
variable {J : Type} [Fintype J] [DecidableEq J]

def Atomic.finsetEval (r : J → J → Prop) [DecidableRel r]
    (rank reverseRank : J → ℕ) : Atomic J → Finset J
  | .constant b => if b then Finset.univ else ∅
  | .threshold frame upper k =>
    let ρ := if frame then reverseRank else rank
    Finset.univ.filter (fun x => if upper then ρ x ≤ k.val else k.val ≤ ρ x)
  | .cone frame kind Z =>
    let R := fun x y => if frame then r y x else r x y
    letI : DecidableRel R := fun x y => inferInstanceAs (Decidable (if frame then r y x else r x y))
    match kind.val with
    | 0 => Z.val
    | 1 => Finset.univ.filter (fun x => ∃ y ∈ Z.val, R x y)
    | 2 => Finset.univ.filter (fun x => ∃ y ∈ Z.val, R y x)
    | 3 => (Finset.univ.filter (fun x => ∃ y ∈ Z.val, R x y)) ∪ Z.val
    | _ => (Finset.univ.filter (fun x => ∃ y ∈ Z.val, R y x)) ∪ Z.val

theorem Atomic.coe_finsetEval (r : J → J → Prop) [DecidableRel r]
    (rank reverseRank : J → ℕ) (a : Atomic J) :
    (finsetEval r rank reverseRank a : Set J) = eval r rank reverseRank a := by
  cases a with
  | constant b => cases b <;> simp [finsetEval,eval]
  | threshold frame upper k =>
    cases frame <;> cases upper <;> ext x <;> simp [finsetEval,eval]
  | cone frame kind Z =>
    fin_cases kind <;> cases frame <;> ext x <;>
      simp [finsetEval,eval,Boundary.pred,Boundary.desc,Boundary.weakPred,Boundary.weakDesc]

instance Atomic.decideEval (r : J → J → Prop) [DecidableRel r]
    (rank reverseRank : J → ℕ) (a : Atomic J) : DecidablePred (eval r rank reverseRank a) :=
  fun x => decidable_of_iff (x ∈ finsetEval r rank reverseRank a) (by
    change x ∈ (finsetEval r rank reverseRank a : Set J) ↔ _
    rw [coe_finsetEval]
    rfl)

def Formula.evalFinset {A : Type} (atoms : A → Finset J) : Formula A → Finset J
  | .leaf a b => if b then (atoms a)ᶜ else atoms a
  | .conj p q => p.evalFinset atoms ∩ q.evalFinset atoms
  | .disj p q => p.evalFinset atoms ∪ q.evalFinset atoms

theorem Formula.coe_evalFinset {A : Type} (atoms : A → Finset J) (p : Formula A) :
    (p.evalFinset atoms : Set J) = p.eval (fun a => (atoms a : Set J)) := by
  induction p with
  | leaf a b => cases b <;> simp [evalFinset, eval]
  | conj p q ihp ihq | disj p q ihp ihq => simp [evalFinset, eval, ihp, ihq]

def effectiveFamily (r : J → J → Prop) [DecidableRel r]
    (rank reverseRank : J → ℕ) (jobs : List J) (K : ℕ) : List (Finset J) :=
  (assignments (Atomic.alphabet jobs) K).flatMap (fun f =>
    (Formula.templates K).map (fun s =>
      (s.map f).evalFinset (fun a => Finset.univ.filter (Atomic.eval r rank reverseRank a))))

open scoped Classical in
theorem effectiveFamily_complete (r : J → J → Prop) [DecidableRel r]
    (rank reverseRank : J → ℕ) (jobs : List J) (hjobs : ∀ x, x ∈ jobs)
    (K : ℕ) (W : Set J) (hW : Described (Atomic.eval r rank reverseRank) W K) :
    W.toFinset ∈ effectiveFamily r rank reverseRank jobs K := by
  classical
  obtain ⟨p,hp,hpk⟩ := hW
  obtain ⟨s,f,hs,he⟩ := Formula.template_representation p hpk
  apply List.mem_flatMap.mpr
  refine ⟨f,mem_assignments _ (Atomic.mem_alphabet jobs hjobs) K f,
    List.mem_map.mpr ⟨s,hs,?_⟩⟩
  apply Finset.coe_injective
  rw [Formula.coe_evalFinset,he]
  have ha : (fun a => (↑(Finset.univ.filter (Atomic.eval r rank reverseRank a)) : Set J)) =
      Atomic.eval r rank reverseRank := by
    funext a; ext x
    exact Finset.mem_filter.trans (and_iff_right (Finset.mem_univ x))
  rw [ha,hp]
  simp

theorem effectiveFamily_length (r : J → J → Prop) [DecidableRel r]
    (rank reverseRank : J → ℕ) (jobs : List J) (K : ℕ) :
    (effectiveFamily r rank reverseRank jobs K).length =
      (Atomic.alphabet jobs).length^K * (Formula.templates K).length := by
  simp [effectiveFamily,List.length_flatMap,assignments_length]

end EffectiveFamily
end ThreeMachine.Structure

namespace ThreeMachine
instance {n m : ℕ} (r : Fin n → Fin n → Prop) [DecidableRel r] :
    DecidableRel (paddedOrder r m) := fun x y =>
  inferInstanceAs (Decidable (∃ a b : Fin n, x.val = a.val ∧ y.val = b.val ∧ r a b))
end ThreeMachine

namespace ThreeMachine.Algorithm
open Structure

def fullSolve {m : ℕ} (r : Fin m → Fin m → Prop) [DecidableRel r] : Option (Block (Fin m)) :=
  lookup (layers r
    (effectiveFamily r (jobRank r) (reverseJobRank r) (List.finRange m) 10000)
    ((tripleList (List.finRange m)).map Subtype.val) m) Finset.univ

theorem fullSolve_sound {m : ℕ} (r : Fin m → Fin m → Prop) [DecidableRel r]
    {s : Block (Fin m)} (hs : fullSolve r = some s) : s.Valid r Finset.univ :=
  layers_good r _ _ m _ _ (lookup_mem hs)

theorem fullSolve_complete {m : ℕ} (r : Fin m → Fin m → Prop) [DecidableRel r]
    (hirr : ∀ x, ¬r x x) (htrans : ∀ ⦃x y z⦄, r x y → r y z → r x z)
    (h : ∃ p : Layout (Fin m), p.Full r) : ∃ s, fullSolve r = some s := by
  classical
  have ha := (accepted_iff_full_layout r (jobRank r) (reverseJobRank r) htrans
    (fun x => by simpa using (jobRank_bounds r x).2)
    (fun x => by simpa using (reverseJobRank_bounds r x).2)
    (jobRank_injective r) (reverseJobRank_injective r)
    (fun _ _ hxy => jobRank_strict r hirr htrans hxy)
    (fun _ _ hxy => reverseJobRank_strict r hirr htrans hxy)).mpr h
  have hh := layers_complete r (Atomic.eval r (jobRank r) (reverseJobRank r))
    (effectiveFamily r (jobRank r) (reverseJobRank r) (List.finRange m) 10000)
    ((tripleList (List.finRange m)).map Subtype.val)
    (fun F hF => effectiveFamily_complete r _ _ _ (fun _ => List.mem_finRange _) 10000 F hF)
    (fun Z => List.mem_map.mpr ⟨Z,mem_tripleList _ (fun _ => List.mem_finRange _) Z,rfl⟩) m
    (by simpa only [Fintype.card_fin] using ha)
  simpa only [Set.toFinset_univ,fullSolve,Has] using hh

theorem reachable_trans {n : ℕ} (G : Instance n) (hG : G.acyclic) :
    ∀ ⦃x y z⦄, reachable G x y → reachable G y z → reachable G x z := by
  intro x y z hxy hyz
  exact (reachable_iff G hG x z).mpr
    (((reachable_iff G hG x y).mp hxy).trans ((reachable_iff G hG y z).mp hyz))

theorem reachable_irrefl {n : ℕ} (G : Instance n) (hG : G.acyclic) :
    ∀ x, ¬reachable G x x := fun x hx => hG x ((reachable_iff G hG x x).mp hx)

def scheduleAt {n : ℕ} (G : Instance n) (T : ℕ) : Option (Fin n → ℕ) :=
  if hn : n ≤ 3*T then
    (fullSolve (paddedOrder (reachable G) (3*T))).map
      (fun s x => s.time (Fin.castLE hn x))
  else none

theorem Block.restrict_feasible {n T : ℕ} (G : Instance n) (hG : G.acyclic) (hn : n ≤ 3*T)
    {s : Block (Fin (3*T))} (hs : s.Valid (paddedOrder (reachable G) (3*T)) Finset.univ) :
    Feasible G T (fun x => s.time (Fin.castLE hn x)) := by
  obtain ⟨b,hbl,hbt⟩ := hs
  have hbT : b.length = T := by
    have hc := b.size
    simp only [Finset.coe_univ,Set.ncard_univ,Nat.card_eq_fintype_card,Fintype.card_fin] at hc
    omega
  have hbcap (t : ℕ) : (Finset.univ.filter (fun x => b.time x = t)).card ≤ 3 := by
    have hc := b.capacity t
    have he : {x | x ∈ (↑(Finset.univ : Finset (Fin (3*T))) : Set (Fin (3*T))) ∧ b.time x = t} =
        (Finset.univ.filter (fun x => b.time x = t) : Set (Fin (3*T))) := by ext x; simp
    rw [he,Set.ncard_coe_finset] at hc
    exact hc
  rw [← hbt]
  refine ⟨?_,?_,?_⟩
  · intro x
    simpa only [hbT] using b.bounds (Fin.castLE hn x) (by simp)
  · intro t
    apply le_trans _ (hbcap t)
    apply Finset.card_le_card_of_injOn (Fin.castLE hn)
    · intro x hx
      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,(Finset.mem_filter.mp hx).2⟩
    · intro x _ y _ hxy
      exact Fin.castLE_injective hn hxy
  · intro x y he
    apply b.respects _ (by simp) _ (by simp)
    apply (paddedOrder_castLE hn x y).mpr
    exact (reachable_iff G hG x y).mpr (.single he)

theorem scheduleAt_sound {n T : ℕ} (G : Instance n) (hG : G.acyclic)
    {time : Fin n → ℕ} (h : scheduleAt G T = some time) : Feasible G T time := by
  unfold scheduleAt at h
  split_ifs at h with hn
  · obtain ⟨s,hs,hstime⟩ := Option.map_eq_some_iff.mp h
    subst time
    exact Block.restrict_feasible G hG hn (fullSolve_sound _ hs)

theorem scheduleAt_complete {n T : ℕ} (G : Instance n) (hG : G.acyclic)
    (hf : ∃ time, Feasible G T time) : ∃ time, scheduleAt G T = some time := by
  obtain ⟨time,htime⟩ := hf
  have hn := htime.size_bound
  have hp := (feasible_iff_padded_layout G hn).mp ⟨time,htime⟩
  have hrel : paddedOrder (reachable G) (3*T) = paddedOrder G.order (3*T) := by
    have hr : reachable G = G.order := by funext x y; exact propext (reachable_iff G hG x y)
    rw [hr]
  obtain ⟨s,hs⟩ := fullSolve_complete (paddedOrder (reachable G) (3*T))
    (paddedOrder_irrefl (reachable_irrefl G hG)) (paddedOrder_trans (reachable_trans G hG))
    (by simpa only [hrel] using hp)
  exact ⟨fun x => s.time (Fin.castLE hn x),by simp [scheduleAt,hn,hs]⟩

theorem scheduleAt_none_iff {n T : ℕ} (G : Instance n) (hG : G.acyclic) :
    scheduleAt G T = none ↔ ¬∃ time, Feasible G T time := by
  constructor
  · intro hn he
    obtain ⟨time,htime⟩ := scheduleAt_complete G hG he
    rw [hn] at htime
    contradiction
  · intro he
    cases h : scheduleAt G T with
    | none => rfl
    | some time => exact (he ⟨time,scheduleAt_sound G hG h⟩).elim

end ThreeMachine.Algorithm

namespace ThreeMachine.Algorithm
open Structure

def best {n : ℕ} (G : Instance n) : ℕ → Option (ℕ × (Fin n → ℕ))
  | 0 => none
  | k+1 => match best G k with
    | some a => some a
    | none => (scheduleAt G (k+1)).map (fun time => (k+1,time))

def BestSpec {n : ℕ} (G : Instance n) (k : ℕ) : Option (ℕ × (Fin n → ℕ)) → Prop
  | none => ∀ T, 1 ≤ T → T ≤ k → ¬∃ time, Feasible G T time
  | some (T,time) => 1 ≤ T ∧ T ≤ k ∧ Feasible G T time ∧
      ∀ T' time', 1 ≤ T' → T' ≤ k → Feasible G T' time' → T ≤ T'

theorem best_spec {n : ℕ} (G : Instance n) (hG : G.acyclic) (k : ℕ) :
    BestSpec G k (best G k) := by
  induction k with
  | zero => intro T hT hTk; omega
  | succ k ih =>
    dsimp only [best]
    cases hb : best G k with
    | some a =>
      rw [hb] at ih
      rcases a with ⟨T,time⟩
      obtain ⟨hT,hTk,hfeas,hmin⟩ := ih
      refine ⟨hT,by omega,hfeas,?_⟩
      intro T' time' hT' hT'k hf'
      by_cases hh : T' ≤ k
      · exact hmin T' time' hT' hh hf'
      · omega
    | none =>
      rw [hb] at ih
      change ∀ T, 1 ≤ T → T ≤ k → ¬∃ time, Feasible G T time at ih
      cases hs : scheduleAt G (k+1) with
      | none =>
        intro T hT hTk
        by_cases he : T = k+1
        · subst T
          exact (scheduleAt_none_iff G hG).mp hs
        · exact ih T hT (by omega)
      | some time =>
        refine ⟨by omega,le_rfl,scheduleAt_sound G hG hs,?_⟩
        intro T' time' hT' hT'k hf'
        by_contra hlt
        exact ih T' hT' (by omega) ⟨time',hf'⟩

theorem serial_feasible {n : ℕ} (G : Instance n) (hG : G.acyclic) :
    Feasible G n (jobRank (reachable G)) := by
  refine ⟨jobRank_bounds _,?_,?_⟩
  · intro t
    apply le_trans (show _ ≤ 1 from ?_) (by omega : 1 ≤ 3)
    apply Finset.card_le_one.mpr
    intro x hx y hy
    apply jobRank_injective (reachable G)
    exact (Finset.mem_filter.mp hx).2.trans (Finset.mem_filter.mp hy).2.symm
  · intro x y he
    exact jobRank_strict (reachable G) (reachable_irrefl G hG) (reachable_trans G hG)
      ((reachable_iff G hG x y).mpr (.single he))

theorem best_optimum {n : ℕ} (G : Instance n) (hn : 1 ≤ n) (hG : G.acyclic) :
    ∃ T time, best G n = some (T,time) ∧ Feasible G T time ∧
      ∀ T' time', Feasible G T' time' → T ≤ T' := by
  have hs := best_spec G hG n
  cases hb : best G n with
  | none =>
    rw [hb] at hs
    exact (hs n hn le_rfl ⟨_,serial_feasible G hG⟩).elim
  | some a =>
    rw [hb] at hs
    rcases a with ⟨T,time⟩
    obtain ⟨_,hTn,hf,hmin⟩ := hs
    refine ⟨T,time,rfl,hf,?_⟩
    intro T' time' hf'
    have hT' : 1 ≤ T' := by
      have := hf'.1 ⟨0,by omega⟩
      omega
    by_cases hle : T' ≤ n
    · exact hmin T' time' hT' hle hf'
    · omega

def output {n : ℕ} (G : Instance n) : Option ℕ → List Bool
  | some T => encodeAnswer ((scheduleAt G T).map slots)
  | none => encodeAnswer ((best G n).map (fun a => slots a.2))

theorem output_correct {n : ℕ} (G : Instance n) (hn : 1 ≤ n) (hG : G.acyclic)
    (deadline : Option ℕ) : CorrectOutput G deadline (output G deadline) := by
  cases deadline with
  | none =>
    obtain ⟨T,time,hbest,hf,hmin⟩ := best_optimum G hn hG
    exact ⟨T,time,hf,hmin,by simp [output,hbest]⟩
  | some T =>
    cases hs : scheduleAt G T with
    | none => exact Or.inl ⟨by simp [output,hs],(scheduleAt_none_iff G hG).mp hs⟩
    | some time => exact Or.inr ⟨time,scheduleAt_sound G hG hs,by simp [output,hs]⟩

end ThreeMachine.Algorithm

end

end OAI