File size: 12,798 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
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentLoop

/-! The actual specialized callback dispatches one stored original factor ID.
The general dispatch theorem fixes its physical payload, flags and exact frame;
hash and marked branch correctness is supplied by their concrete native proofs. -/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentCallback

open OAI BitProgram StructuredCalls
open SqrtLog SqrtLog.LeafProgram MomentsProgram FactorAssignmentProgram

noncomputable section
attribute [local simp] Fin.coe_ofNat_eq_mod

def dispatchInput (a : FactorAssignmentProgram.Data) : State 40 768 :=
  projectState id lowStack (callbackInitial a)

def dispatched (a : FactorAssignmentProgram.Data) (rf : Fin 8 → Bool)
    (rows clauses : List (List Bool)) (marked : Bool) (mark factor : ℕ) : FactorAssignmentProgram.Data :=
  embedState id lowStack (callbackInitial a)
    (FactorDispatch.finished (dispatchInput a) rf rows clauses marked mark factor)

/-- The paid clear preserves an already established callback boundary. -/
theorem callbackInitial_stacks (a : FactorAssignmentProgram.Data)
    (hclean : ∀ i ∈ callbackScratch, a.stacks (lowStack i) = []) :
    (callbackInitial a).stacks = a.stacks := by
  funext i
  by_cases hi : i ∈ callbackScratch.map lowStack
  · obtain ⟨j, hj, rfl⟩ := List.mem_map.mp hi
    rw [callbackInitial_low, ite_eq_left hj, hclean j hj]
  · exact callbackInitial_frame a i hi

private theorem dispatchInput_frame (a : FactorAssignmentProgram.Data) (i : Fin 768)
    (hi : i ∉ callbackScratch) :
    (dispatchInput a).stacks i = a.stacks (lowStack i) :=
  (callbackInitial_low a i).trans (ite_eq_right hi)

private theorem dispatchInput_work (a : FactorAssignmentProgram.Data) :
    ∀ i ∈ FactorDispatch.scratch, (dispatchInput a).stacks i = [] := by
  intro i hi
  have hmem : i ∈ callbackScratch := by
    simp only [callbackScratch, List.mem_append]
    exact Or.inl (Or.inl (Or.inr hi))
  exact (callbackInitial_low a i).trans (ite_eq_left hmem)

/-- All caller stacks are restored except the actual selected payload154.
This frame applies to hash, marked and neutral IDs, without an early exit. -/
theorem dispatched_stacks (a : FactorAssignmentProgram.Data) (rf : Fin 8 → Bool)
    (rows clauses : List (List Bool)) (marked : Bool) (mark factor : ℕ)
    (hrows : a.stacks 701 = Encoding.encodeList id rows)
    (hclauses : a.stacks 700 = Encoding.encodeList id clauses)
    (hcount : a.stacks 704 = List.replicate rows.length true)
    (hmark : a.stacks 705 = Encoding.encodeNat mark) :
    (dispatched a rf rows clauses marked mark factor).stacks =
      Function.update (callbackInitial a).stacks 154
        (LeafFactorDispatchProgram.selectedPayload rows clauses marked mark factor) := by
  have hr : (dispatchInput a).stacks 701 = Encoding.encodeList id rows :=
    (dispatchInput_frame a 701 (by decide)).trans hrows
  have hc : (dispatchInput a).stacks 700 = Encoding.encodeList id clauses :=
    (dispatchInput_frame a 700 (by decide)).trans hclauses
  have hn : (dispatchInput a).stacks 704 = List.replicate rows.length true :=
    (dispatchInput_frame a 704 (by decide)).trans hcount
  have hm : (dispatchInput a).stacks 705 = Encoding.encodeNat mark :=
    (dispatchInput_frame a 705 (by decide)).trans hmark
  have hlow := FactorDispatch.finished_stacks (dispatchInput a) rf rows clauses
    marked mark factor hr hc hn hm (dispatchInput_work a)
  funext i
  by_cases hi : i.val < 768
  · let j : Fin 768 := ⟨i.val, hi⟩
    have hj : lowStack j = i := Fin.ext rfl
    rw [← hj]
    change (embedState id lowStack (callbackInitial a)
      (FactorDispatch.finished (dispatchInput a) rf rows clauses marked mark factor)).stacks
      (lowStack j) = _
    rw [embedState_stack id lowStack _ _ (Fin.castAdd_injective _ _) j, hlow]
    by_cases h154 : j = 154
    · rw [h154]
      simp [lowStack]
    · have hwide : lowStack j ≠ 154 := by
        intro he
        apply h154
        exact Fin.ext (congrArg (fun k : Fin 896 => k.val) he)
      simp only [Function.update_of_ne h154, Function.update_of_ne hwide]
      rfl
  · have h154 : i ≠ 154 := by intro he; subst i; norm_num at hi
    rw [Function.update_of_ne h154]
    apply embedState_stack_frame
    rintro ⟨j, hj⟩
    have hv := congrArg Fin.val hj
    change j.val = i.val at hv
    omega

