Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DifferencePairsProgram.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 31.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DifferencePairsProgram.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DifferencePairsProgram.lean
-
curl -L -o DifferencePairsProgram.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DifferencePairsProgram.lean
31.9 kB
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DifferencePairs | |
| import OAI.Algorithms.SubexponentialSAT.StructuredCalls | |
| import Mathlib.Tactic.FinCases | |
| /-! Fixed finite control for the pruned pair DFS. Four protected stacks hold | |
| remaining depth, remaining strict budget, and the two current masks. The masks | |
| also encode the DFS phases `00`, `10`, `11`; no completed-pair list is retained. | |
| The callback receives the masks in reverse coordinate order. -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DifferencePairsProgram | |
| open OAI.Algorithms.SubexponentialSAT.StructuredProgram (Atom) | |
| open OAI.Algorithms.SubexponentialSAT.StructuredCalls | |
| structure Ports (r s : ℕ) where | |
| register : Fin 5 ↪ Fin r | |
| stack : Fin 4 ↪ Fin s | |
| variable {r s : ℕ} | |
| def atoms (code : List (Atom r s)) : Cmd r s := | |
| .base (code.foldr (fun a rest => .seq (.atom a) rest) .skip) | |
| theorem atoms_eval (code : List (Atom r s)) (a : State r s) : | |
| Eval (atoms code) code.length a (code.foldl (fun d op => op.eval d) a) := by | |
| apply Eval.base | |
| induction code generalizing a with | |
| | nil => exact StructuredProgram.Eval.skip a | |
| | cons op code ih => | |
| simpa only [List.foldr_cons, List.foldl_cons, List.length_cons, Nat.add_comm] | |
| using (StructuredProgram.Eval.atom op a).seq (ih (op.eval a)) | |
| def pushBit (p : Ports r s) (i : Fin 4) (b : Bool) : Cmd r s := | |
| atoms [.set (p.register 2) b, .push (p.stack i) (p.register 2)] | |
| def pushed (p : Ports r s) (i : Fin 4) (b : Bool) (d : State r s) : State r s := | |
| ⟨Function.update d.regs (p.register 2) b, | |
| Function.update d.stacks (p.stack i) (b :: d.stacks (p.stack i))⟩ | |
| theorem pushBit_eval (p : Ports r s) (i : Fin 4) (b : Bool) (d : State r s) : | |
| Eval (pushBit p i b) 2 d (pushed p i b d) := by | |
| simpa [pushBit, pushed, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| StructuredProgram.State.withPC, BitProgram.execInstr] using | |
| atoms_eval [.set (p.register 2) b, .push (p.stack i) (p.register 2)] d | |
| def enter (p : Ports r s) (e u : Bool) : Cmd r s := | |
| .seq (pushBit p 2 e) (.seq (pushBit p 3 u) (atoms [.set (p.register 0) true])) | |
| def entered (p : Ports r s) (e u : Bool) (d : State r s) : State r s := | |
| (Atom.set (p.register 0) true).eval (pushed p 3 u (pushed p 2 e d)) | |
| theorem enter_eval (p : Ports r s) (e u : Bool) (d : State r s) : | |
| Eval (enter p e u) 5 d (entered p e u d) := | |
| (pushBit_eval p 2 e d).seq | |
| ((pushBit_eval p 3 u _).seq (atoms_eval [.set (p.register 0) true] _)) | |
| @[simp] theorem entered_depth (p : Ports r s) (e u : Bool) (d : State r s) : | |
| (entered p e u d).stacks (p.stack 0) = d.stacks (p.stack 0) := by | |
| simp [entered, pushed, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| @[simp] theorem entered_budget (p : Ports r s) (e u : Bool) (d : State r s) : | |
| (entered p e u d).stacks (p.stack 1) = d.stacks (p.stack 1) := by | |
| simp [entered, pushed, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| @[simp] theorem entered_outer (p : Ports r s) (e u : Bool) (d : State r s) : | |
| (entered p e u d).stacks (p.stack 2) = e :: d.stacks (p.stack 2) := by | |
| simp [entered, pushed, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| @[simp] theorem entered_inner (p : Ports r s) (e u : Bool) (d : State r s) : | |
| (entered p e u d).stacks (p.stack 3) = u :: d.stacks (p.stack 3) := by | |
| simp [entered, pushed, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| @[simp] theorem entered_descending (p : Ports r s) (e u : Bool) (d : State r s) : | |
| (entered p e u d).regs (p.register 0) = true := by | |
| simp [entered, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| @[simp] theorem entered_active (p : Ports r s) (e u : Bool) (d : State r s) : | |
| (entered p e u d).regs (p.register 1) = d.regs (p.register 1) := by | |
| simp [entered, pushed, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| def finishLevel (p : Ports r s) : Cmd r s := pushBit p 0 true | |
| def nextOutside (p : Ports r s) : Cmd r s := | |
| .seq | |
| (atoms [.pop (p.stack 1) (p.register 2) (p.register 3), | |
| .peek (p.stack 1) (p.register 2) (p.register 3)]) | |
| (.ite (p.register 3) (enter p true false) | |
| (.seq (pushBit p 1 true) (finishLevel p))) | |
| def backtrack (p : Ports r s) : Cmd r s := | |
| .seq (atoms [.pop (p.stack 2) (p.register 4) (p.register 3)]) | |
| (.ite (p.register 3) | |
| (.seq (atoms [.pop (p.stack 3) (p.register 2) (p.register 3)]) | |
| (.ite (p.register 4) | |
| (.ite (p.register 2) | |
| (.seq (pushBit p 1 true) (finishLevel p)) (enter p true true)) | |
| (nextOutside p))) | |
| (atoms [.set (p.register 1) false])) | |
| def descend (p : Ports r s) (callback : Cmd r s) : Cmd r s := | |
| .seq (atoms [.pop (p.stack 0) (p.register 2) (p.register 3)]) | |
| (.ite (p.register 3) (enter p false false) | |
| (.seq callback (atoms [.set (p.register 0) false, .set (p.register 1) true]))) | |
| def body (p : Ports r s) (callback : Cmd r s) : Cmd r s := | |
| .ite (p.register 0) (descend p callback) (backtrack p) | |
| def command (p : Ports r s) (callback : Cmd r s) : Cmd r s := | |
| .seq (atoms [.peek (p.stack 1) (p.register 2) (p.register 3), | |
| .copy (p.register 1) (p.register 3), .set (p.register 0) true]) | |
| (.while (p.register 1) (body p callback)) | |
| def program (p : Ports r s) (callback : Cmd r s) := | |
| compiled (command p callback) (p.stack 0) (p.stack 2) | |
| def popped (p : Ports r s) (i : Fin 4) (v : Fin 5) (d : State r s) : State r s := | |
| (Atom.pop (p.stack i) (p.register v) (p.register 3)).eval d | |
| def descended (p : Ports r s) (d : State r s) : State r s := | |
| entered p false false (popped p 0 2 d) | |
| theorem body_descend (p : Ports r s) (callback : Cmd r s) (d : State r s) | |
| (hd : d.regs (p.register 0) = true) (b : Bool) (rest : List Bool) | |
| (hn : d.stacks (p.stack 0) = b :: rest) : | |
| Eval (body p callback) 8 d (descended p d) := by | |
| have hp : (popped p 0 2 d).regs (p.register 3) = true := by | |
| simp [popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, hn] | |
| exact .ite_true hd ((atoms_eval [.pop (p.stack 0) (p.register 2) (p.register 3)] d).seq | |
| (.ite_true hp (enter_eval p false false (popped p 0 2 d)))) | |
| def returned (p : Ports r s) (d : State r s) : State r s := | |
| (Atom.set (p.register 1) true).eval ((Atom.set (p.register 0) false).eval d) | |
| theorem body_callback (p : Ports r s) (callback : Cmd r s) (d e : State r s) | |
| (hd : d.regs (p.register 0) = true) (hn : d.stacks (p.stack 0) = []) | |
| (t : ℕ) (hc : Eval callback t (popped p 0 2 d) e) : | |
| Eval (body p callback) (t + 5) d (returned p e) := by | |
| have h := Eval.ite_true (yes := descend p callback) (no := backtrack p) hd | |
| (Eval.seq (atoms_eval [.pop (p.stack 0) (p.register 2) (p.register 3)] d) | |
| (Eval.ite_false (yes := enter p false false) (test := p.register 3) | |
| (by simp [Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, hn]) | |
| (hc.seq (atoms_eval [.set (p.register 0) false, .set (p.register 1) true] e)))) | |
| convert h using 1 | |
| · rfl | |
| · simp only [List.length_cons, List.length_nil] | |
| omega | |
| · rfl | |
| @[simp] theorem returned_stacks (p : Ports r s) (d : State r s) : | |
| (returned p d).stacks = d.stacks := rfl | |
| @[simp] theorem returned_descending (p : Ports r s) (d : State r s) : | |
| (returned p d).regs (p.register 0) = false := by | |
| simp [returned, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| @[simp] theorem returned_active (p : Ports r s) (d : State r s) : | |
| (returned p d).regs (p.register 1) = true := by | |
| simp [returned, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| def backed (p : Ports r s) (d : State r s) : State r s := | |
| popped p 3 2 (popped p 2 4 d) | |
| def finished (p : Ports r s) (d : State r s) : State r s := | |
| pushed p 0 true (pushed p 1 true (backed p d)) | |
| theorem body_finish (p : Ports r s) (callback : Cmd r s) (d : State r s) | |
| (hd : d.regs (p.register 0) = false) (es us : List Bool) | |
| (he : d.stacks (p.stack 2) = true :: es) | |
| (hu : d.stacks (p.stack 3) = true :: us) : | |
| Eval (body p callback) 10 d (finished p d) := by | |
| have hp : (popped p 2 4 d).regs (p.register 3) = true := by | |
| simp [popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, he] | |
| have he' : (backed p d).regs (p.register 4) = true := by | |
| simp [backed, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, he] | |
| have hu' : (backed p d).regs (p.register 2) = true := by | |
| simp [backed, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, hu] | |
| exact .ite_false hd | |
| ((atoms_eval [.pop (p.stack 2) (p.register 4) (p.register 3)] d).seq | |
| (.ite_true hp | |
| ((atoms_eval [.pop (p.stack 3) (p.register 2) (p.register 3)] _).seq | |
| (.ite_true he' (.ite_true hu' | |
| ((pushBit_eval p 1 true _).seq (pushBit_eval p 0 true _))))))) | |
| theorem body_next_inner (p : Ports r s) (callback : Cmd r s) (d : State r s) | |
| (hd : d.regs (p.register 0) = false) (es us : List Bool) | |
| (he : d.stacks (p.stack 2) = true :: es) | |
| (hu : d.stacks (p.stack 3) = false :: us) : | |
| Eval (body p callback) 11 d (entered p true true (backed p d)) := by | |
| have hp : (popped p 2 4 d).regs (p.register 3) = true := by | |
| simp [popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, he] | |
| have he' : (backed p d).regs (p.register 4) = true := by | |
| simp [backed, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, he] | |
| have hu' : (backed p d).regs (p.register 2) = false := by | |
| simp [backed, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, hu] | |
| exact .ite_false hd | |
| ((atoms_eval [.pop (p.stack 2) (p.register 4) (p.register 3)] d).seq | |
| (.ite_true hp | |
| ((atoms_eval [.pop (p.stack 3) (p.register 2) (p.register 3)] _).seq | |
| (.ite_true he' (.ite_false hu' (enter_eval p true true _)))))) | |
| def testedOutside (p : Ports r s) (d : State r s) : State r s := | |
| (Atom.peek (p.stack 1) (p.register 2) (p.register 3)).eval | |
| (popped p 1 2 (backed p d)) | |
| theorem body_next_outer (p : Ports r s) (callback : Cmd r s) (d : State r s) | |
| (hd : d.regs (p.register 0) = false) (es bs : List Bool) (b c : Bool) | |
| (he : d.stacks (p.stack 2) = false :: es) | |
| (hb : d.stacks (p.stack 1) = b :: c :: bs) : | |
| Eval (body p callback) 13 d (entered p true false (testedOutside p d)) := by | |
| have hp : (popped p 2 4 d).regs (p.register 3) = true := by | |
| simp [popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, he] | |
| have he' : (backed p d).regs (p.register 4) = false := by | |
| simp [backed, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, he] | |
| have hb' : (testedOutside p d).regs (p.register 3) = true := by | |
| simp [testedOutside, backed, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, hb] | |
| exact .ite_false hd | |
| ((atoms_eval [.pop (p.stack 2) (p.register 4) (p.register 3)] d).seq | |
| (.ite_true hp | |
| ((atoms_eval [.pop (p.stack 3) (p.register 2) (p.register 3)] _).seq | |
| (.ite_false he' | |
| ((atoms_eval [.pop (p.stack 1) (p.register 2) (p.register 3), | |
| .peek (p.stack 1) (p.register 2) (p.register 3)] _).seq | |
| (.ite_true hb' (enter_eval p true false _))))))) | |
| def pruned (p : Ports r s) (d : State r s) : State r s := | |
| pushed p 0 true (pushed p 1 true (testedOutside p d)) | |
| theorem body_prune (p : Ports r s) (callback : Cmd r s) (d : State r s) | |
| (hd : d.regs (p.register 0) = false) (es : List Bool) (b : Bool) | |
| (he : d.stacks (p.stack 2) = false :: es) (hb : d.stacks (p.stack 1) = [b]) : | |
| Eval (body p callback) 12 d (pruned p d) := by | |
| have hp : (popped p 2 4 d).regs (p.register 3) = true := by | |
| simp [popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, he] | |
| have he' : (backed p d).regs (p.register 4) = false := by | |
| simp [backed, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, he] | |
| have hb' : (testedOutside p d).regs (p.register 3) = false := by | |
| simp [testedOutside, backed, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, hb] | |
| exact .ite_false hd | |
| ((atoms_eval [.pop (p.stack 2) (p.register 4) (p.register 3)] d).seq | |
| (.ite_true hp | |
| ((atoms_eval [.pop (p.stack 3) (p.register 2) (p.register 3)] _).seq | |
| (.ite_false he' | |
| ((atoms_eval [.pop (p.stack 1) (p.register 2) (p.register 3), | |
| .peek (p.stack 1) (p.register 2) (p.register 3)] _).seq | |
| (.ite_false hb' ((pushBit_eval p 1 true _).seq (pushBit_eval p 0 true _)))))))) | |
| def stopped (p : Ports r s) (d : State r s) : State r s := | |
| (Atom.set (p.register 1) false).eval (popped p 2 4 d) | |
| theorem body_stop (p : Ports r s) (callback : Cmd r s) (d : State r s) | |
| (hd : d.regs (p.register 0) = false) (he : d.stacks (p.stack 2) = []) : | |
| Eval (body p callback) 4 d (stopped p d) := by | |
| have hp : (popped p 2 4 d).regs (p.register 3) = false := by | |
| simp [popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, he] | |
| exact .ite_false hd | |
| ((atoms_eval [.pop (p.stack 2) (p.register 4) (p.register 3)] d).seq | |
| (.ite_false hp (atoms_eval [.set (p.register 1) false] _))) | |
| structure Cursor (p : Ports r s) (n J : ℕ) (pre : List (Option Bool)) | |
| (down : Bool) (d : State r s) : Prop where | |
| depth : d.stacks (p.stack 0) = List.replicate n true | |
| budget : d.stacks (p.stack 1) = List.replicate J true | |
| outer : d.stacks (p.stack 2) = (pre.map Option.isSome).reverse | |
| inner : d.stacks (p.stack 3) = (pre.map (fun a => a.getD false)).reverse | |
| descending : d.regs (p.register 0) = down | |
| active : d.regs (p.register 1) = true | |
| theorem cursor_descend (p : Ports r s) (n J : ℕ) (pre : List (Option Bool)) | |
| (d : State r s) (h : Cursor p (n + 1) J pre true d) : | |
| Cursor p n J (pre ++ [none]) true (descended p d) := by | |
| rcases h with ⟨h0, h1, h2, h3, hm, ha⟩ | |
| constructor <;> | |
| simp [descended, entered, popped, pushed, Atom.eval, Atom.instr, | |
| StructuredProgram.State.ofCfg, BitProgram.execInstr, | |
| BitProgram.readRegs, h0, h1, h2, h3, ha, List.replicate_succ] | |
| theorem cursor_next_inner (p : Ports r s) (n J : ℕ) (pre : List (Option Bool)) | |
| (d : State r s) (h : Cursor p n J (pre ++ [some false]) false d) : | |
| Cursor p n J (pre ++ [some true]) true (entered p true true (backed p d)) := by | |
| rcases h with ⟨h0, h1, h2, h3, hm, ha⟩ | |
| constructor <;> | |
| simp [entered, backed, popped, pushed, Atom.eval, Atom.instr, | |
| StructuredProgram.State.ofCfg, BitProgram.execInstr, | |
| BitProgram.readRegs, h0, h1, h2, h3, ha] | |
| theorem cursor_next_outer (p : Ports r s) (n J : ℕ) (pre : List (Option Bool)) | |
| (d : State r s) (h : Cursor p n (J + 2) (pre ++ [none]) false d) : | |
| Cursor p n (J + 1) (pre ++ [some false]) true | |
| (entered p true false (testedOutside p d)) := by | |
| rcases h with ⟨h0, h1, h2, h3, hm, ha⟩ | |
| constructor <;> | |
| simp [entered, testedOutside, backed, popped, pushed, Atom.eval, Atom.instr, | |
| StructuredProgram.State.ofCfg, BitProgram.execInstr, | |
| BitProgram.readRegs, h0, h1, h2, h3, ha, List.replicate_succ] | |
| theorem cursor_finished (p : Ports r s) (n J : ℕ) (pre : List (Option Bool)) | |
| (d : State r s) (h : Cursor p n J (pre ++ [some true]) false d) : | |
| Cursor p (n + 1) (J + 1) pre false (finished p d) := by | |
| rcases h with ⟨h0, h1, h2, h3, hm, ha⟩ | |
| constructor <;> | |
| simp [finished, backed, popped, pushed, Atom.eval, Atom.instr, | |
| StructuredProgram.State.ofCfg, BitProgram.execInstr, | |
| BitProgram.readRegs, h0, h1, h2, h3, hm, ha, List.replicate_succ] | |
| theorem cursor_pruned (p : Ports r s) (n : ℕ) (pre : List (Option Bool)) | |
| (d : State r s) (h : Cursor p n 1 (pre ++ [none]) false d) : | |
| Cursor p (n + 1) 1 pre false (pruned p d) := by | |
| rcases h with ⟨h0, h1, h2, h3, hm, ha⟩ | |
| constructor <;> | |
| simp [pruned, testedOutside, backed, popped, pushed, Atom.eval, Atom.instr, | |
| StructuredProgram.State.ofCfg, BitProgram.execInstr, | |
| BitProgram.readRegs, h0, h1, h2, h3, hm, ha, List.replicate_succ] | |
| inductive BodyTrace (p : Ports r s) (callback : Cmd r s) : ℕ → State r s → State r s → Prop | |
| | refl (a) : BodyTrace p callback 0 a a | |
| | cons {n m a b c} : a.regs (p.register 1) = true → Eval (body p callback) n a b → | |
| BodyTrace p callback m b c → BodyTrace p callback (n + m + 1) a c | |
| theorem BodyTrace.trans {p : Ports r s} {callback : Cmd r s} | |
| {n m : ℕ} {a b c : State r s} | |
| (h : BodyTrace p callback n a b) (g : BodyTrace p callback m b c) : | |
| BodyTrace p callback (n + m) a c := by | |
| induction h with | |
| | refl => simpa using g | |
| | cons ha hab _ ih => | |
| simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using | |
| BodyTrace.cons ha hab (ih g) | |
| theorem BodyTrace.while_eval {p : Ports r s} {callback : Cmd r s} | |
| {n : ℕ} {a b : State r s} (h : BodyTrace p callback n a b) | |
| (hb : b.regs (p.register 1) = false) : | |
| Eval (.while (p.register 1) (body p callback)) (n + 1) a b := by | |
| induction h with | |
| | refl => exact Eval.while_false hb | |
| | cons ha hab _ ih => | |
| simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using | |
| Eval.while_true ha hab (ih hb) | |
| theorem BodyTrace.single {p : Ports r s} {callback : Cmd r s} | |
| {n : ℕ} {a b : State r s} (ha : a.regs (p.register 1) = true) | |
| (he : Eval (body p callback) n a b) : BodyTrace p callback (n + 1) a b := by | |
| simpa using BodyTrace.cons ha he (BodyTrace.refl b) | |
| @[simp] theorem pushed_frame (p : Ports r s) (i : Fin 4) (b : Bool) (d : State r s) | |
| (o : Fin s) (ho : o ≠ p.stack i) : (pushed p i b d).stacks o = d.stacks o := by | |
| simp [pushed, ho] | |
| @[simp] theorem popped_frame (p : Ports r s) (i : Fin 4) (v : Fin 5) (d : State r s) | |
| (o : Fin s) (ho : o ≠ p.stack i) : (popped p i v d).stacks o = d.stacks o := by | |
| simp [popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, ho] | |
| @[simp] theorem entered_frame (p : Ports r s) (e u : Bool) (d : State r s) | |
| (o : Fin s) (h2 : o ≠ p.stack 2) (h3 : o ≠ p.stack 3) : | |
| (entered p e u d).stacks o = d.stacks o := by | |
| simp [entered, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, h2, h3] | |
| @[simp] theorem testedOutside_stacks (p : Ports r s) (d : State r s) : | |
| (testedOutside p d).stacks = (popped p 1 2 (backed p d)).stacks := rfl | |
| structure CallbackSpec (p : Ports r s) (callback : Cmd r s) (output : Fin s) | |
| (visit : List (Option Bool) → List Bool → List Bool) (C N : ℕ) | |
| (I : State r s → Prop) : Prop where | |
| stable : ∀ d e, (∀ o, (∀ i, o ≠ p.stack i) → e.stacks o = d.stacks o) → I d → I e | |
| run : ∀ J pre d, pre.length = N → Cursor p 0 (J + 1) pre true d → I d → | |
| ∃ t e, t ≤ C ∧ Eval callback t (popped p 0 2 d) e ∧ | |
| (∀ i, e.stacks (p.stack i) = d.stacks (p.stack i)) ∧ | |
| e.stacks output = visit pre (d.stacks output) ∧ I e | |
| theorem subtree (p : Ports r s) (callback : Cmd r s) (output : Fin s) | |
| (houtput : ∀ i, output ≠ p.stack i) | |
| (visit : List (Option Bool) → List Bool → List Bool) (C N : ℕ) | |
| (I : State r s → Prop) (spec : CallbackSpec p callback output visit C N I) (n J : ℕ) | |
| (pre : List (Option Bool)) (d : State r s) (hsize : n + pre.length = N) | |
| (h : Cursor p n (J + 1) pre true d) (hi : I d) : | |
| ∃ t e, BodyTrace p callback t d e ∧ Cursor p n (J + 1) pre false e ∧ | |
| e.stacks output = DifferencePairs.fold visit n (J + 1) pre (d.stacks output) ∧ | |
| t ≤ (C + 46) * DifferencePairs.calls n (J + 1) ∧ I e := by | |
| induction n generalizing J pre d with | |
| | zero => | |
| obtain ⟨t, e, ht, he, hf, ho, hie⟩ := spec.run J pre d (by simpa using hsize) h hi | |
| have hr : Cursor p 0 (J + 1) pre false (returned p e) := by | |
| exact ⟨(hf 0).trans h.depth, (hf 1).trans h.budget, (hf 2).trans h.outer, | |
| (hf 3).trans h.inner, returned_descending p e, returned_active p e⟩ | |
| refine ⟨t + 6, returned p e, ?_, hr, ?_, ?_, | |
| spec.stable e (returned p e) (fun _ _ => rfl) hie⟩ | |
| · simpa [Nat.add_assoc] using BodyTrace.single h.active | |
| (body_callback p callback d e h.descending (by simpa using h.depth) t he) | |
| · simpa [DifferencePairs.fold] using ho | |
| · simp only [DifferencePairs.calls]; omega | |
| | succ n ih => | |
| have hs : n + (pre ++ [none]).length = N := by | |
| simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using hsize | |
| have hd := cursor_descend p n (J + 1) pre d h | |
| have hid : I (descended p d) := spec.stable d _ (by | |
| intro o ho; simp [descended, ho]) hi | |
| obtain ⟨t₀, e₀, he₀, hc₀, ho₀, ht₀, hi₀⟩ := | |
| ih J (pre ++ [none]) (descended p d) hs hd hid | |
| have hdtrace := BodyTrace.single h.active (body_descend p callback d h.descending true | |
| (List.replicate n true) (by simpa [List.replicate_succ] using h.depth)) | |
| have hout : (descended p d).stacks output = d.stacks output := by | |
| simp [descended, houtput] | |
| cases J with | |
| | zero => | |
| have hb := body_prune p callback e₀ hc₀.descending | |
| (pre.map Option.isSome).reverse true | |
| (by simpa using hc₀.outer) (by simpa using hc₀.budget) | |
| have hr := cursor_pruned p n pre e₀ hc₀ | |
| refine ⟨9 + t₀ + 13, pruned p e₀, | |
| (hdtrace.trans he₀).trans (BodyTrace.single hc₀.active hb), hr, ?_, ?_, ?_⟩ | |
| · simpa [DifferencePairs.fold, pruned, backed, houtput, hout] using ho₀ | |
| · simp only [DifferencePairs.calls, DifferencePairs.calls_zero] | |
| nlinarith | |
| · exact spec.stable e₀ _ (by intro o ho; simp [pruned, backed, ho]) hi₀ | |
| | succ J => | |
| have hb₁ := body_next_outer p callback e₀ hc₀.descending | |
| (pre.map Option.isSome).reverse (List.replicate J true) true true | |
| (by simpa using hc₀.outer) (by simpa [List.replicate_succ] using hc₀.budget) | |
| have hc₁ := cursor_next_outer p n J pre e₀ hc₀ | |
| have hi₁ : I (entered p true false (testedOutside p e₀)) := | |
| spec.stable e₀ _ (by intro o ho; simp [testedOutside_stacks, backed, ho]) hi₀ | |
| obtain ⟨t₁, e₁, he₁, hc₁', ho₁, ht₁, hi₁'⟩ := ih J (pre ++ [some false]) | |
| (entered p true false (testedOutside p e₀)) | |
| (by simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using hsize) hc₁ hi₁ | |
| have hb₂ := body_next_inner p callback e₁ hc₁'.descending | |
| (pre.map Option.isSome).reverse (pre.map (fun a => a.getD false)).reverse | |
| (by simpa using hc₁'.outer) (by simpa using hc₁'.inner) | |
| have hc₂ := cursor_next_inner p n (J + 1) pre e₁ hc₁' | |
| have hi₂ : I (entered p true true (backed p e₁)) := | |
| spec.stable e₁ _ (by intro o ho; simp [backed, ho]) hi₁' | |
| obtain ⟨t₂, e₂, he₂, hc₂', ho₂, ht₂, hi₂'⟩ := ih J (pre ++ [some true]) | |
| (entered p true true (backed p e₁)) | |
| (by simpa [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using hsize) hc₂ hi₂ | |
| have hb₃ := body_finish p callback e₂ hc₂'.descending | |
| (pre.map Option.isSome).reverse (pre.map (fun a => a.getD false)).reverse | |
| (by simpa using hc₂'.outer) (by simpa using hc₂'.inner) | |
| have hr := cursor_finished p n (J + 1) pre e₂ hc₂' | |
| refine ⟨9 + t₀ + 14 + t₁ + 12 + t₂ + 11, finished p e₂, | |
| (((((hdtrace.trans he₀).trans (BodyTrace.single hc₀.active hb₁)).trans he₁).trans | |
| (BodyTrace.single hc₁'.active hb₂)).trans he₂).trans | |
| (BodyTrace.single hc₂'.active hb₃), hr, ?_, ?_, ?_⟩ | |
| · simp only [finished, pushed_frame _ _ _ _ _ (houtput _)] | |
| simp only [backed, popped_frame _ _ _ _ _ (houtput _)] | |
| rw [ho₂] | |
| simp only [entered_frame _ _ _ _ _ (houtput 2) (houtput 3), | |
| backed, popped_frame _ _ _ _ _ (houtput _)] | |
| rw [ho₁] | |
| simp only [entered_frame _ _ _ _ _ (houtput 2) (houtput 3), | |
| testedOutside_stacks, backed, popped_frame _ _ _ _ _ (houtput _)] | |
| rw [ho₀, hout] | |
| rfl | |
| · simp only [DifferencePairs.calls] | |
| nlinarith | |
| · exact spec.stable e₂ _ (by intro o ho; simp [finished, backed, ho]) hi₂' | |
| def initialized (p : Ports r s) (d : State r s) : State r s := | |
| (Atom.set (p.register 0) true).eval | |
| ((Atom.copy (p.register 1) (p.register 3)).eval | |
| ((Atom.peek (p.stack 1) (p.register 2) (p.register 3)).eval d)) | |
| @[simp] theorem initialized_stacks (p : Ports r s) (d : State r s) : | |
| (initialized p d).stacks = d.stacks := rfl | |
| theorem command_eval (p : Ports r s) (callback : Cmd r s) (output : Fin s) | |
| (houtput : ∀ i, output ≠ p.stack i) | |
| (visit : List (Option Bool) → List Bool → List Bool) (C n J : ℕ) | |
| (I : State r s → Prop) (spec : CallbackSpec p callback output visit C n I) (d : State r s) | |
| (hdepth : d.stacks (p.stack 0) = List.replicate n true) | |
| (hbudget : d.stacks (p.stack 1) = List.replicate (J + 1) true) | |
| (he : d.stacks (p.stack 2) = []) (hu : d.stacks (p.stack 3) = []) (hi : I d) : | |
| ∃ (t : ℕ) (e : State r s), t ≤ (C + 46) * DifferencePairs.calls n (J + 1) + 9 ∧ | |
| Eval (command p callback) t d e ∧ | |
| e.stacks output = DifferencePairs.fold visit n (J + 1) [] (d.stacks output) ∧ | |
| (∀ i, e.stacks (p.stack i) = d.stacks (p.stack i)) ∧ I e := by | |
| have hcursor : Cursor p n (J + 1) [] true (initialized p d) := by | |
| constructor | |
| · exact hdepth | |
| · exact hbudget | |
| · exact he | |
| · exact hu | |
| · simp [initialized, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| · simp [initialized, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, | |
| hbudget, List.replicate_succ] | |
| have hii : I (initialized p d) := spec.stable d _ (fun _ _ => rfl) hi | |
| obtain ⟨t, e, ht, hc, ho, hb, hie⟩ := subtree p callback output houtput visit C n I spec | |
| n J [] (initialized p d) (by simp) hcursor hii | |
| have hend := body_stop p callback e hc.descending (by simpa using hc.outer) | |
| have hstop : (stopped p e).regs (p.register 1) = false := by | |
| simp [stopped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr] | |
| have hw := (ht.trans (BodyTrace.single hc.active hend)).while_eval hstop | |
| have hinit := atoms_eval [.peek (p.stack 1) (p.register 2) (p.register 3), | |
| .copy (p.register 1) (p.register 3), .set (p.register 0) true] d | |
| have hall : Eval (command p callback) (t + 9) d (stopped p e) := by | |
| simpa [command, initialized, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] | |
| using hinit.seq hw | |
| refine ⟨t + 9, stopped p e, by omega, hall, ?_, ?_, ?_⟩ | |
| · simpa [stopped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, popped, houtput] using ho | |
| · intro i | |
| fin_cases i <;> | |
| simp [stopped, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, hc.depth, hc.budget, | |
| hc.outer, hc.inner, hdepth, hbudget, he, hu] | |
| · exact spec.stable e _ (by | |
| intro o ho | |
| simp [stopped, popped, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, ho]) hie | |
| theorem program_trace (p : Ports r s) (callback : Cmd r s) (output : Fin s) | |
| (houtput : ∀ i, output ≠ p.stack i) | |
| (visit : List (Option Bool) → List Bool → List Bool) (C n J : ℕ) | |
| (I : State r s → Prop) (spec : CallbackSpec p callback output visit C n I) (d : State r s) | |
| (hdepth : d.stacks (p.stack 0) = List.replicate n true) | |
| (hbudget : d.stacks (p.stack 1) = List.replicate (J + 1) true) | |
| (he : d.stacks (p.stack 2) = []) (hu : d.stacks (p.stack 3) = []) (hi : I d) : | |
| ∃ (t : ℕ) (e : State r s), t ≤ (C + 46) * DifferencePairs.calls n (J + 1) + 10 ∧ | |
| BitProgram.Trace (program p callback) t | |
| (d.withPC (some (program p callback).entry)) (e.withPC none) ∧ | |
| e.stacks output = DifferencePairs.fold visit n (J + 1) [] (d.stacks output) ∧ | |
| (∀ i, e.stacks (p.stack i) = d.stacks (p.stack i)) ∧ I e := by | |
| obtain ⟨t, e, ht, heval, ho, hf, hie⟩ := command_eval p callback output houtput visit C n J | |
| I spec d hdepth hbudget he hu hi | |
| exact ⟨t + 1, e, by omega, compiled_halt_trace heval (p.stack 0) (p.stack 2), ho, hf, hie⟩ | |
| theorem command_eval_zero (p : Ports r s) (callback : Cmd r s) (d : State r s) | |
| (hbudget : d.stacks (p.stack 1) = []) : | |
| Eval (command p callback) 4 d (initialized p d) := by | |
| have hfalse : (initialized p d).regs (p.register 1) = false := by | |
| simp [initialized, Atom.eval, Atom.instr, StructuredProgram.State.ofCfg, | |
| BitProgram.execInstr, BitProgram.readRegs, hbudget] | |
| exact (atoms_eval [.peek (p.stack 1) (p.register 2) (p.register 3), | |
| .copy (p.register 1) (p.register 3), .set (p.register 0) true] d).seq | |
| (Eval.while_false hfalse) | |
| theorem program_trace_zero (p : Ports r s) (callback : Cmd r s) (d : State r s) | |
| (hbudget : d.stacks (p.stack 1) = []) : | |
| BitProgram.Trace (program p callback) 5 | |
| (d.withPC (some (program p callback).entry)) ((initialized p d).withPC none) := by | |
| exact compiled_halt_trace (command_eval_zero p callback d hbudget) (p.stack 0) (p.stack 2) | |
| def cost (C n J : ℕ) : ℕ := (C + 46) * (3 * n + 1) * DifferencePairs.pairCount n J + 10 | |
| theorem program_runsIn (p : Ports r s) (callback : Cmd r s) (output : Fin s) | |
| (houtput : ∀ i, output ≠ p.stack i) | |
| (visit : List (Option Bool) → List Bool → List Bool) (C n J : ℕ) | |
| (I : State r s → Prop) (spec : CallbackSpec p callback output visit C n I) (d : State r s) | |
| (hdepth : d.stacks (p.stack 0) = List.replicate n true) | |
| (hbudget : d.stacks (p.stack 1) = List.replicate J true) | |
| (he : d.stacks (p.stack 2) = []) (hu : d.stacks (p.stack 3) = []) (hi : I d) : | |
| ∃ e : State r s, BitProgram.RunsIn (program p callback) (cost C n J) | |
| (d.withPC (some (program p callback).entry)) (e.withPC none) ∧ | |
| e.stacks output = DifferencePairs.fold visit n J [] (d.stacks output) ∧ | |
| (∀ i, e.stacks (p.stack i) = d.stacks (p.stack i)) ∧ I e := by | |
| cases J with | |
| | zero => | |
| exact ⟨initialized p d, ⟨5, by simp [cost], | |
| program_trace_zero p callback d (by simpa using hbudget)⟩, | |
| by simp [DifferencePairs.fold], (fun _ => rfl), | |
| spec.stable d _ (fun _ _ => rfl) hi⟩ | |
| | succ J => | |
| obtain ⟨t, e, ht, htrace, ho, hf, hie⟩ := program_trace p callback output houtput visit C n J | |
| I spec d hdepth hbudget he hu hi | |
| refine ⟨e, ⟨t, ht.trans ?_, htrace⟩, ho, hf, hie⟩ | |
| have hc := DifferencePairs.calls_le n (J + 1) (Nat.succ_pos J) | |
| unfold cost | |
| nlinarith | |
| theorem cost_le_support_square (C n J : ℕ) : | |
| cost C n J ≤ (C + 46) * (3 * n + 1) * | |
| (BooleanDifferences.supportFamily n J).card ^ 2 + 10 := by | |
| exact Nat.add_le_add_right | |
| (Nat.mul_le_mul_left _ (DifferencePairs.pairCount_le_square n J)) 10 | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DifferencePairsProgram | |