File size: 11,241 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 243 244 | import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.SubexpVertexPairProgram
import OAI.Algorithms.SubexponentialSAT.Subexp.AssignmentInputState
import OAI.Algorithms.SubexponentialSAT.Subexp.SequentialProgram
namespace OAI.Algorithms
/-!
# Physical raw-pair input for assignment setup
The actual all-vertex pair producer runs in a fixed private bank. Two stack
transfers place its bytes, in their original order, on assignment input 45.
The scope source and private bank are then cleared by actual instructions.
-/
namespace SubexponentialSAT.Subexp.AssignmentPairFrontend
open BitProgram StructuredCalls
abbrev Data := State 16 48
abbrev Code := Cmd 16 48
abbrev unary (n : ℕ) := List.replicate n true
def registers : Fin 13 → Fin 16 := Fin.castAdd 3
def ports : Fin 25 → Fin 48 :=
![0,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,6,4,3,35,36,37,38,39,40]
theorem registers_injective : Function.Injective registers := Fin.castAdd_injective 13 3
theorem ports_injective : Function.Injective ports := by decide
def inputState (regs : Fin 16 → Bool) (r Q Δ D : ℕ) (scopes : List (List ℕ)) : Data :=
⟨regs, fun j => if j = 1 then unary r else if j = 2 then unary Q
else if j = 3 then unary Δ else if j = 4 then unary D
else if j = 5 then unary scopes.length else if j = 6 then
SubexpPlanAlphabetBase.scopeBytes scopes else []⟩
def pairBytes (D Δ : ℕ) (scopes : List (List ℕ)) : List Bool :=
ProgramEncoding.encodeRecords (SubexpVertexPairProgram.pairRows D Δ scopes)
def pairs : Code := .call
(ProgramLinking.liftProgram SubexpVertexPairProgram.program registers ports)
def move : Code := .seq
(.call (StackRoutines.transferProgram (0 : Fin 48) 7 (0 : Fin 16) 1))
(.call (StackRoutines.transferProgram (7 : Fin 48) 45 (0 : Fin 16) 1))
def moved (d : Data) : Data :=
⟨readRegs (readRegs d.regs 0 1 none) 0 1 none,
Function.update (Function.update (Function.update d.stacks 0 []) 7 []) 45 (d.stacks 0)⟩
def clearPorts : List (Fin 48) :=
[6,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40]
theorem clearPorts_length : clearPorts.length = 22 := rfl
theorem mem_clearPorts (j : Fin 48) :
j ∈ clearPorts ↔ j = 6 ∨ (20 ≤ j.val ∧ j.val ≤ 40) := by
fin_cases j <;> decide
def cleanup : Code := SequentialProgram.clearList clearPorts
def command : Code := .seq pairs (.seq move cleanup)
def program := compiled command 6 45
def Frame (a b : Data) : Prop :=
∀ j, j ≠ 0 → j ≠ 3 → j ≠ 4 → j ≠ 6 →
(j.val < 20 ∨ 40 < j.val) → b.stacks j = a.stacks j
theorem pairs_eval (regs : Fin 16 → Bool) (r Q Δ D : ℕ)
(scopes : List (List ℕ))
(hd : ∀ v : Fin D, IncidencePlanSpec.degree scopes v.val ≤ Δ) :
∃ n b, n ≤ SubexpVertexPairProgram.bound D Δ scopes + 1 ∧
Eval pairs n (inputState regs r Q Δ D scopes) b ∧
b.stacks 0 = pairBytes D Δ scopes ∧
b.stacks 3 = unary Δ ∧ b.stacks 4 = unary D ∧
Frame (inputState regs r Q Δ D scopes) b := by
obtain ⟨n, e, hn, ht, h0, _, hmasters⟩ :=
SubexpVertexPairProgram.program_trace_framed (regs ∘ registers) D Δ scopes hd
let a := inputState regs r Q Δ D scopes
let b := embedState registers ports a e
have ha : embedState registers ports a
(SubexpPlanAlphabetBase.data (regs ∘ registers) D Δ scopes [] [] [] []) = a := by
apply embedState_eq_of_ports _ _ _ _ _ registers_injective ports_injective
· intro i; rfl
· intro i hi; rfl
· intro i
fin_cases i <;> simp [a, inputState, ports, SubexpPlanAlphabetBase.data]
· intro i hi; rfl
have he := eval_call_lifted SubexpVertexPairProgram.program registers ports a
registers_injective ports_injective ht
rw [ha] at he
refine ⟨n, b, hn, he, ?_, ?_, ?_, ?_⟩
· exact (embedState_stack registers ports a e ports_injective 0).trans h0
· exact (embedState_stack registers ports a e ports_injective 18).trans hmasters.2.2
· exact (embedState_stack registers ports a e ports_injective 17).trans hmasters.2.1
· intro j h0j h3j h4j h6j hj
apply embedState_stack_frame
rintro ⟨i, hi⟩
subst j
fin_cases i <;> first
| exact h0j rfl
| exact h3j rfl
| exact h4j rfl
| exact h6j rfl
| exact absurd hj (by decide)
theorem move_eval (d : Data) (h7 : d.stacks 7 = []) (h45 : d.stacks 45 = []) :
Eval move (6 * (d.stacks 0).length + 6) d (moved d) := by
let a : Data := ⟨readRegs d.regs 0 1 none, StackRoutines.transferStacks 0 7 d.stacks⟩
have h1 := TupleProgram.transfer_eval (0 : Fin 48) 7 (0 : Fin 16) 1
(by decide) (by decide) d
have h2 := TupleProgram.transfer_eval (7 : Fin 48) 45 (0 : Fin 16) 1
(by decide) (by decide) a
have he : (⟨readRegs a.regs 0 1 none,
StackRoutines.transferStacks 7 45 a.stacks⟩ : Data) = moved d := by
apply congrArg₂ StructuredProgram.State.mk
· rfl
· funext j
by_cases h0j : j = 0
· subst j; simp [a, StackRoutines.transferStacks]
by_cases h7j : j = 7
· subst j; simp [a, StackRoutines.transferStacks]
by_cases h45j : j = 45
· subst j; simp [a, StackRoutines.transferStacks, h7, h45]
· simp [a, StackRoutines.transferStacks, h0j, h7j, h45j]
rw [he] at h2
convert h1.seq h2 using 1 <;>
simp [move, a, StackRoutines.transferStacks, h7] ; omega
def sourceBudget (D Δ : ℕ) (scopes : List (List ℕ)) : ℕ :=
60 * (SubexpVertexPairProgram.bound D Δ scopes +
(SubexpPlanAlphabetBase.scopeBytes scopes).length + 4)
theorem command_eval (regs : Fin 16 → Bool) (r Q Δ D : ℕ)
(scopes : List (List ℕ))
(hd : ∀ v : Fin D, IncidencePlanSpec.degree scopes v.val ≤ Δ) :
∃ n rf, n + 1 ≤ sourceBudget D Δ scopes ∧
Eval command n (inputState regs r Q Δ D scopes)
(AssignmentInputProgram.inputState rf r Q Δ D scopes.length (pairBytes D Δ scopes)) := by
obtain ⟨n, b, hn, hb, h0, h3, h4, hf⟩ := pairs_eval regs r Q Δ D scopes hd
dsimp only [Frame] at hf
have h7 : b.stacks 7 = [] := by
simpa [inputState] using hf 7 (by decide) (by decide) (by decide) (by decide) (by decide)
have h45 : b.stacks 45 = [] := by
simpa [inputState] using hf 45 (by decide) (by decide) (by decide) (by decide) (by decide)
have hg (j : Fin 48) : (b.stacks j).length ≤
((inputState regs r Q Δ D scopes).stacks j).length + n + 1 := by
have h := SequentialProgram.trace_stack_length_le (compiled_halt_trace hb 6 0) j
simpa [StructuredProgram.State.withPC, Nat.add_assoc] using h
have hlen : (b.stacks 0).length ≤ n + 1 := by simpa [inputState] using hg 0
have hclean : ∀ j ∈ clearPorts, ((moved b).stacks j).length ≤
(SubexpPlanAlphabetBase.scopeBytes scopes).length + n + 1 := by
intro j hj
have hj' := (mem_clearPorts j).mp hj
have hj0 : j ≠ 0 := by intro h; subst j; exact absurd hj' (by decide)
have hj7 : j ≠ 7 := by intro h; subst j; exact absurd hj' (by decide)
have hj45 : j ≠ 45 := by intro h; subst j; exact absurd hj' (by decide)
have hs : ((inputState regs r Q Δ D scopes).stacks j).length ≤
(SubexpPlanAlphabetBase.scopeBytes scopes).length := by
rcases hj' with h6 | hj'
· subst j; simp [inputState]
· have h1 : j ≠ 1 := by intro h; subst j; exact absurd hj' (by decide)
have h2 : j ≠ 2 := by intro h; subst j; exact absurd hj' (by decide)
have h3 : j ≠ 3 := by intro h; subst j; exact absurd hj' (by decide)
have h4 : j ≠ 4 := by intro h; subst j; exact absurd hj' (by decide)
have h5 : j ≠ 5 := by intro h; subst j; exact absurd hj' (by decide)
have h6 : j ≠ 6 := by intro h; subst j; exact absurd hj' (by decide)
simp [inputState, h1, h2, h3, h4, h5, h6]
have hh := hg j
simp only [moved, Function.update_of_ne hj45, Function.update_of_ne hj7,
Function.update_of_ne hj0]
omega
obtain ⟨m, hm, e, he, hs⟩ := SequentialProgram.clearList_eval clearPorts (moved b)
((SubexpPlanAlphabetBase.scopeBytes scopes).length + n + 1) hclean
have hout : e = AssignmentInputProgram.inputState e.regs r Q Δ D scopes.length
(pairBytes D Δ scopes) := by
apply congrArg₂ StructuredProgram.State.mk
· rfl
· funext j
rw [hs j]
by_cases hj : j ∈ clearPorts
· simp only [hj, ite_true]
fin_cases j <;> first
| exact absurd hj (by decide)
| simp []
· simp only [hj, ite_false]
by_cases hj0 : j = 0
· subst j; simp [moved]
by_cases hj7 : j = 7
· subst j; simp [moved]
by_cases hj45 : j = 45
· subst j; simp [moved, h0]
by_cases hj3 : j = 3
· subst j; simp [moved, h3]
by_cases hj4 : j = 4
· subst j; simp [moved, h4]
have hj6 : j ≠ 6 := by intro h; subst j; simp [mem_clearPorts] at hj
have hrange : j.val < 20 ∨ 40 < j.val := by
have h : ¬(j = 6 ∨ (20 ≤ j.val ∧ j.val ≤ 40)) :=
fun h => hj ((mem_clearPorts j).mpr h)
omega
simp only [moved, Function.update_of_ne hj45, Function.update_of_ne hj7,
Function.update_of_ne hj0]
rw [hf j hj0 hj3 hj4 hj6 hrange]
simp [inputState, hj6, hj45]
rw [hout] at he
refine ⟨n + (6 * (b.stacks 0).length + 6 + m), e.regs, ?_, hb.seq ((move_eval b h7 h45).seq he)⟩
rw [clearPorts_length] at hm
unfold sourceBudget
omega
theorem program_run (regs : Fin 16 → Bool) (r Q Δ D : ℕ)
(scopes : List (List ℕ))
(hd : ∀ v : Fin D, IncidencePlanSpec.degree scopes v.val ≤ Δ) :
∃ rf, RunsIn program (sourceBudget D Δ scopes)
((inputState regs r Q Δ D scopes).withPC (some program.entry))
((AssignmentInputProgram.inputState rf r Q Δ D scopes.length
(pairBytes D Δ scopes)).withPC none) := by
obtain ⟨n, rf, hn, he⟩ := command_eval regs r Q Δ D scopes hd
exact ⟨rf, n + 1, hn, compiled_halt_trace he 6 45⟩
theorem primitive_run (regs : Fin 16 → Bool) (r Q Δ D : ℕ)
(scopes : List (List ℕ))
(hd : ∀ v : Fin D, IncidencePlanSpec.degree scopes v.val ≤ Δ) :
∃ rf, Computation.RunsIn (BitProgram.primitive program).step
(BitProgram.primitiveOverhead program * sourceBudget D Δ scopes)
(BitProgram.primitiveCfg program
((inputState regs r Q Δ D scopes).withPC (some program.entry)))
(BitProgram.primitiveCfg program
((AssignmentInputProgram.inputState rf r Q Δ D scopes.length
(pairBytes D Δ scopes)).withPC none)) := by
obtain ⟨rf, ht⟩ := program_run regs r Q Δ D scopes hd
exact ⟨rf, BitProgram.primitive_execution program ht⟩
theorem pairBytes_representation (D Δ : ℕ) (scopes : List (List ℕ)) :
∃ rawPlans : List PairScoreProgram.PlanPair,
pairBytes D Δ scopes = PairScoreProgram.pairRecords rawPlans ∧
rawPlans.Perm (SubexpVertexPairProgram.canonicalPairs D Δ scopes) := by
obtain ⟨rawPlans, he, hp⟩ := SubexpVertexPairProgram.rawPlans_exists D Δ scopes
exact ⟨rawPlans, congrArg ProgramEncoding.encodeRecords he, hp⟩
end SubexponentialSAT.Subexp.AssignmentPairFrontend
end OAI.Algorithms
|