/-- The native parser compares the complete original ID and returns both
role flags. Every copy, table scan and finite lifted return is charged. -/
theorem dispatch_eval (a : FactorAssignmentProgram.Data) (rows clauses : List (List Bool))
    (marked : Bool) (mark factor : ℕ)
    (hrows : a.stacks 701 = Encoding.encodeList id rows)
    (hclauses : a.stacks 700 = Encoding.encodeList id clauses)
    (hcount : a.stacks 704 = List.replicate rows.length true)
    (hmark : a.stacks 705 = Encoding.encodeNat mark)
    (hflag : a.stacks 706 = [marked])
    (hfactor : a.stacks 149 = (Encoding.encodeNat factor).reverse)
    (hvalid : marked = true → mark < clauses.length) :
    ∃ steps rf, steps ≤ 7 * (a.stacks 149).length + 7 +
        LeafFactorDispatchProgram.budget rows clauses mark factor ∧
      Eval (liftLow FactorDispatch.command 149 154) steps (callbackInitial a)
        (dispatched a rf rows clauses marked mark factor) ∧
      (dispatched a rf rows clauses marked mark factor).regs 5 =
        decide (factor < rows.length) ∧
      (dispatched a rf rows clauses marked mark factor).regs 6 =
        (marked && decide (factor = rows.length)) := by
  have hr : (dispatchInput a).stacks 701 = Encoding.encodeList id rows :=
    (dispatchInput_frame a 701 (by decide)).trans hrows
  have hc : (dispatchInput a).stacks 700 = Encoding.encodeList id clauses :=
    (dispatchInput_frame a 700 (by decide)).trans hclauses
  have hn : (dispatchInput a).stacks 704 = List.replicate rows.length true :=
    (dispatchInput_frame a 704 (by decide)).trans hcount
  have hm : (dispatchInput a).stacks 705 = Encoding.encodeNat mark :=
    (dispatchInput_frame a 705 (by decide)).trans hmark
  have hf : (dispatchInput a).stacks 706 = [marked] :=
    (dispatchInput_frame a 706 (by decide)).trans hflag
  have hid : (dispatchInput a).stacks 149 = (Encoding.encodeNat factor).reverse :=
    (dispatchInput_frame a 149 (by decide)).trans hfactor
  obtain ⟨k, rf, hk, he, h5, h6, _⟩ := FactorDispatch.command_eval
    (dispatchInput a) rows clauses marked mark factor hr hc hn hm hf hid
      (dispatchInput_work a) hvalid
  refine ⟨k + 1, rf, ?_, ?_, ?_, ?_⟩
  · have hl : (dispatchInput a).stacks 149 = a.stacks 149 :=
      dispatchInput_frame a 149 (by decide)
    rw [hl] at hk
    omega
  · exact eval_liftCommand_from_state FactorDispatch.command 149 154 id lowStack
      (callbackInitial a) Function.injective_id (Fin.castAdd_injective _ _) he
  · rw [show (dispatched a rf rows clauses marked mark factor).regs 5 =
        (FactorDispatch.finished (dispatchInput a) rf rows clauses marked mark factor).regs 5 from
      embedState_register id lowStack _ _ Function.injective_id 5]
    rw [FactorDispatch.finished_role_hash, h5]
  · rw [show (dispatched a rf rows clauses marked mark factor).regs 6 =
        (FactorDispatch.finished (dispatchInput a) rf rows clauses marked mark factor).regs 6 from
      embedState_register id lowStack _ _ Function.injective_id 6]
    rw [FactorDispatch.finished_role_marked, h6]

/-- The two conditionals are charged in their actual chosen branch. -/
theorem choose_hash {k : ℕ} {a b : FactorAssignmentProgram.Data}
    (h5 : a.regs 5 = true) (he : Eval hashFactor k a b) :
    Eval choose (k + 1) a b :=
  Eval.ite_true h5 he

theorem choose_marked {k : ℕ} {a b : FactorAssignmentProgram.Data}
    (h5 : a.regs 5 = false) (h6 : a.regs 6 = true)
    (he : Eval markedFactor k a b) : Eval choose (k + 2) a b := by
  simpa only [choose, Nat.add_assoc] using
    (Eval.ite_false h5 (Eval.ite_true h6 he) :
      Eval (.ite 5 hashFactor (.ite 6 markedFactor (.base .skip))) (k + 1 + 1) a b)

