File size: 19,159 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
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.ExecCNFTupleSplit
import OAI.Algorithms.SubexponentialSAT.ExecSelectedFamilyProgram
import OAI.Algorithms.SubexponentialSAT.TupleGuardProgram
import OAI.Algorithms.SubexponentialSAT.FirstClauseCoreProgram

namespace OAI.Algorithms

/-!
# Concrete preparation of a sunflower candidate

This fixed program splits a preserved mask-first tuple, checks its binary
indices, gathers the selected clauses, and selects a core from the first
gathered clause. Every stage calls an actual finite Boolean-stack program.
The input formula, tuple, limit, and all unrelated stacks are preserved.
-/

namespace SubexponentialSAT.CandidatePrepareProgram

open BitProgram StructuredCalls

abbrev Clause := List (List Bool)
abbrev Formula := List Clause
abbrev Data := State 32 32
abbrev Code := Cmd 32 32

def clauseCode (C : Clause) := Encoding.encodeList id C
def formulaCode (F : Formula) := Encoding.encodeList clauseCode F
def tupleCode (words : List (List Bool)) := Encoding.encodeList id words
def selected (F : Formula) (words : List (List Bool)) :=
  (ExecSelectedFamilyProgram.selectedClauses F words).reverse
def core (F : Formula) (mask : List Bool) (words : List (List Bool)) :=
  CoreMaskProgram.select mask ((selected F words).headD [])
def valid (limit : List Bool) (words : List (List Bool)) :=
  TupleGuardProgram.goodFrom limit none words

def WorkEmpty (d : Data) : Prop :=
  (∀ i : Fin 7, d.stacks (Fin.castAdd 25 i) = []) ∧
  d.stacks 8 = [] ∧ d.stacks 13 = [] ∧ d.stacks 22 = [] ∧
  d.stacks 23 = [] ∧ d.stacks 24 = [] ∧ d.stacks 25 = [] ∧ d.stacks 26 = []

def Ready (F : Formula) (mask limit : List Bool) (words : List (List Bool))
    (d : Data) : Prop :=
  d.stacks 16 = formulaCode F ∧ d.stacks 17 = tupleCode (mask :: words) ∧
  d.stacks 19 = limit ∧ WorkEmpty d

def guardReg (i : Fin 13) : Fin 32 := Fin.castAdd 19 i
def guardStack : Fin 9 → Fin 32 := ![23, 0, 1, 19, 2, 3, 4, 5, 6]
theorem guardReg_injective : Function.Injective guardReg := Fin.castAdd_injective 13 19
theorem guardStack_injective : Function.Injective guardStack := by decide

def guard : Code := .seq
  (.call (ProgramLinking.liftProgram TupleGuardProgram.program guardReg guardStack))
  (RecordPrograms.atom (.copy 30 10))

