Download data/lean/OAI/Computability/Scheduling/OptimumCosts.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 10.8 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/Scheduling/OptimumCosts.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/Scheduling/OptimumCosts.lean
-
curl -L -o OptimumCosts.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/Scheduling/OptimumCosts.lean
10.8 kB
| 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 | |