File size: 10,698 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
import OAI.Algorithms.SubexponentialSAT.CounterWidth
import OAI.Algorithms.SubexponentialSAT.ExecCNFTupleEnumeration
import OAI.Algorithms.SubexponentialSAT.BitProgramSpace
import Mathlib.Data.Nat.Size

namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.Counters

open BitProgram CounterPrograms CounterForPrograms

/-- Fixed-width words and their in-range numeric indices are equivalent.
This specification is not a retained list of the enumerated words. -/
def wordEquiv (width : ℕ) : Fin (2 ^ width) ≃ {xs : List Bool // xs.length = width} where
  toFun i := ⟨ExecCNFTupleEnumeration.fixedBits width i, by simp⟩
  invFun xs := ⟨value xs.val, by
    simpa only [xs.property] using ExecCNFTupleOdometer.value_lt_power_length xs.val⟩
  left_inv i := Fin.ext (ExecCNFTupleEnumeration.fixedBits_value width i i.isLt)
  right_inv xs := Subtype.ext (ExecCNFTupleEnumeration.word_eq_of_length_value
    (by simp only [ExecCNFTupleEnumeration.fixedBits_length, xs.property])
    (ExecCNFTupleEnumeration.fixedBits_value width (value xs.val)
      (by simpa only [xs.property] using ExecCNFTupleOdometer.value_lt_power_length xs.val)))

/-- The binary word of an exponentially large fuel has only linear width. -/
theorem fuel_bits_length (width : ℕ) : (2 ^ width).bits.length = width + 1 := by
  rw [Nat.size_eq_bits_len, Nat.size_pow]

/-- The canonical binary encoding of a number at most the assignment count is short. -/
theorem bits_length_le_of_le_pow {n width : ℕ} (h : n ≤ 2 ^ width) :
    n.bits.length ≤ width + 1 := by
  rw [Nat.size_eq_bits_len, ← Nat.size_pow]
  exact Nat.size_le_size h

/-- The actual ripple increment remains the next fixed-width word before overflow. -/
theorem increment_word {width : ℕ} (i : Fin (2 ^ width)) (h : i.val + 1 < 2 ^ width) :
    ripple true (wordEquiv width i).val = (wordEquiv width ⟨i.val + 1, h⟩).val := by
  apply ExecCNFTupleEnumeration.word_eq_of_length_value
  · apply Nat.le_antisymm
    · exact (increment_length_le_of_lt (wordEquiv width i).val width
        (wordEquiv width i).property.le (by simpa [wordEquiv,
          ExecCNFTupleEnumeration.fixedBits_value width i i.isLt] using h)).trans_eq
          (wordEquiv width ⟨i.val + 1, h⟩).property.symm
    · have hlen : (wordEquiv width i).val.length ≤
          (ripple true (wordEquiv width i).val).length := by
        generalize (wordEquiv width i).val = xs
        induction xs with
        | nil => simp
        | cons b xs ih =>
            cases b
            · simp [ripple]
            · simp only [ripple, ↓reduceIte, Bool.not_true, List.length_cons] at *
              omega
      simpa only [(wordEquiv width i).property,
        (wordEquiv width ⟨i.val + 1, h⟩).property] using hlen
  · simp [wordEquiv, value_increment, ExecCNFTupleEnumeration.fixedBits_value, i.isLt, h]

/-- The local routine is linear in the current word, even when its value is exponential. -/
theorem ripple_prefix_stack_bound (carry bit present flag : Bool) (word : List Bool)
    {steps : ℕ} {intermediate : Cfg 3 2 11}
    (hle : steps ≤ rippleCost carry word + 1)
    (htrace : Trace (rippleProgram carry) steps
      ((localData bit present flag word []).withPC (some (rippleProgram carry).entry))
      intermediate) (i : Fin 2) :
    (intermediate.stacks i).length ≤ 9 * word.length + 8 := by
  have hs : (intermediate.stacks i).length ≤ dataBits intermediate :=
    Finset.single_le_sum (fun j _ => Nat.zero_le ((intermediate.stacks j).length))
      (Finset.mem_univ i)
  have hg := trace_dataBits (rippleProgram carry) htrace
  have hc := rippleCost_le carry word
  have hinit : dataBits
      ((localData bit present flag word []).withPC (some (rippleProgram carry).entry)) =
      word.length := by
    simp [dataBits, stackBits, localData,
      counterStacks, Fin.sum_univ_two]
  rw [hinit] at hg
  omega

/-- Generic actual increment call on the same finite ports as countdown. -/
def incrementCmd {R S : ℕ} (p : Ports R S) : StructuredCalls.Cmd R S :=
  .call (ProgramLinking.liftProgram (rippleProgram true) p.register (stackPorts p))

noncomputable def incrementResult {R S : ℕ} (p : Ports R S) (d : Data R S) : Data R S :=
  install p d false false (d.regs (p.register 2)) (ripple true (d.stacks p.counter)) []

theorem increment_eval {R S : ℕ} (p : Ports R S) (d : Data R S)
    (hs : d.stacks p.scratch = []) :
    StructuredCalls.Eval (incrementCmd p) (rippleCost true (d.stacks p.counter) + 1)
      d (incrementResult p d) := by
  have h := StructuredCalls.eval_call_lifted (rippleProgram true) p.register (stackPorts p) d
    p.register.injective (stackPorts p).injective
    (ripple_local_trace true (d.regs (p.register 0)) (d.regs (p.register 1))
      (d.regs (p.register 2)) (d.stacks p.counter))
  change StructuredCalls.Eval (incrementCmd p) _
    (install p d _ _ _ _ []) (incrementResult p d) at h
  rw [← hs, install_self] at h
  exact h

@[simp] theorem incrementResult_counter {R S : ℕ} (p : Ports R S) (d : Data R S) :
    (incrementResult p d).stacks p.counter = ripple true (d.stacks p.counter) :=
  install_counter p d _ _ _ _ _

@[simp] theorem incrementResult_scratch {R S : ℕ} (p : Ports R S) (d : Data R S) :
    (incrementResult p d).stacks p.scratch = [] := install_scratch p d _ _ _ _ _

/-- Every off-counter caller stack is preserved, including cleared scratch. -/
theorem incrementResult_stacks {R S : ℕ} (p : Ports R S) (d : Data R S)
    (hs : d.stacks p.scratch = []) :
    (incrementResult p d).stacks =
      Function.update d.stacks p.counter (ripple true (d.stacks p.counter)) := by
  funext i
  by_cases hc : i = p.counter
  · subst i
    simp
  · by_cases hi : i = p.scratch
    · subst i
      simp [hc, hs]
    · rw [Function.update_of_ne hc]
      exact install_other_stack p d _ _ _ _ _ i hc hi

theorem incrementResult_register_frame {R S : ℕ} (p : Ports R S) (d : Data R S)
    (i : Fin R) (hi : ¬ ∃ j, p.register j = i) :
    (incrementResult p d).regs i = d.regs i :=
  StructuredCalls.embedState_register_frame _ _ _ _ i hi

/-- Consume a length witness and construct the binary fuel `2^h` by pushing
one zero per witness bit. The finite control never stores `h` or `2^h`. -/
def powerTwoProgram : Program 3 2 7 where
  inputStack := 0
  outputStack := 1
  entry := 0
  code q := match q.val with
    | 0 => .set 0 true 1
    | 1 => .push 1 0 2
    | 2 => .pop 0 0 1 3
    | 3 => .branch 1 4 6
    | 4 => .set 0 false 5
    | 5 => .push 1 0 2
    | _ => .halt

private theorem powerTwo_scan (word output : List Bool) (bit present flag : Bool) :
    Trace powerTwoProgram (4 * word.length + 2)
      (counterCfg 2 bit present flag word output)
      (counterCfg 6 false false flag [] (List.replicate word.length false ++ output)) := by
  induction word generalizing output bit present with
  | nil =>
      exact .cons (b := counterCfg 3 false false flag [] output)
        (by simp [step, powerTwoProgram, counterCfg, execInstr, readRegs])
        (.cons (by simp [step, powerTwoProgram, counterCfg, execInstr]) (.refl _))
  | cons b word ih =>
      have h := Computation.Trace.cons
        (show step powerTwoProgram (counterCfg 2 bit present flag (b :: word) output) =
          some (counterCfg 3 b true flag word output) by
            simp [step, powerTwoProgram, counterCfg, execInstr, readRegs])
        (Computation.Trace.cons
          (show step powerTwoProgram (counterCfg 3 b true flag word output) =
            some (counterCfg 4 b true flag word output) by
              simp [step, powerTwoProgram, counterCfg, execInstr])
          (Computation.Trace.cons
            (show step powerTwoProgram (counterCfg 4 b true flag word output) =
              some (counterCfg 5 false true flag word output) by
                simp [step, powerTwoProgram, counterCfg, execInstr])
            (Computation.Trace.cons
              (show step powerTwoProgram (counterCfg 5 false true flag word output) =
                some (counterCfg 2 false true flag word (false :: output)) by
                  simp [step, powerTwoProgram, counterCfg, execInstr])
              (ih (false :: output) false true))))
      convert h using 1
      simp [List.replicate_succ', List.append_assoc]

theorem powerTwo_trace (word : List Bool) (bit present flag : Bool) :
    Trace powerTwoProgram (4 * word.length + 5)
      ((localData bit present flag word []).withPC (some powerTwoProgram.entry))
      ((localData false false flag []
        (List.replicate word.length false ++ [true])).withPC none) := by
  have hstart : Trace powerTwoProgram 2 (counterCfg 0 bit present flag word [])
      (counterCfg 2 true present flag word [true]) :=
    .cons (b := counterCfg 1 true present flag word [])
      (by simp [step, powerTwoProgram, counterCfg, execInstr])
      (.cons (by simp [step, powerTwoProgram, counterCfg, execInstr]) (.refl _))
  have hend : Trace powerTwoProgram 1
      (counterCfg 6 false false flag [] (List.replicate word.length false ++ [true]))
      ((localData false false flag [] (List.replicate word.length false ++ [true])).withPC none) :=
    .cons (by simp [step, powerTwoProgram, counterCfg, execInstr, localData,
      StructuredProgram.State.withPC]) (.refl _)
  have h := (hstart.trans (powerTwo_scan word [true] true present flag)).trans hend
  have ht : 2 + (4 * word.length + 2) + 1 = 4 * word.length + 5 := by omega
  rw [ht] at h
  simpa [localData, StructuredProgram.State.withPC, counterCfg, powerTwoProgram] using h

theorem powerTwo_value (width : ℕ) :
    value (List.replicate width false ++ [true]) = 2 ^ width := by
  induction width with
  | zero => rfl
  | succ width ih => simp [List.replicate_succ, ih, pow_succ, Nat.mul_comm]

/-- Every prefix of fuel construction has linear storage, including scratch. -/
theorem powerTwo_prefix_stack_bound (word : List Bool) (bit present flag : Bool)
    {steps : ℕ} {intermediate : Cfg 3 2 7} (hle : steps ≤ 4 * word.length + 5)
    (htrace : Trace powerTwoProgram steps
      ((localData bit present flag word []).withPC (some powerTwoProgram.entry)) intermediate)
    (i : Fin 2) : (intermediate.stacks i).length ≤ 5 * word.length + 5 := by
  have hs : (intermediate.stacks i).length ≤ dataBits intermediate :=
    Finset.single_le_sum (fun j _ => Nat.zero_le ((intermediate.stacks j).length))
      (Finset.mem_univ i)
  have hg := trace_dataBits powerTwoProgram htrace
  have hinit : dataBits
      ((localData bit present flag word []).withPC (some powerTwoProgram.entry)) = word.length := by
    simp [dataBits, stackBits, localData,
      counterStacks, Fin.sum_univ_two]
  rw [hinit] at hg
  omega

end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.Counters