introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
27.9 kB
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseDFSProgram
import OAI.Algorithms.SubexponentialSAT.ProgramLogic
/-! Resource bounds for the actual outer DFS commands.
Cleanup is structurally nonallocating. The bounds below concern the concrete
finite tables and every source prefix, before applying the guarded primitive
compiler. The selector and leaf contracts still require their own executions.
-/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseDFSResource
open BitProgram StructuredCalls SparseDFSProgram
private theorem stackBits_single_le {S : ℕ} (words : Fin S → List Bool) (i : Fin S) :
(words i).length ≤ stackBits words :=
Finset.single_le_sum (fun j _ => Nat.zero_le ((words j).length)) (Finset.mem_univ i)
private theorem lifted_call_space {r s l steps localBound frameBound : ℕ}
(routine : Program r s l) (register : Fin r ↪ Fin 80) (stack : Fin s ↪ Fin 1220)
(frame : Data) {a b : State r s}
(htrace : Trace routine steps (a.withPC (some routine.entry)) (b.withPC none))
(hlocal : ∀ prefixSteps c, prefixSteps ≤ steps →
Trace routine prefixSteps (a.withPC (some routine.entry)) c →
∀ i, (c.stacks i).length ≤ localBound)
(hframe : ∀ i, (frame.stacks i).length ≤ frameBound) :
∀ prefixSteps c, prefixSteps ≤ steps →
Trace (compiled (.call (ProgramLinking.liftProgram routine register stack)) 256 256)
prefixSteps ((embedState register stack frame a).withPC
(some (compiled (.call (ProgramLinking.liftProgram routine register stack)) 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ max localBound frameBound := by
have hsource := StructuredSpace.liftProgram_stack_bound routine register stack
(frame.withPC none) register.injective stack.injective htrace hlocal hframe
have he := eval_call_lifted routine register stack frame register.injective stack.injective htrace
cases he with
| call p ht =>
apply StructuredSpace.call_stack_bound (ProgramLinking.liftProgram routine register stack)
(compiled (.call (ProgramLinking.liftProgram routine register stack)) 256 256)
(siteAddress (.call (ProgramLinking.liftProgram routine register stack)))
(exitAddress (.call (ProgramLinking.liftProgram routine register stack)))
(compiled_site (.call (ProgramLinking.liftProgram routine register stack)) 256 256) ht
simpa only [ProgramLinking.embedCfg, ProgramLinking.relocatePc, embedState,
StructuredProgram.State.withPC, id_eq] using hsource
theorem clearPort_space (port : Fin 1220) {steps bound : ℕ} {a b : Data}
(he : Eval (clearPort port) steps a b)
(hstart : ∀ i, (a.stacks i).length ≤ bound) :
∀ prefixSteps c, prefixSteps ≤ steps →
Trace (compiled (clearPort port) 256 256) prefixSteps
(a.withPC (some (compiled (clearPort port) 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ bound := by
cases he with
| call p htrace =>
apply StructuredSpace.call_stack_bound (StackRoutines.clearProgram port 0 1)
(compiled (clearPort port) 256 256) (siteAddress (clearPort port))
(exitAddress (clearPort port)) (compiled_site (clearPort port) 256 256) htrace
intro prefixSteps c _ hc i
exact (SparseDFSBoundarySpace.clearProgram_stack_length_le port 0 1 hc i).trans
(hstart i)
/-- Sequential clearing keeps the same bound, including during every pop
and return jump. The finite list length never multiplies the space bound. -/
theorem clearPorts_space (ports : List (Fin 1220)) {steps bound : ℕ} {a b : Data}
(he : Eval (clearPorts ports) steps a b)
(hstart : ∀ i, (a.stacks i).length ≤ bound) :
∀ prefixSteps c, prefixSteps ≤ steps →
Trace (compiled (clearPorts ports) 256 256) prefixSteps
(a.withPC (some (compiled (clearPorts ports) 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ bound := by
induction ports generalizing steps a b with
| nil =>
cases he with
| base h =>
cases h with
| skip =>
intro prefixSteps c hp hc
have hz : prefixSteps = 0 := by omega
subst prefixSteps
cases hc
exact hstart
| cons port rest ih =>
cases he with
| seq first second =>
have hfirst := clearPort_space port first hstart
have hmiddle := hfirst _ _ le_rfl (compiled_trace first 256 256)
exact StructuredSpace.sequence_stack_bound first second 256 256 hfirst
(ih second hmiddle) (compiled (clearPorts (port :: rest)) 256 256)
(siteAddress (clearPorts (port :: rest)))
(exitAddress (clearPorts (port :: rest))) (compiled_site (clearPorts (port :: rest)) 256 256)
theorem testPending_space (a : Data) (bound : ℕ)
(hstart : ∀ i, (a.stacks i).length ≤ bound) :
∀ prefixSteps c, prefixSteps ≤ 1 →
Trace (compiled testPending 256 256) prefixSteps
(a.withPC (some (compiled testPending 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ bound := by
intro prefixSteps c hp hc
have hcases : prefixSteps = 0 ∨ prefixSteps = 1 := by omega
rcases hcases with rfl | rfl
· cases hc
exact hstart
· rw [trace_same_length_unique hc (compiled_trace (testPending_eval a) 256 256)]
exact hstart
/-- A complete visit cleanup clears the current formula and all 256 DFS
workspace stacks, preserves the other high words, and restores the loop flag
by reading the real frontier. Every intermediate stack remains bounded. -/
theorem finishVisit_execution_space (a : Data) (bound : ℕ)
(hstart : ∀ i, (a.stacks i).length ≤ bound) :
∃ t ≤ (2 * bound + 3) * 257 + 1, ∃ e,
Eval finishVisit t a e ∧
(∀ i, i.val < 256 → e.stacks i = []) ∧ e.stacks 265 = [] ∧
(∀ i, 256 ≤ i.val → i ≠ 265 → e.stacks i = a.stacks i) ∧
e.regs 2 = (a.stacks 257).head?.getD false ∧
∀ prefixSteps c, prefixSteps ≤ t →
Trace (compiled finishVisit 256 256) prefixSteps
(a.withPC (some (compiled finishVisit 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ bound := by
let cleared : Data :=
⟨readRegs a.regs 0 1 none, StackRoutines.clearStacks 265 a.stacks⟩
have hclear : Eval (clearPort 265) (2 * (a.stacks 265).length + 3) a cleared :=
clearPort_eval 265 a
have hclear_space := clearPort_space 265 hclear hstart
have hcleared : ∀ i, (cleared.stacks i).length ≤ bound :=
hclear_space _ _ le_rfl (compiled_trace hclear 256 256)
obtain ⟨lowTime, htime, afterLow, hlow, hempty, hframe, hlowBound⟩ :=
clearLow_eval cleared bound hcleared
let final : Data := ⟨readRegs afterLow.regs 2 1 (afterLow.stacks 257).head?, afterLow.stacks⟩
have htest : Eval testPending 1 afterLow final := testPending_eval afterLow
have hlow_space : ∀ prefixSteps c, prefixSteps ≤ lowTime →
Trace (compiled clearLow 256 256) prefixSteps
(cleared.withPC (some (compiled clearLow 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ bound := by
simpa only [clearLow] using clearPorts_space lowPorts hlow hcleared
have htest_space : ∀ prefixSteps c, prefixSteps ≤ 1 →
Trace (compiled testPending 256 256) prefixSteps
(afterLow.withPC (some (compiled testPending 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ bound :=
testPending_space afterLow bound hlowBound
have htail_space := StructuredSpace.sequence_stack_bound
(first := clearLow) (second := testPending) (n := lowTime) (m := 1)
(bound := bound) (a := cleared) (b := afterLow) (c := final)
hlow htest 256 256
hlow_space htest_space
(compiled (.seq clearLow testPending) 256 256)
(siteAddress (.seq clearLow testPending)) (exitAddress (.seq clearLow testPending))
(compiled_site (.seq clearLow testPending) 256 256)
have hfinish_space : ∀ prefixSteps c,
prefixSteps ≤ 2 * (a.stacks 265).length + 3 + (lowTime + 1) →
Trace (compiled finishVisit 256 256) prefixSteps
(a.withPC (some (compiled finishVisit 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ bound := by
exact StructuredSpace.sequence_stack_bound hclear (hlow.seq htest) 256 256
hclear_space htail_space (compiled finishVisit 256 256)
(siteAddress finishVisit) (exitAddress finishVisit)
(compiled_site finishVisit 256 256)
refine ⟨2 * (a.stacks 265).length + 3 + (lowTime + 1), ?_, final,
hclear.seq (hlow.seq htest), hempty, ?_, ?_, ?_, ?_⟩
· have h := hstart 265
omega
· change afterLow.stacks 265 = []
rw [hframe 265 (by decide)]
simp [cleared, StackRoutines.clearStacks]
· intro i hi hne
change afterLow.stacks i = a.stacks i
rw [hframe i hi]
simp [cleared, StackRoutines.clearStacks, hne]
· have hpending : afterLow.stacks 257 = a.stacks 257 := by
rw [hframe 257 (by decide)]
simp [cleared, StackRoutines.clearStacks]
simp [final, readRegs, hpending]
· exact hfinish_space
/-- The concrete disjoint splitter and child insertion share one uniform
bound. Both child records, the pending list and every caller stack are counted;
no number of previously visited branches occurs in this bound. -/
theorem branch_execution_space (frame : Data) (regs : Fin 15 → Bool)
(pending header : List Bool) (F S : List (List ℕ)) (H : List ℕ)
(frameBound : ℕ) (hframe : ∀ i, (frame.stacks i).length ≤ frameBound) :
∃ t ≤ 621000 * (ExecCoreChildProgram.inputVolume F S H) ^ 2, ∃ e,
Eval branch t (embedState (registers 15 (by decide)) splitterStack frame
(DisjointBranchProgram.inputState regs pending header F S H)) e ∧
∀ prefixSteps c, prefixSteps ≤ t →
Trace (compiled branch 256 256) prefixSteps
((embedState (registers 15 (by decide)) splitterStack frame
(DisjointBranchProgram.inputState regs pending header F S H)).withPC
(some (compiled branch 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ max frameBound
(pending.length + header.length + 620001 * (ExecCoreChildProgram.inputVolume F S H) ^ 2) := by
let V := ExecCoreChildProgram.inputVolume F S H
let bound := max frameBound (pending.length + header.length + 620001 * V ^ 2)
let left := ExecCoreChildProgram.formulaCode (ExecCoreChildProgram.result F S H)
let right := ExecCoreChildProgram.formulaCode
(DisjointBranchProgram.resultB SubexpFrontend.negateCode F S H)
let middle := embedState (registers 15 (by decide)) splitterStack frame
(DisjointBranchProgram.outputState pending header F S H)
have hv : 0 < V := by dsimp [V, ExecCoreChildProgram.inputVolume]; omega
have hleft : left.length ≤ V := by
have h := ExecCoreChildProgram.result_length_le F S H
dsimp [left, V, ExecCoreChildProgram.inputVolume]
omega
have hright : right.length ≤ 5 * V := DisjointBranchProgram.resultB_length_le F S H
obtain ⟨splitTime, htime, hsplitTrace⟩ := DisjointBranchProgram.program_runsIn regs pending header F S H
have hsplit : Eval splitCurrent splitTime
(embedState (registers 15 (by decide)) splitterStack frame
(DisjointBranchProgram.inputState regs pending header F S H)) middle :=
eval_call_lifted DisjointBranchProgram.program (registers 15 (by decide)) splitterStack
frame (registers 15 (by decide)).injective splitterStack.injective hsplitTrace
have hsplitLocal : ∀ t c, t ≤ splitTime →
Trace DisjointBranchProgram.program t
((DisjointBranchProgram.inputState regs pending header F S H).withPC
(some DisjointBranchProgram.program.entry)) c → ∀ i, (c.stacks i).length ≤ bound := by
intro t c ht hc i
have hb := DisjointBranchProgram.prefix_dataBits_le regs pending header F S H (ht.trans htime) hc
have hi : (c.stacks i).length ≤ dataBits c :=
stackBits_single_le c.stacks i
exact (hi.trans hb).trans (Nat.le_max_right _ _)
have hsplitSpace := lifted_call_space (frameBound := bound) DisjointBranchProgram.program (registers 15 (by decide))
splitterStack frame hsplitTrace hsplitLocal
(fun i => (hframe i).trans (Nat.le_max_left frameBound _))
simp only [max_self] at hsplitSpace
have hmiddle : ∀ i, (middle.stacks i).length ≤ bound :=
hsplitSpace splitTime _ le_rfl (compiled_trace hsplit 256 256)
have hpairTrace := SparseFrontierProgram.pushPair_trace left right header pending
false false false false
have hpairLocal : ∀ t c, t ≤ 13 * right.length + 13 * left.length + 37 →
Trace SparseFrontierProgram.pushPairProgram t
((ExecWorklistProgram.data false false false false pending header
(ExecWorklistProgram.record left) (ExecWorklistProgram.record right)).withPC
(some SparseFrontierProgram.pushPairProgram.entry)) c →
∀ i, (c.stacks i).length ≤ bound := by
intro t c ht hc i
have hb := SparseFrontierProgram.pushPair_prefix_space left right header pending
false false false false t c ht hc
have hi : (c.stacks i).length ≤ dataBits c :=
stackBits_single_le c.stacks i
have hsmall : pending.length + header.length + 15 * (left.length + right.length) + 41 ≤
pending.length + header.length + 620001 * V ^ 2 := by nlinarith
exact ((hi.trans hb).trans hsmall).trans (Nat.le_max_right _ _)
have hpairSpace := lifted_call_space SparseFrontierProgram.pushPairProgram
(registers 4 (by decide)) pairStack middle hpairTrace hpairLocal hmiddle
have hproject := splitter_pair_projection frame pending header F S H
change projectState (registers 4 (by decide)) pairStack middle =
ExecWorklistProgram.data false false false false pending header
(ExecWorklistProgram.record left) (ExecWorklistProgram.record right) at hproject
rw [← hproject] at hpairTrace hpairSpace
simp only [embedState_project _ _ _ (registers 4 (by decide)).injective pairStack.injective,
max_self] at hpairSpace
have hpair := eval_call_from_state SparseFrontierProgram.pushPairProgram
(registers 4 (by decide)) pairStack middle (registers 4 (by decide)).injective
pairStack.injective hpairTrace
refine ⟨splitTime + (13 * right.length + 13 * left.length + 37), ?_, _, hsplit.seq hpair, ?_⟩
· change splitTime ≤ 620000 * V ^ 2 at htime
change splitTime + (13 * right.length + 13 * left.length + 37) ≤ 621000 * V ^ 2
nlinarith
· exact StructuredSpace.sequence_stack_bound hsplit hpair 256 256 hsplitSpace hpairSpace
(compiled branch 256 256) (siteAddress branch) (exitAddress branch) (compiled_site branch 256 256)
/-- Frontier initialization moves the actual current formula into its escaped
record and retains the saved declared-variable word and every caller stack. -/
theorem startFrontier_execution_space (frame : Data) (bodyWord saved : List Bool)
(v p flag : Bool) (frameBound : ℕ)
(hframe : ∀ i, (frame.stacks i).length ≤ frameBound) :
Eval startFrontier (8 * bodyWord.length + 13)
(embedState (registers 3 (by decide)) frontierStack frame
(SparseFrontierProgram.state v p flag bodyWord saved [] []))
(embedState (registers 3 (by decide)) frontierStack frame
(SparseFrontierProgram.state true false flag [] saved
(Encoding.encodeList id [bodyWord]) [])) ∧
∀ prefixSteps c, prefixSteps ≤ 8 * bodyWord.length + 13 →
Trace (compiled startFrontier 256 256) prefixSteps
((embedState (registers 3 (by decide)) frontierStack frame
(SparseFrontierProgram.state v p flag bodyWord saved [] [])).withPC
(some (compiled startFrontier 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ max (saved.length + 9 * bodyWord.length + 13) frameBound := by
have htrace := SparseFrontierProgram.initFrontier_trace bodyWord saved v p flag
refine ⟨eval_call_lifted SparseFrontierProgram.initFrontierProgram
(registers 3 (by decide)) frontierStack frame (registers 3 (by decide)).injective
frontierStack.injective htrace, ?_⟩
apply lifted_call_space SparseFrontierProgram.initFrontierProgram
(registers 3 (by decide)) frontierStack frame htrace _ hframe
intro t c ht hc i
exact (stackBits_single_le c.stacks i).trans
(SparseFrontierProgram.initFrontier_prefix_space bodyWord saved v p flag t c ht hc)
/-- A real nonempty frontier pop decodes only its head record. All 1220 root
stacks are included, and no earlier traversal time appears in the bound. -/
theorem popCurrent_execution_space (frame : Data) (bodyWord saved pending : List Bool)
(v p flag : Bool) (frameBound : ℕ)
(hframe : ∀ i, (frame.stacks i).length ≤ frameBound) :
Eval popCurrent (9 * bodyWord.length + 11)
(embedState (registers 3 (by decide)) frontierStack frame
(SparseFrontierProgram.state v p flag [] saved
(true :: (Encoding.frame bodyWord ++ pending)) []))
(embedState (registers 3 (by decide)) frontierStack frame
(SparseFrontierProgram.state false false true bodyWord saved pending [])) ∧
∀ prefixSteps c, prefixSteps ≤ 9 * bodyWord.length + 11 →
Trace (compiled popCurrent 256 256) prefixSteps
((embedState (registers 3 (by decide)) frontierStack frame
(SparseFrontierProgram.state v p flag [] saved
(true :: (Encoding.frame bodyWord ++ pending)) [])).withPC
(some (compiled popCurrent 256 256).entry)) c →
∀ i, (c.stacks i).length ≤
max (saved.length + pending.length + 11 * bodyWord.length + 13) frameBound := by
have htrace := SparseFrontierProgram.popIfPresent_cons_trace bodyWord saved pending v p flag
refine ⟨eval_call_lifted SparseFrontierProgram.popIfPresentProgram
(registers 3 (by decide)) frontierStack frame (registers 3 (by decide)).injective
frontierStack.injective htrace, ?_⟩
apply lifted_call_space SparseFrontierProgram.popIfPresentProgram
(registers 3 (by decide)) frontierStack frame htrace _ hframe
intro t c ht hc i
exact (stackBits_single_le c.stacks i).trans
(SparseFrontierProgram.popIfPresent_prefix_space bodyWord saved pending v p flag t c ht hc)
/-- The root accumulator uses the same concrete addition/normalization trace.
The disjoint-mass premise bounds both canonical input words; the final count
is on physical port260 and both count scratch ports are empty. -/
theorem accumulate_execution_space (frame : Data) (regs : Fin 8 → Bool)
(a b n frameBound : ℕ) (hcount : a + b ≤ 2 ^ n)
(hframe : ∀ i, (frame.stacks i).length ≤ frameBound) :
∃ t ≤ 100 * (n + 1), ∃ e,
Eval accumulate t
(embedState (registers 8 (by decide)) countStack frame
(SparseCountProgram.Accumulator.state regs (binaryNat a) (binaryNat b))) e ∧
e.stacks 260 = binaryNat (a + b) ∧ e.stacks 263 = [] ∧ e.stacks 30 = [] ∧
(∀ i, i ≠ 260 → i ≠ 263 → i ≠ 30 → e.stacks i = frame.stacks i) ∧
∀ prefixSteps c, prefixSteps ≤ t →
Trace (compiled accumulate 256 256) prefixSteps
((embedState (registers 8 (by decide)) countStack frame
(SparseCountProgram.Accumulator.state regs (binaryNat a) (binaryNat b))).withPC
(some (compiled accumulate 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ max (100 * (n + 1)) frameBound := by
obtain ⟨t, final, ht, htrace, houtput, hclear1, hclear2, hprefix⟩ :=
SparseCountProgram.Accumulator.canonical_execution regs a b n hcount
refine ⟨t, ht, embedState (registers 8 (by decide)) countStack frame final,
eval_call_lifted SparseCountProgram.Accumulator.program (registers 8 (by decide))
countStack frame (registers 8 (by decide)).injective countStack.injective htrace,
?_, ?_, ?_, ?_, ?_⟩
· exact (embedState_stack (registers 8 (by decide)) countStack frame final
countStack.injective 0).trans houtput
· exact (embedState_stack (registers 8 (by decide)) countStack frame final
countStack.injective 1).trans hclear1
· exact (embedState_stack (registers 8 (by decide)) countStack frame final
countStack.injective 2).trans hclear2
· intro i h0 h1 h2
apply embedState_stack_frame
rintro ⟨j, rfl⟩
fin_cases j
· exact h0 rfl
· exact h1 rfl
· exact h2 rfl
· apply lifted_call_space SparseCountProgram.Accumulator.program
(registers 8 (by decide)) countStack frame htrace _ hframe
intro prefixSteps c hp hc i
exact (stackBits_single_le c.stacks i).trans (hprefix prefixSteps c hp hc)
/-- Cleanup restores the smaller loop-boundary bound even when the completed
callback used a larger transient workspace. Consequently that workspace bound
is not accumulated from one DFS visit to the next. -/
theorem finishVisit_boundary_space (a : Data) (boundaryBound space : ℕ)
(hstart : ∀ i, (a.stacks i).length ≤ space)
(hhigh : ∀ i, 256 ≤ i.val → i ≠ 265 → (a.stacks i).length ≤ boundaryBound) :
∃ t ≤ (2 * space + 3) * 257 + 1, ∃ e,
Eval finishVisit t a e ∧
(∀ i, (e.stacks i).length ≤ boundaryBound) ∧
(∀ i, 256 ≤ i.val → i ≠ 265 → e.stacks i = a.stacks i) ∧
e.regs 2 = (a.stacks 257).head?.getD false ∧
∀ prefixSteps c, prefixSteps ≤ t →
Trace (compiled finishVisit 256 256) prefixSteps
(a.withPC (some (compiled finishVisit 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ space := by
obtain ⟨t, ht, e, he, hlow, hcurrent, hframe, hflag, hprefix⟩ :=
finishVisit_execution_space a space hstart
refine ⟨t, ht, e, he, ?_, hframe, hflag, hprefix⟩
intro i
by_cases hi : i.val < 256
· rw [hlow i hi]
exact Nat.zero_le _
· by_cases hcurrentPort : i = 265
· subst i
rw [hcurrent]
exact Nat.zero_le _
· have hge : 256 ≤ i.val := by omega
rw [hframe i hge hcurrentPort]
exact hhigh i hge hcurrentPort
/-- The real selector runs in the frozen root bank. Its semantic hit/miss
results and all-prefix storage bound come from the same local execution;
the final return instruction is included before relocation into the root. -/
theorem selectCurrent_execution_space {α : Type*} [DecidableEq α]
(encode : α → List Bool) (hinjective : Function.Injective encode)
(k : ℕ) (F : List (List α)) (base : List Bool)
(initialLocal : SparsePriorityProgram.Selector.Data) (frame : Data) (frameBound : ℕ)
(hlocal : SparsePriorityProgram.Selector.Boundary (F.map (List.map encode)) base initialLocal)
(hwidth : ∀ C ∈ F, C.length ≤ k)
(hframe : ∀ i, (frame.stacks i).length ≤ frameBound) :
∃ t ≤ SparsePriorityProgram.Selector.selectorCoefficient k *
SparsePriorityProgram.Selector.inputVolume (F.map (List.map encode)) base ^ 4,
∃ e : SparsePriorityProgram.Selector.Data,
Eval (selectCurrent k) (t + 1)
(embedState (registers 24 (by decide)) selectorStack frame initialLocal)
(embedState (registers 24 (by decide)) selectorStack frame e) ∧
(∀ i : Fin 24, i ≠ 9 → i ≠ 12 → e.stacks i = initialLocal.stacks i) ∧
(e.regs 23 = false → e.stacks = initialLocal.stacks ∧
∀ c H, (c, H) ∈ SparsePriorityProgram.rawCandidates k F →
0 < H.length → H.length < c →
(SparsePriorityProgram.selectedRaw F c H).length <
BinaryArithmetic.toNat base ^ (c - H.length)) ∧
(e.regs 23 = true → ∃ c H,
SparsePriorityProgram.RawPriority k F (BinaryArithmetic.toNat base) c H ∧
e.stacks 9 = SparsePriorityProgram.Filter.clauseCode (H.map encode) ∧
e.stacks 12 = SparsePriorityProgram.Filter.formulaCode
((SparsePriorityProgram.selectedRaw F c H).map (List.map encode))) ∧
∀ prefixSteps c, prefixSteps ≤ t + 1 →
Trace (compiled (selectCurrent k) 256 256) prefixSteps
((embedState (registers 24 (by decide)) selectorStack frame initialLocal).withPC
(some (compiled (selectCurrent k) 256 256).entry)) c →
∀ i, (c.stacks i).length ≤ max
((SparsePriorityProgram.Selector.selectorCoefficient k + 24) *
SparsePriorityProgram.Selector.inputVolume (F.map (List.map encode)) base ^ 4)
frameBound := by
obtain ⟨t, ht, e, he, hpreserve, hmiss, hhit, hspace⟩ :=
SparsePriorityProgram.Selector.command_execution_map encode hinjective k F base initialLocal hlocal hwidth
have htrace := compiled_halt_trace he 13 12
have hhaltSpace := StructuredSpace.compiled_halt_stack_bound he 13 12 hspace
refine ⟨t, ht, e, eval_call_lifted (SparsePriorityProgram.Selector.program k)
(registers 24 (by decide)) selectorStack frame (registers 24 (by decide)).injective
selectorStack.injective htrace, hpreserve, hmiss, hhit, ?_⟩
exact lifted_call_space (SparsePriorityProgram.Selector.program k)
(registers 24 (by decide)) selectorStack frame htrace hhaltSpace hframe
private theorem lifted_trace_stack_frame {r s l R S steps : ℕ}
(routine : Program r s l) (register : Fin r → Fin R) (stack : Fin s → Fin S)
{a b : Cfg R S l} (htrace : Trace (ProgramLinking.liftProgram routine register stack) steps a b)
(i : Fin S) (hoff : ¬ ∃ j, stack j = i) : b.stacks i = a.stacks i := by
have hne : ∀ j, i ≠ stack j := fun j he => hoff ⟨j, he.symm⟩
induction htrace with
| refl => rfl
| cons hstep _ ih =>
apply ih.trans
apply ProgramLogic.step_stack_frame (ProgramLinking.liftProgram routine register stack) i _ hstep
intro label _
change i ∉ ProgramLogic.stackWrites (ProgramLinking.relocateInstr register stack id none
(routine.code label))
cases routine.code label <;> simp [ProgramLinking.relocateInstr, ProgramLogic.stackWrites, hne]
/-- Every real branch execution preserves high words outside its fixed port
footprint. The header258 is handled separately by the splitter's exact header
readback; this structural rule covers raw input, leaf count, setup words and
all reserved high stacks for the very same branch witness. -/
theorem branch_preserves_other_high {steps : ℕ} {a b : Data}
(he : Eval branch steps a b) (i : Fin 1220) (hi : 256 ≤ i.val)
(hpending : i ≠ 257) (hheader : i ≠ 258) (hleft : i ≠ 261)
(hright : i ≠ 262) (hcurrent : i ≠ 265) : b.stacks i = a.stacks i := by
have hsplitOff : ¬ ∃ j, splitterStack j = i := by
rintro ⟨j, rfl⟩
have hrange := (by decide : ∀ q : Fin 23,
(splitterStack q).val < 256 ∨ splitterStack q = 257 ∨ splitterStack q = 258 ∨
splitterStack q = 261 ∨ splitterStack q = 262 ∨ splitterStack q = 265) j
rcases hrange with h | h | h | h | h | h
· omega
· exact hpending h
· exact hheader h
· exact hleft h
· exact hright h
· exact hcurrent h
have hpairOff : ¬ ∃ j, pairStack j = i := by
rintro ⟨j, rfl⟩
have hrange := (by decide : ∀ q : Fin 5,
(pairStack q).val < 256 ∨ pairStack q = 257 ∨ pairStack q = 258 ∨
pairStack q = 261 ∨ pairStack q = 262) j
rcases hrange with h | h | h | h | h
· omega
· exact hpending h
· exact hheader h
· exact hleft h
· exact hright h
cases he with
| seq hsplit hpair =>
cases hsplit with
| call _ hfirst =>
cases hpair with
| call _ hsecond =>
exact (lifted_trace_stack_frame SparseFrontierProgram.pushPairProgram
(registers 4 (by decide)) pairStack hsecond i hpairOff).trans
(lifted_trace_stack_frame DisjointBranchProgram.program
(registers 15 (by decide)) splitterStack hfirst i hsplitOff)
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseDFSResource