| import OAI.Computability.Scheduling.FiniteRoutines |
|
|
| namespace OAI |
|
|
| universe u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13 u14 u15 u16 u17 u18 |
|
|
| 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 × γ i → β i} |
|
|
| theorem time_mapBody (R : Uniform f) (i : I) (a : α i) (e : γ i) (ys : List (β i)) : |
| (mapBody R).time i (a,(e,ys)) ≤ R.time i (a,e)+ |
| 1000*(volume a+volume e+volume ys+volume (f i (a,e))+1) := by |
| simp only [mapBody,time_pair,time_comp,time_fst,time_snd,time_cons,volume_pair,volume_cons,Function.comp_apply] |
| omega |
|
|
| theorem foldTime_mapBody (R : Uniform f) (i : I) (e : γ i) (T : ℕ) |
| (xs : List (α i)) (ys : List (β i)) |
| (hT : ∀ a ∈ xs, R.time i (a,e) ≤ T) : |
| Realizer.foldTime ((mapBody R).specialize i) (e,ys) xs ≤ |
| xs.length*(T+4000*(volume xs+volume e+volume (xs.map (fun a => f i (a,e)))+volume ys+1))+1 := by |
| induction xs generalizing ys with |
| | nil => simp only [Realizer.foldTime,List.length_nil,Nat.zero_mul,Nat.zero_add]; rfl |
| | cons a xs ih => |
| have hta := hT a (by simp) |
| have ht := ih (f i (a,e) :: ys) (fun a ha => hT a (by simp [ha])) |
| have hb := time_mapBody R i a e ys |
| simp only [Realizer.foldTime] |
| change (mapBody R).time i (a,(e,ys))+ |
| Realizer.foldTime ((mapBody R).specialize i) (e,f i (a,e) :: ys) xs+ |
| 20*(volume (a :: xs)+volume (e,ys)+volume (e,f i (a,e) :: ys)+1) ≤ _ |
| simp only [volume_pair,volume_cons,List.length_cons,List.map_cons] at ht hb ⊢ |
| nlinarith [volume_pos a,volume_pos e,volume_pos ys,volume_pos xs,volume_pos (f i (a,e))] |
|
|
| theorem time_map (R : Uniform f) (i : I) (xs : List (α i)) (e : γ i) (T : ℕ) |
| (hT : ∀ a ∈ xs, R.time i (a,e) ≤ T) : |
| R.map.time i (xs,e) ≤ |
| 30000*(xs.length+1)*(T+volume xs+volume e+volume (xs.map (fun a => f i (a,e)))+1) := by |
| have hf := foldTime_mapBody R i e T xs [] hT |
| have hr := time_reverse i ((xs.map (fun a => f i (a,e))).reverse) |
| simp only [volume_nil] at hf |
| simp only [List.length_reverse,List.length_map,volume_reverse] at hr |
| simp only [map,time_congr,time_comp,time_pair,time_fst,time_snd,time_nil,time_fold, |
| Function.comp_apply,Realizer.map_fold_eq,List.append_nil,volume_pair,volume_nil,volume_reverse] |
| nlinarith [volume_pos xs,volume_pos e,volume_pos (xs.map (fun a => f i (a,e)))] |
|
|
| end ThreeMachine.StackCompiler.Uniform |
|
|
| namespace ThreeMachine.StackCompiler |
|
|
| def lookupList {K : Type u5} {V : Type u6} [DecidableEq K] : List (K × V) → K → Option V |
| | [], _ => none |
| | (a,b) :: xs, k => if a = k then some b else lookupList xs k |
|
|
| namespace Uniform |
| variable {I : Type u7} {α : I → Type u8} {β : I → Type u9} {γ : I → Type u10} |
| variable [∀ i, Coding (α i)] [∀ i, Coding (β i)] [∀ i, Coding (γ i)] |
|
|
| def mapList {f : ∀ i, α i → β i} (R : Uniform f) : |
| Uniform (fun i (xs : List (α i)) => xs.map (f i)) := |
| ((id.pair unit).comp (fst.comp R).map).congr (fun _ _ => rfl) |
|
|
| def mapOption {f : ∀ i, α i → β i} (R : Uniform f) : |
| Uniform (fun i (x : Option (α i)) => x.map (f i)) := |
| ((id.pair unit).comp (fst.comp R).optionMap).congr (fun _ _ => rfl) |
|
|
| def bindOption {f : ∀ i, α i × γ i → Option (β i)} (R : Uniform f) : |
| Uniform (fun i (x : Option (α i) × γ i) => x.1.bind (fun a => f i (a,x.2))) := |
| (((optionToList.onFst.comp R.filterMap).comp head?)).congr (fun _ x => by |
| rcases x with ⟨o,e⟩; cases o with |
| | none => rfl |
| | some a => simp only [Function.comp_apply,Option.toList_some,List.filterMap_cons,List.filterMap_nil,Option.bind_some]; cases f _ (a,e) <;> rfl) |
|
|
| def optionOrElse : Uniform (fun (i : I) (x : Option (α i) × Option (α i)) => x.1.or x.2) := |
| (fst.comp optionIsSome).ite fst snd |>.congr (fun _ x => by |
| rcases x with ⟨o,e⟩; cases o <;> rfl) |
|
|
| def lookup [∀ i, DecidableEq (α i)] |
| (E : Uniform (fun i (x : α i × α i) => decide (x.1 = x.2))) : |
| Uniform (fun i (x : List (α i × β i) × α i) => lookupList x.1 x.2) := |
| ((((fst.comp fst).pair snd).comp E).find?.comp snd.mapOption).congr (fun i x => by |
| dsimp only [Function.comp_apply] |
| induction x.1 with |
| | nil => rfl |
| | cons a xs ih => |
| by_cases ha : a.1 = x.2 <;> simp [lookupList,ha,ih]) |
|
|
| end Uniform |
| end ThreeMachine.StackCompiler |
|
|
| namespace ThreeMachine.StackCompiler.Uniform |
| variable {I : Type u11} {J : Type u12} {α : I → Type u13} {β : I → Type u14} {γ : I → Type u15} |
| variable [∀ i, Coding (α i)] [∀ i, Coding (β i)] [∀ i, Coding (γ i)] |
| variable {f : ∀ i, α i → β i} |
|
|
| def reindex (R : Uniform f) (φ : J → I) : Uniform (fun j => f (φ j)) where |
| transform := R.transform |
| charge := R.charge |
| routine := R.routine |
| correct j x := R.correct (φ j) x |
|
|
| def finValue (d : I → ℕ) : Uniform (fun i (x : Fin (d i)) => x.val) := |
| reinterpret _ (fun _ _ => rfl) |
|
|
| def cardinalValue (d : I → ℕ) : Uniform (fun i (_ : Cardinal (d i)) => d i) := |
| reinterpret _ (fun _ _ => rfl) |
|
|
| def universeListAny (d : I → ℕ) : Uniform (fun i (_ : Universe (d i)) => List.finRange (d i)) := |
| reinterpret _ (fun _ _ => rfl) |
|
|
| def makeUniverseAny (d : I → ℕ) : Uniform (fun i (_ : Cardinal (d i)) => (Universe.mk () : Universe (d i))) := |
| makeUniverse.reindex d |
|
|
| def functionListAny (d : I → ℕ) : Uniform (fun i (f : Fin (d i) → α i) => List.ofFn f) := |
| reinterpret _ (fun _ _ => rfl) |
|
|
| def functionGetOptionAny (d : I → ℕ) : |
| Uniform (fun i (x : (Fin (d i) → α i) × Fin (d i)) => Option.some (x.1 x.2)) := |
| (((fst.comp (functionListAny d)).pair (snd.comp (finValue d))).comp getElem?).congr (fun _ x => by |
| simp only [Function.comp_apply,List.getElem?_ofFn,dite_eq_left x.2.isLt]) |
|
|
| def functionGetAny (d : I → ℕ) : Uniform (fun i (x : (Fin (d i) → α i) × Fin (d i)) => x.1 x.2) where |
| transform := Data.head ∘ (functionGetOptionAny (α := α) d).transform |
| charge := _ |
| routine := (functionGetOptionAny (α := α) d).routine.comp (Routine.select true) |
| correct i x := by |
| simp only [Function.comp_apply,(functionGetOptionAny (α := α) d).correct,enc_some,Data.head] |
|
|
| def vectorMapAny (d : I → ℕ) {f : ∀ i, Fin (d i) × α i → β i} (R : Uniform f) : |
| Uniform (fun i (x : Universe (d i) × α i) => fun v => f i (v,x.2)) where |
| transform := ((universeListAny d).onFst.comp R.map).transform |
| charge := ((universeListAny d).onFst.comp R.map).charge |
| routine := ((universeListAny d).onFst.comp R.map).routine |
| correct i x := by |
| rw [((universeListAny d).onFst.comp R.map).correct] |
| simp only [Function.comp_apply,enc_function,List.ofFn_eq_map] |
|
|
| def recode {H : Type u16} {δ : H → Type u17} {ε : H → Type u18} [∀ h, Coding (δ h)] [∀ h, Coding (ε h)] |
| {g : ∀ h, δ h → ε h} (R : Uniform g) (f : ∀ i, α i → β i) |
| (h : ∀ i x, ∃ j y, enc y = enc x ∧ enc (g j y) = enc (f i x)) : Uniform f where |
| transform := R.transform |
| charge := R.charge |
| routine := R.routine |
| correct i x := by |
| obtain ⟨j,y,hin,hout⟩ := h i x |
| rw [← hin,R.correct,hout] |
|
|
| def cardinalMap (d : I → ℕ) {g : ℕ → ℕ} (R : Realizer g) : |
| Uniform (fun i (_ : Cardinal (d i)) => (Cardinal.mk () : Cardinal (g (d i)))) where |
| transform := R.transform |
| charge := R.charge |
| routine := R.routine |
| correct i _ := R.correct (d i) |
|
|
| end ThreeMachine.StackCompiler.Uniform |
|
|
| end |
|
|
| end OAI |
|
|
