| import OAI.Computability.Scheduling.SchedulingCosts |
|
|
| namespace OAI |
|
|
| universe u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Uniform |
| abbrev BestState (n : ℕ) := (Universe n × Matrix n) × (ℕ × Option (ℕ × (Fin n → ℕ))) |
| def bestNext : Uniform (fun (n : ℕ) (x : BestState n) => x.2.1+1) := |
| (snd.comp fst).comp (Realizer.succ.uniform ℕ) |
| def bestAttempt : Uniform (fun (n : ℕ) (x : BestState n) => |
| (ThreeMachine.StackCompiler.scheduleMatrix x.1.2 (x.2.1+1)).map (fun t => (x.2.1+1,t))) := |
| ((((fst.comp fst).pair (bestNext.pair (fst.comp snd))).comp scheduleMatrix).pair bestNext).comp swap.optionMap |
|
|
| def bestRetain : Uniform (fun (n : ℕ) (x : BestState n) => |
| if x.2.2.isSome then x.2.2 else |
| (ThreeMachine.StackCompiler.scheduleMatrix x.1.2 (x.2.1+1)).map (fun t => (x.2.1+1,t))) := |
| (((snd.comp snd).comp optionIsSome).pair id).comp ((snd.comp snd).choose bestAttempt) |
|
|
| theorem time_bestMatrixStep (n : ℕ) (x : BestState n) : |
| bestMatrixStep.time n x = (fst.pair (bestNext.pair bestRetain)).time n x := by |
| simp only [bestMatrixStep,time_congr,bestNext,bestRetain,bestAttempt] |
| end ThreeMachine.StackCompiler.Uniform |
| namespace ThreeMachine.StackCompiler.Costs |
| variable {J : Type} (s n : J → ℕ) (U : ∀ j, Universe (n j)) (M : ∀ j, Matrix (n j)) |
| variable (k : J → ℕ) (o : ∀ j, Option (ℕ × (Fin (n j) → ℕ))) |
| variable (hn : Poly s n 1) (hk : Poly s k 1) (ho : Poly s (fun j => volume (o j)) 2) |
| include hn hk ho |
| theorem bestNext : Poly s (fun j => Uniform.bestNext.time (n j) ((U j,M j),(k j,o j))) 2 := by |
| poly_auto |
|
|
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Uniform |
| variable {I : Type u1} {α : I → Type u2} {β : I → Type u3} {γ : I → Type u4} |
| variable [∀ i, Coding (α i)] [∀ i, Coding (β i)] [∀ i, Coding (γ i)] |
| variable {f : ∀ i, α i → Option (β i)} {g : ∀ i, α i → γ i} |
|
|
| theorem time_attach_le (R : Uniform f) (K : Uniform g) (i : I) (x : α i) : |
| ((R.pair K).comp swap.optionMap).time i x ≤ |
| 10000000000*(R.time i x+K.time i x+volume x+volume (f i x)+volume (g i x)+1) := by |
| have hmem : ∀ b ∈ f i x, volume b ≤ volume (f i x) := by |
| intro b hb |
| rw [show f i x = Option.some b from hb,volume_some] |
| omega |
| have h := time_optionMap (swap : Uniform (fun i (a : β i × γ i) => (a.2,a.1))) i |
| (f i x) (g i x) (100*(volume (f i x)+volume (g i x)+1)) |
| (volume (f i x)+volume (g i x)+1) (by |
| intro b hb |
| have := hmem b hb |
| simp only [swap,time_pair,time_fst,time_snd,volume_pair] |
| omega) (by |
| intro b hb |
| have := hmem b hb |
| simp only [volume_pair] |
| omega) |
| simp only [time_comp,time_pair,volume_pair] |
| omega |
| end ThreeMachine.StackCompiler.Uniform |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Poly |
| variable {I : Type u5} {J : Type u6} {s : J → ℕ} {α : I → Type u7} {β : I → Type u8} {γ : I → Type u9} |
| variable [∀ i, Coding (α i)] [∀ i, Coding (β i)] [∀ i, Coding (γ i)] |
| variable {f : ∀ i, α i → β i} {g : ∀ i, β i → γ i} |
| variable (R : Uniform f) (S : Uniform g) (idx : J → I) (x : ∀ j, α (idx j)) {d : ℕ} |
|
|
| theorem compTimeSame (hR : Poly s (fun j => R.time (idx j) (x j)) d) |
| (hS : Poly s (fun j => S.time (idx j) (f (idx j) (x j))) d) |
| (hV : Poly s (fun j => volume (f (idx j) (x j))) d) : |
| Poly s (fun j => (R.comp S).time (idx j) (x j)) d := by |
| simp only [Uniform.time_comp] |
| have h := hV.add (const s 1) |
| have ht := (const s 10).mul h |
| simpa only [Nat.zero_add,Nat.max_zero,Nat.max_self] using (hR.add hS).add ht |
|
|
| variable {g' : ∀ i, α i → γ i} |
| theorem pairTimeSame (S : Uniform g') (hR : Poly s (fun j => R.time (idx j) (x j)) d) |
| (hS : Poly s (fun j => S.time (idx j) (x j)) d) |
| (hX : Poly s (fun j => volume (x j)) d) |
| (hF : Poly s (fun j => volume (f (idx j) (x j))) d) |
| (hG : Poly s (fun j => volume (g' (idx j) (x j))) d) : |
| Poly s (fun j => (R.pair S).time (idx j) (x j)) d := by |
| simp only [Uniform.time_pair] |
| have h := ((hX.add hF).add hG).add (const s 1) |
| have ht := (const s 20).mul h |
| simpa only [Nat.zero_add,Nat.max_zero,Nat.max_self] using (hR.add hS).add ht |
| end ThreeMachine.StackCompiler.Poly |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Costs |
| variable {J : Type} (s n : J → ℕ) (U : ∀ j, Universe (n j)) (M : ∀ j, Matrix (n j)) |
| variable (k : J → ℕ) (o : ∀ j, Option (ℕ × (Fin (n j) → ℕ))) |
| variable (hn : Poly s n 1) (hk : Poly s k 1) (ho : Poly s (fun j => volume (o j)) 2) |
| include hn hk ho |
|
|
| theorem bestAttempt : Poly s (fun j => Uniform.bestAttempt.time (n j) ((U j,M j),(k j,o j))) 150010 := by |
| let P : Uniform (fun (n : ℕ) (x : Uniform.BestState n) => (x.1.1,(x.2.1+1,x.1.2))) := |
| (Uniform.fst.comp Uniform.fst).pair (Uniform.bestNext.pair (Uniform.fst.comp Uniform.snd)) |
| have hsucc : Poly s (fun j => k j+1) 1 := hk.add (Poly.const s 1) |
| have hS := Poly.volumeSchedule s n (fun j => k j+1) M hn hsucc |
| have hN := bestNext s n U M k o hn hk ho |
| have hP : Poly s (fun j => P.time (n j) ((U j,M j),(k j,o j))) 2 := by |
| dsimp only [P] |
| poly_auto |
| have hV : Poly s (fun j => volume (U j,(k j+1,M j))) 2 := by poly_auto |
| have hST : Poly s (fun j => Uniform.scheduleMatrix.time (n j) (U j,(k j+1,M j))) 150010 := by |
| have hs : Poly s (fun j => n j+(k j+1)) 1 := hn.add hsucc |
| exact Poly.reparam (r := 1) (d := 150010) scheduleMatrix |
| (fun j => ⟨n j,(U j,(k j+1,M j))⟩) hs |
| have hSC := Poly.compTimeSame P Uniform.scheduleMatrix n (fun j => ((U j,M j),(k j,o j))) |
| (hP.lift (show 2 ≤ 150010 by decide)) hST (hV.lift (show 2 ≤ 150010 by decide)) |
| apply Poly.of_le (fun j => Uniform.time_attach_le (P.comp Uniform.scheduleMatrix) Uniform.bestNext |
| (n j) ((U j,M j),(k j,o j))) |
| poly_auto |
|
|
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Costs |
| variable {J : Type} (s n : J → ℕ) (U : ∀ j, Universe (n j)) (M : ∀ j, Matrix (n j)) |
| variable (k : J → ℕ) (o : ∀ j, Option (ℕ × (Fin (n j) → ℕ))) |
| variable (hn : Poly s n 1) (hk : Poly s k 1) (ho : Poly s (fun j => volume (o j)) 2) |
| include hn hk ho |
| theorem bestRetain : Poly s (fun j => Uniform.bestRetain.time (n j) ((U j,M j),(k j,o j))) 150010 := by |
| have hsucc : Poly s (fun j => k j+1) 1 := hk.add (Poly.const s 1) |
| have hS := Poly.volumeSchedule s n (fun j => k j+1) M hn hsucc |
| have hAV : Poly s (fun j => volume ((ThreeMachine.StackCompiler.scheduleMatrix (M j) (k j+1)).map (fun t => (k j+1,t)))) 2 := by |
| apply Poly.of_le (fun j => volume_tableBody (ThreeMachine.StackCompiler.scheduleMatrix (M j) (k j+1)) (k j+1)) |
| have hvn := Poly.volumeNat hsucc |
| exact (hS.add hvn).add (Poly.const s 1) |
| have hA := bestAttempt s n U M k o hn hk ho |
| poly_auto |
|
|
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Costs |
| variable {J : Type} (s n : J → ℕ) (U : ∀ j, Universe (n j)) (M : ∀ j, Matrix (n j)) |
| variable (k : J → ℕ) (o : ∀ j, Option (ℕ × (Fin (n j) → ℕ))) |
| variable (hn : Poly s n 1) (hk : Poly s k 1) (ho : Poly s (fun j => volume (o j)) 2) |
| include hn hk ho |
| theorem bestMatrixStep : |
| Poly s (fun j => Uniform.bestMatrixStep.time (n j) ((U j,M j),(k j,o j))) 150010 := by |
| have hsucc : Poly s (fun j => k j+1) 1 := hk.add (Poly.const s 1) |
| have hS := Poly.volumeSchedule s n (fun j => k j+1) M hn hsucc |
| have hAV : Poly s (fun j => volume ((ThreeMachine.StackCompiler.scheduleMatrix (M j) (k j+1)).map (fun t => (k j+1,t)))) 2 := by |
| apply Poly.of_le (fun j => volume_tableBody (ThreeMachine.StackCompiler.scheduleMatrix (M j) (k j+1)) (k j+1)) |
| have hvn := Poly.volumeNat hsucc |
| exact (hS.add hvn).add (Poly.const s 1) |
| have hRV := Poly.volumeIte (fun j => (o j).isSome = true) o |
| (fun j => (ThreeMachine.StackCompiler.scheduleMatrix (M j) (k j+1)).map (fun t => (k j+1,t))) ho hAV |
| have hN := bestNext s n U M k o hn hk ho |
| have hR := bestRetain s n U M k o hn hk ho |
| poly_auto |
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Poly |
| variable {I : Type u10} {J : Type u11} {s : J → ℕ} {α : I → Type u12} [∀ i, Coding (α i)] |
| abbrev StrictIterPool (m : J → ℕ) := Σ j, Fin (m j) |
| theorem iterateTimeStrict {f : ∀ i, α i → α i} (R : Uniform f) |
| (idx : J → I) (m : J → ℕ) (a : ∀ j, α (idx j)) {l t v : ℕ} |
| (hm : Poly s m l) |
| (ht : Poly (fun p : StrictIterPool m => s p.1) |
| (fun p => R.time (idx p.1) ((f (idx p.1))^[p.2.1] (a p.1))) t) |
| (hv : Poly (fun p : IterPool m => s p.1) |
| (fun p => volume ((f (idx p.1))^[p.2.1] (a p.1))) v) : |
| Poly s (fun j => R.iterate.time (idx j) (m j,a j)) (l+Max.max t (Max.max v l)) := by |
| obtain ⟨C,hC⟩ := ht |
| obtain ⟨D,hD⟩ := hv |
| have hT := powerBase s C t |
| have hV := powerBase s D v |
| apply of_le (fun j => Uniform.time_iterate_le R (idx j) (m j) (a j) |
| (C*(s j+2)^t) (D*(s j+2)^v) |
| (fun k hk => hC ⟨j,⟨k,hk⟩⟩) (fun k hk => hD ⟨j,⟨k,by omega⟩⟩)) |
| poly_bound |
| end ThreeMachine.StackCompiler.Poly |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Costs |
| variable {J : Type} (s n : J → ℕ) (U : ∀ j, Universe (n j)) (M : ∀ j, Matrix (n j)) |
| theorem bestMatrix (hn : Poly s n 1) : |
| Poly s (fun j => Uniform.bestMatrix.time (n j) (U j,M j)) 150011 := by |
| let a (j : J) : (Universe (n j) × Matrix (n j)) × (ℕ × Option (ℕ × (Fin (n j) → ℕ))) := |
| ((U j,M j),(0,none)) |
| have hnp := hn.precomp (Sigma.fst : Poly.IterPool n → J) |
| have hkp : Poly (fun p : Poly.IterPool n => s p.1) (fun p => p.2.1) 1 := |
| Poly.of_le (fun p : Poly.IterPool n => Nat.le_of_lt_succ p.2.isLt) hnp |
| have hbest := Poly.volumeBest (fun p : Poly.IterPool n => s p.1) (fun p => n p.1) |
| (fun p => p.2.1) (fun p => M p.1) hnp hkp |
| have hstep := bestMatrixStep (fun p : Poly.IterPool n => s p.1) (fun p => n p.1) |
| (fun p => U p.1) (fun p => M p.1) (fun p => p.2.1) (fun p => ThreeMachine.StackCompiler.bestMatrix (M p.1) p.2.1) |
| hnp hkp hbest |
| have hti : Poly (fun p : Poly.IterPool n => s p.1) |
| (fun p => Uniform.bestMatrixStep.time (n p.1) |
| (ThreeMachine.StackCompiler.bestMatrixStep^[p.2.1] (a p.1))) 150010 := by |
| simpa only [a,bestMatrix_iterate] using hstep |
| have hvi : Poly (fun p : Poly.IterPool n => s p.1) |
| (fun p => volume (ThreeMachine.StackCompiler.bestMatrixStep^[p.2.1] (a p.1))) 2 := by |
| simp only [a,bestMatrix_iterate] |
| poly_auto |
| have hIter := Poly.iterateTime Uniform.bestMatrixStep n n a hn hti hvi |
| have hB := Poly.volumeBest s n n M hn hn |
| dsimp only [a] at hIter |
| simp only [Uniform.bestMatrix,Uniform.time_congr,Uniform.time_comp,Uniform.time_pair, |
| Uniform.time_fst,Uniform.time_snd,Function.comp_apply] |
| simp only [bestMatrix_iterate] |
| poly_auto |
| end ThreeMachine.StackCompiler.Costs |
| end |
|
|
| end OAI |
|
|
