| import OAI.Computability.Scheduling.RankCosts |
|
|
| namespace OAI |
|
|
| universe u1 |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Uniform |
| variable {I : Type u1} {α : I → Type} [∀ i, Coding (α i)] |
| theorem time_finEmpty (i : I) (xs : List (α i)) : finEmpty.time i xs = 2 := rfl |
| theorem time_finCons (k : ℕ) (i : I) (x : α i × (Fin k → α i)) : |
| (finCons k).time i x = volume x+2 := rfl |
|
|
| def assignmentsInner (k : ℕ) : Uniform (fun i (x : α i × List (Fin k → α i)) => |
| x.2.map (fun f => (Fin.cons x.1 f : Fin (k+1) → α i))) := |
| ((snd.pair fst).comp (swap.comp (finCons k)).map) |
| def assignmentsStep (k : ℕ) : Uniform (fun i (x : List (α i) × List (Fin k → α i)) => |
| x.1.flatMap (fun a => x.2.map (fun f => (Fin.cons a f : Fin (k+1) → α i)))) := (assignmentsInner k).flatMap |
| theorem time_assignments_succ (k : ℕ) (i : I) (xs : List (α i)) : |
| (assignments (k+1)).time i xs = |
| (((id.pair (assignments k)).comp (assignmentsStep k))).time i xs := rfl |
| end ThreeMachine.StackCompiler.Uniform |
| namespace ThreeMachine.StackCompiler.Costs |
| variable {J : Type} (n : J → ℕ) (k : ℕ) |
|
|
| theorem assignmentsInner (ys : ∀ j, List (Fin k → Finset (Fin (n j)))) |
| (a : ∀ j, Finset (Fin (n j))) (hl : Poly n (fun j => (ys j).length) (3*k)) : |
| Poly n (fun j => (Uniform.assignmentsInner (α := fun n => Finset (Fin n)) k).time (n j) (a j,ys j)) (6*k+5) := by |
| have hv : Poly n (fun j => volume (ys j)) (3*k+2) := by poly_auto |
| have hdegree : |
| max |
| (max |
| (max (max (max (max (2 * 1) (3 * k + 2)) 0) (max (max (2 * 1) (3 * k + 2)) 0)) |
| (0 + max (max (max (max (2 * 1) (3 * k + 2)) (3 * k + 2)) (2 * 1)) 0)) |
| (3 * k + max 2 (max (3 * k + 2) (max (2 * 1) (3 * k + 2))))) |
| (0 + max (max (3 * k + 2) (2 * 1)) 0) ≤ 6 * k + 5 := by omega |
| poly_auto |
|
|
| theorem assignmentsStep (xs : ∀ j, List (Finset (Fin (n j)))) |
| (ys : ∀ j, List (Fin k → Finset (Fin (n j)))) |
| (hl : Poly n (fun j => (xs j).length) 3) |
| (hL : Poly n (fun j => (ys j).length) (3*k)) : |
| Poly n (fun j => (Uniform.assignmentsStep (α := fun n => Finset (Fin n)) k).time (n j) (xs j,ys j)) (9*k+10) := by |
| have hv : Poly n (fun j => volume (ys j)) (3*k+2) := by poly_auto |
| have hx : Poly n (fun j => volume (xs j)) 5 := by poly_auto |
| have hI := assignmentsInner (fun p : Poly.ListPool xs => n p.1) k |
| (fun p => ys p.1) (fun p => p.2.1) (hL.precomp Sigma.fst) |
| have hdegree : 3 + (3 * k + 2) + |
| max (6 * k + 5) (max 5 (max (3 * k + 2) (3 + (3 * k + 2)))) ≤ 9 * k + 10 := by omega |
| poly_auto |
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Costs |
| variable {J : Type} (n : J → ℕ) (xs : ∀ j, List (Finset (Fin (n j)))) |
| theorem assignments (hl : Poly n (fun j => (xs j).length) 3) (k : ℕ) : |
| Poly n (fun j => (Uniform.assignments (α := fun n => Finset (Fin n)) k).time (n j) (xs j)) (9*k+10) := by |
| have hx : Poly n (fun j => volume (xs j)) 5 := by poly_auto |
| induction k with |
| | zero => |
| change Poly n (fun j => (Uniform.assignments (α := fun n => Finset (Fin n)) 0).time (n j) (xs j)) 10 |
| poly_auto |
| | succ k ih => |
| change Poly n (fun j => (Uniform.assignments (α := fun n => Finset (Fin n)) (k+1)).time (n j) (xs j)) (9*(k+1)+10) |
| change Poly n (fun j => (Uniform.assignments (α := fun n => Finset (Fin n)) k).time (n j) (xs j)) (9*k+10) at ih |
| have hL : Poly n (fun j => (Structure.assignments (xs j) k).length) (3*k) := by |
| simpa only [Structure.assignments_length] using hl.pow k |
| have hV : Poly n (fun j => volume (Structure.assignments (xs j) k)) (3*k+2) := by poly_auto |
| change Poly n (fun j => (Uniform.assignments (α := fun n => Finset (Fin n)) (k+1)).time (n j) (xs j)) (9*(k+1)+10) |
| have hStep := assignmentsStep n k xs (fun j => Structure.assignments (xs j) k) hl hL |
| have hdegree : |
| max (max (max (max 5 (9 * k + 10)) (0 + max (max (max 5 5) (3 * k + 2)) 0)) (9 * k + 10)) |
| (0 + max (max 5 (3 * k + 2)) 0) ≤ 9 * (k + 1) + 10 := by omega |
| poly_auto |
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Costs |
| open ThreeMachine.Structure |
| variable {J : Type} (n : J → ℕ) (U : ∀ j, Universe (n j)) |
| variable {K : ℕ} (r : ∀ j, Fin K → Finset (Fin (n j))) |
|
|
| theorem evalTemplate (p : Formula (Fin K)) : |
| Poly n (fun j => (Uniform.evalTemplate p).time (n j) (U j,r j)) 4 := by |
| induction p with |
| | leaf a b => cases b <;> simp only [Uniform.evalTemplate,Bool.false_eq_true,↓reduceDIte] <;> poly_auto |
| | conj p q ihp ihq => poly_auto |
| | disj p q ihp ihq => poly_auto |
|
|
| theorem evalTemplates (ps : List (Formula (Fin K))) : |
| Poly n (fun j => (Uniform.evalTemplates ps).time (n j) (U j,r j)) 4 := by |
| induction ps with |
| | nil => poly_auto |
| | cons p ps ih => |
| have hc := evalTemplate n U r p |
| have hl : Poly n (fun j => (ps.map (Formula.evalFinset (r j))).length) 0 := by |
| simpa only [List.length_map] using Poly.const n ps.length |
| poly_auto |
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Uniform |
|
|
| def atomSetsC : Uniform (fun n (_ : Universe n × Matrix n) => [∅, (Finset.univ : Finset (Fin n))]) := |
| (((fst.comp setEmpty).pair (((fst.comp universeSet).pair nil).comp cons)).comp cons) |
| def atomSetsT := ((thresholds Bool.false).pair (thresholds true)).comp append |
| def atomSetsD := ((cones Bool.false (List.finRange 5)).pair (cones true (List.finRange 5))).comp append |
| theorem time_atomSets (n : ℕ) (x : Universe n × Matrix n) : |
| atomSets.time n x = ((atomSetsC.pair atomSetsT).comp append |>.pair atomSetsD |>.comp append).time n x := rfl |
| end ThreeMachine.StackCompiler.Uniform |
| namespace ThreeMachine.StackCompiler.Costs |
| open ThreeMachine.Structure |
| variable {J : Type} |
| theorem lengthThresholds (n : J → ℕ) (M : ∀ j, Matrix (n j)) (frame : Bool) : |
| Poly n (fun j => ([Bool.false,true].flatMap (fun upper => (List.range (n j+2)).map |
| (fun k => Finset.univ.filter (fun v => if upper then |
| (if frame then reverseJobRank (matrixRel (M j)) else jobRank (matrixRel (M j))) v ≤ k |
| else k ≤ (if frame then reverseJobRank (matrixRel (M j)) else jobRank (matrixRel (M j))) v)))).length) 1 := by |
| simp only [List.flatMap_cons,List.flatMap_nil,List.append_nil,List.length_append,List.length_map,List.length_range] |
| poly_auto |
|
|
| theorem lengthCones (n : J → ℕ) (M : ∀ j, Matrix (n j)) (frame : Bool) (ks : List (Fin 5)) : |
| Poly n (fun j => (ks.flatMap (fun k => ((tripleList (List.finRange (n j))).map Subtype.val).map |
| (coneSet (M j) frame k))).length) 3 := by |
| have htr := Poly.lengthTriples (Poly.size n) |
| have he (j : J) : |
| (ks.flatMap (fun k => ((tripleList (List.finRange (n j))).map Subtype.val).map |
| (coneSet (M j) frame k))).length = ks.length*(tripleList (List.finRange (n j))).length := by |
| simp [List.length_flatMap] |
| apply Poly.of_le (fun j => (he j).le) |
| poly_bound |
|
|
| theorem thresholds (frame : Bool) : |
| Poly (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => (Uniform.thresholds frame).time x.1 x.2) 6 := by |
| let n : (Σ n, Universe n × Matrix n) → ℕ := Sigma.fst |
| let r (x : Σ n, Universe n × Matrix n) := |
| if frame then Structure.reverseJobRank (matrixRel x.2.2) else Structure.jobRank (matrixRel x.2.2) |
| have hv : Poly n (fun x => volume (r x)) 2 := by |
| cases frame |
| · exact Poly.volumeRank (fun x : Σ n, Universe n × Matrix n => x.2.2) (Poly.size n) |
| · exact Poly.volumeReverseRank (fun x : Σ n, Universe n × Matrix n => x.2.2) (Poly.size n) |
| have hF := thresholdSets n Bool.false (fun x => x.2.1) r hv |
| have hT := thresholdSets n true (fun x => x.2.1) r hv |
| poly_auto |
|
|
| theorem atomSetsC : Poly (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => Uniform.atomSetsC.time x.1 x.2) 3 := by poly_auto |
| theorem atomSetsT : Poly (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => Uniform.atomSetsT.time x.1 x.2) 6 := by |
| have hF := lengthThresholds (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => x.2.2) Bool.false |
| have hT := lengthThresholds (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => x.2.2) true |
| poly_auto |
| theorem atomSetsD : Poly (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => Uniform.atomSetsD.time x.1 x.2) 100 := by |
| have hF := lengthCones (fun x : Σ n, Universe n × Matrix n => x.1) (fun x => x.2.2) Bool.false (List.finRange 5) |
| have hT := lengthCones (fun x : Σ n, Universe n × Matrix n => x.1) (fun x => x.2.2) true (List.finRange 5) |
| poly_auto |
| theorem atomSets : Poly (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => Uniform.atomSets.time x.1 x.2) 100 := by |
| have htF := lengthThresholds (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => x.2.2) Bool.false |
| have htT := lengthThresholds (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => x.2.2) true |
| have hF := lengthCones (fun x : Σ n, Universe n × Matrix n => x.1) (fun x => x.2.2) Bool.false (List.finRange 5) |
| have hT := lengthCones (fun x : Σ n, Universe n × Matrix n => x.1) (fun x => x.2.2) true (List.finRange 5) |
| poly_auto |
|
|
| theorem evalTemplatesCanonical {K : ℕ} (ps : List (Formula (Fin K))) : |
| Poly (fun x : Σ n, Universe n × (Fin K → Finset (Fin n)) => x.1) |
| (fun x => (Uniform.evalTemplates ps).time x.1 x.2) 4 := |
| evalTemplates (fun x : Σ n, Universe n × (Fin K → Finset (Fin n)) => x.1) (fun x => x.2.1) (fun x => x.2.2) ps |
|
|
| end ThreeMachine.StackCompiler.Costs |
| namespace ThreeMachine.StackCompiler.Uniform |
| open ThreeMachine.Structure |
| def familyAssignments (K : ℕ) := atomSets.comp (assignments K) |
| def familyEval (K : ℕ) := swap.comp (evalTemplates (Formula.templates K)) |
| def familyFlatten (K : ℕ) := (familyEval K).flatMap |
| theorem time_family (K n : ℕ) (x : Universe n × Matrix n) : |
| (family K).time n x = (((familyAssignments K).pair fst).comp (familyFlatten K)).time n x := rfl |
| end ThreeMachine.StackCompiler.Uniform |
| namespace ThreeMachine.StackCompiler.Costs |
| open ThreeMachine.Structure |
| theorem familyAssignments (K : ℕ) : Poly (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => (Uniform.familyAssignments K).time x.1 x.2) (max (max 100 (9*K+10)) 5) := by |
| let n : (Σ n, Universe n × Matrix n) → ℕ := Sigma.fst |
| let xs (x : Σ n, Universe n × Matrix n) := |
| (Atomic.alphabet (List.finRange x.1)).map |
| (Atomic.finsetEval (matrixRel x.2.2) (Structure.jobRank (matrixRel x.2.2)) (Structure.reverseJobRank (matrixRel x.2.2))) |
| have hl : Poly n (fun x => (xs x).length) 3 := by |
| simpa only [xs,List.length_map] using Poly.lengthAlphabet (Poly.size n) |
| have hA := assignments n xs hl K |
| have hAL : Poly n (fun x => (Structure.assignments (xs x) K).length) (3*K) := by |
| simpa only [Structure.assignments_length] using hl.pow K |
| have hAV : Poly n (fun x => volume (Structure.assignments (xs x) K)) (3*K+2) := by poly_auto |
| poly_auto |
| theorem familyEval (K : ℕ) : Poly (fun x : Σ n, (Fin K → Finset (Fin n)) × Universe n => x.1) |
| (fun x => (Uniform.familyEval K).time x.1 x.2) 4 := by |
| poly_auto |
|
|
| theorem familyFlatten {J : Type} (K : ℕ) (n : J → ℕ) (U : ∀ j, Universe (n j)) |
| (xs : ∀ j, List (Fin K → Finset (Fin (n j)))) |
| (hl : Poly n (fun j => (xs j).length) 30000) : |
| Poly n (fun j => (Uniform.familyFlatten K).time (n j) (xs j,U j)) 60004 := by |
| let P := Σ j, {a : Fin K → Finset (Fin (n j)) |
| let sp (p : P) := n p.1 |
| have ht : Poly sp (fun p => (Uniform.familyEval K).time (n p.1) (p.2.1,U p.1)) 4 := by |
| exact (familyEval K).precomp (fun p : P => (⟨n p.1,(p.2.1,U p.1)⟩ : Σ m, (Fin K → Finset (Fin m)) × Universe m)) |
| have hx : Poly n (fun j => volume (xs j)) 30002 := by poly_auto |
| have he : Poly n (fun j => volume (U j)) 2 := by poly_auto |
| have hlout : Poly sp (fun p => ((Formula.templates K).map (Formula.evalFinset p.2.1)).length) 0 := by |
| simpa only [List.length_map] using Poly.const sp (Formula.templates K).length |
| have hv : Poly sp (fun p => volume ((Formula.templates K).map (Formula.evalFinset p.2.1))) 2 := by |
| poly_auto |
| exact (Poly.flatMapTime (α := fun n => Fin K → Finset (Fin n)) n xs U (Uniform.familyEval K) hl ht hx he hv).lift (by decide) |
|
|
| theorem familyBound (K : ℕ) (hk : K ≤ 10000) : Poly (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => (Uniform.family K).time x.1 x.2) 90010 := by |
| let n : (Σ n, Universe n × Matrix n) → ℕ := Sigma.fst |
| let xs (x : Σ n, Universe n × Matrix n) := |
| (Atomic.alphabet (List.finRange x.1)).map |
| (Atomic.finsetEval (matrixRel x.2.2) (Structure.jobRank (matrixRel x.2.2)) (Structure.reverseJobRank (matrixRel x.2.2))) |
| have hl : Poly n (fun x => (xs x).length) 3 := by |
| simpa only [xs,List.length_map] using Poly.lengthAlphabet (Poly.size n) |
| have hAL : Poly n (fun x => (Structure.assignments (xs x) K).length) 30000 := by |
| simpa only [Structure.assignments_length] using (hl.pow K).lift (Nat.mul_le_mul_left 3 hk) |
| have hAV : Poly n (fun x => volume (Structure.assignments (xs x) K)) 30002 := by poly_auto |
| have hA := (familyAssignments K).lift (show max (max 100 (9*K+10)) 5 ≤ 90010 by omega) |
| have hF := familyFlatten K n (fun x => x.2.1) (fun x => Structure.assignments (xs x) K) hAL |
| poly_auto |
| theorem family : Poly (fun x : Σ n, Universe n × Matrix n => x.1) |
| (fun x => (Uniform.family 10000).time x.1 x.2) 90010 := familyBound 10000 (by omega) |
|
|
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
|
|
| end |
|
|
| end OAI |
|
|
