File size: 11,183 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 | import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.Subexp.DimensionProgram
namespace OAI.Algorithms
/-! Fixed preparation of candidate tables, split dimensions, and coefficient
tuples for the universal block search. All three dimensions are runtime data. -/
namespace SubexponentialSAT.Subexp.BlockSearchPreparation
open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls
abbrev Records := List (List Bool)
def restrictState {r s R S : ℕ} (ρ : Fin r → Fin R) (σ : Fin s → Fin S)
(a : State R S) : State r s := ⟨a.regs ∘ ρ, a.stacks ∘ σ⟩
theorem embed_restrict_eq {r s R S : ℕ} (ρ : Fin r → Fin R) (σ : Fin s → Fin S)
(a : State R S) (hρ : Function.Injective ρ) (hσ : Function.Injective σ) :
embedState ρ σ a (restrictState ρ σ a) = a := by
apply congrArg₂ StructuredProgram.State.mk
· funext i
by_cases h : ∃ j, ρ j = i
· obtain ⟨j,rfl⟩ := h
exact embedState_register ρ σ a (restrictState ρ σ a) hρ j
· exact embedState_register_frame ρ σ a (restrictState ρ σ a) i h
· funext i
by_cases h : ∃ j, σ j = i
· obtain ⟨j,rfl⟩ := h
exact embedState_stack ρ σ a (restrictState ρ σ a) hσ j
· exact embedState_stack_frame ρ σ a (restrictState ρ σ a) i h
theorem lifted_call {r s R S l : ℕ} (p : Program r s l)
(ρ : Fin r → Fin R) (σ : Fin s → Fin S) (hρ : Function.Injective ρ)
(hσ : Function.Injective σ) (a : State R S) (b : State r s) (bound : ℕ)
(h : RunsIn p bound ((restrictState ρ σ a).withPC (some p.entry)) (b.withPC none)) :
∃ n, n ≤ bound ∧ Eval (.call (ProgramLinking.liftProgram p ρ σ)) n
a (embedState ρ σ a b) := by
obtain ⟨n,hn,ht⟩ := h
refine ⟨n,hn,?_⟩
have he := eval_call_lifted p ρ σ a hρ hσ ht
simpa only [embed_restrict_eq ρ σ a hρ hσ] using he
def tupleRegisters (i : Fin 10) : Fin 15 := ⟨i.val, by omega⟩
def tableStacks (i : Fin 9) : Fin 22 := ⟨i.val, by omega⟩
def dimensionRegisters (i : Fin 5) : Fin 15 := ⟨i.val + 10, by omega⟩
def dimensionStacks (i : Fin 5) : Fin 22 := ⟨i.val + 9, by omega⟩
def coefficientStacks : Fin 9 → Fin 22 := ![14,1,15,16,17,18,19,20,21]
theorem tupleRegisters_injective : Function.Injective tupleRegisters := by
intro i j h
apply Fin.ext
exact congrArg (fun x : Fin 15 => x.val) h
theorem tableStacks_injective : Function.Injective tableStacks := by
intro i j h
apply Fin.ext
exact congrArg (fun x : Fin 22 => x.val) h
theorem dimensionRegisters_injective : Function.Injective dimensionRegisters := by
intro i j h
apply Fin.ext
have hv := congrArg Fin.val h
simp only [dimensionRegisters] at hv
omega
theorem dimensionStacks_injective : Function.Injective dimensionStacks := by
intro i j h
apply Fin.ext
have hv := congrArg Fin.val h
simp only [dimensionStacks] at hv
omega
theorem coefficientStacks_injective : Function.Injective coefficientStacks := by
intro i j h
fin_cases i <;> fin_cases j <;> simp_all [coefficientStacks]
theorem table_frame (a : State 15 22) (b : State 10 9) (i : Fin 22) (hi : 9 ≤ i.val) :
(embedState tupleRegisters tableStacks a b).stacks i = a.stacks i := by
apply embedState_stack_frame
rintro ⟨j,hj⟩
have h := congrArg Fin.val hj
simp only [tableStacks] at h
omega
theorem dimension_frame (a : State 15 22) (b : State 5 5) (i : Fin 22)
(hi : i.val < 9 ∨ 14 ≤ i.val) :
(embedState dimensionRegisters dimensionStacks a b).stacks i = a.stacks i := by
apply embedState_stack_frame
rintro ⟨j,hj⟩
have h := congrArg Fin.val hj
simp only [dimensionStacks] at h
omega
theorem coefficient_frame (a : State 15 22) (b : State 10 9) (i : Fin 22)
(hi : i.val < 14) (hi1 : i ≠ 1) :
(embedState tupleRegisters coefficientStacks a b).stacks i = a.stacks i := by
apply embedState_stack_frame
rintro ⟨j,hj⟩
fin_cases j <;> simp [coefficientStacks] at hj
all_goals subst i
all_goals omega
/-- Runtime inputs occupy alphabet 1, table depth 8, and two explicit copies
of the unary vector dimension on 9 and 21. -/
def inputState (alphabet : Records) (tableDepth vectorDepth : List Bool)
(regs : Fin 15 → Bool) : State 15 22 :=
⟨regs, fun i => if i = 1 then ProgramEncoding.encodeRecords alphabet
else if i = 8 then tableDepth
else if i = 9 ∨ i = 21 then vectorDepth else []⟩
abbrev prepareCmd : Cmd 15 22 :=
.seq (.call (ProgramLinking.liftProgram TupleProgram.generateProgram
tupleRegisters tableStacks))
(.seq (.call (ProgramLinking.liftProgram DimensionProgram.program
dimensionRegisters dimensionStacks))
(.call (ProgramLinking.liftProgram TupleProgram.generateProgram
tupleRegisters coefficientStacks)))
def program := StructuredCalls.compiled prepareCmd 1 0
theorem control_size : StructuredCalls.size prepareCmd + 1 = 211 := rfl
def cost (alphabet : Records) (tableDepth vectorDepth : List Bool) : ℕ :=
TupleProgram.powerCost alphabet tableDepth.length [[]] +
TupleProgram.powerCost alphabet vectorDepth.length [[]] +
6 * vectorDepth.length ^ 2 + 22 * vectorDepth.length + 36
def Prepared (alphabet : Records) (tableDepth vectorDepth : List Bool) (a : State 15 22) : Prop :=
a.stacks 0 = ProgramEncoding.encodeRecords (TupleProgram.powerRows alphabet tableDepth.length [[]]) ∧
a.stacks 1 = ProgramEncoding.encodeRecords alphabet ∧
a.stacks 12 = ProgramEncoding.encodeRecords (DimensionProgram.dimensionRows 0 vectorDepth.length) ∧
a.stacks 14 = ProgramEncoding.encodeRecords (TupleProgram.powerRows alphabet vectorDepth.length [[]]) ∧
a.stacks 10 = List.replicate vectorDepth.length true
theorem program_runsIn (alphabet : Records) (tableDepth vectorDepth : List Bool)
(regs : Fin 15 → Bool) :
∃ next, Prepared alphabet tableDepth vectorDepth next ∧
RunsIn program (cost alphabet tableDepth vectorDepth)
((inputState alphabet tableDepth vectorDepth regs).withPC (some program.entry))
(next.withPC none) := by
let a := inputState alphabet tableDepth vectorDepth regs
let ta := restrictState tupleRegisters tableStacks a
obtain ⟨tb,htb,htt⟩ := TupleProgram.generateProgram_runsIn alphabet tableDepth (ta.regs 9) ta
(by norm_num [TupleProgram.outerInvariant,ta,a,restrictState,inputState,tableStacks,
Fin.ext_iff,Fin.coe_ofNat_eq_mod])
(by norm_num [ta,a,restrictState,inputState,tableStacks,Fin.ext_iff,Fin.coe_ofNat_eq_mod])
(by norm_num [ta,a,restrictState,inputState,tableStacks,Fin.ext_iff,Fin.coe_ofNat_eq_mod])
(by norm_num [ta,a,restrictState,inputState,tableStacks,Fin.ext_iff,Fin.coe_ofNat_eq_mod])
let b := embedState tupleRegisters tableStacks a tb
obtain ⟨nt,hnt,het⟩ := lifted_call TupleProgram.generateProgram tupleRegisters tableStacks
tupleRegisters_injective tableStacks_injective a tb _ htt
let da := restrictState dimensionRegisters dimensionStacks b
have hds (i : Fin 5) : da.stacks i = if i = 0 then vectorDepth else [] := by
change (embedState tupleRegisters tableStacks a tb).stacks (dimensionStacks i) = _
rw [table_frame _ _ _ (by simp [dimensionStacks])]
fin_cases i <;> simp [a,inputState,dimensionStacks]
obtain ⟨db,hdb,hdt⟩ := DimensionProgram.program_runsIn_quadratic vectorDepth da
(by simpa using hds 0) (by simpa using hds 1) (by simpa using hds 2)
(by simpa using hds 3) (by simpa using hds 4)
let c := embedState dimensionRegisters dimensionStacks b db
obtain ⟨nd,hnd,hed⟩ := lifted_call DimensionProgram.program dimensionRegisters dimensionStacks
dimensionRegisters_injective dimensionStacks_injective b db _ hdt
let ca := restrictState tupleRegisters coefficientStacks c
have hcs (i : Fin 9) : ca.stacks i =
if i = 1 then ProgramEncoding.encodeRecords alphabet else if i = 8 then vectorDepth else [] := by
change (embedState dimensionRegisters dimensionStacks b db).stacks (coefficientStacks i) = _
rw [dimension_frame _ _ _ (by fin_cases i <;> decide)]
fin_cases i
· change b.stacks 14 = []
rw [table_frame _ _ _ (by decide)]
simp [a,inputState]
· change (embedState tupleRegisters tableStacks a tb).stacks (tableStacks 1) = _
rw [embedState_stack _ _ _ _ tableStacks_injective]
simpa using htb.1.1
all_goals
norm_num [coefficientStacks]
rw [table_frame _ _ _ (by decide)]
simp [a,inputState]
obtain ⟨cb,hcb,hct⟩ := TupleProgram.generateProgram_runsIn alphabet vectorDepth (ca.regs 9) ca
(by simp [TupleProgram.outerInvariant,hcs]) (by simpa using hcs 0)
(by simpa using hcs 2) (by simpa using hcs 5)
let d := embedState tupleRegisters coefficientStacks c cb
obtain ⟨nc,hnc,hec⟩ := lifted_call TupleProgram.generateProgram tupleRegisters coefficientStacks
tupleRegisters_injective coefficientStacks_injective c cb _ hct
refine ⟨d,?_,nt+(nd+nc)+1,?_,StructuredCalls.compiled_halt_trace (het.seq (hed.seq hec)) 1 0⟩
· refine ⟨?_,?_,?_,?_,?_⟩
· change (embedState tupleRegisters coefficientStacks c cb).stacks 0 = _
rw [coefficient_frame _ _ _ (by decide) (by decide),
dimension_frame _ _ _ (by decide)]
change (embedState tupleRegisters tableStacks a tb).stacks (tableStacks 0) = _
rw [embedState_stack _ _ _ _ tableStacks_injective]
exact htb.2.1
· change (embedState tupleRegisters coefficientStacks c cb).stacks (coefficientStacks 1) = _
rw [embedState_stack _ _ _ _ coefficientStacks_injective]
exact hcb.1.1
· change (embedState tupleRegisters coefficientStacks c cb).stacks 12 = _
rw [coefficient_frame _ _ _ (by decide) (by decide)]
change (embedState dimensionRegisters dimensionStacks b db).stacks (dimensionStacks 3) = _
rw [embedState_stack _ _ _ _ dimensionStacks_injective]
exact hdb.2.2.2.1
· change (embedState tupleRegisters coefficientStacks c cb).stacks (coefficientStacks 0) = _
rw [embedState_stack _ _ _ _ coefficientStacks_injective]
exact hcb.2.1
· change (embedState tupleRegisters coefficientStacks c cb).stacks 10 = _
rw [coefficient_frame _ _ _ (by decide) (by decide)]
change (embedState dimensionRegisters dimensionStacks b db).stacks (dimensionStacks 1) = _
rw [embedState_stack _ _ _ _ dimensionStacks_injective]
exact hdb.2.1
· dsimp [cost]
omega
theorem program_primitive_runsIn (alphabet : Records) (tableDepth vectorDepth : List Bool)
(regs : Fin 15 → Bool) :
∃ next, Prepared alphabet tableDepth vectorDepth next ∧
Computation.RunsIn (BitProgram.primitive program).step
(BitProgram.primitiveOverhead program * cost alphabet tableDepth vectorDepth)
(BitProgram.primitiveCfg program
((inputState alphabet tableDepth vectorDepth regs).withPC (some program.entry)))
(BitProgram.primitiveCfg program (next.withPC none)) := by
obtain ⟨next,hp,hr⟩ := program_runsIn alphabet tableDepth vectorDepth regs
exact ⟨next,hp,BitProgram.primitive_execution program hr⟩
end SubexponentialSAT.Subexp.BlockSearchPreparation
end OAI.Algorithms
|