| import OAI.Computability.Superstring.Parsing |
|
|
| namespace OAI |
|
|
| namespace Superstring.BitCode.RunsInPolyTime |
|
|
| variable {α β γ : Type} {ea : α → List Bool} {eb : β → List Bool} {ec : γ → List Bool} |
| {f : α → β} {g : α → γ} |
|
|
| /-- Compute two values from the same explicitly coded input, then concatenate |
| their self-delimiting encodings. Duplication and concatenation are charged bitwise. -/ |
| theorem pair (hf : RunsInPolyTime ea eb f) (hg : RunsInPolyTime ea ec g) : |
| RunsInPolyTime ea (fun p : β × γ => eb p.1 ++ ec p.2) (fun a => (f a, g a)) := by |
| obtain ⟨K, instK, i, o, b, P, hb⟩ := hf |
| obtain ⟨L, instL, j, v, c, Q, hc⟩ := hg |
| let input : (K ⊕ L) ⊕ Unit := .inl (.inl i) |
| let ginput : (K ⊕ L) ⊕ Unit := .inl (.inr j) |
| let foutput : (K ⊕ L) ⊕ Unit := .inl (.inl o) |
| let output : (K ⊕ L) ⊕ Unit := .inl (.inr v) |
| let scratch : (K ⊕ L) ⊕ Unit := .inr () |
| let code : Block ((K ⊕ L) ⊕ Unit) := |
| .seq (Block.copy input ginput scratch) |
| (.seq ((b.rename Sum.inl).rename Sum.inl) |
| (.seq ((c.rename Sum.inr).rename Sum.inl) (Block.move foutput output scratch))) |
| let R : Polynomial ℕ := 17 * Polynomial.X + 9 * P + Q + 5 |
| refine ⟨(K ⊕ L) ⊕ Unit, inferInstance, input, output, code, R, ?_⟩ |
| intro a |
| obtain ⟨n, hn, hf⟩ := hb a |
| obtain ⟨m, hm, hg⟩ := hc a |
| let s₀ := Sum.elim (Sum.elim (single i (ea a)) (single j (ea a))) (fun _ : Unit => []) |
| let s₁ := Sum.elim (Sum.elim (single o (eb (f a))) (single j (ea a))) (fun _ : Unit => []) |
| let s₂ := Sum.elim (Sum.elim (single o (eb (f a))) (single v (ec (g a)))) (fun _ : Unit => []) |
| have hcopy := Block.copy_exec input ginput scratch (by simp [input, ginput]) |
| (by simp [input, scratch]) (by simp [ginput, scratch]) (single input (ea a)) |
| (by simp [single, input, scratch]) |
| have hi : single input (ea a) input = ea a := by simp [single] |
| have hj : single input (ea a) ginput = [] := by simp [single, ginput, input] |
| rw [hi, hj] at hcopy |
| simp only [List.length_nil, Nat.mul_zero, Nat.zero_add] at hcopy |
| have he₀ : Function.update (single input (ea a)) ginput (ea a) = s₀ := by |
| funext k |
| rcases k with (k | k) | k |
| · simp [input, ginput, s₀, single] |
| · by_cases hk : k = j <;> simp [input, ginput, s₀, single, hk] |
| · simp [input, ginput, s₀, single] |
| rw [he₀] at hcopy |
| have hf' : ((b.rename Sum.inl).rename Sum.inl).Exec s₀ s₁ n := |
| (hf.left (single j (ea a))).left (fun _ : Unit => []) |
| have hg' : ((c.rename Sum.inr).rename Sum.inl).Exec s₁ s₂ m := |
| (hg.right (single o (eb (f a)))).left (fun _ : Unit => []) |
| have hmove := Block.move_exec foutput output scratch (by simp [foutput, output]) |
| (by simp [foutput, scratch]) (by simp [output, scratch]) s₂ rfl |
| have hfo : s₂ foutput = eb (f a) := by simp [s₂, foutput, single] |
| have hgo : s₂ output = ec (g a) := by simp [s₂, output, single] |
| rw [hfo, hgo] at hmove |
| have he₂ : Function.update (Function.update s₂ foutput []) output (eb (f a) ++ ec (g a)) = |
| single output (eb (f a) ++ ec (g a)) := by |
| funext k |
| rcases k with (k | k) | k |
| · by_cases hk : k = o <;> simp only [s₂, foutput, output, single, Function.update_apply, Sum.elim, Sum.inl.injEq, reduceCtorEq, hk, ite_true, ite_false] |
| · by_cases hk : k = v <;> simp only [s₂, foutput, output, single, Function.update_apply, Sum.elim, Sum.inl.injEq, Sum.inr.injEq, reduceCtorEq, hk, ite_true, ite_false] |
| · simp only [s₂, foutput, output, single, Function.update_apply, Sum.elim, reduceCtorEq, ite_false] |
| rw [he₂] at hmove |
| refine ⟨9 * (ea a).length + 3 + (n + (m + (8 * (eb (f a)).length + 2))), ?_, |
| Block.Exec.seq hcopy (Block.Exec.seq hf' (Block.Exec.seq hg' hmove))⟩ |
| have hlen := hf.bounded _ (single_bounded i (ea a)) o |
| simp only [single, ↓reduceIte] at hlen |
| simp only [R, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_ofNat, |
| Polynomial.eval_X] |
| omega |
|
|
| end Superstring.BitCode.RunsInPolyTime |
|
|
| namespace Superstring.BitCode |
|
|
| /-- Unary natural numbers have an explicit end marker, so prefix parsing never |
| relies on an uncharged register-length operation. -/ |
| def natCode : ℕ → List Bool |
| | 0 => [true] |
| | n + 1 => false :: natCode n |
|
|
| @[simp] theorem length_natCode (n : ℕ) : (natCode n).length = n + 1 := by |
| induction n with |
| | zero => rfl |
| | succ n ih => simp only [natCode, List.length_cons, ih] |
|
|
| theorem natCode_eq (n : ℕ) : natCode n = listCode (fun _ : Unit => []) (List.replicate n ()) := by |
| induction n with |
| | zero => rfl |
| | succ n ih => simp only [natCode, List.replicate_succ, listCode, List.nil_append, ih] |
|
|
| @[simp] theorem natCode_reverse (n : ℕ) : (natCode n).reverse = true :: List.replicate n false := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| rw [natCode, List.reverse_cons, ih, List.cons_append] |
| exact congrArg (fun x => true :: x) (by |
| simpa only [List.replicate_one] using (List.replicate_add n 1 false).symm) |
|
|
| theorem Parses.nat : Parses natCode := by |
| obtain ⟨K, inst, b, c, hb⟩ := (Parses.const []).list |
| refine ⟨K, inst, b, c, ?_⟩ |
| intro n tail acc |
| simpa only [← natCode_eq] using hb (List.replicate n ()) tail acc |
|
|
| namespace RunsInPolyTime |
|
|
| variable {α β : Type} {ea : α → List Bool} {eb : β → List Bool} {f : α → β} |
|
|
| /-- Normalize any clean routine to the same input and output register. The |
| linear bit-order-preserving relocation is included in its polynomial clock. -/ |
| theorem inPlace (hf : RunsInPolyTime ea eb f) : |
| ∃ (K : Type) (_ : DecidableEq K) (i : K) (b : Block K) (P : Polynomial ℕ), |
| ∀ a, ∃ n ≤ P.eval (ea a).length, b.Exec (single i (ea a)) (single i (eb (f a))) n := by |
| obtain ⟨K, inst, i, o, b, P, hb⟩ := hf |
| let code : Block (K ⊕ Unit) := .seq (b.rename Sum.inl) |
| (Block.move (.inl o) (.inl i) (.inr ())) |
| refine ⟨K ⊕ Unit, inferInstance, .inl i, code, 9 * P + 8 * Polynomial.X + 2, ?_⟩ |
| intro a |
| obtain ⟨n, hn, hh⟩ := hb a |
| have h₁ := hh.left (fun _ : Unit => []) |
| simp only [single_left] at h₁ |
| have h₂ := Block.move_single (Sum.inl o : K ⊕ Unit) (.inl i) (.inr ()) |
| (by simp) (by simp) (eb (f a)) |
| refine ⟨n + (8 * (eb (f a)).length + 2), ?_, Block.Exec.seq h₁ h₂⟩ |
| have hs := hh.bounded _ (single_bounded i (ea a)) o |
| simp only [single, ↓reduceIte] at hs |
| simp only [Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_ofNat, Polynomial.eval_X] |
| omega |
|
|
| end RunsInPolyTime |
|
|
| namespace Block |
|
|
| variable {K : Type} [DecidableEq K] {α : Type} {e : α → List Bool} {f : α → α} |
|
|
| /-- Iterate a clean in-place routine once per explicitly stored counter bit. |
| The hypothesis is a STATE SIZE invariant, not an assumed time or computation |
| oracle. The only computation premise is an actual bit-program execution. -/ |
| theorem iterate_exec (b : Block K) (i : K) (P : Polynomial ℕ) |
| (hb : ∀ a, ∃ n ≤ P.eval (e a).length, b.Exec (single i (e a)) (single i (e (f a))) n) |
| (n M : ℕ) (a : α) (hsize : ∀ j < n, (e (f^[j] a)).length ≤ M) : |
| ∃ t ≤ n * (P.eval M + 2) + 1, |
| (Block.loop (Sum.inr () : K ⊕ Unit) (.seq (.pop (.inr ())) (b.rename Sum.inl))).Exec |
| (Sum.elim (single i (e a)) (fun _ : Unit => List.replicate n false)) |
| (Sum.elim (single i (e (f^[n] a))) (fun _ : Unit => [])) t := by |
| induction n generalizing a with |
| | zero => |
| exact ⟨1, by simp, Exec.loop_nil rfl⟩ |
| | succ n ih => |
| have hrest : ∀ j < n, (e (f^[j] (f a))).length ≤ M := by |
| intro j hj |
| simpa only [← Function.iterate_succ_apply] using hsize (j + 1) (by omega) |
| obtain ⟨m, hm, hrun⟩ := hb a |
| obtain ⟨t, ht, htail⟩ := ih (f a) hrest |
| have hpop : Exec (.pop (Sum.inr () : K ⊕ Unit)) |
| (Sum.elim (single i (e a)) (fun _ : Unit => List.replicate (n + 1) false)) |
| (Sum.elim (single i (e a)) (fun _ : Unit => List.replicate n false)) 1 := by |
| have he : Function.update (fun _ : Unit => List.replicate (n + 1) false) () |
| (List.replicate (n + 1) false).tail = fun _ : Unit => List.replicate n false := by |
| funext k; cases k; simp |
| simpa only [Sum.elim_inr, update_right, he] using |
| Exec.pop (Sum.inr () : K ⊕ Unit) |
| (Sum.elim (single i (e a)) (fun _ : Unit => List.replicate (n + 1) false)) |
| have hstep := hrun.left (fun _ : Unit => List.replicate n false) |
| have hh := Exec.loop_cons (by simp only [Sum.elim_inr, List.replicate_succ, ne_eq, |
| List.cons_ne_nil, not_false_eq_true]) (Exec.seq hpop hstep) htail |
| refine ⟨1 + m + t + 1, ?_, ?_⟩ |
| · have hs := hsize 0 (by omega) |
| simp only [Function.iterate_zero, _root_.id] at hs |
| have hp := eval_mono_nat P hs |
| nlinarith |
| · simpa only [Function.iterate_succ_apply] using hh |
|
|
| end Block |
|
|
| end Superstring.BitCode |
|
|
| namespace Superstring.BitCode |
|
|
| /-- Place the parser's input in an existing work bank, its private storage in a |
| fresh bank, and its output in a fresh counter register. -/ |
| def parserEmbedding {K L : Type} (i : K) : Ports L → (K ⊕ L) ⊕ Unit |
| | .inl false => .inl (.inl i) |
| | .inl true => .inr () |
| | .inr k => .inl (.inr k) |
|
|
| theorem parserEmbedding_injective {K L : Type} (i : K) : |
| Function.Injective (parserEmbedding (L := L) i) := by |
| intro x y he |
| rcases x with (x | x) <;> rcases y with (y | y) |
| · cases x <;> cases y <;> simp_all only [parserEmbedding, reduceCtorEq] |
| · cases x <;> simp only [parserEmbedding, Sum.inl.injEq, reduceCtorEq] at he |
| · cases y <;> simp only [parserEmbedding, Sum.inl.injEq, reduceCtorEq] at he |
| · simpa only [parserEmbedding, Sum.inl.injEq, Sum.inr.injEq] using he |
|
|
| namespace Block |
|
|
| theorem Exec.parseAt {K L : Type} [DecidableEq K] [DecidableEq L] |
| {b : Block (Ports L)} {x y u v : List Bool} {n : ℕ} |
| (h : b.Exec (pairStore x u) (pairStore y v) n) (i : K) : |
| (b.rename (parserEmbedding i)).Exec |
| (Sum.elim (Sum.elim (single i x) (fun _ : L => [])) (fun _ : Unit => u)) |
| (Sum.elim (Sum.elim (single i y) (fun _ : L => [])) (fun _ : Unit => v)) n := by |
| apply h.transport (parserEmbedding i) (parserEmbedding_injective i) |
| · intro k |
| cases k with |
| | inl k => cases k <;> simp [parserEmbedding, pairStore, portStore, single] |
| | inr k => rfl |
| · intro k |
| cases k with |
| | inl k => cases k <;> simp [parserEmbedding, pairStore, portStore, single] |
| | inr k => rfl |
| · intro k hk |
| rcases k with (k | k) | k |
| · have hne : k ≠ i := by |
| intro he |
| exact hk (.inl false) (by simp [parserEmbedding, he]) |
| simp [single, hne] |
| · rfl |
| · cases k |
| exact False.elim (hk (.inl true) rfl) |
|
|
| end Block |
|
|
| namespace RunsInPolyTime |
|
|
| /-- Bounded iteration of an actual polynomial bit routine is polynomial. The |
| bound is on encoded intermediate DATA, and the counter is explicitly unary. |
| This closure rule does not assume a polynomial-time evaluator or a time oracle. -/ |
| theorem iterate {α : Type} {e : α → List Bool} {f : α → α} |
| (hf : RunsInPolyTime e e f) (R : Polynomial ℕ) |
| (hsize : ∀ n a j, j < n → (e (f^[j] a)).length ≤ |
| R.eval (natCode n ++ e a).length) : |
| RunsInPolyTime (fun p : ℕ × α => natCode p.1 ++ e p.2) e |
| (fun p => f^[p.1] p.2) := by |
| obtain ⟨K, instK, i, b, P, hb⟩ := hf.inPlace |
| obtain ⟨L, instL, parse, c, hp⟩ := Parses.nat |
| let inp : (K ⊕ L) ⊕ Unit := .inl (.inl i) |
| let counter : (K ⊕ L) ⊕ Unit := .inr () |
| let code : Block ((K ⊕ L) ⊕ Unit) := |
| .seq (parse.rename (parserEmbedding i)) |
| (.seq (.pop counter) |
| (.loop counter (.seq (.pop counter) ((b.rename Sum.inl).rename Sum.inl)))) |
| let Q : Polynomial ℕ := Polynomial.C (c + 2) * (Polynomial.X + 1) + |
| Polynomial.X * (P.comp R + 2) + 2 |
| refine ⟨(K ⊕ L) ⊕ Unit, inferInstance, inp, inp, code, Q, ?_⟩ |
| rintro ⟨n, a⟩ |
| let N := (natCode n ++ e a).length |
| let M := R.eval N |
| obtain ⟨t, ht, hparse⟩ := hp n (e a) [] |
| simp only [List.append_nil, natCode_reverse, length_natCode] at hparse ht |
| have hparse' := hparse.parseAt i |
| simp only [single_left] at hparse' |
| have hb' : ∀ a, ∃ t ≤ P.eval (e a).length, |
| (b.rename Sum.inl).Exec (single (Sum.inl i : K ⊕ L) (e a)) |
| (single (.inl i) (e (f a))) t := by |
| intro a |
| obtain ⟨t, ht, hh⟩ := hb a |
| exact ⟨t, ht, by simpa only [single_left] using hh.left (fun _ : L => [])⟩ |
| have hpop : Block.Exec (.pop counter) |
| (Sum.elim (single (Sum.inl i : K ⊕ L) (e a)) |
| (fun _ : Unit => true :: List.replicate n false)) |
| (Sum.elim (single (Sum.inl i : K ⊕ L) (e a)) |
| (fun _ : Unit => List.replicate n false)) 1 := by |
| have he : Function.update (fun _ : Unit => true :: List.replicate n false) () |
| (List.replicate n false) = fun _ : Unit => List.replicate n false := by |
| funext k; cases k; simp |
| simpa only [counter, Sum.elim_inr, List.tail_cons, Block.update_right, he] using |
| Block.Exec.pop counter (Sum.elim (single (Sum.inl i : K ⊕ L) (e a)) |
| (fun _ : Unit => true :: List.replicate n false)) |
| obtain ⟨u, hu, hloop⟩ := Block.iterate_exec (b.rename Sum.inl) (Sum.inl i : K ⊕ L) |
| P hb' n M a (hsize n a) |
| simp only [single_left] at hloop |
| refine ⟨t + (1 + u), ?_, Block.Exec.seq hparse' (Block.Exec.seq hpop hloop)⟩ |
| have hn : n + 1 ≤ N := by simp only [N, List.length_append, length_natCode]; omega |
| simp only [Q, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C, |
| Polynomial.eval_X, Polynomial.eval_one, Polynomial.eval_ofNat, Polynomial.eval_comp] |
| change t + (1 + u) ≤ (c + 2) * (N + 1) + N * (P.eval M + 2) + 2 |
| have hm := Nat.mul_le_mul_right (P.eval M + 2) (show n ≤ N by omega) |
| have ht' := ht.trans (Nat.mul_le_mul_left c (show n + 1 + 1 ≤ N + 1 by omega)) |
| nlinarith |
|
|
| end RunsInPolyTime |
|
|
| end Superstring.BitCode |
|
|
| namespace Superstring.BitCode |
|
|
| abbrev Workspace (K : Type) := Unit ⊕ K |
| abbrev workPort {K : Type} : Workspace K := .inl () |
| def workStore {K : Type} (w : List Bool) (z : Store K) : Store (Workspace K) := |
| Sum.elim (fun _ => w) z |
|
|
| @[simp] theorem workStore_single {K : Type} [DecidableEq K] (w : List Bool) : |
| workStore w (fun _ : K => []) = single workPort w := by |
| funext k |
| cases k with |
| | inl k => cases k; simp [workStore, single, workPort] |
| | inr k => simp [workStore, single, workPort] |
|
|
| def workEmbedding {K : Type} [DecidableEq K] (i : K) (k : K) : Workspace K := |
| if k = i then workPort else .inr k |
|
|
| theorem workEmbedding_injective {K : Type} [DecidableEq K] (i : K) : |
| Function.Injective (workEmbedding i) := by |
| intro x y he |
| by_cases hx : x = i <;> by_cases hy : y = i |
| · exact hx.trans hy.symm |
| · simp only [workEmbedding, ite_eq_left hx, ite_eq_right hy, workPort, reduceCtorEq] at he |
| · simp only [workEmbedding, ite_eq_right hx, ite_eq_left hy, workPort, reduceCtorEq] at he |
| · exact Sum.inr.inj (by simpa only [workEmbedding, ite_eq_right hx, ite_eq_right hy] using he) |
|
|
| namespace Block |
|
|
| theorem Exec.inWorkspace {K : Type} [DecidableEq K] {i : K} |
| {b : Block K} {w v : List Bool} {n : ℕ} |
| (h : b.Exec (single i w) (single i v) n) : |
| (b.rename (workEmbedding i)).Exec |
| (workStore w (fun _ : K => [])) (workStore v (fun _ : K => [])) n := by |
| apply h.transport (workEmbedding i) (workEmbedding_injective i) |
| · intro k |
| by_cases hk : k = i <;> simp [workEmbedding, hk, workPort, workStore, single] |
| · intro k |
| by_cases hk : k = i <;> simp [workEmbedding, hk, workPort, workStore, single] |
| · intro k hk |
| cases k with |
| | inl u => |
| cases u |
| exact False.elim (hk i (by simp [workEmbedding, workPort])) |
| | inr k => rfl |
|
|
| /-- Two in-place workspaces may share their data register, with all their |
| private registers disjoint. Everything outside the active workspace is framed. -/ |
| theorem Exec.workspace {K L : Type} [DecidableEq K] [DecidableEq L] |
| {b : Block (Workspace K)} {w v : List Bool} {n : ℕ} |
| (h : b.Exec (workStore w (fun _ : K => [])) (workStore v (fun _ : K => [])) n) |
| (f : K → L) (hf : Function.Injective f) (z : Store L) (hz : ∀ k, z (f k) = []) : |
| (b.rename (Sum.map _root_.id f)).Exec (workStore w z) (workStore v z) n := by |
| apply h.transport (Sum.map _root_.id f) (Sum.map_injective.mpr ⟨Function.injective_id, hf⟩) |
| · intro k |
| cases k with |
| | inl k => rfl |
| | inr k => exact hz k |
| · intro k |
| cases k with |
| | inl k => rfl |
| | inr k => exact hz k |
| · intro k hk |
| cases k with |
| | inl u => exact False.elim (hk (.inl u) rfl) |
| | inr k => rfl |
|
|
| end Block |
|
|
| namespace RunsInPolyTime |
|
|
| theorem canonical {α β : Type} {ea : α → List Bool} {eb : β → List Bool} {f : α → β} |
| (h : RunsInPolyTime ea eb f) : |
| ∃ (K : Type) (_ : DecidableEq K) (b : Block (Workspace K)) (P : Polynomial ℕ), |
| ∀ a, ∃ n ≤ P.eval (ea a).length, |
| b.Exec (workStore (ea a) (fun _ => [])) (workStore (eb (f a)) (fun _ => [])) n := by |
| obtain ⟨K, inst, i, b, P, hb⟩ := h.inPlace |
| refine ⟨K, inst, b.rename (workEmbedding i), P, ?_⟩ |
| intro a |
| obtain ⟨n, hn, hh⟩ := hb a |
| exact ⟨n, hn, hh.inWorkspace⟩ |
|
|
| /-- Branch on an explicitly encoded Boolean, charging the branch and removal |
| of its bit. No unbounded predicate acts as a primitive instruction. -/ |
| theorem boolCase {α β : Type} {ea : α → List Bool} {eb : β → List Bool} |
| {f g : α → β} (hf : RunsInPolyTime ea eb f) (hg : RunsInPolyTime ea eb g) : |
| RunsInPolyTime (fun p : Bool × α => p.1 :: ea p.2) eb |
| (fun p => if p.1 then f p.2 else g p.2) := by |
| obtain ⟨K, instK, b, P, hb⟩ := hf.canonical |
| obtain ⟨L, instL, c, Q, hc⟩ := hg.canonical |
| let bt : Block (Workspace (K ⊕ L)) := b.rename (Sum.map _root_.id Sum.inl) |
| let bf : Block (Workspace (K ⊕ L)) := c.rename (Sum.map _root_.id Sum.inr) |
| let code : Block (Workspace (K ⊕ L)) := .branch workPort .skip |
| (.seq (.pop workPort) bf) (.seq (.pop workPort) bt) |
| refine ⟨Workspace (K ⊕ L), inferInstance, workPort, workPort, code, P + Q + 2, ?_⟩ |
| rintro ⟨v, a⟩ |
| have hpop : Block.Exec (.pop workPort) |
| (workStore (v :: ea a) (fun _ : K ⊕ L => [])) |
| (workStore (ea a) (fun _ : K ⊕ L => [])) 1 := by |
| have he : Function.update (fun _ : Unit => v :: ea a) () (ea a) = |
| fun _ : Unit => ea a := by funext k; cases k; simp |
| simpa only [workStore, workPort, Sum.elim_inl, List.tail_cons, |
| Block.update_left, he] using |
| Block.Exec.pop (workPort : Workspace (K ⊕ L)) |
| (workStore (v :: ea a) (fun _ : K ⊕ L => [])) |
| cases v with |
| | false => |
| obtain ⟨n, hn, hh⟩ := hc a |
| have hrun := hh.workspace (Sum.inr : L → K ⊕ L) Sum.inr_injective (fun _ => []) (fun _ => rfl) |
| have he := Block.Exec.branch_false (k := (workPort : Workspace (K ⊕ L))) |
| (a := Block.skip) (c := .seq (.pop workPort) bt) rfl (Block.Exec.seq hpop hrun) |
| refine ⟨1 + n + 1, ?_, ?_⟩ |
| · have hq : Q.eval (ea a).length ≤ Q.eval (false :: ea a).length := |
| eval_mono_nat Q (by simp) |
| simp only [Polynomial.eval_add, Polynomial.eval_ofNat] |
| omega |
| · simpa only [workStore_single, Bool.false_eq_true, ↓reduceIte] using he |
| | true => |
| obtain ⟨n, hn, hh⟩ := hb a |
| have hrun := hh.workspace (Sum.inl : K → K ⊕ L) Sum.inl_injective (fun _ => []) (fun _ => rfl) |
| have he := Block.Exec.branch_true (k := (workPort : Workspace (K ⊕ L))) |
| (a := Block.skip) (b := .seq (.pop workPort) bf) rfl (Block.Exec.seq hpop hrun) |
| refine ⟨1 + n + 1, ?_, ?_⟩ |
| · have hp : P.eval (ea a).length ≤ P.eval (true :: ea a).length := |
| eval_mono_nat P (by simp) |
| simp only [Polynomial.eval_add, Polynomial.eval_ofNat] |
| omega |
| · simpa only [workStore_single, ↓reduceIte] using he |
|
|
| end RunsInPolyTime |
|
|
| end Superstring.BitCode |
|
|
| end OAI |
|
|
