File size: 18,129 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Subexp.BlockSearchNested

namespace OAI.Algorithms

/-! Actual table enumeration around the checked split and coefficient scans. -/

namespace SubexponentialSAT.Subexp.BlockSearchOuter

open BitProgram StructuredCalls BlockSearchProgram BlockSearchLoop BlockSearchNested

abbrev Data := StructuredProgram.State 24 42

def transferState (a : Data) (src dst : Fin 42) : Data :=
  ⟨readRegs a.regs 21 22 none, StackRoutines.transferStacks src dst a.stacks⟩

theorem transfer_eval (a : Data) (src dst : Fin 42) (h : src ≠ dst) :
    Eval (transfer src dst) (3 * (a.stacks src).length + 3) a (transferState a src dst) :=
  TupleProgram.transfer_eval src dst 21 22 h (by decide) a

def finishTable (a : Data) : Data :=
  (StructuredProgram.Atom.set (9 : Fin 24) true).eval
    ((StructuredProgram.Atom.set (8 : Fin 24) false).eval
      ((StructuredProgram.Atom.copy (10 : Fin 24) 13).eval a))

def TableEntry (ctx : Context) (coefficients dimensions : List (List Bool))
    (splitLimit tableLimit : ℕ) (a : Data) : Prop :=
  DimensionEntry ctx (a.stacks 41) coefficients splitLimit a ∧
  a.stacks 12 = ProgramEncoding.encodeRecords dimensions ∧
  a.stacks 3 = [] ∧ a.stacks 4 = [] ∧ (a.stacks 41).length ≤ tableLimit

def tableCost (oldLength splitLimit : ℕ) (cost : List Bool → List Bool → ℕ)
    (coefficients dimensions : List (List Bool)) (table : List Bool) : ℕ :=
  2 * oldLength + 3 * table.length +
    dimensionScanCost splitLimit cost coefficients dimensions + 9

theorem dimensionEntry_of_stacks_eq (ctx : Context) (table : List Bool)
    (coefficients : List (List Bool)) (limit : ℕ) {a b : Data}
    (hs : b.stacks = a.stacks) (h : DimensionEntry ctx table coefficients limit a) :
    DimensionEntry ctx table coefficients limit b := by
  simpa only [DimensionEntry, CoefficientEntry, WorkReady, hs] using h

