File size: 12,364 Bytes
4a56cd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 | import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DifferencePairsSpace
/-! Relational accumulator correctness for the existing four-stack pair DFS.
Only the proof invariant is generalized: the actual commands, branch order,
callback states and all-prefix space theorem are unchanged. -/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DifferencePairsRelational
open BitProgram StructuredCalls DifferencePairsProgram
open StructuredProgram (Atom)
variable {r s : ℕ} {α : Type*}
/-- The callback returns an actual dictionary representing the next semantic
value. No uniform choice of dictionary bytes is required. -/
structure CallbackSpec (p : Ports r s) (callback : Cmd r s)
(visit : List (Option Bool) → α → α) (C N : ℕ)
(I : α → State r s → Prop) : Prop where
stable : ∀ value d e,
(∀ o, (∀ i, o ≠ p.stack i) → e.stacks o = d.stacks o) → I value d → I value e
run : ∀ J pre value d, pre.length = N → Cursor p 0 (J+1) pre true d → I value 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)) ∧ I (visit pre value) e
/-- Erasing the semantic value supplies exactly the existing resource
contract. Its auxiliary byte observation is the preserved depth controller;
the resource theorem does not require an off-controller output port. -/
theorem CallbackSpec.erased (p : Ports r s) (callback : Cmd r s)
(visit : List (Option Bool) → α → α) (C N : ℕ) (I : α → State r s → Prop)
(spec : CallbackSpec p callback visit C N I) :
DifferencePairsProgram.CallbackSpec p callback (p.stack 0) (fun _ word => word)
C N (fun d => ∃ value, I value d) := by
constructor
· intro d e hf hd
obtain ⟨value,hvalue⟩ := hd
exact ⟨value,spec.stable value d e hf hvalue⟩
· intro J pre d hn hc hd
obtain ⟨value,hvalue⟩ := hd
obtain ⟨t,e,ht,he,hf,hI⟩ := spec.run J pre value d hn hc hvalue
exact ⟨t,e,ht,he,hf,hf 0,visit pre value,hI⟩
/-- The same actual subtree traversal realizes the semantic fold, while its
dictionary witnesses may vary at every callback. -/
theorem subtree (p : Ports r s) (callback : Cmd r s)
(visit : List (Option Bool) → α → α) (C N : ℕ)
(I : α → State r s → Prop) (spec : CallbackSpec p callback visit C N I)
(n J : ℕ) (pre : List (Option Bool)) (value : α) (d : State r s)
(hsize : n + pre.length = N) (h : Cursor p n (J+1) pre true d) (hi : I value d) :
∃ t e, BodyTrace p callback t d e ∧ Cursor p n (J+1) pre false e ∧
t ≤ (C+46)*DifferencePairs.calls n (J+1) ∧
I (DifferencePairs.fold visit n (J+1) pre value) e := by
induction n generalizing J pre value d with
| zero =>
obtain ⟨t,e,ht,he,hf,hIe⟩ := spec.run J pre value d (by simpa using hsize) h hi
have hr : Cursor p 0 (J+1) pre false (returned p e) :=
⟨(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,?_,?_⟩
· simpa [Nat.add_assoc] using BodyTrace.single h.active
(body_callback p callback d e h.descending (by simpa using h.depth) t he)
· simp only [DifferencePairs.calls]
omega
· exact spec.stable _ e _ (fun _ _ => rfl) hIe
| 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 value (descended p d) := spec.stable value d _ (by
intro o ho
simp [descended,ho]) hi
obtain ⟨t₀,e₀,he₀,hc₀,ht₀,hi₀⟩ := ih J (pre++[none]) value (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))
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,?_,?_⟩
· simp only [DifferencePairs.calls,DifferencePairs.calls_zero]
nlinarith
· have hsemantic := spec.stable _ e₀ (pruned p e₀)
(by intro o ho; simp [pruned,backed,ho]) hi₀
simpa only [DifferencePairs.fold] using hsemantic
| 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 (DifferencePairs.fold visit n (J+2) (pre++[none]) value)
(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₁',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₂ := spec.stable _ e₁ (entered p true true (backed p e₁))
(by intro o ho; simp [backed,ho]) hi₁'
obtain ⟨t₂,e₂,he₂,hc₂',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 [DifferencePairs.calls]
nlinarith
· exact spec.stable _ e₂ _ (by intro o ho; simp [finished,backed,ho]) hi₂'
/-- Actual command execution and semantic accumulator correctness, before
the single compiler halt step. -/
theorem command_eval (p : Ports r s) (callback : Cmd r s)
(visit : List (Option Bool) → α → α) (C n J : ℕ)
(I : α → State r s → Prop) (spec : CallbackSpec p callback visit C n I)
(value : α) (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 value d) :
∃ t e, t ≤ (C+46)*DifferencePairs.calls n (J+1)+9 ∧
Eval (command p callback) t d e ∧
(∀ i,e.stacks (p.stack i)=d.stacks (p.stack i)) ∧
I (DifferencePairs.fold visit n (J+1) [] value) 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 value (initialized p d) := spec.stable value d _ (fun _ _ => rfl) hi
obtain ⟨t,e,ht,hc,hb,hIe⟩ := subtree p callback visit C n I spec n J [] value
(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,?_,?_⟩
· 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
/-- Relational correctness, exact native time and all-prefix space refer to
one execution of the unchanged pair iterator, including J=0 and J>N. -/
theorem program_resources (p : Ports r s) (callback : Cmd r s)
(visit : List (Option Bool) → α → α) (I : α → State r s → Prop)
(C N J B D : ℕ) (spec : CallbackSpec p callback visit C N I)
(hcallback : ∀ value j pre a b t, pre.length=N →
(j+1)+pre.countP Option.isSome=J → Cursor p 0 (j+1) pre true a → I value a →
(∀ i, (a.stacks i).length ≤ B) → Eval callback t (popped p 0 2 a) b →
(∀ i, (b.stacks i).length ≤ B) ∧
∀ elapsed z, elapsed ≤ t → Trace (compiled callback (p.stack 0) (p.stack 2)) elapsed
((popped p 0 2 a).withPC (some (compiled callback (p.stack 0) (p.stack 2)).entry)) z →
∀ i, (z.stacks i).length ≤ D)
(value : α) (a : State r s) (ha : ∀ i, (a.stacks i).length ≤ B) (hi : I value a)
(hdepth : a.stacks (p.stack 0)=List.replicate N true)
(hbudget : a.stacks (p.stack 1)=List.replicate J true)
(houter : a.stacks (p.stack 2)=[]) (hinner : a.stacks (p.stack 3)=[]) :
∃ t e, Eval (command p callback) t a e ∧ t + 1 ≤ cost C N J ∧
Trace (program p callback) (t+1)
(a.withPC (some (program p callback).entry)) (e.withPC none) ∧
(∀ i,e.stacks (p.stack i)=a.stacks (p.stack i)) ∧
I (DifferencePairs.fold visit N J [] value) e ∧
∀ elapsed z, elapsed ≤ t + 1 → Trace (program p callback) elapsed
(a.withPC (some (program p callback).entry)) z →
∀ i, (z.stacks i).length ≤ max D (s * B + 13) := by
have hex : ∃ t e, Eval (command p callback) t a e ∧ t + 1 ≤ cost C N J ∧
(∀ i,e.stacks (p.stack i)=a.stacks (p.stack i)) ∧
I (DifferencePairs.fold visit N J [] value) e := by
cases J with
| zero =>
exact ⟨4,initialized p a,command_eval_zero p callback a (by simpa using hbudget),
by simp [cost],fun _ => rfl,by
simpa only [DifferencePairs.fold] using
spec.stable value a (initialized p a) (fun _ _ => rfl) hi⟩
| succ J =>
obtain ⟨t,e,ht,he,hf,hIe⟩ := command_eval p callback visit C N J I spec value a
hdepth hbudget houter hinner hi
refine ⟨t,e,he,?_,hf,hIe⟩
have hc := DifferencePairs.calls_le N (J+1) (Nat.succ_pos J)
unfold cost
nlinarith
obtain ⟨t,e,he,ht,hf,hIe⟩ := hex
refine ⟨t,e,he,ht,compiled_halt_trace he (p.stack 0) (p.stack 2),hf,hIe,?_⟩
apply DifferencePairsSpace.program_stack_bound p callback (p.stack 0) (fun _ word => word)
(fun d => ∃ value,I value d) C N J B D (spec.erased p callback visit C N I)
?_ he ha ⟨value,hi⟩ hdepth hbudget houter hinner
intro j pre d b steps hn hj hc hd hb heval
obtain ⟨v,hv⟩ := hd
exact hcallback v j pre d b steps hn hj hc hv hb heval
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DifferencePairsRelational
|