File size: 6,807 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Subexp.BlockSearchExecution

namespace OAI.Algorithms

/-! Persistent arithmetic data retained by the actual basis-search program. -/

namespace SubexponentialSAT.Subexp.BlockSearchOutputContext

open BitProgram StructuredCalls BlockSearchProgram BlockSearchLoop BlockSearchNested
open BlockSearchOuter BlockSearchEncoding BlockSearchPredicate SubexpTupleRefinement

def Retained (ctx : Context) (a : StructuredProgram.State 24 42) : Prop :=
  a.stacks 27 = ctx.modulus ∧ a.stacks 36 = ctx.zeroWord ∧
  a.stacks 38 = ctx.matrix ∧ a.stacks 39 = ctx.rowCount ∧ a.stacks 10 = ctx.dimension

theorem command_retains (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)
    (base : StructuredProgram.State 24 42)
    (hb : TableEntry ctx coefficients dimensions limit tableLimit base)
    (h0 : base.stacks 0 = ProgramEncoding.encodeRecords tables) (h2 : base.stacks 2 = []) :
    ∃ n next, Retained ctx next ∧ Eval (BlockSearchLoop.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)
  let middle := RecordPrograms.state tablePorts b false true
    (tables.any (tableTest coefficients dimensions test))
    (RecordPrograms.unread (tableTest coefficients dimensions test) tables []) []
  let next := clearState middle 0
  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]
  have hrun : Eval (anyCommand tablePorts (tableCallback matrixPair)) n base middle := by
    rw [← hstart]
    simpa only [middle] using heval
  have ht := hrun.seq (clear_eval middle 0)
  refine ⟨_, next, ?_, ht⟩
  rcases hi.1.1 with ⟨hm, hz, hM, hr, hd, _⟩
  change Retained ctx (clearState middle 0)
  simpa [Retained, next, middle, clearState, StackRoutines.clearStacks,
    RecordPrograms.state, tablePorts] using And.intro hm (And.intro hz (And.intro hM ⟨hr, hd⟩))

/-- A companion to `BlockSearchExecution.program_runsIn`: it identifies
the retained context of any actual completed run, without changing its
instruction bound or the successful-candidate API. -/
theorem program_retains {K : Type*} [Field K] [DecidableEq K]
    (matrixPair : Cmd 24 42) (ctx : Context)
    (code : StackEncoding.BlockCode K) (alphabet : List K)
    {m N : ℕ} (M : Fin m → Fin N → K) (bound : ℕ)
    (hdimension : ctx.dimension = List.replicate N true)
    (contract : ∀ (C : Fin N → Fin N → K) (d : Fin (N + 1)),
      CoefficientContract matrixPair ctx (encodeTuple code (flattenTable C)) (splitCode d)
        (encodedTest code alphabet M (encodeTuple code (flattenTable C)) (splitCode d))
        (fun _ => bound) (BlockSearchCoverage.ValidCoefficient code N))
    (regs : Fin 24 → Bool) {budget : ℕ} {result : StructuredProgram.State 24 42}
    (run : RunsIn (BlockSearchExecution.program matrixPair) budget
      ((BlockSearchExecution.inputState ctx code alphabet N regs).withPC
        (some (BlockSearchExecution.program matrixPair).entry)) (result.withPC none)) :
    Retained ctx result := by
  obtain ⟨np, prepared, hnp, hp, h0, h2, hep⟩ := BlockSearchSetup.command_eval ctx
    (alphabet.map code.block) (List.replicate (N * N) true) (List.replicate N true)
    regs (N * N * code.width) (by simpa using hdimension)
  simp only [List.length_replicate] at hp h0
  have hc : ∀ table, BlockSearchCoverage.ValidTable code N table →
      ∀ split, BlockSearchCoverage.ValidSplit N split →
      CoefficientContract matrixPair ctx table split (encodedTest code alphabet M table split)
        (fun _ => bound) (BlockSearchCoverage.ValidCoefficient code N) := by
    rintro table ⟨C, rfl⟩ split ⟨d, rfl⟩
    exact contract C d
  obtain ⟨ns, next, hnext, he⟩ := command_retains matrixPair ctx
    (BlockSearchCoverage.coefficients code alphabet N) (BlockSearchCoverage.dimensions N)
    (BlockSearchCoverage.tables code alphabet N) N (N * N * code.width)
    (encodedTest code alphabet M) (fun _ _ _ => bound)
    (BlockSearchCoverage.ValidTable code N) (BlockSearchCoverage.ValidSplit N)
    (BlockSearchCoverage.ValidCoefficient code N)
    (fun bits h => (BlockSearchCoverage.valid_table_length code N bits h).le)
    (BlockSearchCoverage.valid_split_reverse N) (BlockSearchCoverage.valid_split_length N)
    (BlockSearchCoverage.valid_coefficient code alphabet N) (BlockSearchCoverage.valid_split N)
    (BlockSearchCoverage.valid_table code alphabet N) hc prepared hp h0 h2
  have full := compiled_halt_trace
    (hep.seq (Eval.call (BlockSearchLoop.program matrixPair)
      (compiled_halt_trace he 0 41))) 0 41
  have run' : RunsIn (BlockSearchExecution.program matrixPair) (np + (ns + 1) + 1)
      ((BlockSearchExecution.inputState ctx code alphabet N regs).withPC
        (some (BlockSearchExecution.program matrixPair).entry)) (next.withPC none) :=
    ⟨_, le_rfl, full⟩
  have hsame := Computation.RunsIn.terminal_unique run run' rfl rfl
  have hd : result = next := by
    simpa only [StructuredProgram.State.ofCfg_withPC] using
      congrArg StructuredProgram.State.ofCfg hsame
  rw [hd]
  exact hnext

end SubexponentialSAT.Subexp.BlockSearchOutputContext

end OAI.Algorithms