File size: 9,645 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Subexp.DimensionProgram
import OAI.Algorithms.SubexponentialSAT.SubexpNormalizeProgram
import OAI.Algorithms.SubexponentialSAT.Subexp.CandidateScoreProgram
import OAI.Algorithms.SubexponentialSAT.ProgramFrames

namespace OAI.Algorithms

/-! Ascending framed unary seed indices from a runtime unary seed count. -/

namespace SubexponentialSAT.Subexp.AssignmentSeedRange

open BitProgram StructuredCalls TupleProgram

abbrev Data := State 5 6
abbrev unary (n : ℕ) := List.replicate n true

def state (regs : Fin 5 → Bool) (current : ℕ) (input descending output : List Bool) : Data :=
  ⟨regs, ![input, unary current, [], descending, [], output]⟩

def dimStacks : Fin 5 → Fin 6 := Fin.castAdd 1
theorem dimStacks_injective : Function.Injective dimStacks := by
  intro i j h
  exact Fin.ext (congrArg (fun x : Fin 6 => x.val) h)

def dimProgram := compiled DimensionProgram.enumerate 0 3
abbrev dimensions : Cmd 5 6 := .call (ProgramLinking.liftProgram dimProgram id dimStacks)

theorem dimensions_eval (regs : Fin 5 → Bool) (n : ℕ) :
    ∃ rf, Eval dimensions (DimensionProgram.loopCost 0 n + 1)
      (state regs 0 (unary n) [false] [])
      (state rf n [] (ProgramEncoding.encodeRecords (DimensionProgram.earlierRows 0 n)) []) := by
  let a : State 5 5 := ⟨regs, ![unary n, [], [], [false], []]⟩
  have ha : DimensionProgram.Ready 0 (unary n) [] a := by
    simp [DimensionProgram.Ready, a, ProgramEncoding.encodeRecords, Encoding.encodeList]
  obtain ⟨b, hb, _, ht⟩ := DimensionProgram.enumerate_eval 0 (unary n) [] a ha
  simp only [List.length_replicate, Nat.zero_add, List.append_nil] at hb ht
  let d := state regs 0 (unary n) [false] []
  have he : embedState id dimStacks d a = d := by
    apply embedState_eq_of_ports _ _ _ _ _ Function.injective_id dimStacks_injective
    · intro i; rfl
    · intro i hi; exact (hi ⟨i, rfl⟩).elim
    · intro i; fin_cases i <;> rfl
    · intros; rfl
  have hf : embedState id dimStacks d b =
      state b.regs n [] (ProgramEncoding.encodeRecords (DimensionProgram.earlierRows 0 n)) [] := by
    apply embedState_eq_of_ports _ _ _ _ _ Function.injective_id dimStacks_injective
    · intro i; rfl
    · intro i hi; exact (hi ⟨i, rfl⟩).elim
    · intro i
      fin_cases i
      · exact hb.1.symm
      · exact hb.2.1.symm
      · exact hb.2.2.1.symm
      · exact hb.2.2.2.1.symm
      · exact hb.2.2.2.2.symm
    · intro i hi
      fin_cases i <;> first | rfl | exact (hi ⟨0, rfl⟩).elim |
        exact (hi ⟨1, rfl⟩).elim | exact (hi ⟨2, rfl⟩).elim |
        exact (hi ⟨3, rfl⟩).elim
  have h := eval_call_lifted dimProgram id dimStacks d Function.injective_id
    dimStacks_injective (compiled_halt_trace ht 0 3)
  exact ⟨b.regs, by simpa only [dimensions, he, hf] using h⟩

def reverseRegisters : Fin 3 → Fin 5 := Fin.castAdd 2
def reverseStacks : Fin 4 → Fin 6 := ![3, 4, 5, 2]
theorem reverseRegisters_injective : Function.Injective reverseRegisters := by
  intro i j h
  exact Fin.ext (congrArg (fun x : Fin 5 => x.val) h)
theorem reverseStacks_injective : Function.Injective reverseStacks := by decide

