math / data /lean /OAI /Algorithms /SubexponentialSAT /SqrtLogSpace /DisjointReuse /SparseDFSResource.lean
Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseDFSResource.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 27.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseDFSResource.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseDFSResource.lean
-
curl -L -o SparseDFSResource.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseDFSResource.lean
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 | |