File size: 8,388 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.CounterForPrograms
import OAI.Algorithms.SubexponentialSAT.ListRegisterProgram
import OAI.Algorithms.SubexponentialSAT.Encoding

namespace OAI.Algorithms

/-!
# Actual binary-to-unary conversion

The finite controller consumes a little-endian binary counter on stack 0.
Each positive iteration pushes one true bit onto stack 1. Stack 2 is counter
scratch. The cleanup empties the counter and resets every Boolean register.
The numeric value controls execution through stack instructions only.
-/

namespace SubexponentialSAT.CounterConversions

open BitProgram StructuredProgram StructuredCalls CounterPrograms CounterForPrograms

abbrev Data := StructuredProgram.State 3 3

def ports : CounterForPrograms.Ports 3 3 where
  register := Function.Embedding.refl _
  counter := 0
  scratch := 2
  counter_ne_scratch := by decide

def zeroRegs : Fin 3 → Bool := fun _ => false

def state (regs : Fin 3 → Bool) (counter output : List Bool) : Data :=
  ⟨regs, ![counter, output, []]⟩

abbrev push (bit : Bool) : StructuredCalls.Cmd 3 3 :=
  .base (.seq (.atom (.set 0 bit)) (.atom (.push 1 0)))

def pushed (bit : Bool) (d : Data) : Data :=
  ⟨Function.update d.regs 0 bit, Function.update d.stacks 1 (bit :: d.stacks 1)⟩

theorem push_eval (bit : Bool) (d : Data) :
    StructuredCalls.Eval (push bit) 2 d (pushed bit d) := by
  have h := (StructuredProgram.Eval.atom (.set (0 : Fin 3) bit) d).seq
    (StructuredProgram.Eval.atom (.push (1 : Fin 3) 0) _)
  exact .base (by simpa [pushed, Atom.eval, Atom.instr, State.ofCfg, State.withPC, execInstr] using h)

abbrev clear : StructuredCalls.Cmd 3 3 := .call (StackRoutines.clearProgram 0 0 1)

def cleared (d : Data) : Data :=
  ⟨readRegs d.regs 0 1 none, Function.update d.stacks 0 []⟩

theorem clear_eval (d : Data) :
    StructuredCalls.Eval clear (2 * (d.stacks 0).length + 3) d (cleared d) :=
  .call _ (ListRegisterProgram.clear_run 0 0 1 d.regs d.stacks)

abbrev reset : StructuredCalls.Cmd 3 3 := .base
  (.seq (.atom (.set 0 false)) (.seq (.atom (.set 1 false)) (.atom (.set 2 false))))

def resetState (d : Data) : Data := ⟨zeroRegs, d.stacks⟩

theorem reset_eval (d : Data) : StructuredCalls.Eval reset 3 d (resetState d) := by
  have h := (StructuredProgram.Eval.atom (.set (0 : Fin 3) false) d).seq
    ((StructuredProgram.Eval.atom (.set (1 : Fin 3) false) _).seq
      (StructuredProgram.Eval.atom (.set (2 : Fin 3) false) _))
  apply StructuredCalls.Eval.base
  convert h using 1
  apply CounterForPrograms.data_ext
  · funext i
    fin_cases i <;>
      simp [resetState, zeroRegs, Atom.eval, Atom.instr, State.ofCfg, execInstr]
  · rfl

def outputInvariant (tail : List Bool) (i : ℕ) (d : Data) : Prop :=
  d.stacks 1 = List.replicate i true ++ tail

theorem outputInvariant_stable (tail : List Bool) :
    FrameStable ports (outputInvariant tail) := by
  intro i a b hab hi
  exact (hab 1 (by decide) (by decide)).symm.trans hi

theorem push_spec (tail : List Bool) :
    BodySpec ports (push true) (outputInvariant tail) (fun _ => 2) := by
  intro i d hi hs _
  refine ⟨2, pushed true d, le_rfl, push_eval true d, ?_, ?_, ?_⟩
  · simp [pushed, ports]
  · simpa [pushed, ports] using hs
  · change d.stacks 1 = List.replicate i true ++ tail at hi
    simp [outputInvariant, pushed, List.replicate_succ, hi]

abbrev unaryCmd : StructuredCalls.Cmd 3 3 :=
  .seq (CounterForPrograms.forCmd ports (push true)) (.seq clear reset)

def coreBound (bits : List Bool) : ℕ :=
  2 * value bits + (value bits + 1) * (16 * bits.length + 16) + 2 * bits.length + 6