theorem guard_eval (limit : List Bool) (words : List (List Bool)) (d : Data)
    (ht : d.stacks 23 = tupleCode words) (hl : d.stacks 19 = limit)
    (hw : ∀ i : Fin 7, d.stacks (Fin.castAdd 25 i) = []) :
    ∃ n ≤ TupleGuardProgram.bound limit words + 1, ∃ e : Data,
      Eval guard n d e ∧ e.stacks = d.stacks ∧ e.regs 30 = valid limit words := by
  let a := projectState guardReg guardStack d
  have haw : TupleGuardProgram.workEmpty a := by
    rcases (show d.stacks 0 = [] ∧ d.stacks 1 = [] ∧ d.stacks 2 = [] ∧
        d.stacks 3 = [] ∧ d.stacks 4 = [] ∧ d.stacks 5 = [] ∧ d.stacks 6 = [] from
      ⟨hw 0, hw 1, hw 2, hw 3, hw 4, hw 5, hw 6⟩) with
      ⟨h0, h1, h2, h3, h4, h5, h6⟩
    simpa [TupleGuardProgram.workEmpty, a, projectState, guardStack] using
      And.intro h0 (And.intro h1 (And.intro h2 (And.intro h3 (And.intro h4 (And.intro h5 h6)))))
  obtain ⟨b, ⟨n, hn, htrace⟩, hb0, hb3, hbw, hb10⟩ :=
    TupleGuardProgram.program_runsIn limit words a ht hl haw
  have hba : b.stacks = a.stacks := by
    rcases hbw with ⟨hb1, hb2, hb4, hb5, hb6, hb7, hb8⟩
    rcases haw with ⟨ha1, ha2, ha4, ha5, ha6, ha7, ha8⟩
    funext i
    fin_cases i
    · exact hb0.trans ht.symm
    · exact hb1.trans ha1.symm
    · exact hb2.trans ha2.symm
    · exact hb3.trans hl.symm
    · exact hb4.trans ha4.symm
    · exact hb5.trans ha5.symm
    · exact hb6.trans ha6.symm
    · exact hb7.trans ha7.symm
    · exact hb8.trans ha8.symm
  let c := embedState guardReg guardStack d b
  have hc : Eval (.call (ProgramLinking.liftProgram TupleGuardProgram.program
      guardReg guardStack)) n d c :=
    eval_call_from_state _ _ _ _ guardReg_injective guardStack_injective htrace
  have hcs : c.stacks = d.stacks := by
    funext i
    classical
    by_cases hi : ∃ j, guardStack j = i
    · obtain ⟨j, rfl⟩ := hi
      exact (embedState_stack _ _ _ _ guardStack_injective j).trans
        (congrFun hba j)
    · exact embedState_stack_frame _ _ _ _ i hi
  have hc10 : c.regs 10 = valid limit words :=
    (embedState_register _ _ _ _ guardReg_injective 10).trans hb10
  let e := (StructuredProgram.Atom.copy (r := 32) (s := 32) 30 10).eval c
  refine ⟨n + 1, by omega, e, Eval.seq hc (.base (.atom _ _)), hcs, ?_⟩
  simpa [e, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr,
    StructuredProgram.State.ofCfg, StructuredProgram.State.withPC, execInstr] using hc10

def smallReg (i : Fin 4) : Fin 32 := Fin.castAdd 28 i
theorem smallReg_injective : Function.Injective smallReg := Fin.castAdd_injective 4 28
def gatherStack : Fin 10 → Fin 32 := ![16, 0, 13, 1, 2, 3, 4, 23, 5, 6]
theorem gatherStack_injective : Function.Injective gatherStack := by decide

def initGather : Code :=
  .seq (RecordPrograms.atom (.set 0 false))
    (.seq (RecordPrograms.atom (.set 1 false))
      (.seq (RecordPrograms.atom (.set 2 false))
        (.seq (RecordPrograms.atom (.set 3 false)) (RecordPrograms.atom (.push 13 0)))))

def initialized (d : Data) : Data :=
  (StructuredProgram.Atom.push 13 0).eval
    ((StructuredProgram.Atom.set 3 false).eval
      ((StructuredProgram.Atom.set 2 false).eval
        ((StructuredProgram.Atom.set 1 false).eval
          ((StructuredProgram.Atom.set 0 false).eval d))))

theorem initialize_eval (d : Data) : Eval initGather 5 d (initialized d) :=
  Eval.seq (.base (.atom _ _)) (Eval.seq (.base (.atom _ _))
    (Eval.seq (.base (.atom _ _)) (Eval.seq (.base (.atom _ _)) (.base (.atom _ _)))))

theorem initialized_stacks (d : Data) :
    (initialized d).stacks = Function.update d.stacks 13 (false :: d.stacks 13) := by
  simp [initialized, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr,
    StructuredProgram.State.ofCfg, execInstr]

theorem initialized_regs (d : Data) (i : Fin 4) :
    (initialized d).regs (smallReg i) = false := by
  fin_cases i <;> simp [initialized, smallReg, StructuredProgram.Atom.eval,
    StructuredProgram.Atom.instr, StructuredProgram.State.ofCfg, execInstr]

theorem initialized_flag (d : Data) : (initialized d).regs 30 = d.regs 30 := by
  simp [initialized, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr,
    StructuredProgram.State.ofCfg, execInstr]

def gather : Code := .seq initGather
  (.call (ProgramLinking.liftProgram ExecSelectedFamilyProgram.program smallReg gatherStack))

theorem gather_eval (F : Formula) (words : List (List Bool)) (d : Data)
    (hF : d.stacks 16 = formulaCode F) (ht : d.stacks 23 = tupleCode words)
    (ho : d.stacks 13 = []) (hw : ∀ i : Fin 7, d.stacks (Fin.castAdd 25 i) = []) :
    ∃ n ≤ 128 * ((formulaCode F).length + 1) * ((tupleCode words).length + 1) + 5,
    ∃ e : Data, Eval gather n d e ∧
      e.stacks = Function.update d.stacks 13 (formulaCode (selected F words)) ∧
      e.regs 30 = d.regs 30 := by
  let a := initialized d
  have ha : projectState smallReg gatherStack a =
      ExecSelectedFamilyProgram.baseState (formulaCode F) (tupleCode words) [false] := by
    apply congrArg₂ StructuredProgram.State.mk
    · funext i
      fin_cases i <;> exact initialized_regs d _
    · funext i
      have h0 : d.stacks 0 = [] := hw 0
      have h1 : d.stacks 1 = [] := hw 1
      have h2 : d.stacks 2 = [] := hw 2
      have h3 : d.stacks 3 = [] := hw 3
      have h4 : d.stacks 4 = [] := hw 4
      have h5 : d.stacks 5 = [] := hw 5
      have h6 : d.stacks 6 = [] := hw 6
      fin_cases i <;> simp [ a, initialized_stacks, gatherStack,
        hF, ht, ho, h0, h1, h2, h3, h4, h5, h6]
  obtain ⟨n, hn, htrace⟩ := ExecSelectedFamilyProgram.clause_family_runs F words
  change n ≤ 128 * ((formulaCode F).length + 1) * ((tupleCode words).length + 1) at hn
  let b := ExecSelectedFamilyProgram.baseState (formulaCode F) (tupleCode words)
    (formulaCode (selected F words))
  have hb : Trace ExecSelectedFamilyProgram.program n
      ((projectState smallReg gatherStack a).withPC (some ExecSelectedFamilyProgram.program.entry))
      (b.withPC none) := by
    rw [ha]
    exact htrace
  let e := embedState smallReg gatherStack a b
  have he := eval_call_from_state _ smallReg gatherStack a
    smallReg_injective gatherStack_injective hb
  refine ⟨5 + n, by omega, e, Eval.seq (initialize_eval d) he, ?_, ?_⟩
  · funext i
    classical
    by_cases hi : ∃ j, gatherStack j = i
    · obtain ⟨j, rfl⟩ := hi
      rw [show e.stacks (gatherStack j) = b.stacks j from
        embedState_stack _ _ _ _ gatherStack_injective j]
      have h0 : d.stacks 0 = [] := hw 0
      have h1 : d.stacks 1 = [] := hw 1
      have h2 : d.stacks 2 = [] := hw 2
      have h3 : d.stacks 3 = [] := hw 3
      have h4 : d.stacks 4 = [] := hw 4
      have h5 : d.stacks 5 = [] := hw 5
      have h6 : d.stacks 6 = [] := hw 6
      fin_cases j <;> simp [b, gatherStack, ExecSelectedFamilyProgram.baseState,
        ExecSelectedFamilyProgram.stage, hF, ht, h0, h1, h2, h3, h4, h5, h6]
    · have h13 : i ≠ 13 := by
        intro h
        apply hi
        exact ⟨2, h.symm⟩
      rw [show e.stacks i = a.stacks i from embedState_stack_frame _ _ _ _ i hi]
      simp [a, initialized_stacks, h13]
  · exact (embedState_register_frame _ _ _ _ 30 (by decide)).trans (initialized_flag d)

def coreStack : Fin 6 → Fin 32 := ![13, 22, 8, 0, 1, 2]
theorem coreStack_injective : Function.Injective coreStack := by decide

def chooseCore : Code :=
  .call (ProgramLinking.liftProgram FirstClauseCoreProgram.program smallReg coreStack)

theorem chooseCore_eval (G : Formula) (mask : List Bool) (d : Data)
    (hG : d.stacks 13 = formulaCode G) (hm : d.stacks 22 = mask)
    (h8 : d.stacks 8 = []) (h0 : d.stacks 0 = [])
    (h1 : d.stacks 1 = []) (h2 : d.stacks 2 = []) :
    ∃ n ≤ FirstClauseCoreProgram.bound G, ∃ e : Data,
      Eval chooseCore n d e ∧
      e.stacks = Function.update
        (Function.update d.stacks 22 (mask.drop (G.headD []).length))
        8 (clauseCode (CoreMaskProgram.select mask (G.headD []))) ∧
      e.regs 30 = d.regs 30 := by
  let a := projectState smallReg coreStack d
  obtain ⟨n, hn, htrace⟩ := FirstClauseCoreProgram.program_runsIn_from G mask a
    hG hm h8 h0 h1 h2
  let b := FirstClauseCoreProgram.state (fun _ => false) (formulaCode G)
    (mask.drop (G.headD []).length)
    (clauseCode (CoreMaskProgram.select mask (G.headD []))) [] [] []
  let e := embedState smallReg coreStack d b
  have he := eval_call_from_state _ smallReg coreStack d
    smallReg_injective coreStack_injective htrace
  refine ⟨n, hn, e, he, ?_, ?_⟩
  · funext i
    classical
    by_cases hi : ∃ j, coreStack j = i
    · obtain ⟨j, rfl⟩ := hi
      rw [show e.stacks (coreStack j) = b.stacks j from
        embedState_stack _ _ _ _ coreStack_injective j]
      fin_cases j <;> simp [b, coreStack, FirstClauseCoreProgram.state, hG, h0, h1, h2]
    · have h8' : i ≠ 8 := by intro h; apply hi; exact ⟨2, h.symm⟩
      have h22' : i ≠ 22 := by intro h; apply hi; exact ⟨1, h.symm⟩
      rw [show e.stacks i = d.stacks i from embedState_stack_frame _ _ _ _ i hi]
      simp [h8', h22']
  · exact embedState_register_frame _ _ _ _ 30 (by decide)

def cleanup : Code := .seq (ExecCNFTupleSplit.clear 22) (ExecCNFTupleSplit.clear 23)
def cleaned (d : Data) := ExecCNFTupleSplit.cleared 23 (ExecCNFTupleSplit.cleared 22 d)

theorem cleanup_eval (d : Data) :
    Eval cleanup (2 * (d.stacks 22).length + 2 * (d.stacks 23).length + 6) d (cleaned d) := by
  have h := Eval.seq (ExecCNFTupleSplit.clear_eval 22 d)
    (ExecCNFTupleSplit.clear_eval 23 (ExecCNFTupleSplit.cleared 22 d))
  change Eval cleanup ((2 * (d.stacks 22).length + 3) +
    (2 * (d.stacks 23).length + 3)) d (cleaned d) at h
  convert h using 1 ; omega

theorem cleaned_stacks (d : Data) : (cleaned d).stacks =
    Function.update (Function.update d.stacks 22 []) 23 [] := rfl

theorem cleaned_flag (d : Data) : (cleaned d).regs 30 = d.regs 30 := by
  simp [cleaned, ExecCNFTupleSplit.cleared, readRegs]

def prepareValid : Code := .seq gather chooseCore
def command : Code := .seq ExecCNFTupleSplit.command
  (.seq guard (.seq (.ite 30 prepareValid (.base .skip)) cleanup))
def program := compiled command 17 13

def bound (F : Formula) (mask limit : List Bool) (words : List (List Bool)) : ℕ :=
  ExecCNFTupleSplit.cost mask words + TupleGuardProgram.bound limit words +
  128 * ((formulaCode F).length + 1) * ((tupleCode words).length + 1) +
  FirstClauseCoreProgram.bound (selected F words) +
  2 * mask.length + 2 * (tupleCode words).length + 20

