File size: 11,183 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Subexp.DimensionProgram

namespace OAI.Algorithms

/-! Fixed preparation of candidate tables, split dimensions, and coefficient
tuples for the universal block search. All three dimensions are runtime data. -/

namespace SubexponentialSAT.Subexp.BlockSearchPreparation

open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls

abbrev Records := List (List Bool)

def restrictState {r s R S : ℕ} (ρ : Fin r → Fin R) (σ : Fin s → Fin S)
    (a : State R S) : State r s := ⟨a.regs ∘ ρ, a.stacks ∘ σ⟩

theorem embed_restrict_eq {r s R S : ℕ} (ρ : Fin r → Fin R) (σ : Fin s → Fin S)
    (a : State R S) (hρ : Function.Injective ρ) (hσ : Function.Injective σ) :
    embedState ρ σ a (restrictState ρ σ a) = a := by
  apply congrArg₂ StructuredProgram.State.mk
  · funext i
    by_cases h : ∃ j, ρ j = i
    · obtain ⟨j,rfl⟩ := h
      exact embedState_register ρ σ a (restrictState ρ σ a) hρ j
    · exact embedState_register_frame ρ σ a (restrictState ρ σ a) i h
  · funext i
    by_cases h : ∃ j, σ j = i
    · obtain ⟨j,rfl⟩ := h
      exact embedState_stack ρ σ a (restrictState ρ σ a) hσ j
    · exact embedState_stack_frame ρ σ a (restrictState ρ σ a) i h

theorem lifted_call {r s R S l : ℕ} (p : Program r s l)
    (ρ : Fin r → Fin R) (σ : Fin s → Fin S) (hρ : Function.Injective ρ)
    (hσ : Function.Injective σ) (a : State R S) (b : State r s) (bound : ℕ)
    (h : RunsIn p bound ((restrictState ρ σ a).withPC (some p.entry)) (b.withPC none)) :
    ∃ n, n ≤ bound ∧ Eval (.call (ProgramLinking.liftProgram p ρ σ)) n
      a (embedState ρ σ a b) := by
  obtain ⟨n,hn,ht⟩ := h
  refine ⟨n,hn,?_⟩
  have he := eval_call_lifted p ρ σ a hρ hσ ht
  simpa only [embed_restrict_eq ρ σ a hρ hσ] using he

def tupleRegisters (i : Fin 10) : Fin 15 := ⟨i.val, by omega⟩
def tableStacks (i : Fin 9) : Fin 22 := ⟨i.val, by omega⟩
def dimensionRegisters (i : Fin 5) : Fin 15 := ⟨i.val + 10, by omega⟩
def dimensionStacks (i : Fin 5) : Fin 22 := ⟨i.val + 9, by omega⟩
def coefficientStacks : Fin 9 → Fin 22 := ![14,1,15,16,17,18,19,20,21]

theorem tupleRegisters_injective : Function.Injective tupleRegisters := by
  intro i j h
  apply Fin.ext
  exact congrArg (fun x : Fin 15 => x.val) h
theorem tableStacks_injective : Function.Injective tableStacks := by
  intro i j h
  apply Fin.ext
  exact congrArg (fun x : Fin 22 => x.val) h
theorem dimensionRegisters_injective : Function.Injective dimensionRegisters := by
  intro i j h
  apply Fin.ext
  have hv := congrArg Fin.val h
  simp only [dimensionRegisters] at hv
  omega
theorem dimensionStacks_injective : Function.Injective dimensionStacks := by
  intro i j h
  apply Fin.ext
  have hv := congrArg Fin.val h
  simp only [dimensionStacks] at hv
  omega
theorem coefficientStacks_injective : Function.Injective coefficientStacks := by
  intro i j h
  fin_cases i <;> fin_cases j <;> simp_all [coefficientStacks]

theorem table_frame (a : State 15 22) (b : State 10 9) (i : Fin 22) (hi : 9 ≤ i.val) :
    (embedState tupleRegisters tableStacks a b).stacks i = a.stacks i := by
  apply embedState_stack_frame
  rintro ⟨j,hj⟩
  have h := congrArg Fin.val hj
  simp only [tableStacks] at h
  omega

theorem dimension_frame (a : State 15 22) (b : State 5 5) (i : Fin 22)
    (hi : i.val < 9 ∨ 14 ≤ i.val) :
    (embedState dimensionRegisters dimensionStacks a b).stacks i = a.stacks i := by
  apply embedState_stack_frame
  rintro ⟨j,hj⟩
  have h := congrArg Fin.val hj
  simp only [dimensionStacks] at h
  omega

