Download data/lean/OAI/Computability/Scheduling/ListParserCosts.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 13.8 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/Scheduling/ListParserCosts.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/Scheduling/ListParserCosts.lean
-
curl -L -o ListParserCosts.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/Scheduling/ListParserCosts.lean
13.8 kB
| import OAI.Computability.Scheduling.ReaderCosts | |
| namespace OAI | |
| section | |
| namespace ThreeMachine.StackCompiler.Binary | |
| variable {Ξ± : Type} | |
| theorem readNat_listHeader (enc : Ξ± β List Bool) (xs : List Ξ±) (rest : List Bool) : | |
| readNat (ThreeMachine.encodeList enc xs ++ rest) = (xs.length,xs.flatMap enc ++ rest) := by | |
| simp only [ThreeMachine.encodeList,List.append_assoc,readNat_encodeNat] | |
| theorem readAtSuffix {encode : Ξ± β List Bool} {reader : List Bool β Ξ± Γ List Bool} | |
| (hr : β a rest, reader (encode a ++ rest) = (a,rest)) (xs : List Ξ±) (rest : List Bool) | |
| (k : β) (hk : k < xs.length) : | |
| reader ((xs.drop k).flatMap encode ++ rest) = (xs[k],(xs.drop (k+1)).flatMap encode ++ rest) := by | |
| rw [List.drop_eq_getElem_cons hk,List.flatMap_cons,List.append_assoc,hr] | |
| end ThreeMachine.StackCompiler.Binary | |
| namespace ThreeMachine.StackCompiler.Realizer | |
| theorem time_pred (n : β) : pred.time n = volume n+2 := rfl | |
| end ThreeMachine.StackCompiler.Realizer | |
| namespace ThreeMachine.StackCompiler.Uniform | |
| variable {I : Type} {Ξ± : I β Type} [β i, Coding (Ξ± i)] | |
| theorem time_binaryReadList {reader : β i, List Bool β Ξ± i Γ List Bool} (R : Uniform reader) | |
| (i : I) (bs : List Bool) : | |
| R.binaryReadList.time i bs = binaryReadNat.time i bs + | |
| R.binaryReadMany.time i (Binary.readNat bs)+10*(volume (Binary.readNat bs)+1) := by | |
| change (binaryReadNat.comp R.binaryReadMany).time i bs = _ | |
| exact time_comp _ _ _ _ | |
| theorem time_binaryReadEdge_le (i : I) (bs : List Bool) : | |
| (binaryReadEdge (I := I)).time i bs β€ 1000*(binaryReadNat.time i bs+ | |
| binaryReadNat.time i (Binary.readNat bs).2+volume bs+ | |
| volume (Binary.readNat bs)+volume (Binary.readNat (Binary.readNat bs).2)+1) := by | |
| let A := binaryReadNat (I := I) | |
| let B := A.comp (snd.comp binaryReadNat) | |
| change (((A.comp (fst.comp (Realizer.pred.uniform I))).pair | |
| (B.comp (fst.comp (Realizer.pred.uniform I)))).pair (B.comp snd)).time i bs β€ _ | |
| simp only [A,B,time_pair,time_comp,time_snd,time_fst,time_uniform,Realizer.time_pred, | |
| Function.comp_apply,volume_prod,volume_nat,Nat.pred_eq_sub_one] | |
| omega | |
| end ThreeMachine.StackCompiler.Uniform | |
| namespace ThreeMachine.StackCompiler.Costs | |
| variable {I J : Type} (s : J β β) (idx : J β I) | |
| theorem volumeNatBools (k : J β β) (bs : J β List Bool) | |
| (hk : Poly s k 1) (hb : Poly s (fun j => (bs j).length) 1) : | |
| Poly s (fun j => volume (k j,bs j)) 1 := by | |
| have hv := Poly.of_le (fun j : J => volume_boolList_le (bs j)) | |
| (show Poly s (fun j => 4*(bs j).length+1) 1 from by poly_auto) | |
| simp only [volume_pair,volume_nat] | |
| poly_auto | |
| theorem binaryReadNatEncoded (k : J β β) (rest : J β List Bool) | |
| (hk : Poly s k 1) (hl : Poly s (fun j => (ThreeMachine.encodeNat (k j) ++ rest j).length) 1) : | |
| Poly s (fun j => (Uniform.binaryReadNat (I := I)).time (idx j) (ThreeMachine.encodeNat (k j) ++ rest j)) 3 := by | |
| apply binaryReadNat s idx _ hl | |
| simpa only [Binary.readNat_encodeNat] using hk | |
| theorem binaryReadEdgeCost (bs : J β List Bool) | |
| (hA : Poly s (fun j => (Uniform.binaryReadNat (I := I)).time (idx j) (bs j)) 3) | |
| (hB : Poly s (fun j => (Uniform.binaryReadNat (I := I)).time (idx j) (Binary.readNat (bs j)).2) 3) | |
| (hvI : Poly s (fun j => volume (bs j)) 1) | |
| (hvA : Poly s (fun j => volume (Binary.readNat (bs j))) 1) | |
| (hvB : Poly s (fun j => volume (Binary.readNat (Binary.readNat (bs j)).2)) 1) : | |
| Poly s (fun j => (Uniform.binaryReadEdge (I := I)).time (idx j) (bs j)) 3 := by | |
| apply Poly.of_le (fun j : J => Uniform.time_binaryReadEdge_le (idx j) (bs j)) | |
| poly_auto | |
| theorem binaryReadEdgeEncoded (edge : J β β Γ β) (rest : J β List Bool) | |
| (ha : Poly s (fun j => (edge j).1) 1) (hb : Poly s (fun j => (edge j).2) 1) | |
| (hl : Poly s (fun j => (Binary.encodeEdge (edge j) ++ rest j).length) 1) : | |
| Poly s (fun j => (Uniform.binaryReadEdge (I := I)).time (idx j) (Binary.encodeEdge (edge j) ++ rest j)) 3 := by | |
| have he (j) : Binary.readNat (Binary.encodeEdge (edge j) ++ rest j) = | |
| ((edge j).1+1,ThreeMachine.encodeNat ((edge j).2+1) ++ rest j) := by | |
| simp only [Binary.encodeEdge,List.append_assoc,Binary.readNat_encodeNat] | |
| have ha1 : Poly s (fun j => (edge j).1+1) 1 := ha.add (Poly.const s 1) | |
| have hb1 : Poly s (fun j => (edge j).2+1) 1 := hb.add (Poly.const s 1) | |
| have hA := binaryReadNat s idx (fun j => Binary.encodeEdge (edge j) ++ rest j) hl | |
| (show Poly s (fun j => (Binary.readNat (Binary.encodeEdge (edge j) ++ rest j)).1) 1 from by | |
| simpa only [he] using ha1) | |
| have hRest : Poly s (fun j => (ThreeMachine.encodeNat ((edge j).2+1) ++ rest j).length) 1 := by | |
| apply Poly.of_le _ hl | |
| intro j | |
| simp only [List.length_append,Binary.encodeEdge] | |
| omega | |
| have hB := binaryReadNatEncoded s idx (fun j => (edge j).2+1) rest hb1 hRest | |
| have hvA : Poly s (fun j => volume (Binary.readNat (Binary.encodeEdge (edge j) ++ rest j))) 1 := by | |
| simp only [he] | |
| exact volumeNatBools s (fun j => (edge j).1+1) _ ha1 hRest | |
| have hrl : Poly s (fun j => (rest j).length) 1 := | |
| Poly.of_le (fun j : J => by simp only [List.length_append]; omega) hRest | |
| have hvB : Poly s (fun j => volume (Binary.readNat (ThreeMachine.encodeNat ((edge j).2+1) ++ rest j))) 1 := by | |
| simp only [Binary.readNat_encodeNat] | |
| exact volumeNatBools s (fun j => (edge j).2+1) _ hb1 hrl | |
| have hExact : Poly s (fun j => (Uniform.binaryReadNat (I := I)).time (idx j) | |
| (Binary.readNat (Binary.encodeEdge (edge j) ++ rest j)).2) 3 := by simpa only [he] using hB | |
| have hvExact : Poly s (fun j => volume (Binary.readNat (Binary.readNat (Binary.encodeEdge (edge j) ++ rest j)).2)) 1 := by | |
| simpa only [he] using hvB | |
| have hvIn : Poly s (fun j => volume (Binary.encodeEdge (edge j) ++ rest j)) 1 := | |
| Poly.of_le (fun j => volume_boolList_le _) ((Poly.const s 4 |>.mul hl).add (Poly.const s 1)) | |
| exact binaryReadEdgeCost s idx _ hA hExact hvIn hvA hvExact | |
| variable {Ξ± : I β Type} [β i, Coding (Ξ± i)] | |
| theorem binaryReadListEncoded {reader : β i, List Bool β Ξ± i Γ List Bool} (R : Uniform reader) | |
| (encode : β i, Ξ± i β List Bool) | |
| (hr : β i a rest, reader i (encode i a ++ rest) = (a,rest)) | |
| (xs : β j, List (Ξ± (idx j))) (rest : J β List Bool) | |
| (hl : Poly s (fun j => (xs j).length) 1) | |
| (hb : Poly s (fun j => (ThreeMachine.encodeList (encode (idx j)) (xs j) ++ rest j).length) 1) | |
| (hx : Poly s (fun j => volume (xs j)) 2) | |
| (ht : Poly (fun p : Poly.StrictIterPool (fun j => (xs j).length) => s p.1) | |
| (fun p => R.time (idx p.1) (((xs p.1).drop p.2.1).flatMap (encode (idx p.1)) ++ rest p.1)) 3) | |
| (hv : Poly (fun p : Poly.StrictIterPool (fun j => (xs j).length) => s p.1) | |
| (fun p => volume (reader (idx p.1) (((xs p.1).drop p.2.1).flatMap (encode (idx p.1)) ++ rest p.1))) 2) : | |
| Poly s (fun j => R.binaryReadList.time (idx j) (ThreeMachine.encodeList (encode (idx j)) (xs j) ++ rest j)) 4 := by | |
| have hpay : Poly s (fun j => ((xs j).flatMap (encode (idx j)) ++ rest j).length) 1 := by | |
| apply Poly.of_le _ hb | |
| intro j | |
| simp only [ThreeMachine.encodeList,List.length_append] | |
| omega | |
| have hM := binaryReadManyEncoded s idx R encode hr xs rest hl hpay hx ht hv | |
| have hN := binaryReadNat s idx (fun j => ThreeMachine.encodeList (encode (idx j)) (xs j) ++ rest j) hb | |
| (show Poly s (fun j => (Binary.readNat (ThreeMachine.encodeList (encode (idx j)) (xs j) ++ rest j)).1) 1 from by | |
| simpa only [Binary.readNat_listHeader] using hl) | |
| have hExact : Poly s (fun j => R.binaryReadMany.time (idx j) | |
| (Binary.readNat (ThreeMachine.encodeList (encode (idx j)) (xs j) ++ rest j))) 4 := by | |
| simpa only [Binary.readNat_listHeader] using hM | |
| have hvN : Poly s (fun j => volume (Binary.readNat (ThreeMachine.encodeList (encode (idx j)) (xs j) ++ rest j))) 1 := by | |
| simp only [Binary.readNat_listHeader] | |
| exact volumeNatBools s _ _ hl hpay | |
| simp only [Uniform.time_binaryReadList] | |
| poly_auto | |
| end ThreeMachine.StackCompiler.Costs | |
| end | |
| section | |
| namespace ThreeMachine.StackCompiler.Costs | |
| variable {I J : Type} (s : J β β) (idx : J β I) | |
| theorem binaryNatList (xs : J β List β) (rest : J β List Bool) (K : J β β) | |
| (hl : Poly s (fun j => (xs j).length) 1) (hK : Poly s K 1) | |
| (hB : β j a, a β xs j β a β€ K j) | |
| (hb : Poly s (fun j => (ThreeMachine.encodeList ThreeMachine.encodeNat (xs j) ++ rest j).length) 1) : | |
| Poly s (fun j => (Uniform.binaryReadNat (I := I)).binaryReadList.time (idx j) | |
| (ThreeMachine.encodeList ThreeMachine.encodeNat (xs j) ++ rest j)) 4 := by | |
| let P := Poly.StrictIterPool (fun j => (xs j).length) | |
| let sp (p : P) := s p.1 | |
| let a (p : P) := (xs p.1)[p.2.val] | |
| let suf (p : P) := ((xs p.1).drop p.2.val).flatMap ThreeMachine.encodeNat ++ rest p.1 | |
| have hpay : Poly s (fun j => ((xs j).flatMap ThreeMachine.encodeNat ++ rest j).length) 1 := by | |
| apply Poly.of_le _ hb | |
| intro j | |
| simp only [ThreeMachine.encodeList,List.length_append] | |
| omega | |
| have hsuf : Poly sp (fun p => (suf p).length) 1 := by | |
| apply Poly.of_le (fun p : P => Binary.flatMap_drop_length _ _ _ _) | |
| exact hpay.precomp Sigma.fst | |
| have hafter : Poly sp (fun p => (((xs p.1).drop (p.2.val+1)).flatMap ThreeMachine.encodeNat ++ rest p.1).length) 1 := by | |
| apply Poly.of_le (fun p : P => Binary.flatMap_drop_length _ _ _ _) | |
| exact hpay.precomp Sigma.fst | |
| have ha : Poly sp a 1 := Poly.of_le (fun p => hB p.1 (a p) (List.getElem_mem _)) (hK.precomp Sigma.fst) | |
| have he (p : P) : Binary.readNat (suf p) = | |
| (a p,((xs p.1).drop (p.2.val+1)).flatMap ThreeMachine.encodeNat ++ rest p.1) := | |
| Binary.readAtSuffix Binary.readNat_encodeNat (xs p.1) (rest p.1) _ p.2.isLt | |
| have hval : Poly sp (fun p => (Binary.readNat (suf p)).1) 1 := by simpa only [he] using ha | |
| have hT := binaryReadNat sp (fun p => idx p.1) suf hsuf hval | |
| have hV : Poly sp (fun p => volume (Binary.readNat (suf p))) 2 := by | |
| simp only [he] | |
| exact (volumeNatBools sp a _ ha hafter).lift (by omega) | |
| have hX : Poly s (fun j => volume (xs j)) 2 := by | |
| apply Poly.volumeList hl (show Poly s (fun j => 2*K j+1) 1 from by poly_bound) | |
| intro j a ha | |
| rw [volume_nat] | |
| have := hB j a ha | |
| omega | |
| exact binaryReadListEncoded s idx (Uniform.binaryReadNat (I := I)) (fun _ => ThreeMachine.encodeNat) | |
| (fun _ => Binary.readNat_encodeNat) xs rest hl hb hX hT hV | |
| end ThreeMachine.StackCompiler.Costs | |
| end | |
| section | |
| namespace ThreeMachine.StackCompiler.Costs | |
| variable {I J : Type} (s : J β β) (idx : J β I) | |
| theorem binaryEdgeList (xs : J β List (β Γ β)) (rest : J β List Bool) (K : J β β) | |
| (hl : Poly s (fun j => (xs j).length) 1) (hK : Poly s K 1) | |
| (hB : β j a, a β xs j β a.1 β€ K j β§ a.2 β€ K j) | |
| (hb : Poly s (fun j => (ThreeMachine.encodeList Binary.encodeEdge (xs j) ++ rest j).length) 1) : | |
| Poly s (fun j => (Uniform.binaryReadEdge (I := I)).binaryReadList.time (idx j) | |
| (ThreeMachine.encodeList Binary.encodeEdge (xs j) ++ rest j)) 4 := by | |
| let P := Poly.StrictIterPool (fun j => (xs j).length) | |
| let sp (p : P) := s p.1 | |
| let a (p : P) := (xs p.1)[p.2.val] | |
| let suf (p : P) := ((xs p.1).drop p.2.val).flatMap Binary.encodeEdge ++ rest p.1 | |
| have hpay : Poly s (fun j => ((xs j).flatMap Binary.encodeEdge ++ rest j).length) 1 := by | |
| apply Poly.of_le _ hb | |
| intro j | |
| simp only [ThreeMachine.encodeList,List.length_append] | |
| omega | |
| have hsuf : Poly sp (fun p => (suf p).length) 1 := by | |
| apply Poly.of_le (fun p : P => Binary.flatMap_drop_length _ _ _ _) | |
| exact hpay.precomp Sigma.fst | |
| have hafter : Poly sp (fun p => (((xs p.1).drop (p.2.val+1)).flatMap Binary.encodeEdge ++ rest p.1).length) 1 := by | |
| apply Poly.of_le (fun p : P => Binary.flatMap_drop_length _ _ _ _) | |
| exact hpay.precomp Sigma.fst | |
| have ha : Poly sp (fun p => (a p).1) 1 := | |
| Poly.of_le (fun p => (hB p.1 (a p) (List.getElem_mem _)).1) (hK.precomp Sigma.fst) | |
| have hc : Poly sp (fun p => (a p).2) 1 := | |
| Poly.of_le (fun p => (hB p.1 (a p) (List.getElem_mem _)).2) (hK.precomp Sigma.fst) | |
| have hs (p : P) : suf p = Binary.encodeEdge (a p) ++ | |
| ((xs p.1).drop (p.2.val+1)).flatMap Binary.encodeEdge ++ rest p.1 := by | |
| dsimp [suf,a] | |
| rw [List.drop_eq_getElem_cons p.2.isLt,List.flatMap_cons,List.append_assoc] | |
| have hlenc : Poly sp (fun p => (Binary.encodeEdge (a p) ++ | |
| (((xs p.1).drop (p.2.val+1)).flatMap Binary.encodeEdge ++ rest p.1)).length) 1 := by | |
| simpa only [hs,List.append_assoc] using hsuf | |
| have hT0 := binaryReadEdgeEncoded sp (fun p => idx p.1) a | |
| (fun p => ((xs p.1).drop (p.2.val+1)).flatMap Binary.encodeEdge ++ rest p.1) ha hc hlenc | |
| have hT : Poly sp (fun p => (Uniform.binaryReadEdge (I := I)).time (idx p.1) (suf p)) 3 := by | |
| simpa only [hs,List.append_assoc] using hT0 | |
| have he (p : P) : Binary.readEdge (suf p) = | |
| (a p,((xs p.1).drop (p.2.val+1)).flatMap Binary.encodeEdge ++ rest p.1) := | |
| Binary.readAtSuffix Binary.readEdge_correct (xs p.1) (rest p.1) _ p.2.isLt | |
| have hV : Poly sp (fun p => volume (Binary.readEdge (suf p))) 2 := by | |
| simp only [he,volume_prod,volume_nat] | |
| have hbV := Poly.of_le (fun p : P => volume_boolList_le | |
| (((xs p.1).drop (p.2.val+1)).flatMap Binary.encodeEdge ++ rest p.1)) | |
| (show Poly sp (fun p => 4*((((xs p.1).drop (p.2.val+1)).flatMap Binary.encodeEdge ++ rest p.1).length)+1) 1 from by poly_bound) | |
| poly_auto | |
| have hX : Poly s (fun j => volume (xs j)) 2 := by | |
| apply Poly.volumeList hl (show Poly s (fun j => 4*K j+3) 1 from by poly_bound) | |
| intro j a ha | |
| rw [volume_prod,volume_nat,volume_nat] | |
| have := hB j a ha | |
| omega | |
| exact binaryReadListEncoded s idx (Uniform.binaryReadEdge (I := I)) (fun _ => Binary.encodeEdge) | |
| (fun _ => Binary.readEdge_correct) xs rest hl hb hX hT hV | |
| end ThreeMachine.StackCompiler.Costs | |
| end | |
| end OAI | |