File size: 7,809 Bytes
4a56cd6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.DFSLoop
/-! Instantiate the loop invariant using actual normalized formulas, concrete
frontier bytes and the count-mass invariant. Only the concrete streamed leaf
execution remains an intermediate contract for integration.
-/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.DFSNative
open BitProgram StructuredCalls SparseDFSProgram SparseDFSRefinement DFSVisit
variable {n : ℕ}
theorem visitTime_mono (k n a b thresholdLength leafTime bound : ℕ) (hab : a ≤ b) :
visitTime k n a thresholdLength leafTime bound ≤
visitTime k n b thresholdLength leafTime bound := by
have hp := Nat.mul_le_mul_left (SparsePriorityProgram.Selector.selectorCoefficient k)
(Nat.pow_le_pow_left (Nat.add_le_add_right (Nat.add_le_add_right hab thresholdLength) 1) 4)
have hq := Nat.mul_le_mul_left 621000
(Nat.pow_le_pow_left (Nat.add_le_add_right (Nat.mul_le_mul_left 4 hab) 3) 2)
have hm := max_le_max hq (le_refl (leafTime + 100 * (n + 1)))
unfold visitTime
omega
/-- The pending stack has one formula per retained depth, including all unary
literal encodings. This bound is independent of elapsed visit count. -/
theorem remaining_bytes_le {k M visits total : ℕ} (F : RawCNF n)
(node : Node n) (rest : List (Node n)) (hM : 2 ≤ M)
(hwidth : ∀ C ∈ F, C.length ≤ k)
(htrace : Transitions k M visits
⟨[⟨ExecCNF.normalize SAT.Literal.negate F, 0⟩], 0⟩ ⟨node :: rest, total⟩) :
(pendingBytes rest).length ≤ SparseDFSBoundarySpace.frontierBound
(SparseCountProgram.formulaBound n k) (F.length * k) := by
obtain ⟨hvalid, hdepth⟩ := htrace.normalized_pending_invariants F hM hwidth
have modelTrace := htrace.model
have ordered := modelTrace.ordered (.cons _ [] .nil (by simp))
have depthModel : ∀ entry ∈ (Frontier.model ⟨node :: rest, total⟩).pending,
entry.depth ≤ F.length * k := by
intro entry hentry
obtain ⟨raw, hraw, rfl⟩ := List.mem_map.mp hentry
exact hdepth raw hraw
have hlen := SparseCountProgram.ordered_length_le (F.length * k) ordered depthModel
have hrest : rest.length ≤ F.length * k + 2 := by
simp only [Frontier.model, List.length_map, List.length_cons] at hlen
omega
exact SparseDFSInvariantSpace.pendingBytes_length_le rest k (F.length * k) hrest
(fun entry hentry => hvalid entry (List.mem_cons_of_mem node hentry))
/-- A closed outer loop relative to the actual finite leaf command's contract.
All other algorithmic services are the concrete routines in `body_refinement`.
The resource inequalities below are numerical envelopes, discharged by fixed
polynomials before exposing the final machine theorem. -/
theorem normalized_loop (k : ℕ) (threshold : List Bool) (leaf : Code)
(F : RawCNF n) (d : Data) (leafTime parameterBound bound : ℕ)
(hk : 2 ≤ k) (hM : 2 ≤ BinaryArithmetic.toNat threshold)
(hwidth : ∀ C ∈ F, C.length ≤ k)
(hb : Boundary threshold ⟨[⟨ExecCNF.normalize SAT.Literal.negate F, 0⟩], 0⟩ 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)
(hbound : ∀ i, (d.stacks i).length ≤ bound)
(hpop : n + 1 + SparseDFSBoundarySpace.frontierBound (SparseCountProgram.formulaBound n k)
(F.length * k) + 11 * SparseCountProgram.formulaBound n k + 13 ≤ bound)
(hselect : (SparsePriorityProgram.Selector.selectorCoefficient k + 24) *
(SparseCountProgram.formulaBound n k + threshold.length + 1) ^ 4 ≤ bound)
(hbranch : SparseDFSBoundarySpace.frontierBound (SparseCountProgram.formulaBound n k)
(F.length * k) + (n + 1) +
620001 * (4 * SparseCountProgram.formulaBound n k + 3) ^ 2 ≤ bound)
(hadd : 100 * (n + 1) ≤ bound)
(hleaf : LeafContract (n := n) k threshold parameterBound leaf leafTime bound) :
∃ visits t e, t ≤ visits *
(visitTime k n (SparseCountProgram.formulaBound n k) threshold.length leafTime bound + 1) + 1 ∧
BoundedEval (loop k leaf) t d e bound ∧
Boundary (n := n) threshold ⟨[], rawCount F⟩ e ∧
Transitions k (BinaryArithmetic.toNat threshold) visits
⟨[⟨ExecCNF.normalize SAT.Literal.negate F, 0⟩], 0⟩ ⟨[], rawCount F⟩ := by
let initial : Frontier n := ⟨[⟨ExecCNF.normalize SAT.Literal.negate F, 0⟩], 0⟩
let I : Frontier n → Data → Prop := fun s e =>
(∃ visits, Transitions k (BinaryArithmetic.toNat threshold) visits initial s) ∧
Boundary threshold s e ∧ (∀ i, (e.stacks i).length ≤ bound) ∧
BinaryArithmetic.toNat (e.stacks 264) = 4 * BinaryArithmetic.toNat threshold ^ (k - 1) ∧
BinaryArithmetic.toNat (e.stacks 267) = n ∧
(e.stacks 264).length ≤ parameterBound ∧ (e.stacks 267).length ≤ n + 1
have start : I initial d :=
⟨⟨0, .refl _⟩, hb, hbound, hdimension, hambient, hparameterLength, hambientLength⟩
have step : ∀ (node : Node n) rest total e, I ⟨node :: rest, total⟩ e →
∃ next t, t ≤ visitTime k n (SparseCountProgram.formulaBound n k)
threshold.length leafTime bound ∧ ∃ f, BoundedEval (body k leaf) t e f bound ∧
Transition k (BinaryArithmetic.toNat threshold) ⟨node :: rest, total⟩ next ∧ I next f := by
intro node rest total e invariant
obtain ⟨⟨visits, trace⟩, boundary, sourceBound, dimension, ambient,
parameterLength, ambientLength⟩ := invariant
have valid := (trace.normalized_pending_invariants F hM hwidth).1 node (List.mem_cons_self)
have bodyLen := SparseCountProgram.encodeBody_length_le node.formula k valid.literal_nodup
valid.clause_nodup (formulaSet_width_le node.formula valid.width)
have pendingLen := remaining_bytes_le F node rest hM hwidth trace
have inputVolume := SparseSelectorRefinement.inputVolume_le_formulaBound node.formula threshold k
valid.width valid.literal_nodup valid.clause_nodup
obtain ⟨next, t, ht, f, he, transition, nextBoundary, setupFrame⟩ :=
body_refinement threshold leaf node rest total parameterBound leafTime bound e hk hM valid boundary
dimension ambient parameterLength ambientLength trace.next_sum_le_pow sourceBound
(by omega)
((Nat.mul_le_mul_left _ (Nat.pow_le_pow_left inputVolume 4)).trans hselect)
(by
have hp := Nat.mul_le_mul_left 620001
(Nat.pow_le_pow_left (Nat.add_le_add_right (Nat.mul_le_mul_left 4 bodyLen) 3) 2)
omega)
hadd hleaf
refine ⟨next, t, ht.trans (visitTime_mono k n _ _ threshold.length leafTime bound bodyLen),
f, he, transition, ?_⟩
refine ⟨⟨visits + 1, trace.trans (.cons transition (.refl _))⟩,
nextBoundary, he.final_bound, ?_, ?_, ?_, ?_⟩
· rw [setupFrame 264 (by simp)]
exact dimension
· rw [setupFrame 267 (by simp)]
exact ambient
· rw [setupFrame 264 (by simp)]
exact parameterLength
· rw [setupFrame 267 (by simp)]
exact ambientLength
obtain ⟨visits, t, total, e, ht, he, transitions, final⟩ := DFSLoop.execute k
(BinaryArithmetic.toNat threshold) threshold leaf
(visitTime k n (SparseCountProgram.formulaBound n k) threshold.length leafTime bound)
bound I hM (fun _ _ h => h.2.1) (fun _ _ h => h.2.2.1) step initial d start
have total_eq : total = rawCount F := by
simpa only [rawCount_normalize] using transitions.finished_count
subst total
exact ⟨visits, t, e, ht, he, final.2.1, transitions⟩
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.DFSNative
|