/-- One concrete table callback installs a table in forward scalar order and
retains the split selected by the actual inner search. -/
theorem tableCallback_eval (matrixPair : Cmd 24 42) (ctx : Context)
    (table : List Bool) (coefficients dimensions : List (List Bool)) (limit tableLimit : ℕ)
    (test : List Bool → List Bool → Bool) (cost : List Bool → List Bool → ℕ)
    (validSplit : List Bool → Prop) (validCoefficient : List Bool → Prop)
    (hreversal : ∀ bits, validSplit bits → bits.reverse = bits)
    (hlimit : ∀ bits, validSplit bits → bits.length ≤ limit)
    (hcoefficients : ∀ bits ∈ coefficients, validCoefficient bits)
    (hdimensions : ∀ bits ∈ dimensions, validSplit bits)
    (contract : ∀ split, validSplit split →
      CoefficientContract matrixPair ctx table split (test split) (cost split) validCoefficient)
    (base : Data) (hb : TableEntry ctx coefficients dimensions limit tableLimit base)
    (h2 : base.stacks 2 = table.reverse) :
    ∃ n next,
      n ≤ tableCost (base.stacks 41).length limit cost coefficients dimensions table ∧
      DimensionEntry ctx table coefficients limit next ∧
      (∀ j : Fin 42, j ≠ 8 → j ≠ 41 → j ≠ 2 → next.stacks j = base.stacks j) ∧
      next.stacks 41 = table ∧ next.stacks 2 = [] ∧
      next.regs 8 = false ∧ next.regs 9 = true ∧
      next.regs 10 = dimensions.any (fun split => coefficients.all (test split)) ∧
      (dimensions.any (fun split => coefficients.all (test split)) = true →
        ∃ split ∈ dimensions, coefficients.all (test split) = true ∧ next.stacks 8 = split) ∧
      Eval (tableCallback matrixPair) n base next := by
  let a1 := clearState base 41
  let a2 := transferState a1 2 41
  have e1 := clear_eval base 41
  have e2 := transfer_eval a1 2 41 (by decide)
  have a2st : a2.stacks = Function.update (Function.update base.stacks 2 []) 41 table := by
    funext j
    by_cases hj2 : j = 2 <;> by_cases hj41 : j = 41 <;> subst_vars <;>
      simp_all [a2, a1, transferState, clearState, StackRoutines.transferStacks,
        StackRoutines.clearStacks]
  have ha2 : DimensionEntry ctx table coefficients limit a2 := by
    rcases hb.1.1 with ⟨hm, hz, hM, hr, hd, ht, hsplit, hw⟩
    refine ⟨⟨?_, ?_, ?_, ?_, ?_, ?_, rfl, ?_⟩, ?_, ?_, ?_, ?_⟩
    · simpa [a2st] using hm
    · simpa [a2st] using hz
    · simpa [a2st] using hM
    · simpa [a2st] using hr
    · simpa [a2st] using hd
    · simp [a2st]
    · refine ⟨?_, ?_⟩
      · simpa [a2st] using hw.1
      · intro j hj h27 h36 h38 h39 h41
        have h2 : j ≠ 2 := by intro h; subst j; change 22 ≤ 2 at hj; omega
        simpa [a2st, h2, h41] using hw.2 j hj h27 h36 h38 h39 h41
    · simpa [a2st] using hb.1.2.1
    · simpa [a2st] using hb.1.2.2.1
    · simpa [a2st] using hb.1.2.2.2.1
    · simpa [a2st] using hb.1.2.2.2.2
  obtain ⟨n, a3, hn, hi, hframe, hreg, hresult, hselected, e3⟩ :=
    dimensionScan_eval matrixPair ctx table coefficients dimensions limit test cost
      validSplit validCoefficient hreversal hlimit hcoefficients hdimensions contract a2 ha2
      (by simpa [a2st] using hb.2.1) (by simpa [a2st] using hb.2.2.1)
      (by simpa [a2st] using hb.2.2.2.1)
  let next := finishTable a3
  have e4 : Eval (sequence [atom (.copy 10 13), atom (.set 8 false), atom (.set 9 true)])
      (1 + (1 + (1 + 0))) a3 next :=
    (Eval.base (.atom _ _)).seq ((Eval.base (.atom _ _)).seq
      ((Eval.base (.atom _ _)).seq (Eval.base (.skip _))))
  have nextst : next.stacks = a3.stacks := rfl
  refine ⟨_, next, ?_, dimensionEntry_of_stacks_eq _ _ _ _ nextst hi,
    ?_, ?_, ?_, ?_, ?_, ?_, ?_, e1.seq (e2.seq (e3.seq e4))⟩
  · have hl : (a1.stacks 2).length = table.length := by
      simp [a1, clearState, StackRoutines.clearStacks, h2]
    change (2 * (base.stacks 41).length + 3) +
      ((3 * (a1.stacks 2).length + 3) + (n + (1 + (1 + (1 + 0))))) ≤ _
    rw [hl]
    unfold tableCost
    omega
  · intro j h8 h41 h2
    rw [nextst, hframe j h8, a2st]
    simp [h41, h2]
  · rw [nextst, hframe 41 (by decide), a2st]
    simp
  · rw [nextst, hframe 2 (by decide), a2st]
    simp
  · simp [next, finishTable, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr,
      StructuredProgram.State.ofCfg, execInstr]
  · simp [next, finishTable, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr,
      StructuredProgram.State.ofCfg, execInstr]
  · simpa [next, finishTable, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr,
      StructuredProgram.State.ofCfg, StructuredProgram.State.withPC, execInstr] using hresult
  · simpa only [nextst] using hselected

theorem tableEntry_state (ctx : Context) (coefficients dimensions : List (List Bool))
    (limit tableLimit : ℕ) (base : Data) (v pr f : Bool) (src payload : List Bool)
    (hb : TableEntry ctx coefficients dimensions limit tableLimit base) :
    TableEntry ctx coefficients dimensions limit tableLimit
      (RecordPrograms.state tablePorts base v pr f src payload) := by
  rcases hb.1.1 with ⟨hm, hz, hM, hr, hd, ht, hsplit, hw⟩
  refine ⟨⟨⟨?_, ?_, ?_, ?_, ?_, rfl, rfl, ?_⟩, ?_, ?_, ?_, ?_⟩, ?_, ?_, ?_, ?_⟩
  · simpa [RecordPrograms.state, tablePorts] using hm
  · simpa [RecordPrograms.state, tablePorts] using hz
  · simpa [RecordPrograms.state, tablePorts] using hM
  · simpa [RecordPrograms.state, tablePorts] using hr
  · simpa [RecordPrograms.state, tablePorts] using hd
  · refine ⟨?_, ?_⟩
    · simpa [RecordPrograms.state, tablePorts] using hw.1
    · intro j hj h27 h36 h38 h39 h41
      have h0 : j ≠ 0 := by intro h; subst j; change 22 ≤ 0 at hj; omega
      have h2 : j ≠ 2 := by intro h; subst j; change 22 ≤ 2 at hj; omega
      simpa [RecordPrograms.state, tablePorts, h0, h2] using hw.2 j hj h27 h36 h38 h39 h41
  · simpa [RecordPrograms.state, tablePorts] using hb.1.2.1
  · simpa [RecordPrograms.state, tablePorts] using hb.1.2.2.1
  · simpa [RecordPrograms.state, tablePorts] using hb.1.2.2.2.1
  · simpa [RecordPrograms.state, tablePorts] using hb.1.2.2.2.2
  · simpa [RecordPrograms.state, tablePorts] using hb.2.1
  · simpa [RecordPrograms.state, tablePorts] using hb.2.2.1
  · simpa [RecordPrograms.state, tablePorts] using hb.2.2.2.1
  · simpa [RecordPrograms.state, tablePorts] using hb.2.2.2.2

def tableTest (coefficients dimensions : List (List Bool))
    (test : List Bool → List Bool → List Bool → Bool) (table : List Bool) : Bool :=
  dimensions.any (fun split => coefficients.all (test table split))

def Selected (coefficients dimensions : List (List Bool))
    (test : List Bool → List Bool → List Bool → Bool) (table : List Bool) (a : Data) : Prop :=
  a.stacks 41 = table ∧
  (tableTest coefficients dimensions test table = true →
    ∃ split ∈ dimensions, coefficients.all (test table split) = true ∧ a.stacks 8 = split)