theorem coefficient_frame (a : State 15 22) (b : State 10 9) (i : Fin 22)
    (hi : i.val < 14) (hi1 : i ≠ 1) :
    (embedState tupleRegisters coefficientStacks a b).stacks i = a.stacks i := by
  apply embedState_stack_frame
  rintro ⟨j,hj⟩
  fin_cases j <;> simp [coefficientStacks] at hj
  all_goals subst i
  all_goals omega

/-- Runtime inputs occupy alphabet 1, table depth 8, and two explicit copies
of the unary vector dimension on 9 and 21. -/
def inputState (alphabet : Records) (tableDepth vectorDepth : List Bool)
    (regs : Fin 15 → Bool) : State 15 22 :=
  ⟨regs, fun i => if i = 1 then ProgramEncoding.encodeRecords alphabet
    else if i = 8 then tableDepth
    else if i = 9 ∨ i = 21 then vectorDepth else []⟩

abbrev prepareCmd : Cmd 15 22 :=
  .seq (.call (ProgramLinking.liftProgram TupleProgram.generateProgram
      tupleRegisters tableStacks))
    (.seq (.call (ProgramLinking.liftProgram DimensionProgram.program
      dimensionRegisters dimensionStacks))
      (.call (ProgramLinking.liftProgram TupleProgram.generateProgram
        tupleRegisters coefficientStacks)))

def program := StructuredCalls.compiled prepareCmd 1 0

theorem control_size : StructuredCalls.size prepareCmd + 1 = 211 := rfl

def cost (alphabet : Records) (tableDepth vectorDepth : List Bool) : ℕ :=
  TupleProgram.powerCost alphabet tableDepth.length [[]] +
    TupleProgram.powerCost alphabet vectorDepth.length [[]] +
    6 * vectorDepth.length ^ 2 + 22 * vectorDepth.length + 36

def Prepared (alphabet : Records) (tableDepth vectorDepth : List Bool) (a : State 15 22) : Prop :=
  a.stacks 0 = ProgramEncoding.encodeRecords (TupleProgram.powerRows alphabet tableDepth.length [[]]) ∧
  a.stacks 1 = ProgramEncoding.encodeRecords alphabet ∧
  a.stacks 12 = ProgramEncoding.encodeRecords (DimensionProgram.dimensionRows 0 vectorDepth.length) ∧
  a.stacks 14 = ProgramEncoding.encodeRecords (TupleProgram.powerRows alphabet vectorDepth.length [[]]) ∧
  a.stacks 10 = List.replicate vectorDepth.length true

