math / data /lean /OAI /Algorithms /SubexponentialSAT /SqrtLogSpace /DisjointReuse /SparseDFSProgram.lean
Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseDFSProgram.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 24.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseDFSProgram.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseDFSProgram.lean
-
curl -L -o SparseDFSProgram.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/SparseDFSProgram.lean
24.2 kB
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseDFSBoundarySpace | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparsePriorityProgram | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointSparsifyProgram | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseControllerProgram | |
| import OAI.Algorithms.SubexponentialSAT.ProgramStateFrames | |
| /-! Fixed finite control for the outer disjoint counting traversal. | |
| The leaf command is an explicit piece of finite code chosen with `k`. Its | |
| layout, reconstruction, input loading and output export are still | |
| separate obligations until the concrete leaf implementation is substituted. | |
| There is no oracle instruction or endpoint theorem in this module. | |
| -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseDFSProgram | |
| open BitProgram StructuredCalls SubexpPostfixControl | |
| abbrev Data := State 80 1220 | |
| abbrev Code := Cmd 80 1220 | |
| def registers (r : ℕ) (hr : r ≤ 80) : Fin r ↪ Fin 80 := Fin.castLEEmb hr | |
| def selectorStack : Fin 24 ↪ Fin 1220 := | |
| (Fin.castLEEmb (by decide : 24 ≤ 31)).trans SparseDFSBoundarySpace.rootEmbedding | |
| def frontierStack : Fin 4 ↪ Fin 1220 := | |
| SparseDFSBoundarySpace.popStack.trans SparseDFSBoundarySpace.rootEmbedding | |
| def pairStack : Fin 5 ↪ Fin 1220 := | |
| SparseDFSBoundarySpace.pairStack.trans SparseDFSBoundarySpace.rootEmbedding | |
| def countStack : Fin 3 ↪ Fin 1220 := | |
| SparseDFSBoundarySpace.countStack.trans SparseDFSBoundarySpace.rootEmbedding | |
| /-- The splitter keeps the threshold outside its entire local footprint. -/ | |
| def splitterView : Fin 23 ↪ Fin 31 where | |
| toFun := ![24, 25, 26, 27, 13, 9, 12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 14, 15, 16, 17, 18] | |
| inj' := by decide | |
| def splitterStack : Fin 23 ↪ Fin 1220 := | |
| splitterView.trans SparseDFSBoundarySpace.rootEmbedding | |
| def startFrontier : Code := | |
| .call (ProgramLinking.liftProgram SparseFrontierProgram.initFrontierProgram | |
| (registers 3 (by decide)) frontierStack) | |
| def popCurrent : Code := | |
| .call (ProgramLinking.liftProgram SparseFrontierProgram.popIfPresentProgram | |
| (registers 3 (by decide)) frontierStack) | |
| def selectCurrent (k : ℕ) : Code := | |
| .call (ProgramLinking.liftProgram (SparsePriorityProgram.Selector.program k) | |
| (registers 24 (by decide)) selectorStack) | |
| def splitCurrent : Code := | |
| .call (ProgramLinking.liftProgram DisjointBranchProgram.program | |
| (registers 15 (by decide)) splitterStack) | |
| def pushChildren : Code := | |
| .call (ProgramLinking.liftProgram SparseFrontierProgram.pushPairProgram | |
| (registers 4 (by decide)) pairStack) | |
| def accumulate : Code := | |
| .call (ProgramLinking.liftProgram SparseCountProgram.Accumulator.program | |
| (registers 8 (by decide)) countStack) | |
| def clearPort (port : Fin 1220) : Code := | |
| .call (StackRoutines.clearProgram port 0 1) | |
| /-- The finite list is part of the instruction table, never a stored work list. -/ | |
| def clearPorts : List (Fin 1220) → Code | |
| | [] => .base .skip | |
| | port :: rest => .seq (clearPort port) (clearPorts rest) | |
| private opaque lowPortsWrapped : | |
| {ports : List (Fin 1220) // | |
| ports = (List.finRange 256).map (Fin.castLE (by decide : 256 ≤ 1220))} := | |
| ⟨(List.finRange 256).map (Fin.castLE (by decide : 256 ≤ 1220)), rfl⟩ | |
| /-- The fixed low-workspace ports, kept opaque to avoid reducing the entire | |
| 256-element instruction table during routine typeclass and theorem checking. -/ | |
| def lowPorts : List (Fin 1220) := lowPortsWrapped.1 | |
| theorem lowPorts_eq : | |
| lowPorts = (List.finRange 256).map (Fin.castLE (by decide : 256 ≤ 1220)) := | |
| lowPortsWrapped.2 | |
| def clearLow : Code := clearPorts lowPorts | |
| /-- Every iteration re-reads the physical pending tag after all callbacks. -/ | |
| def testPending : Code := .base (.atom (.peek 257 2 1)) | |
| /-- The total stack is empty on entry and becomes canonical binary zero. -/ | |
| def startTotal : Code := | |
| .base (.seq (.atom (.set 0 false)) (.atom (.push 260 0))) | |
| def branch : Code := .seq splitCurrent pushChildren | |
| /-- Explicitly discard the current body and every low workspace port before | |
| retesting the frontier. No callback cleanup or register persistence is implicit. -/ | |
| def finishVisit : Code := | |
| .seq (clearPort 265) (.seq clearLow testPending) | |
| /-- `leaf` includes the actual charged leaf loaders, computation, result | |
| export to stack263, and cleanup. It must preserve the persistent outer frame. -/ | |
| def body (k : ℕ) (leaf : Code) : Code := | |
| .seq popCurrent | |
| (.seq (selectCurrent k) | |
| (.seq (.ite 23 branch (.seq leaf accumulate)) finishVisit)) | |
| def loop (k : ℕ) (leaf : Code) : Code := .while 2 (body k leaf) | |
| /-- Physically clear the external word and copy scratch before preserving bit | |
| order in the final canonical output. Retained raw input is charged here. -/ | |
| def exportCount : Code := | |
| .seq (clearPort 0) (.seq (clearPort 256) | |
| (.call (StackRoutines.copyProgram 260 256 0 0 1))) | |
| /-- This command starts from an already normalized current body, saved original | |
| header and chosen threshold. Preprocessing is charged in the caller. -/ | |
| def command (k : ℕ) (leaf : Code) : Code := | |
| .seq startFrontier | |
| (.seq startTotal (.seq testPending (.seq (loop k leaf) exportCount))) | |
| def program (k : ℕ) (leaf : Code) := compiled (command k leaf) 256 256 | |
| theorem testPending_eval (d : Data) : | |
| Eval testPending 1 d | |
| ⟨readRegs d.regs 2 1 (d.stacks 257).head?, d.stacks⟩ := by | |
| simpa [testPending, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr, | |
| StructuredProgram.State.withPC, StructuredProgram.State.ofCfg, execInstr] | |
| using Eval.base (StructuredProgram.Eval.atom (.peek (257 : Fin 1220) (2 : Fin 80) 1) d) | |
| theorem testPending_tag (d : Data) (tag : Bool) (tail : List Bool) | |
| (hpending : d.stacks 257 = tag :: tail) : | |
| ∃ e, Eval testPending 1 d e ∧ e.regs 2 = tag ∧ e.stacks = d.stacks := by | |
| refine ⟨_, testPending_eval d, ?_, rfl⟩ | |
| simp [hpending, readRegs] | |
| theorem startTotal_eval (d : Data) (htotal : d.stacks 260 = []) : | |
| Eval startTotal 2 d | |
| ⟨Function.update d.regs 0 false, Function.update d.stacks 260 [false]⟩ := by | |
| have h := (StructuredProgram.Eval.atom (.set (0 : Fin 80) false) d).seq | |
| (StructuredProgram.Eval.atom (.push (260 : Fin 1220) (0 : Fin 80)) _) | |
| simpa [startTotal, StructuredProgram.Atom.eval, StructuredProgram.Atom.instr, | |
| StructuredProgram.State.withPC, StructuredProgram.State.ofCfg, execInstr, htotal] | |
| using Eval.base h | |
| theorem clearPort_eval (port : Fin 1220) (d : Data) : | |
| Eval (clearPort port) (2 * (d.stacks port).length + 3) d | |
| ⟨readRegs d.regs 0 1 none, StackRoutines.clearStacks port d.stacks⟩ := | |
| Eval.call _ (ListRegisterProgram.clear_run port 0 1 d.regs d.stacks) | |
| theorem clearPorts_eval (ports : List (Fin 1220)) (d : Data) (bound : ℕ) | |
| (hbound : ∀ i, (d.stacks i).length ≤ bound) : | |
| ∃ t ≤ (2 * bound + 3) * ports.length, ∃ e, | |
| Eval (clearPorts ports) t d e ∧ | |
| (∀ i ∈ ports, e.stacks i = []) ∧ | |
| (∀ i, i ∉ ports → e.stacks i = d.stacks i) ∧ | |
| (∀ i, (e.stacks i).length ≤ bound) := by | |
| induction ports generalizing d with | |
| | nil => exact ⟨0, by simp, d, .base (.skip d), by simp, by simp, hbound⟩ | |
| | cons port rest ih => | |
| let a : Data := ⟨readRegs d.regs 0 1 none, StackRoutines.clearStacks port d.stacks⟩ | |
| have habound : ∀ i, (a.stacks i).length ≤ bound := by | |
| intro i | |
| by_cases hi : i = port | |
| · subst i | |
| simp [a, StackRoutines.clearStacks] | |
| · simpa [a, StackRoutines.clearStacks, hi] using hbound i | |
| obtain ⟨t, ht, e, he, hclear, hframe, hbe⟩ := ih a habound | |
| refine ⟨2 * (d.stacks port).length + 3 + t, ?_, e, | |
| (clearPort_eval port d).seq he, ?_, ?_, hbe⟩ | |
| · have hd := hbound port | |
| simp only [List.length_cons, Nat.mul_add, Nat.mul_one] | |
| omega | |
| · intro i hi | |
| rcases List.mem_cons.mp hi with hi | hi | |
| · subst i | |
| by_cases hp : port ∈ rest | |
| · exact hclear port hp | |
| · rw [hframe port hp] | |
| simp [a, StackRoutines.clearStacks] | |
| · exact hclear i hi | |
| · intro i hi | |
| have hir : i ∉ rest := fun hir => hi (List.mem_cons_of_mem _ hir) | |
| have hip : i ≠ port := fun heq => hi (by simp [heq]) | |
| rw [hframe i hir] | |
| simp [a, StackRoutines.clearStacks, hip] | |
| theorem mem_lowPorts (i : Fin 1220) : i ∈ lowPorts ↔ i.val < 256 := by | |
| rw [lowPorts_eq] | |
| simp only [List.mem_map, List.mem_finRange, true_and] | |
| constructor | |
| · rintro ⟨j, rfl⟩ | |
| exact j.isLt | |
| · intro hi | |
| exact ⟨⟨i.val, hi⟩, Fin.ext rfl⟩ | |
| theorem clearLow_eval (d : Data) (bound : ℕ) | |
| (hbound : ∀ i, (d.stacks i).length ≤ bound) : | |
| ∃ t ≤ (2 * bound + 3) * 256, ∃ e, | |
| Eval clearLow t d e ∧ | |
| (∀ i, i.val < 256 → e.stacks i = []) ∧ | |
| (∀ i, 256 ≤ i.val → e.stacks i = d.stacks i) ∧ | |
| (∀ i, (e.stacks i).length ≤ bound) := by | |
| obtain ⟨t, ht, e, he, hc, hf, hb⟩ := clearPorts_eval lowPorts d bound hbound | |
| refine ⟨t, by simpa [lowPorts_eq] using ht, e, he, ?_, ?_, hb⟩ | |
| · intro i hi | |
| exact hc i ((mem_lowPorts i).mpr hi) | |
| · intro i hi | |
| exact hf i (by rw [mem_lowPorts]; omega) | |
| theorem exportCount_eval (d : Data) : | |
| ∃ e, Eval exportCount | |
| (2 * (d.stacks 0).length + 2 * (d.stacks 256).length + | |
| 7 * (d.stacks 260).length + 11) d e ∧ | |
| e.stacks 256 = d.stacks 260 ∧ e.stacks 0 = [] ∧ | |
| ∀ i, i ≠ 0 → i ≠ 256 → e.stacks i = d.stacks i := by | |
| let a : Data := ⟨readRegs d.regs 0 1 none, StackRoutines.clearStacks 0 d.stacks⟩ | |
| let b : Data := ⟨readRegs a.regs 0 1 none, StackRoutines.clearStacks 256 a.stacks⟩ | |
| have h0 : b.stacks 0 = [] := by simp [b, a, StackRoutines.clearStacks] | |
| have hout : b.stacks 256 = [] := by simp [b, StackRoutines.clearStacks] | |
| have htotal : b.stacks 260 = d.stacks 260 := by | |
| simp [b, a, StackRoutines.clearStacks] | |
| have h256 : a.stacks 256 = d.stacks 256 := by simp [a, StackRoutines.clearStacks] | |
| have hcopy : Eval (.call (StackRoutines.copyProgram 260 256 0 0 1)) | |
| (7 * (b.stacks 260).length + 5) b | |
| ⟨readRegs b.regs 0 1 none, StackRoutines.copyStacks 260 256 b.stacks⟩ := | |
| Eval.call _ (ListRegisterProgram.copy_run (r := 80) (s := 1220) | |
| 260 256 0 0 1 (by decide) (by decide) (by decide) (by decide) b.regs b.stacks h0) | |
| have hrun := (clearPort_eval 0 d).seq ((clearPort_eval 256 a).seq hcopy) | |
| refine ⟨⟨readRegs b.regs 0 1 none, StackRoutines.copyStacks 260 256 b.stacks⟩, | |
| ?_, ?_, ?_, ?_⟩ | |
| · convert hrun using 1 | |
| · rfl | |
| · simp [htotal, h256] | |
| omega | |
| · simp [StackRoutines.copyStacks, hout, htotal] | |
| · simp [StackRoutines.copyStacks, h0] | |
| · intro i hi0 hi256 | |
| simp [StackRoutines.copyStacks, b, a, StackRoutines.clearStacks, hi0, hi256] | |
| /-- Output cleanup and copying use only their own linear work, never the | |
| exponentially long traversal time; every one of the 1220 stacks is counted. -/ | |
| theorem exportCount_prefix_space (d : Data) (n bound : ℕ) | |
| (hcount : (d.stacks 260).length ≤ n + 1) | |
| (hframe : ∀ i, (d.stacks i).length ≤ bound) | |
| (prefixSteps : ℕ) | |
| (c : Cfg 80 1220 (size exportCount + 1)) | |
| (ht : prefixSteps ≤ 2 * (d.stacks 0).length + 2 * (d.stacks 256).length + | |
| 7 * (d.stacks 260).length + 12) | |
| (hc : Trace (compiled exportCount 256 256) prefixSteps | |
| (d.withPC (some (compiled exportCount 256 256).entry)) c) : | |
| dataBits c ≤ 1224 * bound + 7 * n + 19 := by | |
| have hsum : stackBits d.stacks ≤ 1220 * bound := by | |
| have h := Finset.sum_le_sum (fun i (_ : i ∈ Finset.univ) => hframe i) | |
| simpa only [stackBits, Finset.sum_const, Finset.card_univ, Fintype.card_fin, | |
| smul_eq_mul] using h | |
| have h0 := hframe 0 | |
| have hout := hframe 256 | |
| have hg := trace_dataBits (compiled exportCount 256 256) hc | |
| change dataBits c ≤ stackBits d.stacks + prefixSteps at hg | |
| omega | |
| /-- Once concrete phase executions are proved, this is the exact branch trace | |
| of the already defined body; the found flag is consumed immediately. -/ | |
| theorem body_branch_eval {k : ℕ} {leaf : Code} {a b c d e : Data} | |
| {tpop tselect tbranch tfinish : ℕ} | |
| (hpop : Eval popCurrent tpop a b) | |
| (hselect : Eval (selectCurrent k) tselect b c) | |
| (hfound : c.regs 23 = true) (hbranch : Eval branch tbranch c d) | |
| (hfinish : Eval finishVisit tfinish d e) : | |
| Eval (body k leaf) (tpop + (tselect + (tbranch + 1 + tfinish))) a e := | |
| hpop.seq (hselect.seq ((Eval.ite_true hfound hbranch).seq hfinish)) | |
| theorem body_leaf_eval {k : ℕ} {leaf : Code} {a b c d e f : Data} | |
| {tpop tselect tleaf tadd tfinish : ℕ} | |
| (hpop : Eval popCurrent tpop a b) | |
| (hselect : Eval (selectCurrent k) tselect b c) | |
| (hmissing : c.regs 23 = false) (hleaf : Eval leaf tleaf c d) | |
| (hadd : Eval accumulate tadd d e) (hfinish : Eval finishVisit tfinish e f) : | |
| Eval (body k leaf) (tpop + (tselect + (tleaf + tadd + 1 + tfinish))) a f := | |
| hpop.seq (hselect.seq ((Eval.ite_false hmissing (hleaf.seq hadd)).seq hfinish)) | |
| theorem splitter_pair_projection (frame : Data) (pending header : List Bool) | |
| (F S : List (List ℕ)) (H : List ℕ) : | |
| projectState (registers 4 (by decide)) pairStack | |
| (embedState (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H)) = | |
| ExecWorklistProgram.data false false false false pending header | |
| (ExecWorklistProgram.record | |
| (ExecCoreChildProgram.formulaCode (ExecCoreChildProgram.result F S H))) | |
| (ExecWorklistProgram.record (ExecCoreChildProgram.formulaCode | |
| (DisjointBranchProgram.resultB SubexpFrontend.negateCode F S H))) := by | |
| apply congrArg₂ StructuredProgram.State.mk | |
| · funext i | |
| fin_cases i | |
| · exact embedState_register (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) | |
| (registers 15 (by decide)).injective 0 | |
| · exact embedState_register (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) | |
| (registers 15 (by decide)).injective 1 | |
| · exact embedState_register (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) | |
| (registers 15 (by decide)).injective 2 | |
| · exact embedState_register (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) | |
| (registers 15 (by decide)).injective 3 | |
| · funext i | |
| fin_cases i | |
| · exact embedState_stack (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) splitterStack.injective 0 | |
| · exact embedState_stack (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) splitterStack.injective 1 | |
| · exact embedState_stack (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) splitterStack.injective 2 | |
| · exact embedState_stack (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) splitterStack.injective 3 | |
| · exact embedState_stack (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) splitterStack.injective 7 | |
| theorem branch_execution (frame : Data) (regs : Fin 15 → Bool) | |
| (pending header : List Bool) (F S : List (List ℕ)) (H : List ℕ) : | |
| ∃ 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 ∧ | |
| e.stacks 257 = | |
| ExecWorklistProgram.record | |
| (ExecCoreChildProgram.formulaCode (ExecCoreChildProgram.result F S H)) ++ | |
| (ExecWorklistProgram.record (ExecCoreChildProgram.formulaCode | |
| (DisjointBranchProgram.resultB SubexpFrontend.negateCode F S H)) ++ pending) ∧ | |
| e.stacks 258 = header ∧ e.stacks 261 = [] ∧ e.stacks 262 = [] ∧ | |
| e.stacks 265 = [] ∧ e.stacks 259 = frame.stacks 259 ∧ | |
| e.stacks 260 = frame.stacks 260 := by | |
| 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) | |
| obtain ⟨t, ht, hs⟩ := DisjointBranchProgram.program_runsIn regs pending header F S H | |
| have hsplit : Eval splitCurrent t | |
| (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 hs | |
| have hpair := SparseFrontierProgram.pushPair_trace left right header pending | |
| false false false false | |
| rw [← splitter_pair_projection frame pending header F S H] at hpair | |
| have hp := eval_call_from_state SparseFrontierProgram.pushPairProgram | |
| (registers 4 (by decide)) pairStack middle (registers 4 (by decide)).injective | |
| pairStack.injective hpair | |
| refine ⟨t + (13 * right.length + 13 * left.length + 37), ?_, _, hsplit.seq hp, | |
| ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩ | |
| · have hl := ExecCoreChildProgram.result_length_le F S H | |
| have hr := DisjointBranchProgram.resultB_length_le F S H | |
| have hv : 0 < ExecCoreChildProgram.inputVolume F S H := by | |
| unfold ExecCoreChildProgram.inputVolume | |
| omega | |
| have hla : left.length ≤ ExecCoreChildProgram.inputVolume F S H := by | |
| dsimp [left] | |
| unfold ExecCoreChildProgram.inputVolume | |
| omega | |
| dsimp [right] at hr ⊢ | |
| nlinarith only [ht, hr, hla, hv] | |
| · exact embedState_stack (registers 4 (by decide)) pairStack middle _ pairStack.injective 0 | |
| · exact embedState_stack (registers 4 (by decide)) pairStack middle _ pairStack.injective 1 | |
| · exact embedState_stack (registers 4 (by decide)) pairStack middle _ pairStack.injective 2 | |
| · exact embedState_stack (registers 4 (by decide)) pairStack middle _ pairStack.injective 3 | |
| · rw [embedState_stack_frame (registers 4 (by decide)) pairStack middle _ 265 (by decide)] | |
| exact embedState_stack (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) splitterStack.injective 4 | |
| · rw [embedState_stack_frame (registers 4 (by decide)) pairStack middle _ 259 (by decide)] | |
| exact embedState_stack_frame (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) 259 (by decide) | |
| · rw [embedState_stack_frame (registers 4 (by decide)) pairStack middle _ 260 (by decide)] | |
| exact embedState_stack_frame (registers 15 (by decide)) splitterStack frame | |
| (DisjointBranchProgram.outputState pending header F S H) 260 (by decide) | |
| theorem splitter_input_projection (d : Data) (F S : List (List ℕ)) (H : List ℕ) | |
| (hF : d.stacks 265 = ExecCoreChildProgram.formulaCode F) | |
| (hH : d.stacks 9 = ExecCoreChildProgram.clauseCode H) | |
| (hS : d.stacks 12 = ExecCoreChildProgram.formulaCode S) | |
| (hleft : d.stacks 261 = []) (hright : d.stacks 262 = []) | |
| (hscratch : ∀ i : Fin 23, 7 ≤ i.val → d.stacks (splitterStack i) = []) : | |
| projectState (registers 15 (by decide)) splitterStack d = | |
| DisjointBranchProgram.inputState (d.regs ∘ registers 15 (by decide)) | |
| (d.stacks 257) (d.stacks 258) F S H := by | |
| apply congrArg₂ StructuredProgram.State.mk rfl | |
| funext i | |
| refine Fin.addCases (m := 7) (n := 16) (fun j => ?_) (fun j => ?_) i | |
| · fin_cases j | |
| · rfl | |
| · rfl | |
| · exact hleft | |
| · exact hright | |
| · exact hF | |
| · exact hH | |
| · exact hS | |
| · simpa [ExecBranchControllerSupport.emptyBank] using | |
| hscratch (Fin.natAdd 7 j) (by simp) | |
| theorem splitter_input_projection_of_clean (d : Data) | |
| (F S : List (List ℕ)) (H : List ℕ) | |
| (hF : d.stacks 265 = ExecCoreChildProgram.formulaCode F) | |
| (hH : d.stacks 9 = ExecCoreChildProgram.clauseCode H) | |
| (hS : d.stacks 12 = ExecCoreChildProgram.formulaCode S) | |
| (hleft : d.stacks 261 = []) (hright : d.stacks 262 = []) | |
| (hclean : ∀ i : Fin 1220, i.val < 24 → i ≠ 9 → i ≠ 12 → d.stacks i = []) : | |
| projectState (registers 15 (by decide)) splitterStack d = | |
| DisjointBranchProgram.inputState (d.regs ∘ registers 15 (by decide)) | |
| (d.stacks 257) (d.stacks 258) F S H := by | |
| apply splitter_input_projection d F S H hF hH hS hleft hright | |
| intro i hi | |
| have hrange : (splitterStack i).val < 24 ∧ splitterStack i ≠ 9 ∧ splitterStack i ≠ 12 := by | |
| have h : ∀ j : Fin 23, 7 ≤ j.val → | |
| (splitterStack j).val < 24 ∧ splitterStack j ≠ 9 ∧ splitterStack j ≠ 12 := by decide | |
| exact h i hi | |
| exact hclean _ hrange.1 hrange.2.1 hrange.2.2 | |
| /- The typed count identity for the concrete disjoint branch. -/ | |
| /-- The physical selector filter accumulates its records in reverse order. | |
| Only the selected finite family matters, and the variable type stays `Fin n`. -/ | |
| theorem raw_branch_count_reverse {n k M c : ℕ} (F : RawCNF n) | |
| (H : List (SAT.Literal (Fin n))) (hpriority : SparsePriorityProgram.RawPriority k F M c H) | |
| (hnodup : ∀ C ∈ F, C.Nodup) : | |
| rawCount F = | |
| rawCount (ExecCoreChildProgram.result F (SparsePriorityProgram.selectedRaw F c H).reverse H) + | |
| rawCount | |
| (DisjointBranchProgram.resultB SAT.Literal.negate F (SparsePriorityProgram.selectedRaw F c H).reverse H) := by | |
| have hc : 2 ≤ c := by | |
| have hpos := hpriority.core_nonempty | |
| have hproper := hpriority.core_proper | |
| omega | |
| apply DisjointBranchProgram.count_results F (SparsePriorityProgram.selectedRaw F c H).reverse H c hc | |
| simpa only [ExecCNF.formulaSet, List.map_reverse, List.toFinset_reverse] using | |
| SparsePriorityProgram.selectedRaw_set F c H hnodup | |
| theorem raw_branch_count {n k M c : ℕ} (F : RawCNF n) | |
| (H : List (SAT.Literal (Fin n))) (hpriority : SparsePriorityProgram.RawPriority k F M c H) | |
| (hnodup : ∀ C ∈ F, C.Nodup) : | |
| rawCount F = | |
| rawCount (ExecCoreChildProgram.result F (SparsePriorityProgram.selectedRaw F c H) H) + | |
| rawCount (DisjointBranchProgram.resultB SAT.Literal.negate F (SparsePriorityProgram.selectedRaw F c H) H) := by | |
| have hc : 2 ≤ c := by | |
| have hpos := hpriority.core_nonempty | |
| have hproper := hpriority.core_proper | |
| omega | |
| exact DisjointBranchProgram.count_results F (SparsePriorityProgram.selectedRaw F c H) H c hc | |
| (SparsePriorityProgram.selectedRaw_set F c H hnodup) | |
| theorem branch_execution_from_state (d : Data) (F S : List (List ℕ)) (H : List ℕ) | |
| (hF : d.stacks 265 = ExecCoreChildProgram.formulaCode F) | |
| (hH : d.stacks 9 = ExecCoreChildProgram.clauseCode H) | |
| (hS : d.stacks 12 = ExecCoreChildProgram.formulaCode S) | |
| (hleft : d.stacks 261 = []) (hright : d.stacks 262 = []) | |
| (hclean : ∀ i : Fin 1220, i.val < 24 → i ≠ 9 → i ≠ 12 → d.stacks i = []) : | |
| ∃ t ≤ 621000 * (ExecCoreChildProgram.inputVolume F S H) ^ 2, | |
| ∃ e, Eval branch t d e ∧ | |
| e.stacks 257 = | |
| ExecWorklistProgram.record | |
| (ExecCoreChildProgram.formulaCode (ExecCoreChildProgram.result F S H)) ++ | |
| (ExecWorklistProgram.record (ExecCoreChildProgram.formulaCode | |
| (DisjointBranchProgram.resultB SubexpFrontend.negateCode F S H)) ++ d.stacks 257) ∧ | |
| e.stacks 258 = d.stacks 258 ∧ e.stacks 261 = [] ∧ e.stacks 262 = [] ∧ | |
| e.stacks 265 = [] ∧ e.stacks 259 = d.stacks 259 ∧ | |
| e.stacks 260 = d.stacks 260 := by | |
| have hp := splitter_input_projection_of_clean d F S H hF hH hS hleft hright hclean | |
| have he := branch_execution d (d.regs ∘ registers 15 (by decide)) | |
| (d.stacks 257) (d.stacks 258) F S H | |
| rw [← hp, embedState_project _ _ d | |
| (registers 15 (by decide)).injective splitterStack.injective] at he | |
| exact he | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseDFSProgram | |