| import OAI.Computability.Scheduling.TransitionCosts |
| |
| namespace OAI |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Costs |
| variable {J : Type} (n : J → ℕ) |
| variable (U : ∀ j, Universe (n j)) (tab : ∀ j, Table (n j)) |
| variable (u : ∀ j, Algorithm.State (Fin (n j)) × Algorithm.Block (Fin (n j))) |
| variable (v : ∀ j, Algorithm.State (Fin (n j))) |
| |
| theorem tryW |
| (hl : Poly n (fun j => (tab j).length) 30000) |
| (ht : ∀ j, TableSmall (tab j)) (hb : ∀ j, BlockSmall (u j).2) : |
| Poly n (fun j => Uniform.tryW.time (n j) (U j,(tab j,(u j,v j)))) 30002 := by |
| have htv := Poly.volumeTable tab (Poly.size n) hl ht |
| have hbV := Poly.volumeSmallBlock (fun j => (u j).2) (Poly.size n) hb |
| poly_auto |
|
|
| theorem tryL |
| (hl : Poly n (fun j => (tab j).length) 30000) |
| (ht : ∀ j, TableSmall (tab j)) (hb : ∀ j, BlockSmall (u j).2) : |
| Poly n (fun j => Uniform.tryL.time (n j) (U j,(tab j,(u j,v j)))) 30002 := by |
| have htv := Poly.volumeTable tab (Poly.size n) hl ht |
| have hbV := Poly.volumeSmallBlock (fun j => (u j).2) (Poly.size n) hb |
| poly_auto |
|
|
| theorem tryP |
| (hl : Poly n (fun j => (tab j).length) 30000) |
| (ht : ∀ j, TableSmall (tab j)) (hb : ∀ j, BlockSmall (u j).2) : |
| Poly n (fun j => Uniform.tryP.time (n j) (U j,(tab j,(u j,v j)))) 30002 := by |
| have hW := tryW n U tab u v hl ht hb |
| have hL := tryL n U tab u v hl ht hb |
| have htv := Poly.volumeTable tab (Poly.size n) hl ht |
| have hbV := Poly.volumeSmallBlock (fun j => (u j).2) (Poly.size n) hb |
| poly_auto |
|
|
| theorem tryDiff |
| (hl : Poly n (fun j => (tab j).length) 30000) |
| (ht : ∀ j, TableSmall (tab j)) (hb : ∀ j, BlockSmall (u j).2) : |
| Poly n (fun j => Uniform.tryDiff.time (n j) (U j,(tab j,(u j,v j)))) 30002 := by |
| have hW := tryW n U tab u v hl ht hb |
| have hL := tryL n U tab u v hl ht hb |
| have htv := Poly.volumeTable tab (Poly.size n) hl ht |
| have hbV := Poly.volumeSmallBlock (fun j => (u j).2) (Poly.size n) hb |
| poly_auto |
|
|
| theorem tryO |
| (hl : Poly n (fun j => (tab j).length) 30000) |
| (ht : ∀ j, TableSmall (tab j)) (hb : ∀ j, BlockSmall (u j).2) : |
| Poly n (fun j => Uniform.tryO.time (n j) (U j,(tab j,(u j,v j)))) 60002 := by |
| have hD := tryDiff n U tab u v hl ht hb |
| have htv := Poly.volumeTable tab (Poly.size n) hl ht |
| have hbV := Poly.volumeSmallBlock (fun j => (u j).2) (Poly.size n) hb |
| poly_auto |
|
|
| theorem tryWork |
| (hl : Poly n (fun j => (tab j).length) 30000) |
| (ht : ∀ j, TableSmall (tab j)) (hb : ∀ j, BlockSmall (u j).2) : |
| Poly n (fun j => Uniform.tryWork.time (n j) (U j,(tab j,(u j,v j)))) 60002 := by |
| have hO := tryO n U tab u v hl ht hb |
| have htv := Poly.volumeTable tab (Poly.size n) hl ht |
| have hbV : Poly n (fun j => volume (u j).2) 2 := Poly.volumeSmallBlock _ (Poly.size n) hb |
| have hL : Poly n (fun j => volume (Algorithm.lookup (tab j) ((v j).left \ (u j).1.upto))) 2 := |
| Poly.volumeSmallLookup tab _ (Poly.size n) ht |
| have ha := advanceLast (fun p : Poly.ListPool (fun j => (Algorithm.lookup (tab j) |
| ((v j).left \ (u j).1.upto)).toList) => n p.1) (fun p => U p.1) |
| (fun p => u p.1) (fun p => p.2.1) (fun p => hb p.1) (fun p => |
| ht p.1 _ _ (Algorithm.lookup_mem (by simpa using p.2.2))) |
| have hAv : Poly (fun p : Poly.ListPool (fun j => (Algorithm.lookup (tab j) |
| ((v j).left \ (u j).1.upto)).toList) => n p.1) |
| (fun p => volume ((u p.1).1.advance (u p.1).2 p.2.1)) 2 := by |
| apply Poly.volumeAdvance _ _ _ (Poly.size _) (fun p => hb p.1) |
| intro p |
| exact ht p.1 _ _ (Algorithm.lookup_mem (by simpa using p.2.2)) |
| poly_auto |
| theorem tryAdvance |
| (hl : Poly n (fun j => (tab j).length) 30000) |
| (ht : ∀ j, TableSmall (tab j)) (hb : ∀ j, BlockSmall (u j).2) : |
| Poly n (fun j => Uniform.tryAdvance.time (n j) (U j,(tab j,(u j,v j)))) 60002 := by |
| have hp := tryP n U tab u v hl ht hb |
| have hw := tryWork n U tab u v hl ht hb |
| have htv := Poly.volumeTable tab (Poly.size n) hl ht |
| have hbV := Poly.volumeSmallBlock (fun j => (u j).2) (Poly.size n) hb |
| have hAv : Poly (fun p : Poly.ListPool (fun j => (Algorithm.lookup (tab j) |
| ((v j).left \ (u j).1.upto)).toList) => n p.1) |
| (fun p => volume ((u p.1).1.advance (u p.1).2 p.2.1)) 2 := by |
| apply Poly.volumeAdvance _ _ _ (Poly.size _) (fun p => hb p.1) |
| intro p |
| exact ht p.1 _ _ (Algorithm.lookup_mem (by simpa using p.2.2)) |
| have hWV := Poly.volumeOptionMap (s := n) (fun j c => (u j).1.advance (u j).2 c) |
| (fun j => Algorithm.lookup (tab j) ((v j).left \ (u j).1.upto)) hAv |
| poly_auto |
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Costs |
| variable {J : Type} (n : J → ℕ) (U : ∀ j, Universe (n j)) (tab : ∀ j, Table (n j)) |
| variable (u : ∀ j, Algorithm.State (Fin (n j)) × Algorithm.Block (Fin (n j))) |
| |
| theorem finishing |
| (hl : Poly n (fun j => (tab j).length) 30000) |
| (ht : ∀ j, TableSmall (tab j)) (hb : ∀ j, BlockSmall (u j).2) : |
| Poly n (fun j => Uniform.finishing.time (n j) (u j,(U j,tab j))) 60002 := by |
| have htv := Poly.volumeTable tab (Poly.size n) hl ht |
| have hbV := Poly.volumeSmallBlock (fun j => (u j).2) (Poly.size n) hb |
| have hL : Poly n (fun j => volume (Algorithm.lookup (tab j) (u j).1.right)) 2 := |
| Poly.volumeSmallLookup tab _ (Poly.size n) ht |
| have ha := advanceLast (fun p : Poly.ListPool (fun j => (Algorithm.lookup (tab j) |
| (u j).1.right).toList) => n p.1) (fun p => U p.1) |
| (fun p => u p.1) (fun p => p.2.1) (fun p => hb p.1) (fun p => |
| ht p.1 _ _ (Algorithm.lookup_mem (by simpa using p.2.2))) |
| have hAv : Poly (fun p : Poly.ListPool (fun j => (Algorithm.lookup (tab j) |
| (u j).1.right).toList) => n p.1) |
| (fun p => volume ((u p.1).1.advance (u p.1).2 p.2.1)) 2 := by |
| apply Poly.volumeAdvance _ _ _ (Poly.size _) (fun p => hb p.1) |
| intro p |
| exact ht p.1 _ _ (Algorithm.lookup_mem (by simpa using p.2.2)) |
| poly_auto |
|
|
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Uniform |
| abbrev SolveInput (n : ℕ) := Universe n × (Matrix n × |
| (Table n × (List (Finset (Fin n)) × (List (Finset (Fin n)) × Finset (Fin n))))) |
| def solveU : Uniform (fun n (x : SolveInput n) => x.1) := fst |
| def solveM : Uniform (fun n (x : SolveInput n) => x.2.1) := snd.comp fst |
| def solveT : Uniform (fun n (x : SolveInput n) => x.2.2.1) := snd.comp (snd.comp fst) |
| def solveF : Uniform (fun n (x : SolveInput n) => x.2.2.2.1) := snd.comp (snd.comp (snd.comp fst)) |
| def solveZ : Uniform (fun n (x : SolveInput n) => x.2.2.2.2.1) := snd.comp (snd.comp (snd.comp (snd.comp fst))) |
| def solveW : Uniform (fun n (x : SolveInput n) => x.2.2.2.2.2) := snd.comp (snd.comp (snd.comp (snd.comp snd))) |
| def solveS : Uniform (fun n (x : SolveInput n) => |
| Algorithm.states (matrixRel x.2.1) x.2.2.2.1 x.2.2.2.2.1 x.2.2.2.2.2) := (solveU.pair (solveM.pair (solveF.pair (solveZ.pair solveW)))).comp states |
| def solveMarks : Uniform (fun n (x : SolveInput n) => |
| Algorithm.markings x.2.2.1 (Algorithm.states (matrixRel x.2.1) x.2.2.2.1 x.2.2.2.2.1 x.2.2.2.2.2) n) := ((solveU.comp universeNumber).pair (solveU.pair (solveT.pair solveS))).comp markings |
| def solveOut : Uniform (fun n (x : SolveInput n) => |
| Algorithm.firstResult (fun u => (Algorithm.lookup x.2.2.1 u.1.right).map (u.1.finish u.2)) |
| (Algorithm.markings x.2.2.1 (Algorithm.states (matrixRel x.2.1) x.2.2.2.1 x.2.2.2.2.1 x.2.2.2.2.2) n)) := (solveMarks.pair (solveU.pair solveT)).comp finishing.firstResultA |
| theorem time_solve (n : ℕ) (x : SolveInput n) : |
| solve.time n x = ((solveW.comp setIsEmpty).ite (solveU.comp (blockEmpty.comp some)) solveOut).time n x := by |
| simp only [solve, time_congr, solveOut, solveMarks, solveS, solveU, solveM, solveT, solveF, solveZ, solveW] |
| end ThreeMachine.StackCompiler.Uniform |
| namespace ThreeMachine.StackCompiler.Poly |
| variable {J : Type} {s n : J → ℕ} {d : ℕ} |
| theorem volumeSolve (M : ∀ j, Matrix (n j)) (tab : ∀ j, Table (n j)) |
| (fs zs : ∀ j, List (Finset (Fin (n j)))) (W : ∀ j, Finset (Fin (n j))) |
| (hn : Poly s n d) (ht : ∀ j, Algorithm.TableGood (matrixRel (M j)) (tab j)) |
| (hb : ∀ j, Algorithm.TableBounded (tab j)) : |
| Poly s (fun j => volume (Algorithm.solve (matrixRel (M j)) (tab j) (fs j) (zs j) (W j))) (2*d) := by |
| apply volumeOption _ (show Poly s (fun j => 10*(n j+1)^2) (2*d) from by poly_bound) |
| intro j b h |
| have hs := blockSmall_of_good (Algorithm.solve_good _ (ht j) _ _ h) |
| (Algorithm.solve_bounded _ (hb j) _ _ h) |
| exact volume_block_le b hs.1 hs.2 |
| end ThreeMachine.StackCompiler.Poly |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Poly |
| variable {J : Type} {s n : J → ℕ} {d : ℕ} |
| theorem volumeSolveOut (M : ∀ j, Matrix (n j)) (tab : ∀ j, Table (n j)) |
| (fs zs : ∀ j, List (Finset (Fin (n j)))) (W : ∀ j, Finset (Fin (n j))) |
| (hn : Poly s n d) (ht : ∀ j, Algorithm.TableGood (matrixRel (M j)) (tab j)) |
| (hb : ∀ j, Algorithm.TableBounded (tab j)) : |
| Poly s (fun j => volume (Algorithm.firstResult |
| (fun u => (Algorithm.lookup (tab j) u.1.right).map (u.1.finish u.2)) |
| (Algorithm.markings (tab j) (Algorithm.states (matrixRel (M j)) (fs j) (zs j) (W j)) (n j)))) (2*d) := by |
| apply volumeOption _ (show Poly s (fun j => 100*(n j+2)^2) (2*d) from by poly_bound) |
| intro j b h |
| obtain ⟨⟨u,bb⟩,hmem,hm⟩ := Algorithm.firstResult_some h |
| obtain ⟨t,ht',rfl⟩ := Option.map_eq_some_iff.mp hm |
| have hmark : MarksSmall (Algorithm.markings (tab j) |
| (Algorithm.states (matrixRel (M j)) (fs j) (zs j) (W j)) (n j)) := markings_small (matrixRel (M j)) (ht j) (hb j) |
| (fun _ hu => Algorithm.states_compatible _ hu) (n j) |
| have htSmall : TableSmall (tab j) := fun a b h => blockSmall_of_good (ht j a b h) (hb j a b h) |
| exact volume_advance_le u bb t (hmark u bb hmem) (htSmall _ _ (Algorithm.lookup_mem ht')) |
| end ThreeMachine.StackCompiler.Poly |
| end |
|
|
| end OAI |
|
|
