Download data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/DFSVisit.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/DFSVisit.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/DFSVisit.lean
-
curl -L -o DFSVisit.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/DisjointReuse/DFSVisit.lean
12.6 kB
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseSelectorRefinement | |
| import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.SparseDFSInvariantSpace | |
| /-! One complete native DFS visit. The leaf callback below is an intermediate | |
| implementation contract for a fixed finite command, not a final theorem premise. | |
| The actual streamed leaf program must instantiate it at integration. | |
| -/ | |
| namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.DFSVisit | |
| open BitProgram StructuredCalls SparseDFSProgram SparseDFSRefinement | |
| structure BoundedEval (command : Code) (steps : ℕ) (a b : Data) (bound : ℕ) : Prop where | |
| eval : Eval command steps a b | |
| space : ∀ prefixSteps c, prefixSteps ≤ steps → | |
| Trace (compiled command 256 256) prefixSteps | |
| (a.withPC (some (compiled command 256 256).entry)) c → | |
| ∀ i, (c.stacks i).length ≤ bound | |
| namespace BoundedEval | |
| variable {command first second yes no : Code} {t u B : ℕ} {a b c : Data} | |
| theorem final_bound (h : BoundedEval command t a b B) : | |
| ∀ i, (b.stacks i).length ≤ B := | |
| h.space t _ le_rfl (compiled_trace h.eval 256 256) | |
| theorem seq (h : BoundedEval first t a b B) (g : BoundedEval second u b c B) : | |
| BoundedEval (.seq first second) (t + u) a c B := | |
| ⟨h.eval.seq g.eval, StructuredSpace.sequence_stack_bound h.eval g.eval 256 256 h.space g.space | |
| (compiled (.seq first second) 256 256) (siteAddress (.seq first second)) | |
| (exitAddress (.seq first second)) (compiled_site (.seq first second) 256 256)⟩ | |
| theorem ite_true {flag : Fin 80} (hf : a.regs flag = true) | |
| (h : BoundedEval yes t a b B) : BoundedEval (.ite flag yes no) (t + 1) a b B := | |
| ⟨.ite_true hf h.eval, StructuredSpace.conditional_true_stack_bound hf h.eval 256 256 h.space | |
| (compiled (.ite flag yes no) 256 256) (siteAddress (.ite flag yes no)) | |
| (exitAddress (.ite flag yes no)) (compiled_site (.ite flag yes no) 256 256)⟩ | |
| theorem ite_false {flag : Fin 80} (hf : a.regs flag = false) | |
| (h : BoundedEval no t a b B) : BoundedEval (.ite flag yes no) (t + 1) a b B := | |
| ⟨.ite_false hf h.eval, StructuredSpace.conditional_false_stack_bound hf h.eval 256 256 h.space | |
| (compiled (.ite flag yes no) 256 256) (siteAddress (.ite flag yes no)) | |
| (exitAddress (.ite flag yes no)) (compiled_site (.ite flag yes no) 256 256)⟩ | |
| end BoundedEval | |
| variable {n : ℕ} | |
| structure LeafReady (k : ℕ) (threshold : List Bool) (parameterBound : ℕ) | |
| (F : RawCNF n) (d : Data) : Prop where | |
| current : d.stacks 265 = SparseCountProgram.encodeBody F | |
| dimension : BinaryArithmetic.toNat (d.stacks 264) = 4 * BinaryArithmetic.toNat threshold ^ (k - 1) | |
| ambient : BinaryArithmetic.toNat (d.stacks 267) = n | |
| occurrence_length : (d.stacks 264).length ≤ parameterBound | |
| dimension_length : (d.stacks 267).length ≤ n + 1 | |
| header : d.stacks 258 = Encoding.encodeNat n | |
| threshold : d.stacks 259 = threshold | |
| left_empty : d.stacks 261 = [] | |
| right_empty : d.stacks 262 = [] | |
| leaf_empty : d.stacks 263 = [] | |
| low_empty : ∀ i : Fin 1220, i.val < 256 → d.stacks i = [] | |
| structure LeafDone (F : RawCNF n) (d e : Data) : Prop where | |
| count : e.stacks 263 = binaryNat (rawCount F) | |
| scratch : e.stacks 30 = [] | |
| persistent : ∀ i, i ∈ ([256, 257, 258, 259, 260, 261, 262, 264, 266, 267] : List (Fin 1220)) → | |
| e.stacks i = d.stacks i | |
| /-- The bound is uniform over all actual leaf inputs; time is separate. -/ | |
| structure LeafContract (k : ℕ) (threshold : List Bool) (parameterBound : ℕ) | |
| (leaf : Code) (time space : ℕ) : Prop where | |
| execution : ∀ (F : RawCNF n) (d : Data), Valid k F → LeafReady k threshold parameterBound F d → | |
| SparsePriority.select (ExecCNF.formulaSet F) (BinaryArithmetic.toNat threshold) = none → | |
| (∀ i, (d.stacks i).length ≤ space) → | |
| ∃ t ≤ time, ∃ e, BoundedEval leaf t d e space ∧ LeafDone F d e | |
| def visitTime (k n bodyLength thresholdLength leafTime bound : ℕ) : ℕ := | |
| 9 * bodyLength + 11 + | |
| (SparsePriorityProgram.Selector.selectorCoefficient k * (bodyLength + thresholdLength + 1) ^ 4 + 1 + | |
| (max (621000 * (4 * bodyLength + 3) ^ 2) (leafTime + 100 * (n + 1)) + 1 + | |
| ((2 * bound + 3) * 257 + 1))) | |
| /-- All branch construction, failed selector scans, accumulation and cleanup | |
| are part of the same actual body evaluation. No elapsed traversal time enters | |
| its source-space bound. -/ | |
| theorem body_refinement {k : ℕ} (threshold : List Bool) (leaf : Code) | |
| (node : Node n) (rest : List (Node n)) (total parameterBound leafTime bound : ℕ) (d : Data) | |
| (hk : 2 ≤ k) (hM : 2 ≤ BinaryArithmetic.toNat threshold) | |
| (hv : Valid k node.formula) (hb : Boundary threshold ⟨node :: rest, total⟩ d) | |
| (hdimension : BinaryArithmetic.toNat (d.stacks 264) = 4 * BinaryArithmetic.toNat threshold ^ (k - 1)) | |
| (hambient : BinaryArithmetic.toNat (d.stacks 267) = n) | |
| (hparameterLength : (d.stacks 264).length ≤ parameterBound) | |
| (hambientLength : (d.stacks 267).length ≤ n + 1) | |
| (hcount : total + rawCount node.formula ≤ 2 ^ n) | |
| (hbound : ∀ i, (d.stacks i).length ≤ bound) | |
| (hpop : n + 1 + (pendingBytes rest).length + | |
| 11 * (SparseCountProgram.encodeBody node.formula).length + 13 ≤ bound) | |
| (hselect : (SparsePriorityProgram.Selector.selectorCoefficient k + 24) * | |
| SparseSelectorRefinement.inputVolume node.formula threshold ^ 4 ≤ bound) | |
| (hbranch : (pendingBytes rest).length + (n + 1) + | |
| 620001 * (4 * (SparseCountProgram.encodeBody node.formula).length + 3) ^ 2 ≤ bound) | |
| (hadd : 100 * (n + 1) ≤ bound) | |
| (hleaf : LeafContract (n := n) k threshold parameterBound leaf leafTime bound) : | |
| ∃ next t, t ≤ visitTime k n (SparseCountProgram.encodeBody node.formula).length | |
| threshold.length leafTime bound ∧ | |
| ∃ e, BoundedEval (body k leaf) t d e bound ∧ | |
| Transition k (BinaryArithmetic.toNat threshold) ⟨node :: rest, total⟩ next ∧ | |
| Boundary threshold next e ∧ | |
| (∀ i, i ∈ ([256, 264, 266, 267] : List (Fin 1220)) → e.stacks i = d.stacks i) := by | |
| obtain ⟨a, hpa, hcurrent, hpending, hpf, hlow, _, _, _, hpspace⟩ := | |
| popCurrent_boundary threshold node rest total d bound hb hbound | |
| have popEval : BoundedEval popCurrent | |
| (9 * (SparseCountProgram.encodeBody node.formula).length + 11) d a bound := | |
| ⟨hpa, fun t c ht hc i => (hpspace t c ht hc i).trans (max_le hpop le_rfl)⟩ | |
| obtain ⟨ts, hts, b, hsb, hsf, hmissing, hfound, hsspace⟩ := | |
| SparseSelectorRefinement.selectCurrent_execution node.formula threshold a bound hk hM | |
| hv.width hv.literal_nodup hv.clause_nodup hcurrent | |
| ((hpf 259 (by decide) (by decide)).trans hb.threshold) | |
| (fun i hi => hlow i (by omega)) popEval.final_bound | |
| have selectEval : BoundedEval (selectCurrent k) ts a b bound := | |
| ⟨hsb, fun t c ht hc i => (hsspace t c ht hc i).trans (max_le hselect le_rfl)⟩ | |
| have highFrame (i : Fin 1220) (hi : 256 ≤ i.val) (hic : i ≠ 265) (hip : i ≠ 257) : | |
| b.stacks i = d.stacks i := by | |
| rw [hsf i (by intro h; subst i; omega) (by intro h; subst i; omega), hpf i hic hip] | |
| have bPending : b.stacks 257 = pendingBytes rest := | |
| (hsf 257 (by decide) (by decide)).trans hpending | |
| have bCurrent : b.stacks 265 = SparseCountProgram.encodeBody node.formula := | |
| (hsf 265 (by decide) (by decide)).trans hcurrent | |
| have bHeader := (highFrame 258 (by decide) (by decide) (by decide)).trans hb.header | |
| have bThreshold := (highFrame 259 (by decide) (by decide) (by decide)).trans hb.threshold | |
| have bTotal := (highFrame 260 (by decide) (by decide) (by decide)).trans hb.total | |
| have bLeft := (highFrame 261 (by decide) (by decide) (by decide)).trans hb.left_empty | |
| have bRight := (highFrame 262 (by decide) (by decide) (by decide)).trans hb.right_empty | |
| have bLeaf := (highFrame 263 (by decide) (by decide) (by decide)).trans hb.leaf_empty | |
| have finish (next : Frontier n) (c : Data) (visit : AfterVisit threshold next c) | |
| (hc : ∀ i, (c.stacks i).length ≤ bound) := | |
| finishVisit_boundary threshold next c bound visit hc | |
| cases hflag : b.regs 23 with | |
| | false => | |
| obtain ⟨hstacks, _, _, hnone, _, _⟩ := hmissing hflag | |
| have ready : LeafReady k threshold parameterBound node.formula b := | |
| ⟨bCurrent, by rw [highFrame 264 (by decide) (by decide) (by decide)]; exact hdimension, | |
| by rw [highFrame 267 (by decide) (by decide) (by decide)]; exact hambient, | |
| by rw [highFrame 264 (by decide) (by decide) (by decide)]; exact hparameterLength, | |
| by rw [highFrame 267 (by decide) (by decide) (by decide)]; exact hambientLength, | |
| bHeader, bThreshold, bLeft, bRight, bLeaf, | |
| fun i hi => (congrFun hstacks i).trans (hlow i hi)⟩ | |
| obtain ⟨tl, htl, c, leafEval, done⟩ := hleaf.execution node.formula b hv ready hnone selectEval.final_bound | |
| obtain ⟨ta, hta, f, hacc, hvisit, hacframe, haspace⟩ := | |
| accumulate_after_leaf threshold node rest total bound c | |
| ((done.persistent 257 (by simp)).trans bPending) | |
| ((done.persistent 258 (by simp)).trans bHeader) | |
| ((done.persistent 259 (by simp)).trans bThreshold) | |
| ((done.persistent 260 (by simp)).trans bTotal) | |
| ((done.persistent 261 (by simp)).trans bLeft) | |
| ((done.persistent 262 (by simp)).trans bRight) | |
| done.count done.scratch hcount leafEval.final_bound | |
| have accEval : BoundedEval accumulate ta c f bound := | |
| ⟨hacc, fun t c ht hc i => (haspace t c ht hc i).trans (max_le hadd le_rfl)⟩ | |
| obtain ⟨tf, htf, e, hfe, hboundary, hfframe, hfspace⟩ := | |
| finish ⟨rest, total + rawCount node.formula⟩ f hvisit accEval.final_bound | |
| have finishEval : BoundedEval finishVisit tf f e bound := ⟨hfe, hfspace⟩ | |
| have whole := popEval.seq (selectEval.seq | |
| (((leafEval.seq accEval).ite_false (yes := branch) hflag).seq finishEval)) | |
| have hm := Nat.le_max_right (621000 * (4 * (SparseCountProgram.encodeBody node.formula).length + 3) ^ 2) | |
| (leafTime + 100 * (n + 1)) | |
| refine ⟨⟨rest, total + rawCount node.formula⟩, _, ?_, e, whole, | |
| .leaf node rest total hnone, hboundary, ?_⟩ | |
| · unfold visitTime SparseSelectorRefinement.inputVolume at * | |
| omega | |
| · intro i hi | |
| simp only [List.mem_cons, List.not_mem_nil, or_false] at hi | |
| rcases hi with rfl | rfl | rfl | rfl | |
| all_goals rw [hfframe _ (by decide) (by decide), hacframe _ (by decide) (by decide) (by decide), done.persistent _ (by simp), highFrame _ (by decide) (by decide) (by decide)] | |
| | true => | |
| obtain ⟨c, H, priority, _, hH, hS⟩ := hfound hflag | |
| have hclean : ∀ i : Fin 1220, i.val < 24 → i ≠ 9 → i ≠ 12 → b.stacks i = [] := by | |
| intro i hi hi9 hi12 | |
| rw [hsf i hi9 hi12] | |
| exact hlow i (by omega) | |
| obtain ⟨tb, htb, f, hbf, transition, hvisit, hbspace⟩ := | |
| branch_after_selection threshold node rest total bound H b hv priority bPending bHeader | |
| bThreshold bTotal bLeft bRight bLeaf bCurrent hH hS hclean selectEval.final_bound | |
| have hV := SparseDFSInvariantSpace.selected_inputVolume_le node.formula H priority.candidate | |
| have hVpow := Nat.pow_le_pow_left hV 2 | |
| have branchEval : BoundedEval branch tb b f bound := by | |
| refine ⟨hbf, ?_⟩ | |
| intro t c ht hc i | |
| apply (hbspace t c ht hc i).trans | |
| apply max_le le_rfl | |
| exact (Nat.add_le_add_left (Nat.mul_le_mul_left 620001 hVpow) _).trans hbranch | |
| obtain ⟨tf, htf, e, hfe, hboundary, hfframe, hfspace⟩ := | |
| finish _ f hvisit branchEval.final_bound | |
| have finishEval : BoundedEval finishVisit tf f e bound := ⟨hfe, hfspace⟩ | |
| have whole := popEval.seq (selectEval.seq | |
| ((branchEval.ite_true (no := .seq leaf accumulate) hflag).seq finishEval)) | |
| have htime := htb.trans (Nat.mul_le_mul_left 621000 hVpow) | |
| have hm := Nat.le_max_left (621000 * (4 * (SparseCountProgram.encodeBody node.formula).length + 3) ^ 2) | |
| (leafTime + 100 * (n + 1)) | |
| refine ⟨_, _, ?_, e, whole, transition, hboundary, ?_⟩ | |
| · unfold visitTime SparseSelectorRefinement.inputVolume at * | |
| omega | |
| · intro i hi | |
| simp only [List.mem_cons, List.not_mem_nil, or_false] at hi | |
| rcases hi with rfl | rfl | rfl | rfl | |
| all_goals rw [hfframe _ (by decide) (by decide), SparseDFSResource.branch_preserves_other_high hbf _ (by decide) (by decide) (by decide) (by decide) (by decide) (by decide), highFrame _ (by decide) (by decide) (by decide)] | |
| end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.DFSVisit | |