/-- The only lower-level premise is a measured execution of the concrete
coefficient callback; table/split control is proved here from fixed code. -/
theorem tableContract (matrixPair : Cmd 24 42) (ctx : Context)
    (coefficients dimensions : List (List Bool)) (limit tableLimit : ℕ)
    (test : List Bool → List Bool → List Bool → Bool)
    (cost : List Bool → List Bool → List Bool → ℕ)
    (validTable validSplit validCoefficient : List Bool → Prop)
    (htableLimit : ∀ bits, validTable bits → bits.length ≤ tableLimit)
    (hreversal : ∀ bits, validSplit bits → bits.reverse = bits)
    (hlimit : ∀ bits, validSplit bits → bits.length ≤ limit)
    (hcoefficients : ∀ bits ∈ coefficients, validCoefficient bits)
    (hdimensions : ∀ bits ∈ dimensions, validSplit bits)
    (contract : ∀ table, validTable table → ∀ split, validSplit split →
      CoefficientContract matrixPair ctx table split (test table split) (cost table split)
        validCoefficient) :
    RecordPrograms.CallbackContractWithOn tablePorts (tableCallback matrixPair)
      (tableTest coefficients dimensions test)
      (fun table => tableCost tableLimit limit (cost table) coefficients dimensions table)
      (TableEntry ctx coefficients dimensions limit tableLimit)
      (fun table _ b => Selected coefficients dimensions test table b) validTable := by
  intro table tail base htable hb
  let start := RecordPrograms.state tablePorts base false true false tail table.reverse
  have hstart := tableEntry_state ctx coefficients dimensions limit tableLimit base
    false true false tail table.reverse hb
  obtain ⟨n, out, hn, hi, hframe, h41, h2, h8, h9, h10, hselected, heval⟩ :=
    tableCallback_eval matrixPair ctx table coefficients dimensions limit tableLimit
      (test table) (cost table) validSplit validCoefficient hreversal hlimit hcoefficients
      hdimensions (contract table htable) start hstart
      (by simp [start, RecordPrograms.state, tablePorts])
  have hout : TableEntry ctx coefficients dimensions limit tableLimit out := by
    refine ⟨?_, ?_, ?_, ?_, ?_⟩
    · simpa only [h41] using hi
    · rw [hframe 12 (by decide) (by decide) (by decide)]
      simpa [start, RecordPrograms.state, tablePorts] using hb.2.1
    · rw [hframe 3 (by decide) (by decide) (by decide)]
      simpa [start, RecordPrograms.state, tablePorts] using hb.2.2.1
    · rw [hframe 4 (by decide) (by decide) (by decide)]
      simpa [start, RecordPrograms.state, tablePorts] using hb.2.2.2.1
    · simpa only [h41] using htableLimit table htable
  let next := RecordPrograms.state tablePorts out false true
    (tableTest coefficients dimensions test table) (base.stacks 0) (base.stacks 2)
  have hnext := tableEntry_state ctx coefficients dimensions limit tableLimit out false true
    (tableTest coefficients dimensions test table) (base.stacks 0) (base.stacks 2) hout
  have h0 : out.stacks 0 = tail := by
    rw [hframe 0 (by decide) (by decide) (by decide)]
    simp [start, RecordPrograms.state, tablePorts]
  have hstate : RecordPrograms.state tablePorts next false true
      (tableTest coefficients dimensions test table) tail [] = out := by
    rw [RecordPrograms.state_state]
    exact RecordPrograms.state_eq_self tablePorts out false true
      (tableTest coefficients dimensions test table) tail [] h8 h9 h10 h0 h2
  refine ⟨n, next, ?_, hnext, ⟨?_, ?_⟩, ?_⟩
  · have hold : (start.stacks 41).length ≤ tableLimit := by
      simpa [start, RecordPrograms.state, tablePorts] using hb.2.2.2.2
    change n ≤ tableCost tableLimit limit (cost table) coefficients dimensions table
    unfold tableCost at hn ⊢
    omega
  · simpa [next, RecordPrograms.state, tablePorts] using h41
  · intro success
    obtain ⟨split, hmem, ht, hs⟩ := hselected success
    exact ⟨split, hmem, ht, by simpa [next, RecordPrograms.state, tablePorts] using hs⟩
  · simpa only [hstate] using heval

theorem selected_of_history (coefficients dimensions tables : List (List Bool))
    (test : List Bool → List Bool → List Bool → Bool) {base next : Data}
    (history : RecordPrograms.Visits (tableTest coefficients dimensions test)
      (fun table _ b => Selected coefficients dimensions test table b) tables base next)
    (success : tables.any (tableTest coefficients dimensions test) = true) :
    ∃ table ∈ tables, ∃ split ∈ dimensions,
      coefficients.all (test table split) = true ∧
      next.stacks 41 = table ∧ next.stacks 8 = split := by
  induction history with
  | nil => simp at success
  | @hit table rest base next ht he =>
      obtain ⟨split, hmem, htest, hsplit⟩ := he.2 ht
      exact ⟨table, by simp, split, hmem, htest, he.1, hsplit⟩
  | @miss table rest base middle next ht he history ih =>
      have hr : rest.any (tableTest coefficients dimensions test) = true := by
        simpa [ht] using success
      obtain ⟨table', hmem, split, hsplit, htest, htable', hsplit'⟩ := ih hr
      exact ⟨table', by simp [hmem], split, hsplit, htest, htable', hsplit'⟩

def searchCost (limit tableLimit : ℕ)
    (cost : List Bool → List Bool → List Bool → ℕ)
    (coefficients dimensions tables : List (List Bool)) : ℕ :=
  RecordPrograms.budget (fun table =>
    tableCost tableLimit limit (cost table) coefficients dimensions table) tables +
    2 * (ProgramEncoding.encodeRecords tables).length + 6