def outputStacks (F : Formula) (mask limit : List Bool) (words : List (List Bool))
    (d : Data) : Fin 32 → List Bool :=
  Function.update (Function.update d.stacks 13
    (if valid limit words then formulaCode (selected F words) else []))
    8 (if valid limit words then clauseCode (core F mask words) else [])

theorem split_eval (mask : List Bool) (words : List (List Bool)) (d : Data)
    (h : ExecCNFTupleSplit.Ready mask words d) :
    ∃ e : Data, Eval ExecCNFTupleSplit.command (ExecCNFTupleSplit.cost mask words) d e ∧
      e.stacks = Function.update (Function.update d.stacks 22 mask) 23 (tupleCode words) := by
  obtain ⟨e, he, hm, ht, h24, hf⟩ := ExecCNFTupleSplit.command_eval mask words d h
  refine ⟨e, he, ?_⟩
  funext i
  by_cases hi22 : i = 22
  · subst i
    simpa using hm
  by_cases hi23 : i = 23
  · subst i
    simpa [tupleCode] using ht
  by_cases hi24 : i = 24
  · subst i
    simpa using h24.trans h.2.2.2.1.symm
  simpa [hi22, hi23] using hf i hi22 hi23 hi24

/-- Complete preparation, including both branches and deletion of parsed
tuple copies. Only the two output stacks differ from the original state. -/
theorem command_eval (F : Formula) (mask limit : List Bool) (words : List (List Bool))
    (d : Data) (h : Ready F mask limit words d) :
    ∃ n, n + 1 ≤ bound F mask limit words ∧ ∃ e : Data,
      Eval command n d e ∧ e.stacks = outputStacks F mask limit words d ∧
      e.regs 30 = valid limit words := by
  rcases h with ⟨hF, ht, hl, hw, h8, h13, h22, h23, h24, h25, h26⟩
  obtain ⟨a, ha, has⟩ := split_eval mask words d ⟨ht, h22, h23, h24, h25, h26⟩
  have haw : ∀ i : Fin 7, a.stacks (Fin.castAdd 25 i) = [] := by
    intro i
    fin_cases i
    · simpa [has] using hw 0
    · simpa [has] using hw 1
    · simpa [has] using hw 2
    · simpa [has] using hw 3
    · simpa [has] using hw 4
    · simpa [has] using hw 5
    · simpa [has] using hw 6
  have hat : a.stacks 23 = tupleCode words := by simp [has]
  have hal : a.stacks 19 = limit := by simp [has, hl]
  obtain ⟨n, hn, b, hb, hbs, hbg⟩ := guard_eval limit words a hat hal haw
  have hbw : ∀ i : Fin 7, b.stacks (Fin.castAdd 25 i) = [] := by
    simpa only [hbs] using haw
  cases hv : valid limit words with
  | false =>
    have hbranch : Eval (.ite 30 prepareValid (.base .skip)) 1 b b :=
      Eval.ite_false (hbg.trans hv) (.base (.skip b))
    have hclean := cleanup_eval b
    have hb22 : b.stacks 22 = mask := by simp [hbs, has]
    have hb23 : b.stacks 23 = tupleCode words := by simp [hbs, has]
    refine ⟨ExecCNFTupleSplit.cost mask words +
      (n + (1 + (2 * (b.stacks 22).length + 2 * (b.stacks 23).length + 6))),
      ?_, cleaned b, Eval.seq ha (Eval.seq hb (Eval.seq hbranch hclean)), ?_, ?_⟩
    · rw [hb22, hb23]
      unfold bound
      omega
    · funext i
      fin_cases i <;> simp [cleaned_stacks, outputStacks, hbs, has, hv,
        h8, h13, h22, h23]
    · exact (cleaned_flag b).trans (hbg.trans hv)
  | true =>
    have hbF : b.stacks 16 = formulaCode F := by simp [hbs, has, hF]
    have hbt : b.stacks 23 = tupleCode words := by simp [hbs, has]
    have hb13 : b.stacks 13 = [] := by simp [hbs, has, h13]
    obtain ⟨g, hg, c, hc, hcs, hcg⟩ := gather_eval F words b hbF hbt hb13 hbw
    have hcG : c.stacks 13 = formulaCode (selected F words) := by simp [hcs]
    have hcm : c.stacks 22 = mask := by simp [hcs, hbs, has]
    have hc8 : c.stacks 8 = [] := by simp [hcs, hbs, has, h8]
    have hc0 : c.stacks 0 = [] := by simpa [hcs] using hbw 0
    have hc1 : c.stacks 1 = [] := by simpa [hcs] using hbw 1
    have hc2 : c.stacks 2 = [] := by simpa [hcs] using hbw 2
    obtain ⟨q, hq, e, he, hes, heg⟩ :=
      chooseCore_eval (selected F words) mask c hcG hcm hc8 hc0 hc1 hc2
    have hbranch : Eval (.ite 30 prepareValid (.base .skip)) (g + q + 1) b e :=
      Eval.ite_true (hbg.trans hv) (Eval.seq hc he)
    have he22 : e.stacks 22 = mask.drop ((selected F words).headD []).length := by
      simp [hes]
    have he23 : e.stacks 23 = tupleCode words := by simp [hes, hcs, hbs, has]
    refine ⟨ExecCNFTupleSplit.cost mask words +
      (n + ((g + q + 1) + (2 * (e.stacks 22).length + 2 * (e.stacks 23).length + 6))),
      ?_, cleaned e, Eval.seq ha (Eval.seq hb (Eval.seq hbranch (cleanup_eval e))), ?_, ?_⟩
    · rw [he22, he23]
      simp only [List.length_drop]
      unfold bound
      omega
    · funext i
      fin_cases i <;> simp [cleaned_stacks, outputStacks, hes, hcs, hbs, has,
        hv, core, h22, h23]
    · exact (cleaned_flag e).trans (heg.trans (hcg.trans (hbg.trans hv)))

theorem program_runsIn (F : Formula) (mask limit : List Bool) (words : List (List Bool))
    (d : Data) (h : Ready F mask limit words d) :
    ∃ e : Data, RunsIn program (bound F mask limit words)
      (d.withPC (some program.entry)) (e.withPC none) ∧
      e.stacks = outputStacks F mask limit words d ∧ e.regs 30 = valid limit words := by
  obtain ⟨n, hn, e, he, hs, hg⟩ := command_eval F mask limit words d h
  exact ⟨e, ⟨n + 1, hn, compiled_halt_trace he 17 13⟩, hs, hg⟩

theorem primitive_execution (F : Formula) (mask limit : List Bool)
    (words : List (List Bool)) (d : Data) (h : Ready F mask limit words d) :
    ∃ e : Data, Computation.RunsIn (primitive program).step
      (primitiveOverhead program * bound F mask limit words)
      (primitiveCfg program (d.withPC (some program.entry)))
      (primitiveCfg program (e.withPC none)) ∧
      e.stacks = outputStacks F mask limit words d ∧ e.regs 30 = valid limit words := by
  obtain ⟨e, he, hs, hg⟩ := program_runsIn F mask limit words d h
  exact ⟨e, BitProgram.primitive_execution program he, hs, hg⟩

theorem valid_iff (limit : List Bool) (words : List (List Bool)) :
    valid limit words = true ↔
      (∀ bits ∈ words, BinaryArithmetic.toNat bits < BinaryArithmetic.toNat limit) ∧
      words.Pairwise (fun x y => BinaryArithmetic.toNat x < BinaryArithmetic.toNat y) :=
  TupleGuardProgram.goodFrom_none_iff limit words

theorem outputStacks_frame (F : Formula) (mask limit : List Bool) (words : List (List Bool))
    (d : Data) (i : Fin 32) (h8 : i ≠ 8) (h13 : i ≠ 13) :
    outputStacks F mask limit words d i = d.stacks i := by
  simp [outputStacks, h8, h13]

end SubexponentialSAT.CandidatePrepareProgram

end OAI.Algorithms