theorem program_runsIn (alphabet : Records) (tableDepth vectorDepth : List Bool)
    (regs : Fin 15 → Bool) :
    ∃ next, Prepared alphabet tableDepth vectorDepth next ∧
      RunsIn program (cost alphabet tableDepth vectorDepth)
        ((inputState alphabet tableDepth vectorDepth regs).withPC (some program.entry))
        (next.withPC none) := by
  let a := inputState alphabet tableDepth vectorDepth regs
  let ta := restrictState tupleRegisters tableStacks a
  obtain ⟨tb,htb,htt⟩ := TupleProgram.generateProgram_runsIn alphabet tableDepth (ta.regs 9) ta
    (by norm_num [TupleProgram.outerInvariant,ta,a,restrictState,inputState,tableStacks,
      Fin.ext_iff,Fin.coe_ofNat_eq_mod])
    (by norm_num [ta,a,restrictState,inputState,tableStacks,Fin.ext_iff,Fin.coe_ofNat_eq_mod])
    (by norm_num [ta,a,restrictState,inputState,tableStacks,Fin.ext_iff,Fin.coe_ofNat_eq_mod])
    (by norm_num [ta,a,restrictState,inputState,tableStacks,Fin.ext_iff,Fin.coe_ofNat_eq_mod])
  let b := embedState tupleRegisters tableStacks a tb
  obtain ⟨nt,hnt,het⟩ := lifted_call TupleProgram.generateProgram tupleRegisters tableStacks
    tupleRegisters_injective tableStacks_injective a tb _ htt
  let da := restrictState dimensionRegisters dimensionStacks b
  have hds (i : Fin 5) : da.stacks i = if i = 0 then vectorDepth else [] := by
    change (embedState tupleRegisters tableStacks a tb).stacks (dimensionStacks i) = _
    rw [table_frame _ _ _ (by simp [dimensionStacks])]
    fin_cases i <;> simp [a,inputState,dimensionStacks]
  obtain ⟨db,hdb,hdt⟩ := DimensionProgram.program_runsIn_quadratic vectorDepth da
    (by simpa using hds 0) (by simpa using hds 1) (by simpa using hds 2)
    (by simpa using hds 3) (by simpa using hds 4)
  let c := embedState dimensionRegisters dimensionStacks b db
  obtain ⟨nd,hnd,hed⟩ := lifted_call DimensionProgram.program dimensionRegisters dimensionStacks
    dimensionRegisters_injective dimensionStacks_injective b db _ hdt
  let ca := restrictState tupleRegisters coefficientStacks c
  have hcs (i : Fin 9) : ca.stacks i =
      if i = 1 then ProgramEncoding.encodeRecords alphabet else if i = 8 then vectorDepth else [] := by
    change (embedState dimensionRegisters dimensionStacks b db).stacks (coefficientStacks i) = _
    rw [dimension_frame _ _ _ (by fin_cases i <;> decide)]
    fin_cases i
    · change b.stacks 14 = []
      rw [table_frame _ _ _ (by decide)]
      simp [a,inputState]
    · change (embedState tupleRegisters tableStacks a tb).stacks (tableStacks 1) = _
      rw [embedState_stack _ _ _ _ tableStacks_injective]
      simpa using htb.1.1
    all_goals
      norm_num [coefficientStacks]
      rw [table_frame _ _ _ (by decide)]
      simp [a,inputState]
  obtain ⟨cb,hcb,hct⟩ := TupleProgram.generateProgram_runsIn alphabet vectorDepth (ca.regs 9) ca
    (by simp [TupleProgram.outerInvariant,hcs]) (by simpa using hcs 0)
    (by simpa using hcs 2) (by simpa using hcs 5)
  let d := embedState tupleRegisters coefficientStacks c cb
  obtain ⟨nc,hnc,hec⟩ := lifted_call TupleProgram.generateProgram tupleRegisters coefficientStacks
    tupleRegisters_injective coefficientStacks_injective c cb _ hct
  refine ⟨d,?_,nt+(nd+nc)+1,?_,StructuredCalls.compiled_halt_trace (het.seq (hed.seq hec)) 1 0⟩
  · refine ⟨?_,?_,?_,?_,?_⟩
    · change (embedState tupleRegisters coefficientStacks c cb).stacks 0 = _
      rw [coefficient_frame _ _ _ (by decide) (by decide),
        dimension_frame _ _ _ (by decide)]
      change (embedState tupleRegisters tableStacks a tb).stacks (tableStacks 0) = _
      rw [embedState_stack _ _ _ _ tableStacks_injective]
      exact htb.2.1
    · change (embedState tupleRegisters coefficientStacks c cb).stacks (coefficientStacks 1) = _
      rw [embedState_stack _ _ _ _ coefficientStacks_injective]
      exact hcb.1.1
    · change (embedState tupleRegisters coefficientStacks c cb).stacks 12 = _
      rw [coefficient_frame _ _ _ (by decide) (by decide)]
      change (embedState dimensionRegisters dimensionStacks b db).stacks (dimensionStacks 3) = _
      rw [embedState_stack _ _ _ _ dimensionStacks_injective]
      exact hdb.2.2.2.1
    · change (embedState tupleRegisters coefficientStacks c cb).stacks (coefficientStacks 0) = _
      rw [embedState_stack _ _ _ _ coefficientStacks_injective]
      exact hcb.2.1
    · change (embedState tupleRegisters coefficientStacks c cb).stacks 10 = _
      rw [coefficient_frame _ _ _ (by decide) (by decide)]
      change (embedState dimensionRegisters dimensionStacks b db).stacks (dimensionStacks 1) = _
      rw [embedState_stack _ _ _ _ dimensionStacks_injective]
      exact hdb.2.1
  · dsimp [cost]
    omega

theorem program_primitive_runsIn (alphabet : Records) (tableDepth vectorDepth : List Bool)
    (regs : Fin 15 → Bool) :
    ∃ next, Prepared alphabet tableDepth vectorDepth next ∧
      Computation.RunsIn (BitProgram.primitive program).step
        (BitProgram.primitiveOverhead program * cost alphabet tableDepth vectorDepth)
        (BitProgram.primitiveCfg program
          ((inputState alphabet tableDepth vectorDepth regs).withPC (some program.entry)))
        (BitProgram.primitiveCfg program (next.withPC none)) := by
  obtain ⟨next,hp,hr⟩ := program_runsIn alphabet tableDepth vectorDepth regs
  exact ⟨next,hp,BitProgram.primitive_execution program hr⟩

end SubexponentialSAT.Subexp.BlockSearchPreparation

end OAI.Algorithms