/-- Compose the actual clear, dispatcher, chosen branch and record return.
The branch frame is the one supplied by native table/arithmetic execution. -/
theorem callback_chosen_eval {n B d : ℕ}
    (a b : FactorAssignmentProgram.Data) (rf : Fin 8 → Bool) (rows clauses : List (List Bool))
    (marked : Bool) (mark factor kd kc : ℕ) (out : FactorAssignmentLoop.Raw n B d)
    (hrows : a.stacks 701 = Encoding.encodeList id rows)
    (hclauses : a.stacks 700 = Encoding.encodeList id clauses)
    (hcount : a.stacks 704 = List.replicate rows.length true)
    (hmark : a.stacks 705 = Encoding.encodeNat mark)
    (hclean : ∀ i ∈ callbackScratch, a.stacks (lowStack i) = [])
    (hd : Eval (liftLow FactorDispatch.command 149 154) kd (callbackInitial a)
      (dispatched a rf rows clauses marked mark factor))
    (hc : Eval choose kc (dispatched a rf rows clauses marked mark factor) b)
    (hb : b.stacks = Function.update
      (Function.update (dispatched a rf rows clauses marked mark factor).stacks 154 [])
      151 (Product.bytes out)) :
    Eval callback (clearCallbackCost a + (kd + (kc + (2 * (a.stacks 149).length + 6))))
      a (callbackFinished b) ∧
    (callbackFinished b).stacks =
      Function.update (Function.update a.stacks 149 []) 151 (Product.bytes out) ∧
    (callbackFinished b).regs 13 = false ∧
    (callbackFinished b).regs 14 = true ∧
    (callbackFinished b).regs 15 = false := by
  have hstart := callbackInitial_stacks a hclean
  have hw := dispatched_stacks a rf rows clauses marked mark factor hrows hclauses hcount hmark
  have h154 : a.stacks 154 = [] := hclean 154 (by decide)
  have hframe : b.stacks = Function.update a.stacks 151 (Product.bytes out) := by
    rw [hb, hw, hstart]
    funext i
    by_cases hi151 : i = 151 <;> by_cases hi154 : i = 154
    all_goals simp [hi151, hi154, h154]
  have h149 : b.stacks 149 = a.stacks 149 := by rw [hframe]; simp
  refine ⟨?_, ?_, ?_, ?_, ?_⟩
  · simpa only [callback, h149] using
      (clearCallback_eval a).seq (hd.seq (hc.seq (callbackFinish_eval b)))
  · funext i
    by_cases hi149 : i = 149 <;> by_cases hi151 : i = 151
    all_goals simp [callbackFinished, returned, cleared, hframe, hi149, hi151]
  all_goals simp [callbackFinished, returned]

/-- A neutral ID leaves the actual accumulated dictionary unchanged and
restores the same callback boundary, after its paid dispatch and return. -/
theorem callback_neutral_frame (a : FactorAssignmentProgram.Data) (rows clauses : List (List Bool))
    (marked : Bool) (mark factor : ℕ)
    (hrows : a.stacks 701 = Encoding.encodeList id rows)
    (hclauses : a.stacks 700 = Encoding.encodeList id clauses)
    (hcount : a.stacks 704 = List.replicate rows.length true)
    (hmark : a.stacks 705 = Encoding.encodeNat mark)
    (hflag : a.stacks 706 = [marked])
    (hfactor : a.stacks 149 = (Encoding.encodeNat factor).reverse)
    (hvalid : marked = true → mark < clauses.length)
    (hhash : ¬factor < rows.length)
    (hmarked : (marked && decide (factor = rows.length)) = false)
    (hclean : ∀ i ∈ callbackScratch, a.stacks (lowStack i) = []) :
    ∃ steps b, steps ≤ clearCallbackCost a + 9 * (a.stacks 149).length + 15 +
        LeafFactorDispatchProgram.budget rows clauses mark factor ∧
      Eval callback steps a b ∧ b.stacks = Function.update a.stacks 149 [] ∧
      b.regs 13 = false ∧ b.regs 14 = true ∧ b.regs 15 = false := by
  obtain ⟨steps, b, hs, he, hb, h13, h14, h15⟩ :=
    callback_neutral_eval a rows clauses marked mark factor hrows hclauses hcount hmark
      hflag hfactor hvalid hhash hmarked
  exact ⟨steps, b, hs, he, hb.trans
    (congrArg (fun ss : Fin 896 → List Bool => Function.update ss 149 [])
      (callbackInitial_stacks a hclean)), h13, h14, h15⟩

/-- Exact callback byte restoration supplies the state expected by the
record-fold theorem, while allowing the accumulator encoding to change. -/
theorem result_eq_state {n B d : ℕ} (base : Fin 896 → List Bool)
    (regs : Fin 40 → Bool) (seed out : FactorAssignmentLoop.Raw n B d)
    (tail payload : List Bool) (b : FactorAssignmentProgram.Data)
    (hb : b.stacks = Function.update
      (Function.update (FactorAssignmentLoop.state base regs seed tail payload).stacks 149 [])
      151 (Product.bytes out)) :
    b = FactorAssignmentLoop.state base b.regs out tail [] := by
  cases b with
  | mk rb sb =>
    apply congrArg (StructuredProgram.State.mk rb)
    funext i
    have hi := congrFun hb i
    by_cases h149 : i = 149 <;> by_cases h150 : i = 150 <;> by_cases h151 : i = 151
    all_goals simpa [FactorAssignmentLoop.state, Function.update_apply, h149, h150, h151] using hi

end
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentCallback