File size: 6,151 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
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.DFSNative
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.DFSStartup

/-! Concrete count command including startup and physical full-word export.
The actual positivity suffix is appended by the shared native integration.
-/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.DFSCountProgram

open BitProgram StructuredCalls SparseDFSProgram SparseDFSRefinement DFSVisit
variable {n : ℕ}

def command (k : ℕ) (leaf : Code) : Code :=
  .seq DFSStartup.startup (.seq (loop k leaf) exportCount)

/-- An explicit numerical sum of the four independently proved local resource
requirements. It contains no traversal count or exponential time term. -/
def visitSpace (k n m thresholdLength : ℕ) : ℕ :=
  let P := SparseCountProgram.formulaBound n k
  let Q := SparseDFSBoundarySpace.frontierBound P (m * k)
  (n + 1 + Q + 11 * P + 13) +
    ((SparsePriorityProgram.Selector.selectorCoefficient k + 24) * (P + thresholdLength + 1) ^ 4) +
    (Q + (n + 1) + 620001 * (4 * P + 3) ^ 2) + 100 * (n + 1)

theorem boundedEval_mono {code : Code} {t a b small large}
    (h : BoundedEval code t a b small) (hle : small ≤ large) : BoundedEval code t a b large :=
  ⟨h.eval, fun p c hp hc i => (h.space p c hp hc i).trans hle⟩

private theorem stack_length_le_dataBits {r s l : ℕ} (c : Cfg r s l) (i : Fin s) :
    (c.stacks i).length ≤ dataBits c :=
  Finset.single_le_sum (fun j _ => Nat.zero_le ((c.stacks j).length)) (Finset.mem_univ i)

/-- Startup, every real DFS visit, and the canonical count-word copy form one
actual source execution. The leaf is still an explicit finite-command contract
which the streamed evaluator must discharge before endpoint acceptance. -/
theorem command_execution (k : ℕ) (threshold : List Bool) (leaf : Code)
    (F : RawCNF n) (d : Data) (leafTime inputBound bound : ℕ)
    (hk : 2 ≤ k) (hM : 2 ≤ BinaryArithmetic.toNat threshold)
    (hwidth : ∀ C ∈ F, C.length ≤ k)
    (prepared : DFSStartup.Prepared threshold (ExecCNF.normalize SAT.Literal.negate F) d)
    (hdimension : BinaryArithmetic.toNat (d.stacks 264) =
      4 * BinaryArithmetic.toNat threshold ^ (k - 1))
    (hambient : BinaryArithmetic.toNat (d.stacks 267) = n)
    (hambientLength : (d.stacks 267).length ≤ n + 1)
    (hinput : ∀ i, (d.stacks i).length ≤ inputBound)
    (hstartup : 1220 * inputBound +
      8 * (SparseCountProgram.encodeBody (ExecCNF.normalize SAT.Literal.negate F)).length + 17 ≤ bound)
    (hvisit : visitSpace k n F.length threshold.length ≤ bound)
    (hleaf : LeafContract (n := n) k threshold inputBound leaf leafTime bound) :
    ∃ visits t e,
      t ≤ 8 * (SparseCountProgram.encodeBody (ExecCNF.normalize SAT.Literal.negate F)).length + 16 +
        (visits * (visitTime k n (SparseCountProgram.formulaBound n k)
          threshold.length leafTime bound + 1) + 1) + (2 * bound + 7 * n + 18) ∧
      BoundedEval (command k leaf) t d e (1224 * bound + 7 * n + 19) ∧
      e.stacks 256 = OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.countWord (rawCount F) ∧
      Transitions k (BinaryArithmetic.toNat threshold) visits
        ⟨[⟨ExecCNF.normalize SAT.Literal.negate F, 0⟩], 0⟩ ⟨[], rawCount F⟩ := by
  obtain ⟨a, heval, hboundary, hframe⟩ :=
    DFSStartup.startup_refinement threshold (ExecCNF.normalize SAT.Literal.negate F) d prepared
  have startEval : BoundedEval DFSStartup.startup
      (8 * (SparseCountProgram.encodeBody (ExecCNF.normalize SAT.Literal.negate F)).length + 16)
      d a bound := by
    refine ⟨heval, ?_⟩
    intro t c ht hc i
    exact (DFSStartup.startup_prefix_space d
      (SparseCountProgram.encodeBody (ExecCNF.normalize SAT.Literal.negate F)).length
      inputBound hinput t c (by omega) hc i).trans hstartup
  have aDimension : BinaryArithmetic.toNat (a.stacks 264) =
      4 * BinaryArithmetic.toNat threshold ^ (k - 1) := by
    rw [hframe 264 (by decide) (by decide) (by decide)]
    exact hdimension
  have aAmbient : BinaryArithmetic.toNat (a.stacks 267) = n := by
    rw [hframe 267 (by decide) (by decide) (by decide)]
    exact hambient
  have aParameterLength : (a.stacks 264).length ≤ inputBound := by
    rw [hframe 264 (by decide) (by decide) (by decide)]
    exact hinput 264
  have aAmbientLength : (a.stacks 267).length ≤ n + 1 := by
    rw [hframe 267 (by decide) (by decide) (by decide)]
    exact hambientLength
  have constraints := hvisit
  dsimp [visitSpace] at constraints
  obtain ⟨visits, tl, b, htl, loopEval, finalBoundary, transitions⟩ :=
    DFSNative.normalized_loop k threshold leaf F a leafTime inputBound bound hk hM hwidth hboundary
      aDimension aAmbient aParameterLength aAmbientLength startEval.final_bound
      (by omega) (by omega) (by omega) (by omega) hleaf
  have lengthTotal : (b.stacks 260).length ≤ n + 1 := by
    rw [finalBoundary.total]
    exact binaryNat_length_le (rawCount_le F)
  have bBound := loopEval.final_bound
  obtain ⟨e, exportEval, hout, _, _⟩ := exportCount_eval b
  let exportTime := 2 * (b.stacks 0).length + 2 * (b.stacks 256).length +
    7 * (b.stacks 260).length + 11
  have exportBounded : BoundedEval exportCount exportTime b e (1224 * bound + 7 * n + 19) := by
    refine ⟨exportEval, ?_⟩
    intro t c ht hc i
    have htotal := exportCount_prefix_space b n bound lengthTotal bBound t c
      (by dsimp [exportTime] at ht; omega) hc
    exact (stack_length_le_dataBits c i).trans htotal
  have bound_le : bound ≤ 1224 * bound + 7 * n + 19 := by omega
  have whole := (boundedEval_mono startEval bound_le).seq ((boundedEval_mono loopEval bound_le).seq exportBounded)
  have hExportTime : exportTime ≤ 2 * bound + 7 * n + 18 := by
    have hz := finalBoundary.low_empty 0 (by decide)
    have hb256 := bBound 256
    dsimp [exportTime]
    rw [hz]
    simp only [List.length_nil, Nat.mul_zero, Nat.zero_add]
    omega
  refine ⟨visits, _, e, ?_, whole, ?_, transitions⟩
  · omega
  · rw [hout, finalBoundary.total, binaryNat_eq_countWord]

end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.DisjointReuse.DFSCountProgram