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
|