File size: 11,265 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.ModularPrograms
import OAI.Algorithms.SubexponentialSAT.ListRegisterProgram
import OAI.Algorithms.SubexponentialSAT.StructuredCalls

namespace OAI.Algorithms

/-!
# A binary-score minimum update implemented by finite bit programs

The score is a little-endian bit word. Comparisons inspect its numeric value,
not its length. Candidate payloads may themselves be binary indices or encoded
rows. Ports 0/1 hold the incoming payload/score, 2/3 the incumbent, 4--7 are
scratch, and 8 is an untouched caller queue. Every copy and comparison below
has a measured trace of a fixed finite instruction table.
-/

namespace SubexponentialSAT.SqrtLog.BinaryArgmin

open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls SubexponentialSAT.StackRoutines

abbrev Data := State 8 9

structure Entry where
  payload : List Bool
  score : List Bool
  deriving DecidableEq

def value (a : Entry) : ℕ := BinaryArithmetic.toNat a.score

def pick (best next : Entry) : Entry := if value next < value best then next else best

def empty : Entry := ⟨[], []⟩

def store (next best : Entry) (queue : List Bool) : Fin 9 → List Bool :=
  ![next.payload, next.score, best.payload, best.score, [], [], [], [], queue]

def data (regs : Fin 8 → Bool) (next best : Entry) (queue : List Bool) : Data :=
  ⟨regs, store next best queue⟩

abbrev atom (a : StructuredProgram.Atom 8 9) : Cmd 8 9 := .base (.atom a)
abbrev clear (dst : Fin 9) : Cmd 8 9 := .call (clearProgram dst 1 2)
abbrev copy (src dst : Fin 9) : Cmd 8 9 := .call (copyProgram src dst 7 1 2)

def afterClear (d : Data) (dst : Fin 9) : Data :=
  ⟨readRegs d.regs 1 2 none, clearStacks dst d.stacks⟩
def afterCopy (d : Data) (src dst : Fin 9) : Data :=
  ⟨readRegs d.regs 1 2 none, copyStacks src dst d.stacks⟩
def reset (d : Data) : Data := ⟨Function.update d.regs 0 false, d.stacks⟩

theorem clear_eval (d : Data) (dst : Fin 9) :
    Eval (clear dst) (2 * (d.stacks dst).length + 3) d (afterClear d dst) :=
  .call _ (ListRegisterProgram.clear_run dst 1 2 d.regs d.stacks)

theorem copy_eval (d : Data) (src dst : Fin 9)
    (hsd : src ≠ dst) (hs : src ≠ 7) (hd : (7 : Fin 9) ≠ dst)
    (htmp : d.stacks 7 = []) :
    Eval (copy src dst) (7 * (d.stacks src).length + 5) d (afterCopy d src dst) :=
  .call _ (ListRegisterProgram.copy_run src dst 7 1 2 hsd hs hd
    (by decide) d.regs d.stacks htmp)

theorem reset_eval (d : Data) : Eval (atom (.set 0 false)) 1 d (reset d) := by
  exact Eval.base (StructuredProgram.Eval.atom (.set 0 false) d)

def compareStacks : Fin 3 → Fin 9 := ![4, 5, 6]

theorem compareStacks_injective : Function.Injective compareStacks := by
  intro i j h
  fin_cases i <;> fin_cases j <;> simp_all [compareStacks]

abbrev comparator : Program 8 9 13 :=
  ProgramLinking.liftProgram ModularPrograms.subtractProgram id compareStacks

private theorem state_ext {a b : Data}
    (hr : a.regs = b.regs) (hs : a.stacks = b.stacks) : a = b := by
  cases a; cases b; cases hr; cases hs; rfl

private theorem embed_input (d : Data) (h6 : d.stacks 6 = []) :
    embedState id compareStacks d
      ⟨d.regs, ModularPrograms.operandStacks (d.stacks 4) (d.stacks 5) []⟩ = d := by
  apply state_ext
  · funext j
    exact embedState_register _ _ _ _ Function.injective_id j
  · funext j
    by_cases h : ∃ i, compareStacks i = j
    · obtain ⟨i, rfl⟩ := h
      rw [embedState_stack _ _ _ _ compareStacks_injective]
      fin_cases i <;> simp [compareStacks, ModularPrograms.operandStacks, h6]
    · exact embedState_stack_frame _ _ _ _ j h

/-- Destructive binary comparison; only scratch stacks 4, 5, 6 change. -/
theorem compare_eval (d : Data) (h0 : d.regs 0 = false)
    (h6 : d.stacks 6 = []) (hlen : (d.stacks 4).length = (d.stacks 5).length) :
    ∃ e : Data,
      Eval (.call comparator) (12 * (d.stacks 4).length + 3) d e ∧
      (e.regs 0 = true ↔ BinaryArithmetic.toNat (d.stacks 4) <
        BinaryArithmetic.toNat (d.stacks 5)) ∧
      e.stacks 4 = [] ∧ e.stacks 5 = [] ∧
      (e.stacks 6).length = (d.stacks 4).length ∧
      (∀ j : Fin 9, j ≠ 4 → j ≠ 5 → j ≠ 6 → e.stacks j = d.stacks j) := by
  obtain ⟨regs, ht, hb⟩ := ModularPrograms.subtract_comparison d.regs
    (d.stacks 4) (d.stacks 5) h0 hlen
  let out : State 8 3 := ⟨regs, ModularPrograms.operandStacks [] []
    (ModularArithmetic.subCarry false (d.stacks 4) (d.stacks 5)).1.reverse⟩
  let e := embedState id compareStacks d out
  change Trace ModularPrograms.subtractProgram _
    ((⟨d.regs, ModularPrograms.operandStacks (d.stacks 4) (d.stacks 5) []⟩ :
      State 8 3).withPC (some ModularPrograms.subtractProgram.entry))
    (out.withPC none) at ht
  have he := eval_call_lifted ModularPrograms.subtractProgram id compareStacks d
    Function.injective_id compareStacks_injective ht
  rw [embed_input d h6] at he
  refine ⟨e, he, ?_, ?_, ?_, ?_, ?_⟩
  · change (embedState id compareStacks d out).regs (id 0) = true ↔ _
    rw [embedState_register _ _ _ _ Function.injective_id]
    exact hb
  · exact embedState_stack _ _ _ _ compareStacks_injective 0
  · exact embedState_stack _ _ _ _ compareStacks_injective 1
  · change ((embedState id compareStacks d out).stacks (compareStacks 2)).length = _
    rw [embedState_stack _ _ _ _ compareStacks_injective]
    simpa [out] using ModularArithmetic.subCarry_length false
      (d.stacks 4) (d.stacks 5) hlen
  · intro j h4 h5 h6
    apply embedState_stack_frame
    rintro ⟨i, hi⟩
    fin_cases i <;> simp_all [compareStacks]

abbrev replace : Cmd 8 9 :=
  .seq (clear 2) (.seq (copy 0 2) (.seq (clear 3) (copy 1 3)))

def afterReplace (d : Data) : Data :=
  afterCopy (afterClear (afterCopy (afterClear d 2) 0 2) 3) 1 3

theorem replace_eval (d : Data) (htmp : d.stacks 7 = []) :
    Eval replace (2 * (d.stacks 2).length + 7 * (d.stacks 0).length +
      2 * (d.stacks 3).length + 7 * (d.stacks 1).length + 16) d (afterReplace d) := by
  have h1 := clear_eval d 2
  have h2 := copy_eval (afterClear d 2) 0 2 (by decide) (by decide) (by decide)
    (by simpa [afterClear, clearStacks] using htmp)
  have h3 := clear_eval (afterCopy (afterClear d 2) 0 2) 3
  have h4 := copy_eval (afterClear (afterCopy (afterClear d 2) 0 2) 3) 1 3
    (by decide) (by decide) (by decide)
    (by simpa [afterClear, afterCopy, clearStacks, copyStacks] using htmp)
  convert Eval.seq h1 (Eval.seq h2 (Eval.seq h3 h4)) using 1 <;>
    simp [ afterReplace, afterClear, afterCopy, clearStacks, copyStacks] ; omega

abbrev cleanup : Cmd 8 9 := .seq (clear 0) (.seq (clear 1) (clear 6))
def afterCleanup (d : Data) : Data := afterClear (afterClear (afterClear d 0) 1) 6

theorem cleanup_eval (d : Data) :
    Eval cleanup (2 * (d.stacks 0).length + 2 * (d.stacks 1).length +
      2 * (d.stacks 6).length + 9) d (afterCleanup d) := by
  convert Eval.seq (clear_eval d 0) (Eval.seq (clear_eval (afterClear d 0) 1)
    (clear_eval (afterClear (afterClear d 0) 1) 6)) using 1 <;>
    simp [ afterCleanup, afterClear, clearStacks] ; omega

abbrev update : Cmd 8 9 :=
  .seq (copy 1 4) (.seq (copy 3 5) (.seq (atom (.set 0 false))
    (.seq (.call comparator) (.seq (.ite 0 replace (.base .skip)) cleanup))))