theorem command_eval (matrixPair : Cmd 24 42) (ctx : Context)
    (coefficients dimensions tables : List (List Bool)) (limit tableLimit : ℕ)
    (test : List Bool → List Bool → List Bool → Bool)
    (cost : List Bool → List Bool → List Bool → ℕ)
    (validTable validSplit validCoefficient : List Bool → Prop)
    (htableLimit : ∀ bits, validTable bits → bits.length ≤ tableLimit)
    (hreversal : ∀ bits, validSplit bits → bits.reverse = bits)
    (hlimit : ∀ bits, validSplit bits → bits.length ≤ limit)
    (hcoefficients : ∀ bits ∈ coefficients, validCoefficient bits)
    (hdimensions : ∀ bits ∈ dimensions, validSplit bits)
    (htables : ∀ bits ∈ tables, validTable bits)
    (contract : ∀ table, validTable table → ∀ split, validSplit split →
      CoefficientContract matrixPair ctx table split (test table split) (cost table split)
        validCoefficient)
    (success : tables.any (tableTest coefficients dimensions test) = true)
    (base : Data) (hb : TableEntry ctx coefficients dimensions limit tableLimit base)
    (h0 : base.stacks 0 = ProgramEncoding.encodeRecords tables) (h2 : base.stacks 2 = []) :
    ∃ n next, n ≤ searchCost limit tableLimit cost coefficients dimensions tables ∧
      (∃ table ∈ tables, ∃ split ∈ dimensions, coefficients.all (test table split) = true ∧
        next.stacks 41 = table ∧ next.stacks 8 = split) ∧
      next.stacks 0 = [] ∧ next.regs 10 = true ∧
      Eval (command matrixPair) n base next := by
  have hc := tableContract matrixPair ctx coefficients dimensions limit tableLimit test cost
    validTable validSplit validCoefficient htableLimit hreversal hlimit hcoefficients
    hdimensions contract
  obtain ⟨n, b, hn, hi, history, heval⟩ := RecordPrograms.iterate_run_with_on tablePorts
    (tableCallback matrixPair) (tableTest coefficients dimensions test)
    (fun table => tableCost tableLimit limit (cost table) coefficients dimensions table)
    (TableEntry ctx coefficients dimensions limit tableLimit)
    (fun table _ b => Selected coefficients dimensions test table b) validTable hc tables []
    base htables hb (base.regs 8) (base.regs 9) (base.regs 10)
  have hstart : RecordPrograms.state tablePorts base (base.regs 8) (base.regs 9)
      (base.regs 10) (ProgramEncoding.encodeRecords tables ++ []) [] = base := by
    apply RecordPrograms.state_eq_self <;> simp [tablePorts, h0, h2]
  let middle := RecordPrograms.state tablePorts b false true true
    (RecordPrograms.unread (tableTest coefficients dimensions test) tables []) []
  let next := clearState middle 0
  have eclear := clear_eval middle 0
  have hrun : Eval (anyCommand tablePorts (tableCallback matrixPair)) n base middle := by
    rw [← hstart]
    simpa only [middle, success] using heval
  have hm0 : middle.stacks 0 =
      RecordPrograms.unread (tableTest coefficients dimensions test) tables [] :=
    RecordPrograms.state_source tablePorts b false true true _ []
  refine ⟨_, next, ?_, ?_, ?_, ?_, hrun.seq eclear⟩
  · have hlen := unread_length_le (tableTest coefficients dimensions test) tables
    change n + (2 * (middle.stacks 0).length + 3) ≤ _
    rw [hm0]
    unfold searchCost
    omega
  · obtain ⟨table, ht, split, hs, htest, htout, hsout⟩ :=
      selected_of_history coefficients dimensions tables test history success
    refine ⟨table, ht, split, hs, htest, ?_, ?_⟩
    · simpa [next, middle, clearState, StackRoutines.clearStacks, RecordPrograms.state,
        tablePorts] using htout
    · simpa [next, middle, clearState, StackRoutines.clearStacks, RecordPrograms.state,
        tablePorts] using hsout
  · simp [next, clearState, StackRoutines.clearStacks]
  · simp [next, clearState, readRegs, middle, RecordPrograms.state, tablePorts]

end SubexponentialSAT.Subexp.BlockSearchOuter

end OAI.Algorithms