| import OAI.Computability.Scheduling.StateCosts |
|
|
| namespace OAI |
|
|
| universe u1 u2 u3 u4 u5 u6 u7 u8 |
|
|
| section |
| namespace ThreeMachine.Algorithm |
|
|
| theorem tableOf_length {K V : Type} (ks : List K) (f : K → Option V) : |
| (tableOf ks f).length ≤ ks.length := List.length_filterMap_le _ _ |
|
|
| theorem states_length {J : Type} [Fintype J] [DecidableEq J] |
| (r : J → J → Prop) [DecidableRel r] (fs zs : List (Finset J)) (W : Finset J) : |
| (states r fs zs W).length ≤ fs.length*zs.length := by |
| calc |
| _ ≤ (fs.flatMap (fun F => zs.map (State.candidate W F))).length := List.length_filter_le _ _ |
| _ = _ := by simp [List.length_flatMap] |
|
|
| theorem markings_length {J : Type} [DecidableEq J] |
| (tab : List (Finset J × Block J)) (sts : List (State J)) (k : ℕ) : |
| (markings tab sts k).length ≤ sts.length := by |
| cases k <;> exact tableOf_length _ _ |
|
|
| theorem layers_length {J : Type} [Fintype J] [DecidableEq J] |
| (r : J → J → Prop) [DecidableRel r] (fs zs : List (Finset J)) (k : ℕ) : |
| (layers r fs zs k).length ≤ fs.length+1 := by |
| cases k with |
| | zero => simp [layers] |
| | succ k => exact (tableOf_length _ _).trans (Nat.le_add_right _ _) |
|
|
| end ThreeMachine.Algorithm |
|
|
| namespace ThreeMachine.StackCompiler |
| open ThreeMachine.Algorithm |
|
|
| def BlockSmall {n : ℕ} (b : Algorithm.Block (Fin n)) : Prop := |
| b.length ≤ n ∧ ∀ v, b.time v ≤ n |
|
|
| def TableSmall {n : ℕ} (tab : Table n) : Prop := ∀ W b, (W,b) ∈ tab → BlockSmall b |
|
|
| def MarksSmall {n : ℕ} (marks : Marks n) : Prop := ∀ u b, (u,b) ∈ marks → BlockSmall b |
|
|
| theorem blockSmall_of_good {n : ℕ} {r : Fin n → Fin n → Prop} {W : Finset (Fin n)} |
| {b : Algorithm.Block (Fin n)} (hg : b.Valid r W) (hb : b.Bounded) : BlockSmall b := |
| ⟨hg.length_le,fun v => (hb v).trans hg.length_le⟩ |
|
|
| theorem layers_small {n : ℕ} (r : Fin n → Fin n → Prop) [DecidableRel r] |
| (fs zs : List (Finset (Fin n))) (k : ℕ) : TableSmall (Algorithm.layers r fs zs k) := |
| fun W b h => blockSmall_of_good (Algorithm.layers_good r fs zs k W b h) |
| (Algorithm.layers_bounded r fs zs k W b h) |
|
|
| theorem markings_small {n : ℕ} (r : Fin n → Fin n → Prop) [DecidableRel r] |
| {tab : Table n} {sts : List (Algorithm.State (Fin n))} {W : Finset (Fin n)} |
| (ht : Algorithm.TableGood r tab) (hb : Algorithm.TableBounded tab) |
| (hs : ∀ u ∈ sts, u.Compatible r W) (k : ℕ) : MarksSmall (Algorithm.markings tab sts k) := |
| fun u b h => blockSmall_of_good ((Algorithm.markings_good r ht hs k u b h).2) |
| (Algorithm.markings_bounded hb k u b h) |
|
|
| theorem volume_table_le {n : ℕ} (tab : Table n) (ht : TableSmall tab) : |
| volume tab ≤ 1+tab.length*(30*(n+1)^2+1) := by |
| have h := volume_list_le tab (30*(n+1)^2) (by |
| rintro ⟨W,b⟩ h |
| have hW := volume_finset_le W |
| have hb := volume_block_le b (ht W b h).1 (ht W b h).2 |
| rw [volume_pair] |
| have hp : 1 ≤ (n+1)^2 := Nat.one_le_pow _ _ (by omega) |
| omega) |
| omega |
|
|
| theorem volume_marks_le {n : ℕ} (ms : Marks n) (ht : MarksSmall ms) : |
| volume ms ≤ 1+ms.length*(30*(n+1)^2+1) := by |
| have h := volume_list_le ms (30*(n+1)^2) (by |
| rintro ⟨u,b⟩ h |
| have hW := volume_state_le u |
| have hb := volume_block_le b (ht u b h).1 (ht u b h).2 |
| rw [volume_pair] |
| have hp : 1 ≤ (n+1)^2 := Nat.one_le_pow _ _ (by omega) |
| omega) |
| omega |
|
|
| namespace Poly |
| variable {J : Type} {s n : J → ℕ} {d l : ℕ} |
|
|
| theorem volumeTable (tab : ∀ j, Table (n j)) (hn : Poly s n d) |
| (hl : Poly s (fun j => (tab j).length) l) (ht : ∀ j, TableSmall (tab j)) : |
| Poly s (fun j => volume (tab j)) (l+2*d) := by |
| apply of_le (fun j => volume_table_le (tab j) (ht j)) |
| poly_bound |
|
|
| theorem volumeMarks (ms : ∀ j, Marks (n j)) (hn : Poly s n d) |
| (hl : Poly s (fun j => (ms j).length) l) (ht : ∀ j, MarksSmall (ms j)) : |
| Poly s (fun j => volume (ms j)) (l+2*d) := by |
| apply of_le (fun j => volume_marks_le (ms j) (ht j)) |
| poly_bound |
|
|
| theorem lengthTriples (hn : Poly s n d) : |
| Poly s (fun j => (Structure.tripleList (List.finRange (n j))).length) (3*d) := by |
| apply of_le (fun j => Structure.tripleList_length (List.finRange (n j))) |
| simp only [List.length_finRange] |
| poly_bound |
|
|
| theorem lengthAlphabet (hn : Poly s n d) : |
| Poly s (fun j => (Structure.Atomic.alphabet (List.finRange (n j))).length) (3*d) := by |
| apply of_le (fun j => Structure.Atomic.alphabet_length (List.finRange (n j))) |
| simp only [Fintype.card_fin,List.length_finRange] |
| poly_bound |
|
|
| theorem lengthFamily (M : ∀ j, Matrix (n j)) (K : ℕ) (hn : Poly s n d) : |
| Poly s (fun j => (Structure.effectiveFamily (matrixRel (M j)) |
| (Structure.jobRank (matrixRel (M j))) (Structure.reverseJobRank (matrixRel (M j))) |
| (List.finRange (n j)) K).length) (3*K*d) := by |
| simp only [Structure.effectiveFamily_length] |
| have h := (lengthAlphabet hn).pow K |
| convert h.mul (const s (Structure.Formula.templates K).length) using 1; ring |
|
|
| end Poly |
| end ThreeMachine.StackCompiler |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler |
| open Algorithm |
|
|
| theorem volume_block_bound {n : ℕ} (b : Block (Fin n)) (B : ℕ) |
| (hl : b.length ≤ B) (ht : ∀ v, b.time v ≤ B) : |
| volume b ≤ 4*(n+1)*(B+1) := by |
| have h := volume_function_le b.time (2*B+1) (by intro v; rw [volume_nat]; have := ht v; omega) |
| rw [volume_block,volume_nat] |
| nlinarith |
|
|
| theorem volume_advance_le {n : ℕ} (v : Algorithm.State (Fin n)) (b c : Block (Fin n)) |
| (hb : BlockSmall b) (hc : BlockSmall c) : |
| volume (v.advance b c) ≤ 100*(n+2)^2 := by |
| have hl : (v.advance b c).length ≤ 2*n+1 := by |
| change b.length+1+c.length ≤ _ |
| have := hb.1; have := hc.1; omega |
| have ht (a : Fin n) : (v.advance b c).time a ≤ 2*n+1 := by |
| simp only [Algorithm.State.advance,Block.append,Block.triple] |
| have := hb.1; have := hb.2 a; have := hc.2 a |
| split_ifs <;> omega |
| have h := volume_block_bound (v.advance b c) (2*n+1) hl ht |
| nlinarith |
|
|
| namespace Poly |
| variable {J : Type} {s n : J → ℕ} {d : ℕ} |
|
|
| theorem volumeSmallBlock (b : ∀ j, Block (Fin (n j))) (hn : Poly s n d) |
| (hb : ∀ j, BlockSmall (b j)) : Poly s (fun j => volume (b j)) (2*d) := by |
| apply of_le (fun j => volume_block_le (b j) (hb j).1 (hb j).2) |
| poly_bound |
|
|
| theorem volumeSmallLookup {K : J → Type} [∀ j, Coding (K j)] [∀ j, DecidableEq (K j)] |
| (xs : ∀ j, List (K j × Block (Fin (n j)))) (k : ∀ j, K j) |
| (hn : Poly s n d) (hb : ∀ j a b, (a,b) ∈ xs j → BlockSmall b) : |
| Poly s (fun j => volume (Algorithm.lookup (xs j) (k j))) (2*d) := by |
| apply volumeOption _ (show Poly s (fun j => 10*(n j+1)^2) (2*d) from by poly_bound) |
| intro j b h |
| exact volume_block_le b (hb j (k j) b (Algorithm.lookup_mem h)).1 |
| (hb j (k j) b (Algorithm.lookup_mem h)).2 |
|
|
| theorem volumeAdvance (v : ∀ j, Algorithm.State (Fin (n j))) (b c : ∀ j, Block (Fin (n j))) |
| (hn : Poly s n d) (hb : ∀ j, BlockSmall (b j)) (hc : ∀ j, BlockSmall (c j)) : |
| Poly s (fun j => volume ((v j).advance (b j) (c j))) (2*d) := by |
| apply of_le (fun j => volume_advance_le (v j) (b j) (c j) (hb j) (hc j)) |
| poly_bound |
|
|
| theorem volumeTryAdvance (tab : ∀ j, Table (n j)) (u : ∀ j, Algorithm.State (Fin (n j)) × Block (Fin (n j))) |
| (v : ∀ j, Algorithm.State (Fin (n j))) (hn : Poly s n d) |
| (ht : ∀ j, TableSmall (tab j)) (hb : ∀ j, BlockSmall (u j).2) : |
| Poly s (fun j => volume (Algorithm.tryAdvance (tab j) (u j) (v j))) (2*d) := by |
| apply volumeOption _ (show Poly s (fun j => 100*(n j+2)^2) (2*d) from by poly_bound) |
| intro j b h |
| simp only [Algorithm.tryAdvance] at h |
| split_ifs at h with hp |
| · cases hc : Algorithm.lookup (tab j) ((v j).left \ (u j).1.upto) with |
| | none => simp [hc] at h |
| | some c => |
| have he : (u j).1.advance (u j).2 c = b := by simpa [hc] using h |
| subst b |
| exact volume_advance_le _ _ _ (hb j) (ht j _ c (Algorithm.lookup_mem hc)) |
| · simp at h |
|
|
| end Poly |
| end ThreeMachine.StackCompiler |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler |
| namespace Uniform |
| variable {I : Type u1} {α : I → Type u2} [∀ i, Coding (α i)] |
| theorem time_append_le (i : I) (xs ys : List (α i)) : |
| append.time i (xs,ys) ≤ 100000*(xs.length+1)*(volume xs+volume ys+1) := by |
| have h := time_consFold i xs.reverse ys |
| have hr := time_reverse i xs |
| simp only [List.length_reverse,volume_reverse] at h |
| simp only [append,time_congr,time_comp,time_pair,time_fst,time_snd,volume_prod,Function.comp_apply,volume_reverse] |
| nlinarith [volume_pos xs,volume_pos ys] |
| end Uniform |
| namespace Realizer |
| variable {α : Type u3} [Coding α] |
| theorem time_zero (x : α) : (zero : Realizer (fun _ : α => (0 : ℕ))).time x = 2 := rfl |
| theorem time_nil (x : α) : (nil : Realizer (fun _ : α => ([] : List α))).time x = 2 := rfl |
| theorem time_cons (x : α × List α) : cons.time x = volume x+2 := rfl |
| theorem time_reverse_le (xs : List α) : |
| reverse.time xs ≤ 200*(xs.length+1)*(volume xs+1) := |
| Uniform.time_reverse (I := Unit) (α := fun _ => α) () xs |
|
|
| theorem volume_range_le (n : ℕ) : volume (List.range n) ≤ 10*(n+1)^2 := by |
| have h := volume_list_le (List.range n) (2*n+1) (by |
| intro a ha |
| rw [volume_nat] |
| have := List.mem_range.mp ha |
| omega) |
| simp only [List.length_range] at h |
| nlinarith |
|
|
| theorem time_rangeStep_le (j n : ℕ) (hj : j ≤ n) : |
| rangeStep.time (j,(List.range j).reverse) ≤ 100000*(n+1)^2 := by |
| have hv := volume_range_le j |
| have ht := time_succ_le j |
| simp only [rangeStep,time_pair,time_comp,time_fst,time_cons,volume_prod,volume_nat, |
| Function.comp_apply,volume_cons,volume_nat,volume_reverse] |
| nlinarith |
|
|
| theorem time_range_le (n : ℕ) : range.time n ≤ 100000000000*(n+1)^3 := by |
| have ht := time_iterate_le rangeStep n (0,[]) (100000*(n+1)^2) (20*(n+1)^2) |
| (fun j hj => by rw [rangeStep_iterate]; exact time_rangeStep_le j n (by omega)) |
| (fun j hj => by |
| rw [rangeStep_iterate,volume_prod,volume_nat,volume_reverse] |
| have := volume_range_le j |
| nlinarith) |
| have hr := time_reverse_le (List.range n).reverse |
| have hv := volume_range_le n |
| simp only [List.length_reverse,List.length_range,volume_reverse] at hr |
| simp only [range,time_congr,time_comp,time_pair,time_id,time_zero,time_snd, |
| Function.comp_apply,rangeStep_iterate,volume_prod,volume_nat,volume_nil,volume_reverse,id_eq] |
| have hz : (nil : Realizer (fun _ : ℕ => ([] : List ℕ))).time n = 2 := rfl |
| rw [hz] |
| nlinarith |
| end Realizer |
| namespace Uniform |
| variable {I : Type u4} {α : I → Type u5} [∀ i, Coding (α i)] |
| theorem time_orD_le {p q : ∀ i, α i → Prop} |
| [∀ i, DecidablePred (p i)] [∀ i, DecidablePred (q i)] |
| (P : Uniform (fun i x => decide (p i x))) (Q : Uniform (fun i x => decide (q i x))) |
| (i : I) (x : α i) : (P.orD Q).time i x ≤ P.time i x+Q.time i x+20*volume x+11000 := by |
| rw [orD,time_congr,time_comp,time_pair,time_uniform] |
| have h := Realizer.time_or_le (decide (p i x),decide (q i x)) |
| have hp := volume_bool (decide (p i x)); have hq := volume_bool (decide (q i x)) |
| simp only [volume_pair] at * |
| omega |
| end Uniform |
| end ThreeMachine.StackCompiler |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Poly |
| variable {I : Type u6} {J : Type u7} {s : J → ℕ} {α : I → Type u8} [∀ i, Coding (α i)] |
| abbrev IterPool (m : J → ℕ) := Σ j, Fin (m j+1) |
| theorem iterateTime {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 : IterPool 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,by omega⟩⟩) (fun k hk => hD ⟨j,⟨k,by omega⟩⟩)) |
| poly_bound |
| end ThreeMachine.StackCompiler.Poly |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Poly |
| variable {J : Type} {s : J → ℕ} {d e : ℕ} {α β : J → Type} |
| variable [∀ j, Coding (α j)] [∀ j, Coding (β j)] |
| omit [∀ j, Coding (α j)] in |
| theorem volumeFirstResult (xs : ∀ j, List (α j)) (f : ∀ j, α j → Option (β j)) |
| (hv : Poly (fun p : ListPool xs => s p.1) (fun p => volume (f p.1 p.2.1)) d) : |
| Poly s (fun j => volume (Algorithm.firstResult (f j) (xs j))) d := by |
| obtain ⟨C,hC⟩ := hv |
| apply volumeOption _ (powerBase s C d) |
| intro j b hb |
| obtain ⟨a,ha,h⟩ := Algorithm.firstResult_some hb |
| have ht := hC ⟨j,⟨a,ha⟩⟩ |
| dsimp only at ht |
| rw [h,volume_some] at ht |
| omega |
|
|
| omit [∀ j, Coding (β j)] in |
| theorem volumeOptionOr (a b : ∀ j, Option (α j)) |
| (ha : Poly s (fun j => volume (a j)) d) (hb : Poly s (fun j => volume (b j)) e) : |
| Poly s (fun j => volume ((a j).or (b j))) (Max.max d e) := by |
| apply of_le (g := fun j => Max.max (volume (a j)) (volume (b j))) _ (ha.max hb) |
| intro j |
| cases a j <;> simp |
| end ThreeMachine.StackCompiler.Poly |
| end |
|
|
| section |
| namespace ThreeMachine.StackCompiler.Poly |
| open Algorithm |
| variable {J : Type} {s n : J → ℕ} {d l : ℕ} |
| theorem volumeStateList (sts : ∀ j, List (Algorithm.State (Fin (n j)))) |
| (hn : Poly s n d) (hl : Poly s (fun j => (sts j).length) l) : |
| Poly s (fun j => volume (sts j)) (l+2*d) := by |
| apply volumeList hl (show Poly s (fun j => 12*(n j+1)^2) (2*d) from by poly_bound) |
| intro j a _ha |
| exact volume_state_le a |
|
|
| theorem volumeSetList (xs : ∀ j, List (Finset (Fin (n j)))) |
| (hn : Poly s n d) (hl : Poly s (fun j => (xs j).length) l) : |
| Poly s (fun j => volume (xs j)) (l+2*d) := by |
| apply volumeList hl (show Poly s (fun j => 3*(n j+1)^2) (2*d) from by poly_bound) |
| intro j a _ha |
| exact volume_finset_le a |
|
|
| theorem volumeExpandBody (tab : ∀ j, Table (n j)) (ms : ∀ j, Marks (n j)) |
| (v : ∀ j, Algorithm.State (Fin (n j))) (hn : Poly s n d) |
| (ht : ∀ j, TableSmall (tab j)) (hm : ∀ j, MarksSmall (ms j)) : |
| Poly s (fun j => volume ((Algorithm.lookup (ms j) (v j)).or |
| (Algorithm.firstResult (fun u => Algorithm.tryAdvance (tab j) u (v j)) (ms j)))) (2*d) := by |
| have h₁ := volumeSmallLookup ms v hn hm |
| have h₂ : Poly s (fun j => volume (Algorithm.firstResult (fun u => Algorithm.tryAdvance (tab j) u (v j)) (ms j))) (2*d) := by |
| apply volumeFirstResult |
| exact volumeTryAdvance (fun p : ListPool ms => tab p.1) (fun p => p.2.1) (fun p => v p.1) |
| (hn.precomp (fun p : ListPool ms => p.1)) (fun p => ht p.1) |
| (fun p => hm p.1 _ _ p.2.2) |
| simpa only [Nat.max_self] using volumeOptionOr _ _ h₁ h₂ |
| end ThreeMachine.StackCompiler.Poly |
| end |
|
|
| end OAI |
|
|
