File size: 10,751 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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.NativeCode
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchBudgets

/-! Numerical bounds for the actual graph-then-local code stage, including
all physical routing, saved outputs, and reused-bank cleanup. -/

namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets
open SqrtLog SparseCodeSearch CodeSearchBudgets

/-- Unary entry metadata already pays for both retained matrix dimensions. -/
theorem searchBoundary_le (A m B : β„•)
    (hg : SparseCode.degree m B * SparseCode.dimension m B ≀ A)
    (hl : SparseCode.localRows m B * SparseCode.degree m B ≀ A) :
    NativeCode.graphBoundary A m B ≀ 7 * A + 1 ∧
    NativeCode.searchBoundary A m B ≀ 13 * A + 2 := by
  simp only [NativeCode.graphBoundary, NativeCode.searchBoundary, boundary]
  omega

/-- The actual graph/local sequence has a quadratic source-prefix bound
when its exact input metadata words fit in the supplied input bound. -/
theorem searchesSpace_le (A m B ql Dl : β„•) (hA : 1 ≀ A)
    (hD : SparseCode.degree m B ≀ A)
    (ht : SparseCode.localRows m B ≀ A)
    (hd : SparseCode.degree m B / (100 * B * SparseCode.logSize m) + 1 ≀ A)
    (hr : SparseCode.dimension m B ≀ A) (hq : ql ≀ A) (hDl : Dl ≀ A)
    (hg : SparseCode.degree m B * SparseCode.dimension m B ≀ A)
    (hl : SparseCode.localRows m B * SparseCode.degree m B ≀ A) :
    NativeCode.searchesSpace A m B ql Dl ≀ 20000000000000000 * A ^ 2 := by
  have hb := searchBoundary_le A m B hg hl
  have hgb : NativeCode.graphBoundary A m B ≀ 8 * A := by omega
  have hsb : NativeCode.searchBoundary A m B ≀ 15 * A := by omega
  have hgg := graphCodeSpace_polynomial A (SparseCode.degree m B)
    (SparseCode.dimension m B) ql Dl
  have hll := localCodeSpace_polynomial (NativeCode.graphBoundary A m B)
    (SparseCode.localRows m B) (SparseCode.degree m B)
    (SparseCode.degree m B / (100 * B * SparseCode.logSize m) + 1)
  have hgs : A + SparseCode.degree m B + SparseCode.dimension m B + ql + Dl + 1 ≀ 6 * A := by omega
  have hls : NativeCode.graphBoundary A m B + SparseCode.localRows m B +
      SparseCode.degree m B + (SparseCode.degree m B / (100 * B * SparseCode.logSize m) + 1) + 1 ≀
      12 * A := by omega
  have hgg' := hgg.trans (Nat.mul_le_mul_left 100000000000000 (Nat.pow_le_pow_left hgs 2))
  have hll' := hll.trans (Nat.mul_le_mul_left 100000000000000 (Nat.pow_le_pow_left hls 2))
  have hp : A ≀ A ^ 2 := by nlinarith only [hA]
  have hgg'' : graphSpace A (SparseCode.degree m B) (SparseCode.dimension m B) ql Dl ≀
      20000000000000000 * A ^ 2 := by nlinarith only [hgg']
  have hll'' : localSpace (NativeCode.graphBoundary A m B) (SparseCode.localRows m B)
      (SparseCode.degree m B) (SparseCode.degree m B / (100 * B * SparseCode.logSize m) + 1) ≀
      20000000000000000 * A ^ 2 := by nlinarith only [hll']
  have hbA : A ≀ 20000000000000000 * A ^ 2 := by nlinarith only [hp]
  have hbG : NativeCode.graphBoundary A m B ≀ 20000000000000000 * A ^ 2 := by nlinarith only [hgb, hp]
  have hbL : NativeCode.searchBoundary A m B ≀ 20000000000000000 * A ^ 2 := by nlinarith only [hsb, hp]
  unfold NativeCode.searchesSpace NativeCode.graphStageSpace NativeCode.localStageSpace
  exact max_le (max_le hbA (max_le (max_le hgg'' hbA) hbG))
    (max_le hbG (max_le (max_le hll'' hbG) hbL))

end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets

namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets
open SqrtLog SqrtLog.Asymptotic
open Filter
open scoped Topology

/-- The actual four code dimensions satisfy the original numerical height
estimate, uniformly over every leaf with the chosen occurrence cap. -/
theorem produced_dimensions_le (n m B q : β„•) (hm : 0 < m) (hB : 0 < B)
    (hmn : m ≀ n * B) (hBn : B ≀ L n ^ q) :
    let H := (320000 * (q + 2) ^ 3 + q + 4) * L n ^ (2 * q + 3)
    SparseCode.localRows m B ≀ H ∧ SparseCode.degree m B ≀ H ∧
      SparseCode.degree m B / (100 * B * SparseCode.logSize m) + 1 ≀ H ∧
      SparseCode.dimension m B ≀ H := by
  have hd := (SparseCode.degree_le_bound m B).trans
    (CostAssembly.code_degreeBound_le n m B q hmn hBn)
  have hl := CostAssembly.code_logSize_le n m B q hmn hBn
  have hp : L n ≀ L n ^ (2 * q + 3) := by
    simpa using Nat.pow_le_pow_right (L_pos n) (by omega : 1 ≀ 2 * q + 3)
  have hpos : 1 ≀ L n ^ (2 * q + 3) := Nat.one_le_pow _ _ (L_pos n)
  have height : SparseCode.degree m B + SparseCode.logSize m + 2 ≀
      (320000 * (q + 2) ^ 3 + q + 4) * L n ^ (2 * q + 3) := by nlinarith
  have ht := Nat.div_le_self (SparseCode.degree m B) (8 * B)
  have hdist := Nat.div_le_self (SparseCode.degree m B) (100 * B * SparseCode.logSize m)
  have hr := SparseCode.dimension_lt_logSize hm hB
  dsimp only
  unfold SparseCode.localRows
  omega

end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets

namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets
open SqrtLog SparseCodeSearch CodeSearchBudgets
open OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSetupCost

/-- All actual routes, searches, retained outputs and clearing fit a fixed
cubic power of the original explicit numerical envelope. -/
theorem searchesTime_le_envelope (A m B ql Dl H W : β„•)
    (ht : SparseCode.localRows m B ≀ H) (hD : SparseCode.degree m B ≀ H)
    (hd : SparseCode.degree m B / (100 * B * SparseCode.logSize m) + 1 ≀ H)
    (hr : SparseCode.dimension m B ≀ H) (hq : ql ≀ W) (hDl : Dl ≀ W)
    (hg : SparseCode.degree m B * SparseCode.dimension m B ≀ A)
    (hl : SparseCode.localRows m B * SparseCode.degree m B ≀ A) :
    NativeCode.searchesTime A m B ql Dl ≀
      5000000000 * (A + envelope 3000000000000 H W + 1) ^ 3 := by
  let t := SparseCode.localRows m B
  let D := SparseCode.degree m B
  let d := D / (100 * B * SparseCode.logSize m) + 1
  let r := SparseCode.dimension m B
  let E := envelope 3000000000000 H W
  let X := A + E + 1
  have hX : 1 ≀ X := by dsimp [X]; omega
  have hA : A ≀ X := by dsimp [X]; omega
  have hX3 : X ≀ X ^ 3 := by nlinarith [Nat.one_le_pow 2 X hX]
  have he := combinedNumeric_bound 0 0 0 0 t D d r ql Dl 1 1 H W
    3000000000000 ht hD hd hr hq hDl (by norm_num)
  simp only [one_mul] at he
  have hle : localNumeric 0 0 t D d (t * D) (3 ^ D) (3 ^ (t * D)) ≀ E := by dsimp [E]; omega
  have hge : graphNumeric 0 0 D r ql Dl (D * r) (2 ^ r) (2 ^ (D * r)) ≀ E := by dsimp [E]; omega
  have hb := searchBoundary_le A m B hg hl
  have hgb : NativeCode.graphBoundary A m B ≀ 8 * X := by omega
  have hL : NativeCode.graphBoundary A m B +
      localNumeric 0 0 t D d (t * D) (3 ^ D) (3 ^ (t * D)) + 1 ≀ 8 * X := by
    dsimp [X]
    omega
  have hG : A + graphNumeric 0 0 D r ql Dl (D * r) (2 ^ r) (2 ^ (D * r)) + 1 ≀ X := by
    dsimp [X]
    omega
  have hlt := (localCodeTime_le_numeric (NativeCode.graphBoundary A m B) 0 0 t D d).trans
    (Nat.mul_le_mul_left 8000000 (Nat.pow_le_pow_left hL 3))
  have hgt := (graphCodeTime_le_numeric A 0 0 D r ql Dl).trans
    (Nat.mul_le_mul_left 8000000 (Nat.pow_le_pow_left hG 3))
  have hbound : boundary (NativeCode.graphBoundary A m B) (t * D) ≀ 15 * X := by
    change NativeCode.searchBoundary A m B ≀ _
    omega
  change _ ≀ 5000000000 * X ^ 3
  unfold NativeCode.searchesTime NativeCode.graphStageTime NativeCode.localStageTime
  change 5 * (9 * A + 8) + 3 +
      (graphTime A D r ql Dl + 1 + (105 * NativeCode.graphBoundary A m B + 155)) +
      (4 * (9 * NativeCode.graphBoundary A m B + 8) + 3 +
        (localTime (NativeCode.graphBoundary A m B) t D d + 1 +
          (105 * boundary (NativeCode.graphBoundary A m B) (t * D) + 155))) ≀ _
  nlinarith only [hlt, hgt, hX, hX3, hA, hgb, hbound]

end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets

namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets
open SqrtLog SparseCodeSearch CodeSearchBudgets
open OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSetupCost OAI.Algorithms.SubexponentialSAT.SqrtLog.Statement
open Filter
open scoped Topology

/-- The complete native code stage preserves the supplied exponent scale;
its actual retained input bound remains an explicit fixed polynomial factor. -/
theorem eventually_searchesTime (heightCoefficient heightDegree wordDegree : β„•) :
    βˆ€αΆ  n : β„• in atTop, βˆ€ A m B ql Dl H : β„•,
      SparseCode.localRows m B ≀ H β†’ SparseCode.degree m B ≀ H β†’
      SparseCode.degree m B / (100 * B * SparseCode.logSize m) + 1 ≀ H β†’
      SparseCode.dimension m B ≀ H β†’
      H ≀ heightCoefficient * OAI.Algorithms.SubexponentialSAT.SqrtLog.Asymptotic.L n ^ heightDegree β†’
      ql ≀ (n + 1) ^ wordDegree β†’ Dl ≀ (n + 1) ^ wordDegree β†’
      SparseCode.degree m B * SparseCode.dimension m B ≀ A β†’
      SparseCode.localRows m B * SparseCode.degree m B ≀ A β†’
      (NativeCode.searchesTime A m B ql Dl : ℝ) ≀
        runtimeBound 40000000000 3 3 A n := by
  filter_upwards [eventually_envelope 3000000000000 heightCoefficient heightDegree wordDegree]
    with n hn A m B ql Dl H ht hD hd hr hH hq hDl hg hl
  have h := cubic_cost_runtimeBound (NativeCode.searchesTime A m B ql Dl) A
    (envelope 3000000000000 H (max ql Dl)) n 5000000000
    (searchesTime_le_envelope A m B ql Dl H (max ql Dl)
      ht hD hd hr (le_max_left _ _) (le_max_right _ _) hg hl)
    (hn H (max ql Dl) hH (max_le hq hDl))
  norm_num only [Nat.cast_ofNat] at h
  exact h

end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets

namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets
open SqrtLog SqrtLog.Asymptotic SqrtLog.Statement
open Filter
open scoped Topology

/-- Uniform runtime for the actual selected dimensions. The only remaining
size hypotheses are the sparse leaf count and physical entry-word bounds. -/
theorem eventually_produced_searchesTime (q wordDegree : β„•) :
    βˆ€αΆ  n : β„• in atTop, βˆ€ A m B ql Dl : β„•,
      0 < m β†’ 0 < B β†’ m ≀ n * B β†’ B ≀ L n ^ q β†’
      ql ≀ (n + 1) ^ wordDegree β†’ Dl ≀ (n + 1) ^ wordDegree β†’
      SparseCode.degree m B * SparseCode.dimension m B ≀ A β†’
      SparseCode.localRows m B * SparseCode.degree m B ≀ A β†’
      (NativeCode.searchesTime A m B ql Dl : ℝ) ≀
        runtimeBound 40000000000 3 3 A n := by
  filter_upwards [eventually_searchesTime (320000 * (q + 2) ^ 3 + q + 4)
    (2 * q + 3) wordDegree]
    with n hn A m B ql Dl hm hB hmn hBn hq hDl hg hl
  obtain ⟨ht, hD, hd, hr⟩ := produced_dimensions_le n m B q hm hB hmn hBn
  exact hn A m B ql Dl _ ht hD hd hr le_rfl hq hDl hg hl

end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchNativeBudgets