lean/OAI/Computability/Scheduling/RankCosts.lean

import OAI.Computability.Scheduling.ScheduleBounds

namespace OAI

universe u1 u2

section
namespace ThreeMachine.StackCompiler.Costs
variable {J : Type u1} (n : J → ℕ) (x : ∀ j, Uniform.RankCellInput (n j))
theorem rankCellLT (h : Poly n (fun j => volume (x j).2.1) 2) :
    Poly n (fun j => Uniform.rankCellLT.time (n j) (x j)) 4 := by poly_auto
theorem rankCellEQ (h : Poly n (fun j => volume (x j).2.1) 2) :
    Poly n (fun j => Uniform.rankCellEQ.time (n j) (x j)) 4 := by poly_auto
theorem rankCellFinLT (h : Poly n (fun j => volume (x j).2.1) 2) :
    Poly n (fun j => Uniform.rankCellFinLT.time (n j) (x j)) 4 := by
  simp only [Uniform.rankCellFinLT, Uniform.time_comp, Uniform.time_pair, Uniform.time_fst, Uniform.time_snd, Uniform.time_finVal, Function.comp_apply]
  poly_auto
theorem rankCell (h : Poly n (fun j => volume (x j).2.1) 2) :
    Poly n (fun j => Uniform.rankCell.time (n j) (x j)) 4 := by
  have h1 := rankCellLT n x h
  have h2 := rankCellEQ n x h
  have h3 := rankCellFinLT n x h
  poly_auto
end ThreeMachine.StackCompiler.Costs
end

section
namespace ThreeMachine.StackCompiler.Costs
variable {J : Type u2} (n : J → ℕ)
theorem rankFromCounts (U : ∀ j, Universe (n j)) (r : ∀ j, Fin (n j) → ℕ)
    (v : ∀ j, Fin (n j)) (h : Poly n (fun j => volume (r j)) 2) :
    Poly n (fun j => Uniform.rankFromCounts.time (n j) (U j,(r j,v j))) 5 := by
  have hc := rankCell (fun p : Poly.ListPool (fun j => (Finset.univ : Finset (Fin (n j))).sort (· ≤ ·)) => n p.1)
    (fun p => (p.2.1,(r p.1,v p.1))) (h.precomp Sigma.fst)
  poly_auto

theorem rank : Poly (fun x : Σ n, Universe n × Matrix n => x.1)
    (fun x => Uniform.rank.time x.1 x.2) 6 := by
  let n : (Σ n, Universe n × Matrix n) → ℕ := Sigma.fst
  have hv := Poly.volumePredecessors (fun x : Σ n, Universe n × Matrix n => x.2.2) (Poly.size n)
  have hC := rankFromCounts (fun p : Poly.ListPool (fun x : Σ n, Universe n × Matrix n => List.finRange x.1) => p.1.1)
    (fun p => p.1.2.1) (fun p => Structure.predecessorCount (matrixRel p.1.2.2))
    (fun p => p.2.1) (hv.precomp Sigma.fst)
  poly_auto

theorem reverseRank (U : ∀ j, Universe (n j)) (r : ∀ j, Fin (n j) → ℕ)
    (h : Poly n (fun j => volume (r j)) 2) :
    Poly n (fun j => Uniform.reverseRank.time (n j) (U j,r j)) 5 := by poly_auto

theorem ranks (frame : Bool) : Poly (fun x : Σ n, Universe n × Matrix n => x.1)
    (fun x => (Uniform.ranks frame).time x.1 x.2) 6 := by
  cases frame
  · poly_auto
  · have hv := Poly.volumeRank (fun x : Σ n, Universe n × Matrix n => x.2.2)
      (Poly.size (fun x : Σ n, Universe n × Matrix n => x.1))
    have hr := reverseRank (fun x : Σ n, Universe n × Matrix n => x.1) (fun x => x.2.1)
      (fun x => Structure.jobRank (matrixRel x.2.2)) hv
    poly_auto
end ThreeMachine.StackCompiler.Costs
end

section
namespace ThreeMachine.StackCompiler.Uniform
abbrev ThresholdInput (n : ℕ) := Fin n × (ℕ × (Fin n → ℕ))
def thresholdA : Uniform (fun n (x : ThresholdInput n) => x.2.2 x.1) :=
  ((snd.comp snd).pair fst).comp functionGet
def thresholdB : Uniform (fun n (x : ThresholdInput n) => x.2.1) := snd.comp fst
def thresholdP (upper : Bool) : Uniform (fun n (x : ThresholdInput n) =>
    decide (if upper then x.2.2 x.1 ≤ x.2.1 else x.2.1 ≤ x.2.2 x.1)) := by
  cases upper
  · exact (thresholdB.pair thresholdA).comp (Realizer.le.uniform ℕ)
  · exact (thresholdA.pair thresholdB).comp (Realizer.le.uniform ℕ)
def thresholdF (upper : Bool) : Uniform (fun n (x : ℕ × (Universe n × (Fin n → ℕ))) =>
    Finset.univ.filter (fun v => decide (if upper then x.2.2 v ≤ x.1 else x.1 ≤ x.2.2 v) = true)) :=
  (((snd.comp fst).comp universeSet).pair (fst.pair (snd.comp snd))).comp (thresholdP upper).setFilter
def thresholdN : Uniform (fun n (_ : Universe n × (Fin n → ℕ)) => List.range (n+2)) :=
  (((fst.comp universeNumber).pair (constant 2)).comp (Realizer.add.uniform ℕ)).comp (Realizer.range.uniform ℕ)
theorem time_thresholdSets (upper : Bool) (n : ℕ) (x : Universe n × (Fin n → ℕ)) :
    (thresholdSets upper).time n x = ((thresholdN.pair id).comp (thresholdF upper).map).time n x := by
  cases upper <;> rfl
end ThreeMachine.StackCompiler.Uniform
namespace ThreeMachine.StackCompiler.Costs
variable {J : Type} (n : J → ℕ)
theorem thresholdP (upper : Bool) (x : ∀ j, Uniform.ThresholdInput (n j))
    (hk : Poly n (fun j => (x j).2.1) 1) (hr : Poly n (fun j => volume (x j).2.2) 2) :
    Poly n (fun j => (Uniform.thresholdP upper).time (n j) (x j)) 4 := by
  cases upper <;> poly_auto

theorem thresholdF (upper : Bool) (U : ∀ j, Universe (n j))
    (r : ∀ j, Fin (n j) → ℕ) (k : J → ℕ)
    (hk : Poly n k 1) (hr : Poly n (fun j => volume (r j)) 2) :
    Poly n (fun j => (Uniform.thresholdF upper).time (n j) (k j,(U j,r j))) 5 := by
  have hp := thresholdP (fun p : Poly.ListPool (fun j => (Finset.univ : Finset (Fin (n j))).sort (· ≤ ·)) => n p.1)
    upper (fun p => (p.2.1,(k p.1,r p.1))) (hk.precomp Sigma.fst) (hr.precomp Sigma.fst)
  poly_auto

theorem thresholdSets (upper : Bool) (U : ∀ j, Universe (n j))
    (r : ∀ j, Fin (n j) → ℕ) (hr : Poly n (fun j => volume (r j)) 2) :
    Poly n (fun j => (Uniform.thresholdSets upper).time (n j) (U j,r j)) 6 := by
  have hk : Poly (fun p : Poly.ListPool (fun j => List.range (n j+2)) => n p.1)
      (fun p => p.2.1) 1 := by
    apply Poly.of_le (fun p => (Nat.le_of_lt (List.mem_range.mp p.2.2)))
    exact (Poly.base n).precomp Sigma.fst
  have hF := thresholdF (fun p : Poly.ListPool (fun j => List.range (n j+2)) => n p.1)
    upper (fun p => U p.1) (fun p => r p.1) (fun p => p.2.1) hk (hr.precomp Sigma.fst)
  poly_auto
end ThreeMachine.StackCompiler.Costs
end

section
namespace ThreeMachine.StackCompiler.Uniform
def triplesE := (universeList.pair (universeList.pair universeList |>.comp product)).comp product
def triplesA := (triplesE.pair id).comp (swap.comp tripleSet).map
def triplesP : Uniform (fun n (x : Finset (Fin n) × Unit) => decide (x.1.card = 3)) :=
  (((fst.comp setCard).pair (constant 3)).comp (Realizer.eqNat.uniform ℕ))
theorem time_triples (n : ℕ) (x : Universe n) :
    triples.time n x = ((triplesA.pair unit).comp triplesP.filter).time n x := rfl

def conesF (frame : Bool) (k : Fin 5) :=
  ((((snd.comp fst).pair ((snd.comp snd).pair fst))).comp (cone frame k))
def conesOne (frame : Bool) (k : Fin 5) :=
  (((fst.comp triples).pair id).comp (conesF frame k).map)
theorem time_cones_cons (frame : Bool) (k : Fin 5) (ks : List (Fin 5))
    (n : ℕ) (x : Universe n × Matrix n) :
    (cones frame (k::ks)).time n x = ((conesOne frame k).pair (cones frame ks) |>.comp append).time n x := rfl
end ThreeMachine.StackCompiler.Uniform
namespace ThreeMachine.StackCompiler.Costs
open ThreeMachine.Structure

theorem matrixGetFrame (frame : Bool) :
    Poly (fun x : Σ n, Matrix n × (Fin n × Fin n) => x.1)
      (fun x => (Uniform.matrixGetFrame frame).time x.1 x.2) 3 := by
  cases frame <;> poly_auto

theorem conePred (frame : Bool) :
    Poly (fun x : Σ n, Universe n × (Matrix n × Finset (Fin n)) => x.1)
      (fun x => (Uniform.conePred frame).time x.1 x.2) 20 := by
  cases frame <;> poly_auto

theorem cone (frame : Bool) (kind : Fin 5) :
    Poly (fun x : Σ n, Universe n × (Matrix n × Finset (Fin n)) => x.1)
      (fun x => (Uniform.cone frame kind).time x.1 x.2) 20 := by
  have hf := conePred frame
  have hr := conePred (!frame)
  fin_cases kind <;> poly_auto

theorem triplesE : Poly (fun x : Σ n, Universe n => x.1)
    (fun x => Uniform.triplesE.time x.1 x.2) 20 := by poly_auto
theorem triplesA : Poly (fun x : Σ n, Universe n => x.1)
    (fun x => Uniform.triplesA.time x.1 x.2) 20 := by poly_auto
theorem triplesP : Poly (fun x : Σ n, Finset (Fin n) × Unit => x.1)
    (fun x => Uniform.triplesP.time x.1 x.2) 3 := by poly_auto
theorem triples : Poly (fun x : Σ n, Universe n => x.1)
    (fun x => Uniform.triples.time x.1 x.2) 20 := by poly_auto

theorem conesF (frame : Bool) (k : Fin 5) :
    Poly (fun x : Σ n, Finset (Fin n) × (Universe n × Matrix n) => x.1)
      (fun x => (Uniform.conesF frame k).time x.1 x.2) 20 := by poly_auto
theorem conesOne (frame : Bool) (k : Fin 5) :
    Poly (fun x : Σ n, Universe n × Matrix n => x.1)
      (fun x => (Uniform.conesOne frame k).time x.1 x.2) 100 := by
  have ht := Poly.lengthTriples (Poly.size (fun x : Σ n, Universe n × Matrix n => x.1))
  poly_auto

theorem cones (frame : Bool) (ks : List (Fin 5)) :
    Poly (fun x : Σ n, Universe n × Matrix n => x.1)
      (fun x => (Uniform.cones frame ks).time x.1 x.2) 100 := by
  induction ks with
  | nil => poly_auto
  | cons k ks ih =>
    have hCone := cone frame k
    have htr := Poly.lengthTriples (Poly.size (fun x : Σ n, Universe n × Matrix n => x.1))
    have hlen : Poly (fun x : Σ n, Universe n × Matrix n => x.1)
        (fun x => (ks.flatMap (fun k =>
          ((Structure.tripleList (List.finRange x.1)).map Subtype.val).map (coneSet x.2.2 frame k))).length) 3 := by
      have he (x : Σ n, Universe n × Matrix n) :
          (ks.flatMap (fun k => ((Structure.tripleList (List.finRange x.1)).map Subtype.val).map (coneSet x.2.2 frame k))).length =
          ks.length*(Structure.tripleList (List.finRange x.1)).length := by simp [List.length_flatMap]
      apply Poly.of_le (fun x => (he x).le)
      poly_bound
    poly_auto
end ThreeMachine.StackCompiler.Costs
end

end OAI