/-- One strict-improvement update. The bound depends on bit lengths, never on
the numeric score. The queue and the first incumbent on equal scores survive. -/
theorem update_eval (B C : ℕ) (next best : Entry) (queue : List Bool)
    (regs : Fin 8 → Bool) (hn : next.score.length = B)
    (hb : best.score.length = B) (hcn : next.payload.length ≤ C)
    (hcb : best.payload.length ≤ C) :
    ∃ n ≤ 100 * (B + C + 1), ∃ regs',
      Eval update n (data regs next best queue)
        (data regs' empty (pick best next) queue) := by
  let d := data regs next best queue
  let a := afterCopy d 1 4
  let b := afterCopy a 3 5
  let c := reset b
  have hcopy1 := copy_eval d 1 4 (by decide) (by decide) (by decide) (by rfl)
  have hcopy2 := copy_eval a 3 5 (by decide) (by decide) (by decide) (by rfl)
  have hc4 : c.stacks 4 = next.score := by simp [c, b, a, d, reset, afterCopy, copyStacks, data, store]
  have hc5 : c.stacks 5 = best.score := by simp [c, b, a, d, reset, afterCopy, copyStacks, data, store]
  obtain ⟨e, he, hlt, he4, he5, he6, hef⟩ := compare_eval c (by simp [c, reset])
    (by rfl) (by rw [hc4, hc5, hn, hb])
  rw [hc4, hc5] at hlt
  rw [hc4, hn] at he6
  have he0 : e.stacks 0 = next.payload := by
    rw [hef 0 (by decide) (by decide) (by decide)]; rfl
  have he1 : e.stacks 1 = next.score := by
    rw [hef 1 (by decide) (by decide) (by decide)]; rfl
  have he2 : e.stacks 2 = best.payload := by
    rw [hef 2 (by decide) (by decide) (by decide)]; rfl
  have he3 : e.stacks 3 = best.score := by
    rw [hef 3 (by decide) (by decide) (by decide)]; rfl
  have he7 : e.stacks 7 = [] := by
    rw [hef 7 (by decide) (by decide) (by decide)]; rfl
  have he8 : e.stacks 8 = queue := by
    rw [hef 8 (by decide) (by decide) (by decide)]; rfl
  let k := if value next < value best then afterReplace e else e
  have hbranch : ∃ m ≤ 9 * C + 9 * B + 17,
      Eval (.ite 0 replace (.base .skip)) m e k := by
    by_cases h : value next < value best
    · refine ⟨2 * (e.stacks 2).length + 7 * (e.stacks 0).length +
        2 * (e.stacks 3).length + 7 * (e.stacks 1).length + 16 + 1, ?_, ?_⟩
      · rw [he2, he0, he3, he1, hn, hb]; omega
      · simpa [k, h] using Eval.ite_true (hlt.mpr h) (replace_eval e he7)
    · refine ⟨1, by omega, ?_⟩
      have hf : e.regs 0 = false := by
        cases hv : e.regs 0 <;> simp_all [value]
      simpa [k, h] using Eval.ite_false hf (Eval.base (.skip e))
  obtain ⟨m, hm, hbranch⟩ := hbranch
  have hk0 : k.stacks 0 = next.payload := by
    dsimp only [k]
    split_ifs <;> simp [afterReplace, afterCopy, afterClear, copyStacks, clearStacks, he0]
  have hk1 : k.stacks 1 = next.score := by
    dsimp only [k]
    split_ifs <;> simp [afterReplace, afterCopy, afterClear, copyStacks, clearStacks, he1]
  have hk6 : (k.stacks 6).length = B := by
    dsimp only [k]
    split_ifs <;> simpa [afterReplace, afterCopy, afterClear, copyStacks, clearStacks] using he6
  have hfinal : afterCleanup k =
      data (afterCleanup k).regs empty (pick best next) queue := by
    apply state_ext
    · rfl
    · funext j
      by_cases h : value next < value best <;> fin_cases j <;>
        simp [afterCleanup, k, pick, h, afterReplace, afterClear, afterCopy,
          clearStacks, copyStacks, data, store, empty, he0, he1, he2, he3, he4, he5, he7, he8]
  let total := (7 * (d.stacks 1).length + 5) +
    ((7 * (a.stacks 3).length + 5) +
      (1 + ((12 * (c.stacks 4).length + 3) +
        (m + (2 * (k.stacks 0).length + 2 * (k.stacks 1).length +
          2 * (k.stacks 6).length + 9)))))
  refine ⟨total, ?_, (afterCleanup k).regs, ?_⟩
  · simp only [total, hk0, hk1, hk6, hc4]
    have hd1 : d.stacks 1 = next.score := rfl
    have ha3 : a.stacks 3 = best.score := rfl
    rw [hd1, ha3, hn, hb]
    omega
  · rw [← hfinal]
    exact Eval.seq hcopy1 (Eval.seq hcopy2 (Eval.seq (reset_eval b)
      (Eval.seq he (Eval.seq hbranch (cleanup_eval k)))))

end SubexponentialSAT.SqrtLog.BinaryArgmin

end OAI.Algorithms