| import OAI.Computability.Scheduling.PolynomialLoops |
| |
| namespace OAI |
|
|
| universe u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13 u14 u15 u16 |
|
|
| section |
| namespace ThreeMachine.StackCompiler |
|
|
| @[simp] theorem volume_block {n : ℕ} (b : Algorithm.Block (Fin n)) : |
| volume b = volume b.length+volume b.time+1 := by |
| change volume (b.length,b.time) = _ |
| rw [volume_pair] |
|
|
| theorem block_length_le_volume {n : ℕ} (b : Algorithm.Block (Fin n)) : b.length ≤ volume b := by |
| rw [volume_block,volume_nat] |
|
|
| theorem block_time_volume_le {n : ℕ} (b : Algorithm.Block (Fin n)) : volume b.time ≤ volume b := by |
| rw [volume_block] |
|
|
| namespace Poly |
| variable {J : Type u1} {s n : J → ℕ} {d e : ℕ} |
| theorem blockLength (b : ∀ j, Algorithm.Block (Fin (n j))) |
| (h : Poly s (fun j => volume (b j)) d) : Poly s (fun j => (b j).length) d := |
| of_le (fun j => block_length_le_volume (b j)) h |
|
|
| theorem blockTime (b : ∀ j, Algorithm.Block (Fin (n j))) |
| (h : Poly s (fun j => volume (b j)) d) : Poly s (fun j => volume (b j).time) d := |
| of_le (fun j => block_time_volume_le (b j)) h |
|
|
| theorem volumeBlock (b : ∀ j, Algorithm.Block (Fin (n j))) |
| (hl : Poly s (fun j => (b j).length) d) |
| (ht : Poly s (fun j => volume (b j).time) e) : Poly s (fun j => volume (b j)) (Max.max d e) := by |
| simp only [volume_block,volume_nat] |
| poly_bound |
|
|
| variable {α : J → Type u2} {β : J → Type u3} [∀ j, Coding (α j)] [∀ j, Coding (β j)] |
| theorem volumeFst (p : ∀ j, α j × β j) (h : Poly s (fun j => volume (p j)) d) : |
| Poly s (fun j => volume (p j).1) d := of_le (fun j => by rw [volume_prod] |
|
|
| theorem volumeSnd (p : ∀ j, α j × β j) (h : Poly s (fun j => volume (p j)) d) : |
| Poly s (fun j => volume (p j).2) d := of_le (fun j => by rw [volume_prod] |
|
|
| omit [∀ j, Coding (β j)] in |
| theorem volumeOption (o : ∀ j, Option (α j)) {v : J → ℕ} |
| (h : Poly s v d) (hv : ∀ j, ∀ a ∈ o j, volume a ≤ v j) : Poly s (fun j => volume (o j)) d := by |
| apply of_le (fun j => volume_option_le (o j) (v j) (hv j)) |
| poly_bound |
|
|
| omit [∀ j, Coding (β j)] in |
| theorem volumeOptionSome (a : ∀ j, α j) (h : Poly s (fun j => volume (a j)) d) : |
| Poly s (fun j => volume (some (a j))) d := by simp only [volume_some] |
|
|
| omit [∀ j, Coding (β j)] in |
| theorem volumeOptionNone (s : J → ℕ) : Poly s (fun j => volume (none : Option (α j))) 0 := by |
| simp only [volume_none] |
|
|
| end Poly |
| end ThreeMachine.StackCompiler |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Poly |
| variable {I : Type u4} {J : Type u5} {s : J → ℕ} |
| variable {α : I → Type u6} {β : I → Type u7} {γ : I → Type u8} [∀ i, Coding (α i)] [∀ i, Coding (β i)] [∀ i, Coding (γ i)] |
| variable (idx : J → I) (xs : ∀ j, List (α (idx j))) (e : ∀ j, γ (idx j)) |
| |
| theorem flatMapTime {f : ∀ i, α i × γ i → List (β i)} (R : Uniform f) {l t vx ve v : ℕ} |
| (hl : Poly s (fun j => (xs j).length) l) |
| (ht : Poly (fun p : Pool idx xs => s p.1) |
| (fun p => R.time (idx p.1) (p.2.1,e p.1)) t) |
| (hx : Poly s (fun j => volume (xs j)) vx) |
| (he : Poly s (fun j => volume (e j)) ve) |
| (hv : Poly (fun p : Pool idx xs => s p.1) |
| (fun p => volume (f (idx p.1) (p.2.1,e p.1))) v) : |
| Poly s (fun j => R.flatMap.time (idx j) (xs j,e j)) |
| (l+v+Max.max t (Max.max vx (Max.max ve (l+v)))) := by |
| have hm := volumeMap idx xs e (β := fun i => List (β i)) hl hv |
| have hfV : Poly s (fun j => volume ((xs j).flatMap (fun a => f (idx j) (a,e j)))) (l+v) := by |
| have hv (j : J) : volume ((xs j).flatMap (fun a => f (idx j) (a,e j))) ≤ |
| volume ((xs j).map (fun a => f (idx j) (a,e j))) := by |
| rw [volume_flatten,← List.flatMap_def] |
| omega |
| exact of_le hv hm |
| have hf := lengthVolume _ hfV |
| obtain ⟨C,hC⟩ := ht |
| have hT := powerBase s C t |
| apply of_le (fun j => Uniform.time_flatMap R (idx j) (xs j) (e j) |
| (C*(s j+2)^t) (fun a ha => hC ⟨j,⟨a,ha⟩⟩)) |
| poly_bound |
|
|
| variable (o : ∀ j, Option (α (idx j))) |
| |
| theorem optionMapTime {f : ∀ i, α i × γ i → β i} (R : Uniform f) {t vo ve v : ℕ} |
| (ht : Poly (fun p : Pool idx (fun j => (o j).toList) => s p.1) |
| (fun p => R.time (idx p.1) (p.2.1,e p.1)) t) |
| (ho : Poly s (fun j => volume (o j)) vo) |
| (he : Poly s (fun j => volume (e j)) ve) |
| (hv : Poly (fun p : Pool idx (fun j => (o j).toList) => s p.1) |
| (fun p => volume (f (idx p.1) (p.2.1,e p.1))) v) : |
| Poly s (fun j => R.optionMap.time (idx j) (o j,e j)) (Max.max t (Max.max vo (Max.max ve v))) := 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_optionMap R (idx j) (o j) (e j) |
| (C*(s j+2)^t) (D*(s j+2)^v) (fun a ha => hC ⟨j,⟨a,by simpa using ha⟩⟩) |
| (fun a ha => hD ⟨j,⟨a,by simpa using ha⟩⟩)) |
| poly_bound |
|
|
| end ThreeMachine.StackCompiler.Poly |
|
|
| namespace ThreeMachine.StackCompiler.Poly |
| variable {J : Type u9} {s : J → ℕ} {d e : ℕ} {α : J → Type u10} {β : J → Type u11} |
| variable [∀ j, Coding (α j)] [∀ j, Coding (β j)] |
| |
| omit [∀ j, Coding (α j)] [∀ j, Coding (β j)] in |
| theorem lengthOption (o : ∀ j, Option (α j)) : Poly s (fun j => (o j).toList.length) 0 := |
| of_le (fun j => by cases o j < |
|
|
| omit [∀ j, Coding (β j)] in |
| theorem volumeIte (p : J → Prop) [∀ j, Decidable (p j)] (a b : ∀ j, α j) |
| (ha : Poly s (fun j => volume (a j)) d) (hb : Poly s (fun j => volume (b j)) e) : |
| Poly s (fun j => volume (if p j then a j else b j)) (Max.max d e) := by |
| convert iteNat p ha hb using 1 |
| funext j; split < |
|
|
| omit [∀ j, Coding (α j)] in |
| theorem volumeOptionMap (f : ∀ j, α j → β j) (o : ∀ j, Option (α j)) |
| (h : Poly (fun p : ListPool (fun j => (o j).toList) => s p.1) |
| (fun p => volume (f p.1 p.2.1)) d) : Poly s (fun j => volume ((o j).map (f j))) d := by |
| obtain ⟨C,hC⟩ := h |
| apply volumeOption _ (powerBase s C d) |
| intro j b hb |
| cases ho : o j with |
| | none => simp [ho] at hb |
| | some a => |
| have he : f j a = b := by simpa [ho] using hb |
| subst b |
| exact hC ⟨j,⟨a,by simp [ho]⟩⟩ |
|
|
| end ThreeMachine.StackCompiler.Poly |
|
|
| namespace ThreeMachine.StackCompiler.Poly |
| variable {J : Type u12} {s : J → ℕ} {d : ℕ} {K V : J → Type} |
| variable [∀ j, Coding (K j)] [∀ j, Coding (V j)] [∀ j, DecidableEq (K j)] |
| theorem volumeLookup (xs : ∀ j, List (K j × V j)) (k : ∀ j, K j) |
| (h : Poly s (fun j => volume (xs j)) d) : |
| Poly s (fun j => volume (Algorithm.lookup (xs j) (k j))) d := by |
| apply volumeOption _ h |
| intro j v hv |
| have h := volume_mem_le (Algorithm.lookup_mem hv) |
| rw [volume_prod] at h |
| dsimp only at h |
| omega |
| end ThreeMachine.StackCompiler.Poly |
|
|
| namespace ThreeMachine.StackCompiler.Poly |
| variable {J : Type u13} {s : J → ℕ} {d : ℕ} {α : J → Type u14} [∀ j, Coding (α j)] |
| theorem volumeOptionToList (o : ∀ j, Option (α j)) |
| (h : Poly s (fun j => volume (o j)) d) : |
| Poly s (fun j => volume (o j).toList) d := by |
| simpa only [volume_optionToList] using h |
| end ThreeMachine.StackCompiler.Poly |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Poly |
| variable {J : Type u15} {s : J → ℕ} {d e : ℕ} {α : J → Type u16} |
| theorem lengthCons (a : ∀ j, α j) (xs : ∀ j, List (α j)) |
| (h : Poly s (fun j => (xs j).length) d) : |
| Poly s (fun j => (a j :: xs j).length) d := by |
| simp only [List.length_cons] |
|
|
| theorem lengthTail (xs : ∀ j, List (α j)) |
| (h : Poly s (fun j => (xs j).length) d) : |
| Poly s (fun j => (xs j).tail.length) d := |
| of_le (fun j => by simp only [List.length_tail] |
|
|
| theorem lengthTake (k : J → ℕ) (xs : ∀ j, List (α j)) |
| (h : Poly s (fun j => (xs j).length) d) : |
| Poly s (fun j => ((xs j).take (k j)).length) d := |
| of_le (fun j => (List.take_sublist (k j) (xs j)).length_le) h |
|
|
| theorem lengthDrop (k : J → ℕ) (xs : ∀ j, List (α j)) |
| (h : Poly s (fun j => (xs j).length) d) : |
| Poly s (fun j => ((xs j).drop (k j)).length) d := |
| of_le (fun j => (List.drop_sublist (k j) (xs j)).length_le) h |
|
|
| theorem lengthReverse (xs : ∀ j, List (α j)) |
| (h : Poly s (fun j => (xs j).length) d) : |
| Poly s (fun j => (xs j).reverse.length) d := by simpa only [List.length_reverse] using h |
|
|
| theorem lengthAppend (xs ys : ∀ j, List (α j)) |
| (hx : Poly s (fun j => (xs j).length) d) (hy : Poly s (fun j => (ys j).length) e) : |
| Poly s (fun j => (xs j ++ ys j).length) (Max.max d e) := by |
| simpa only [List.length_append] using hx.add hy |
|
|
| theorem lengthRange (k : J → ℕ) (h : Poly s k d) : |
| Poly s (fun j => (List.range (k j)).length) d := by simpa only [List.length_range] using h |
|
|
| theorem lengthReplicate (k : J → ℕ) (a : ∀ j, α j) (h : Poly s k d) : |
| Poly s (fun j => (List.replicate (k j) (a j)).length) d := by simpa only [List.length_replicate] using h |
| end ThreeMachine.StackCompiler.Poly |
| end |
|
|
| end OAI |
|
|
