| 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 |
|
|