/-- The suffix is arbitrary, which permits both unary strings and terminated
natural-number fields to use the same fixed conversion loop. -/
theorem unary_correct (d : Data) (hs : d.stacks 2 = []) :
    ∃ n, StructuredCalls.Eval unaryCmd n d
      (state zeroRegs [] (List.replicate (value (d.stacks 0)) true ++ d.stacks 1)) ∧
      n ≤ coreBound (d.stacks 0) := by
  obtain ⟨n, e, he, hi, hz, hw, hes, hn⟩ := CounterForPrograms.for_correct
    ports (push true) (outputInvariant (d.stacks 1)) (fun _ => 2)
    (outputInvariant_stable _) (push_spec _) d hs (by simp [outputInvariant])
  have ho : e.stacks 1 = List.replicate (value (d.stacks 0)) true ++ d.stacks 1 := hi
  have hw' : (e.stacks 0).length = (d.stacks 0).length := hw
  have hs' : e.stacks 2 = [] := hes
  have heq : resetState (cleared e) =
      state zeroRegs [] (List.replicate (value (d.stacks 0)) true ++ d.stacks 1) := by
    apply CounterForPrograms.data_ext
    · rfl
    · funext j
      fin_cases j <;> simp [resetState, cleared, state, ho, hs']
  refine ⟨n + ((2 * (e.stacks 0).length + 3) + 3), ?_, ?_⟩
  · rw [← heq]
    exact he.seq ((clear_eval e).seq (reset_eval (cleared e)))
  · have hn' : n ≤ value (d.stacks 0) * 2 +
        (value (d.stacks 0) + 1) * (16 * (d.stacks 0).length + 16) := by
      simpa [ports, budgetSum_const] using hn
    rw [hw']
    dsimp [coreBound]
    omega

theorem unary_eval (regs : Fin 3 → Bool) (bits tail : List Bool) :
    ∃ n, StructuredCalls.Eval unaryCmd n (state regs bits tail)
      (state zeroRegs [] (List.replicate (value bits) true ++ tail)) ∧ n ≤ coreBound bits := by
  simpa [state] using unary_correct (state regs bits tail) rfl

abbrev encodeNatCmd : StructuredCalls.Cmd 3 3 := .seq (push false) unaryCmd

theorem encodeNat_eval (regs : Fin 3 → Bool) (bits : List Bool) :
    ∃ n, StructuredCalls.Eval encodeNatCmd n (state regs bits [])
      (state zeroRegs [] (Encoding.encodeNat (value bits))) ∧ n ≤ coreBound bits + 2 := by
  let d := state regs bits []
  obtain ⟨n, he, hn⟩ := unary_correct (pushed false d) (by simp [pushed, d, state])
  refine ⟨2 + n, ?_, ?_⟩
  · have h := (push_eval false d).seq he
    simpa [encodeNatCmd, pushed, d, state, Encoding.encodeNat] using h
  · have hn' : n ≤ coreBound bits := by simpa [pushed, d, state] using hn
    omega

def runtimeBound (bits : List Bool) : ℕ := 32 * (value bits + 1) * (bits.length + 1)

theorem coreBound_le (bits : List Bool) : coreBound bits + 3 ≤ runtimeBound bits := by
  dsimp [coreBound, runtimeBound]
  nlinarith [Nat.zero_le (value bits * bits.length)]

def unaryProgram := StructuredCalls.compiled unaryCmd (0 : Fin 3) 1
def encodeNatProgram := StructuredCalls.compiled encodeNatCmd (0 : Fin 3) 1

theorem unary_runs (regs : Fin 3 → Bool) (bits tail : List Bool) :
    BitProgram.RunsIn unaryProgram (runtimeBound bits)
      ((state regs bits tail).withPC (some unaryProgram.entry))
      ((state zeroRegs [] (List.replicate (value bits) true ++ tail)).withPC none) := by
  obtain ⟨n, he, hn⟩ := unary_eval regs bits tail
  exact ⟨n + 1, by have := coreBound_le bits; omega,
    StructuredCalls.compiled_halt_trace he 0 1⟩

theorem encodeNat_runs (regs : Fin 3 → Bool) (bits : List Bool) :
    BitProgram.RunsIn encodeNatProgram (runtimeBound bits)
      ((state regs bits []).withPC (some encodeNatProgram.entry))
      ((state zeroRegs [] (Encoding.encodeNat (value bits))).withPC none) := by
  obtain ⟨n, he, hn⟩ := encodeNat_eval regs bits
  exact ⟨n + 1, by have := coreBound_le bits; omega,
    StructuredCalls.compiled_halt_trace he 0 1⟩

theorem unary_primitive (regs : Fin 3 → Bool) (bits tail : List Bool) :
    Computation.RunsIn (BitProgram.primitive unaryProgram).step
      (BitProgram.primitiveOverhead unaryProgram * runtimeBound bits)
      (BitProgram.primitiveCfg unaryProgram
        ((state regs bits tail).withPC (some unaryProgram.entry)))
      (BitProgram.primitiveCfg unaryProgram
        ((state zeroRegs [] (List.replicate (value bits) true ++ tail)).withPC none)) :=
  BitProgram.primitive_execution unaryProgram (unary_runs regs bits tail)

theorem encodeNat_primitive (regs : Fin 3 → Bool) (bits : List Bool) :
    Computation.RunsIn (BitProgram.primitive encodeNatProgram).step
      (BitProgram.primitiveOverhead encodeNatProgram * runtimeBound bits)
      (BitProgram.primitiveCfg encodeNatProgram
        ((state regs bits []).withPC (some encodeNatProgram.entry)))
      (BitProgram.primitiveCfg encodeNatProgram
        ((state zeroRegs [] (Encoding.encodeNat (value bits))).withPC none)) :=
  BitProgram.primitive_execution encodeNatProgram (encodeNat_runs regs bits)

end SubexponentialSAT.CounterConversions

end OAI.Algorithms