File size: 12,114 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Subexp.ScoreBuilderPorts
import OAI.Algorithms.SubexponentialSAT.Subexp.BlockCopyProgram
import OAI.Algorithms.SubexponentialSAT.ProgramFrames

namespace OAI.Algorithms

/-!
# Physical initialization of the sequential assignment memory

The input contains the already generated alphabet and incidence records.
This fixed routine duplicates the runtime tables, creates the initial packed
assignment by actual repeated copying, and clears all temporary ports. The
production of the input records is a separate frontend stage.
-/

namespace SubexponentialSAT.Subexp.AssignmentInitProgram

open BitProgram StructuredCalls StackRoutines

abbrev Data := State 16 48

structure Context where
  defaultWord : List Bool
  packedAlphabet : List Bool
  alphabetRecords : List Bool
  width : List Bool
  depth : List Bool
  rawPairs : List Bool
  seedRecords : List Bool
  seedCount : ℕ

def unary (n : ℕ) : List Bool := List.replicate n true

def state (ctx : Context) (regs : Fin 16 → Bool)
    (word assignment remaining counter duplicate : List Bool) : Data :=
  ⟨regs, fun j =>
    if j = 0 then word
    else if j = 2 then counter
    else if j = 8 then assignment
    else if j = 9 then ctx.packedAlphabet
    else if j = 10 then ctx.width
    else if j = 11 then remaining
    else if j = 30 then ctx.alphabetRecords
    else if j = 34 then ctx.depth
    else if j = 39 then duplicate
    else if j = 45 then ctx.rawPairs
    else if j = 46 then ctx.seedRecords
    else if j = 47 then unary ctx.seedCount else []⟩

def inputState (ctx : Context) (regs : Fin 16 → Bool) : Data :=
  state ctx regs ctx.defaultWord [] [] [] []

def outputState (ctx : Context) : Data :=
  state ctx (fun _ => false) []
    (BlockCopyProgram.copies ctx.seedCount ctx.defaultWord)
    (unary ctx.seedCount) [] ctx.alphabetRecords

def copyRegisters : Fin 3 → Fin 16 := Fin.castAdd 13
def copyPorts : Fin 4 → Fin 48 := ![0, 8, 1, 2]

theorem copyRegisters_injective : Function.Injective copyRegisters := by
  intro i j h
  exact Fin.ext (congrArg (fun z : Fin 16 => z.val) h)

theorem copyPorts_injective : Function.Injective copyPorts := by decide

abbrev reset : Cmd 16 48 := SequentialProgram.resetList (List.finRange 16)
abbrev copyRemaining : Cmd 16 48 := .call (copyProgram 47 11 1 (0 : Fin 16) 1)
abbrev copyCounter : Cmd 16 48 := .call (copyProgram 47 2 1 (0 : Fin 16) 1)
abbrev repeatDefault : Cmd 16 48 :=
  .call (ProgramLinking.liftProgram BlockCopyProgram.program copyRegisters copyPorts)
abbrev copyAlphabet : Cmd 16 48 := .call (copyProgram 30 39 1 (0 : Fin 16) 1)
abbrev clearDefault : Cmd 16 48 := .call (clearProgram 0 (0 : Fin 16) 1)

abbrev command : Cmd 16 48 :=
  .seq reset (.seq copyRemaining (.seq copyCounter
    (.seq repeatDefault (.seq copyAlphabet clearDefault))))

abbrev program : Program 16 48 (size command + 1) := compiled command 0 8

theorem reset_eval (d : Data) :
    Eval reset 16 d ⟨fun _ => false, d.stacks⟩ := by
  have h := SequentialProgram.resetList_eval (List.finRange 16) d
  simpa [reset, SequentialProgram.resetState] using h

theorem copyRemaining_eval (ctx : Context) :
    Eval copyRemaining (7 * ctx.seedCount + 5)
      (state ctx (fun _ => false) ctx.defaultWord [] [] [] [])
      (state ctx (fun _ => false) ctx.defaultWord [] (unary ctx.seedCount) [] []) := by
  have h := TupleProgram.copy_eval (47 : Fin 48) 11 1 (0 : Fin 16) 1
    (by decide) (by decide) (by decide) (by decide)
    (state ctx (fun _ => false) ctx.defaultWord [] [] [] []) (by simp [state])
  convert h using 1
  · simp [state, unary]
  · apply congrArg₂ StructuredProgram.State.mk
    · funext j; fin_cases j <;> simp [state, readRegs]
    · funext j; fin_cases j <;> simp [state, copyStacks]

theorem copyCounter_eval (ctx : Context) :
    Eval copyCounter (7 * ctx.seedCount + 5)
      (state ctx (fun _ => false) ctx.defaultWord [] (unary ctx.seedCount) [] [])
      (state ctx (fun _ => false) ctx.defaultWord [] (unary ctx.seedCount)
        (unary ctx.seedCount) []) := by
  have h := TupleProgram.copy_eval (47 : Fin 48) 2 1 (0 : Fin 16) 1
    (by decide) (by decide) (by decide) (by decide)
    (state ctx (fun _ => false) ctx.defaultWord [] (unary ctx.seedCount) [] [])
    (by simp [state])
  convert h using 1
  · simp [state, unary]
  · apply congrArg₂ StructuredProgram.State.mk
    · funext j; fin_cases j <;> simp [state, readRegs]
    · funext j; fin_cases j <;> simp [state, copyStacks]

theorem repeatDefault_eval (ctx : Context) :
    Eval repeatDefault (ctx.seedCount * (7 * ctx.defaultWord.length + 7) + 3)
      (state ctx (fun _ => false) ctx.defaultWord [] (unary ctx.seedCount)
        (unary ctx.seedCount) [])
      (state ctx (fun _ => false) ctx.defaultWord
        (BlockCopyProgram.copies ctx.seedCount ctx.defaultWord)
        (unary ctx.seedCount) [] []) := by
  let before := state ctx (fun _ => false) ctx.defaultWord []
    (unary ctx.seedCount) (unary ctx.seedCount) []
  let after := state ctx (fun _ => false) ctx.defaultWord
    (BlockCopyProgram.copies ctx.seedCount ctx.defaultWord) (unary ctx.seedCount) [] []
  have hin : embedState copyRegisters copyPorts before
      (BlockCopyProgram.initialState ctx.seedCount ctx.defaultWord []) = before := by
    apply embedState_eq_of_ports _ _ _ _ _ copyRegisters_injective copyPorts_injective
    · intro i; fin_cases i <;> simp [before, state, copyRegisters,
        BlockCopyProgram.initialState, BlockCopyProgram.data]
    · intros; rfl
    · intro i; fin_cases i <;> simp [before, state, copyPorts, unary,
        BlockCopyProgram.initialState, BlockCopyProgram.data]
    · intros; rfl
  have hout : embedState copyRegisters copyPorts before
      (BlockCopyProgram.data false false ctx.defaultWord
        (BlockCopyProgram.copies ctx.seedCount ctx.defaultWord ++ []) []) = after := by
    apply embedState_eq_of_ports _ _ _ _ _ copyRegisters_injective copyPorts_injective
    · intro i; fin_cases i <;> simp [after, state, copyRegisters, BlockCopyProgram.data]
    · intros; rfl
    · intro i; fin_cases i <;> simp [after, state, copyPorts, BlockCopyProgram.data]
    · intro j hj
      have h2 : j ≠ 2 := fun h => hj ⟨3, by simpa [copyPorts] using h.symm⟩
      have h8 : j ≠ 8 := fun h => hj ⟨1, by simpa [copyPorts] using h.symm⟩
      simp [before, after, state, h2, h8]
  have h := eval_call_lifted BlockCopyProgram.program copyRegisters copyPorts before
    copyRegisters_injective copyPorts_injective
    (BlockCopyProgram.program_trace ctx.seedCount ctx.defaultWord [])
  simpa only [hin, hout, repeatDefault, before, after] using h

theorem copyAlphabet_eval (ctx : Context) :
    Eval copyAlphabet (7 * ctx.alphabetRecords.length + 5)
      (state ctx (fun _ => false) ctx.defaultWord
        (BlockCopyProgram.copies ctx.seedCount ctx.defaultWord) (unary ctx.seedCount) [] [])
      (state ctx (fun _ => false) ctx.defaultWord
        (BlockCopyProgram.copies ctx.seedCount ctx.defaultWord) (unary ctx.seedCount) []
        ctx.alphabetRecords) := by
  have h := TupleProgram.copy_eval (30 : Fin 48) 39 1 (0 : Fin 16) 1
    (by decide) (by decide) (by decide) (by decide)
    (state ctx (fun _ => false) ctx.defaultWord
      (BlockCopyProgram.copies ctx.seedCount ctx.defaultWord) (unary ctx.seedCount) [] [])
    (by simp [state])
  convert h using 1
  · simp [state]
  · apply congrArg₂ StructuredProgram.State.mk
    · funext j; fin_cases j <;> simp [state, readRegs]
    · funext j; fin_cases j <;> simp [state, copyStacks]

theorem clearDefault_eval (ctx : Context) :
    Eval clearDefault (2 * ctx.defaultWord.length + 3)
      (state ctx (fun _ => false) ctx.defaultWord
        (BlockCopyProgram.copies ctx.seedCount ctx.defaultWord) (unary ctx.seedCount) []
        ctx.alphabetRecords)
      (outputState ctx) := by
  have h := TupleProgram.clear_eval (0 : Fin 48) (0 : Fin 16) 1
    (state ctx (fun _ => false) ctx.defaultWord
      (BlockCopyProgram.copies ctx.seedCount ctx.defaultWord) (unary ctx.seedCount) []
      ctx.alphabetRecords)
  convert h using 1
  · simp [state]
  · apply congrArg₂ StructuredProgram.State.mk
    · funext j; fin_cases j <;> simp [state, readRegs]
    · funext j; fin_cases j <;> simp [state, clearStacks]

def sourceCost (ctx : Context) : ℕ :=
  ctx.seedCount * (7 * ctx.defaultWord.length + 21) +
    7 * ctx.alphabetRecords.length + 2 * ctx.defaultWord.length + 38

theorem sourceCost_le (ctx : Context) (B : ℕ)
    (hcount : ctx.seedCount ≤ B) (hword : ctx.defaultWord.length ≤ B)
    (halphabet : ctx.alphabetRecords.length ≤ B) :
    sourceCost ctx ≤ 40 * (B + 1) ^ 2 := by
  calc
    sourceCost ctx ≤ B * (7 * B + 21) + 7 * B + 2 * B + 38 := by
      unfold sourceCost
      gcongr
    _ ≤ 40 * (B + 1) ^ 2 := by nlinarith

theorem command_eval (ctx : Context) (regs : Fin 16 → Bool) :
    Eval command (sourceCost ctx - 1) (inputState ctx regs) (outputState ctx) := by
  have hr := reset_eval (inputState ctx regs)
  have he := hr.seq ((copyRemaining_eval ctx).seq ((copyCounter_eval ctx).seq
    ((repeatDefault_eval ctx).seq ((copyAlphabet_eval ctx).seq (clearDefault_eval ctx)))))
  convert he using 1 ; simp [sourceCost, Nat.mul_add] ; omega

theorem program_trace (ctx : Context) (regs : Fin 16 → Bool) :
    Trace program (sourceCost ctx)
      ((inputState ctx regs).withPC (some program.entry))
      ((outputState ctx).withPC none) := by
  have ht := compiled_halt_trace (command_eval ctx regs) 0 8
  have hp : 1 ≤ sourceCost ctx := by unfold sourceCost; omega
  simpa [program, Nat.sub_add_cancel hp] using ht

theorem program_primitive (ctx : Context) (regs : Fin 16 → Bool) :
    Computation.RunsIn (primitive program).step
      (primitiveOverhead program * sourceCost ctx)
      (primitiveCfg program ((inputState ctx regs).withPC (some program.entry)))
      (primitiveCfg program ((outputState ctx).withPC none)) :=
  primitive_trace _ (program_trace ctx regs)

theorem output_highState (ctx : Context) :
    SequentialProgram.HighState
      (ScoreBuilderProgram.environment ctx.alphabetRecords ctx.depth ctx.rawPairs
        ctx.seedRecords (unary ctx.seedCount))
      (outputState ctx).stacks := by
  intro j hj
  have h0 : j ≠ 0 := by intro h; subst j; omega
  have h2 : j ≠ 2 := by intro h; subst j; omega
  have h8 : j ≠ 8 := by intro h; subst j; omega
  have h9 : j ≠ 9 := by intro h; subst j; omega
  have h10 : j ≠ 10 := by intro h; subst j; omega
  have h11 : j ≠ 11 := by intro h; subst j; omega
  simp [outputState, state, ScoreBuilderProgram.environment, h0, h2, h8, h9, h10, h11]

theorem output_memory {A : Type*} (encode : A → List Bool) (a : A) (tail : List A)
    (ctx : Context) (hword : ctx.defaultWord = encode a)
    (halphabet : ctx.packedAlphabet = ((a :: tail).map encode).flatten)
    (hwidth : ctx.width.length = (encode a).length) :
    SequentialProgram.Memory encode a tail ctx.seedCount [] (outputState ctx).stacks := by
  constructor
  · simp [outputState, state, BlockCopyProgram.copies, hword]
  · simp [outputState, state, halphabet]
  · simpa [outputState, state] using hwidth
  · simp [outputState, state]
  · intro j hj
    have hn : j ≠ 8 ∧ j ≠ 9 ∧ j ≠ 10 ∧ j ≠ 11 ∧ j.val < 20 :=
      (show ∀ j : Fin 48, j ∈ SequentialProgram.scratchPorts →
        j ≠ 8 ∧ j ≠ 9 ∧ j ≠ 10 ∧ j ≠ 11 ∧ j.val < 20 by decide) j hj
    have h30 : j ≠ 30 := by intro h; subst j; omega
    have h34 : j ≠ 34 := by intro h; subst j; omega
    have h39 : j ≠ 39 := by intro h; subst j; omega
    have h45 : j ≠ 45 := by intro h; subst j; omega
    have h46 : j ≠ 46 := by intro h; subst j; omega
    have h47 : j ≠ 47 := by intro h; subst j; omega
    simp [outputState, state, hn.1, hn.2.1, hn.2.2.1, hn.2.2.2.1,
      h30, h34, h39, h45, h46, h47]

@[simp] theorem output_remaining (ctx : Context) :
    ((outputState ctx).stacks 11).length = ctx.seedCount := by
  simp [outputState, state, unary]

end SubexponentialSAT.Subexp.AssignmentInitProgram

end OAI.Algorithms