abbrev reverse : Cmd 5 6 := .call (ProgramLinking.liftProgram
  SubexpNormalizeProgram.reverseRecordsProgram reverseRegisters reverseStacks)

def reversedRegs (regs : Fin 5 → Bool) : Fin 5 → Bool :=
  fun j => if j = 0 then false else if j = 1 then true else if j = 2 then false else regs j

theorem reverse_eval (regs : Fin 5 → Bool) (n : ℕ) (records : List (List Bool)) :
    ∃ ticks, ticks ≤ 10 * (ProgramEncoding.encodeRecords records).length ∧
      Eval reverse ticks
        (state regs n [] (ProgramEncoding.encodeRecords records) [false])
        (state (reversedRegs regs) n [] [] (ProgramEncoding.encodeRecords records.reverse)) := by
  let a := state regs n [] (ProgramEncoding.encodeRecords records) [false]
  let x := SubexpNormalizeProgram.filterState (regs 0) (regs 1) (regs 2)
    (ProgramEncoding.encodeRecords records) [] [false] []
  let y := SubexpNormalizeProgram.filterState false true false [] []
    (ProgramEncoding.encodeRecords records.reverse) []
  have hx : embedState reverseRegisters reverseStacks a x = a := by
    apply embedState_eq_of_ports _ _ _ _ _ reverseRegisters_injective reverseStacks_injective
    · intro i; fin_cases i <;> rfl
    · intros; rfl
    · intro i; fin_cases i <;> rfl
    · intros; rfl
  have hy : embedState reverseRegisters reverseStacks a y =
      state (reversedRegs regs) n [] [] (ProgramEncoding.encodeRecords records.reverse) := by
    apply embedState_eq_of_ports _ _ _ _ _ reverseRegisters_injective reverseStacks_injective
    · intro i; fin_cases i <;> rfl
    · intro i hi
      fin_cases i <;> first | rfl | exact (hi ⟨0, rfl⟩).elim |
        exact (hi ⟨1, rfl⟩).elim | exact (hi ⟨2, rfl⟩).elim
    · intro i; fin_cases i <;> rfl
    · intro i hi
      fin_cases i <;> first | rfl | exact (hi ⟨0, rfl⟩).elim |
        exact (hi ⟨1, rfl⟩).elim | exact (hi ⟨2, rfl⟩).elim
  obtain ⟨ticks, hbound, ht⟩ := SubexpNormalizeProgram.reverseRecords_runsIn
    records [] [] [] (regs 0) (regs 1) (regs 2)
  simp only [List.append_nil] at ht
  have h := eval_call_lifted SubexpNormalizeProgram.reverseRecordsProgram
    reverseRegisters reverseStacks a reverseRegisters_injective reverseStacks_injective
    (a := x) (b := y) ht
  exact ⟨ticks, hbound, by simpa only [reverse, hx, hy] using h⟩

theorem earlierRows_eq (k n : ℕ) :
    DimensionProgram.earlierRows k n = (List.range' k n).reverse.map unary := by
  induction n generalizing k with
  | zero => simp [DimensionProgram.earlierRows]
  | succ n ih =>
      simp only [DimensionProgram.earlierRows, List.range'_succ, List.reverse_cons,
        List.map_append, List.map_singleton, ih]

def seedRecords (n : ℕ) : List Bool :=
  ProgramEncoding.encodeRecords ((List.range n).map unary)

abbrev reset : Cmd 5 6 := .base (CandidateScoreProgram.resetList (List.finRange 5))
abbrev command : Cmd 5 6 := .seq (pushConst 3 0 false)
  (.seq dimensions (.seq (pushConst 5 0 false)
    (.seq reverse (.seq (.call (StackRoutines.clearProgram 1 0 1)) reset))))

def inputState (regs : Fin 5 → Bool) (n : ℕ) : Data := state regs 0 (unary n) [] []
def outputState (n : ℕ) : Data := state (fun _ => false) 0 [] [] (seedRecords n)

def budget (n : ℕ) : ℕ := DimensionProgram.loopCost 0 n +
  10 * (ProgramEncoding.encodeRecords (DimensionProgram.earlierRows 0 n)).length + 2 * n + 13

theorem budget_le (n : ℕ) : budget n ≤ 60 * (n + 1) ^ 2 := by
  have hlength : (DimensionProgram.earlierRows 0 n).length = n := by
    simp [earlierRows_eq]
  have hwidth : ∀ bits ∈ DimensionProgram.earlierRows 0 n, bits.length ≤ n := by
    intro bits hb
    rw [earlierRows_eq] at hb
    obtain ⟨i, hi, rfl⟩ := List.mem_map.mp hb
    have hi' : i < n := by simpa using hi
    simp only [List.length_replicate]
    omega
  have hsize := ProgramEncoding.encodeRecords_length_le
    (DimensionProgram.earlierRows 0 n) n hwidth
  rw [hlength] at hsize
  unfold budget
  rw [DimensionProgram.loopCost_eq]
  nlinarith

theorem command_eval (regs : Fin 5 → Bool) (n : ℕ) :
    ∃ ticks, ticks ≤ budget n ∧ Eval command ticks (inputState regs n) (outputState n) := by
  let a := inputState regs n
  let b := pushedState 3 0 false a
  have hb : b = state b.regs 0 (unary n) [false] [] := by
    apply congrArg (StructuredProgram.State.mk b.regs)
    funext i; fin_cases i <;> rfl
  obtain ⟨rf, hd⟩ := dimensions_eval b.regs n
  rw [← hb] at hd
  let c := state rf n [] (ProgramEncoding.encodeRecords (DimensionProgram.earlierRows 0 n)) []
  let d := pushedState 5 0 false c
  have he : d = state d.regs n []
      (ProgramEncoding.encodeRecords (DimensionProgram.earlierRows 0 n)) [false] := by
    apply congrArg (StructuredProgram.State.mk d.regs)
    funext i; fin_cases i <;> rfl
  obtain ⟨ticks, hbound, hr⟩ := reverse_eval d.regs n (DimensionProgram.earlierRows 0 n)
  rw [← he] at hr
  have hrecords : (DimensionProgram.earlierRows 0 n).reverse = (List.range n).map unary := by
    simp [earlierRows_eq, List.map_reverse, ← List.range_eq_range']
  rw [hrecords] at hr
  let e := state (reversedRegs d.regs) n [] [] (seedRecords n)
  let f : Data := ⟨readRegs e.regs 0 1 none, StackRoutines.clearStacks 1 e.stacks⟩
  have h1 := pushConst_eval 3 0 false a
  have h3 := pushConst_eval 5 0 false c
  have h5 := TupleProgram.clear_eval 1 0 1 e
  have h6 := Eval.base (CandidateScoreProgram.resetList_eval (List.finRange 5) f)
  have hout : (⟨CandidateScoreProgram.resetValues (List.finRange 5) f.regs, f.stacks⟩ : Data) =
      outputState n := by
    apply congrArg₂ StructuredProgram.State.mk
    · funext i; simp [CandidateScoreProgram.resetValues_apply ]
    · funext i; fin_cases i <;> simp [f, e, state, StackRoutines.clearStacks]
  rw [hout] at h6
  have h := h1.seq (hd.seq (h3.seq (hr.seq (h5.seq h6))))
  change Eval command _ a (outputState n) at h
  refine ⟨_, ?_, h⟩
  have he1 : (e.stacks 1).length = n := by simp [e, state]
  simp only [he1, List.length_finRange]
  dsimp [budget]
  omega

def program := compiled command 0 5

theorem program_runsIn (regs : Fin 5 → Bool) (n : ℕ) :
    RunsIn program (budget n + 1)
      ((inputState regs n).withPC (some program.entry)) ((outputState n).withPC none) := by
  obtain ⟨ticks, ht, he⟩ := command_eval regs n
  exact ⟨ticks + 1, Nat.add_le_add_right ht 1, compiled_halt_trace he 0 5⟩

end SubexponentialSAT.Subexp.AssignmentSeedRange

end OAI.Algorithms