File size: 14,962 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 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 | import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.SparseCodeSearch
import OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSetupCostPolynomial
/-! Fixed-degree bounds for the actual streamed sparse-code search commands.
The time comparison uses the original complete numerical search envelope;
workspace is bounded separately by ordinary input words and dimensions. -/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchBudgets
open SparseCodeSearch CodeChecks
/-- Every candidate and every invalid two-bit word is charged. -/
theorem streamedCodeTime_le (A md wd callback : β) :
timeBudget md (boundary A md)
(candidateBudget (boundary A md) md wd callback
(4 ^ wd * (callback + 110 * wd + 36) + 3))
(candidateSpace (boundary A md) md wd callback) β€
4000000 * (A + md + wd + callback + 1) * (4 ^ md * 4 ^ wd) := by
let S := A + md + wd + callback + 1
have hS : 1 β€ S := by dsimp [S]; omega
have hB : boundary A md β€ 7 * S := by dsimp [boundary, S]; omega
have hsum : boundary A md + md + wd + callback + 1 β€ 8 * S := by
dsimp [boundary, S]
omega
have hC := candidateSpace_le (boundary A md) md wd callback
have hC' : candidateSpace (boundary A md) md wd callback β€ 160000 * S := by omega
have hx : 1 β€ 4 ^ wd := Nat.one_le_pow _ _ (by decide)
have hy : 1 β€ 4 ^ md := Nat.one_le_pow _ _ (by decide)
have hscan : callback + 110 * wd + 36 β€ 147 * S := by dsimp [S]; omega
have hsw : 4 ^ wd * (callback + 110 * wd + 36) + 3 β€ 150 * S * 4 ^ wd := by
have hmul := Nat.mul_le_mul_left (4 ^ wd) hscan
have hpos : 1 β€ S * 4 ^ wd := by nlinarith
nlinarith
have hT := candidateBudget_le (boundary A md) md wd callback
(4 ^ wd * (callback + 110 * wd + 36) + 3)
have hST : S β€ S * 4 ^ wd := by nlinarith
have hT' : candidateBudget (boundary A md) md wd callback
(4 ^ wd * (callback + 110 * wd + 36) + 3) β€ 158000 * S * 4 ^ wd := by
nlinarith
have hmd : md β€ S := by dsimp [S]; omega
have hbody : candidateBudget (boundary A md) md wd callback
(4 ^ wd * (callback + 110 * wd + 36) + 3) +
7 * (boundary A md + candidateSpace (boundary A md) md wd callback) +
10 + 42 * md + 12 β€ 1300000 * S * 4 ^ wd := by nlinarith
have hmain := Nat.mul_le_mul_left (4 ^ md) hbody
have htail : 3 + 15 * md + 4 * boundary A md + 17 β€ 63 * S := by omega
have hprod : S β€ S * (4 ^ md * 4 ^ wd) := by
have hp : 1 β€ 4 ^ md * 4 ^ wd := by nlinarith
nlinarith
dsimp [timeBudget]
change _ β€ 4000000 * S * (4 ^ md * 4 ^ wd)
nlinarith
/-- The retained code-search workspace contains no enumeration-domain factor. -/
theorem streamedCodeSpace_le (A md wd callback : β) :
spaceBudget md (boundary A md)
(candidateSpace (boundary A md) md wd callback) β€
10000000 * (A + md + wd + callback + 1) := by
let S := A + md + wd + callback + 1
have hS : 1 β€ S := by dsimp [S]; omega
have hB : boundary A md β€ 7 * S := by dsimp [boundary, S]; omega
have hsum : boundary A md + md + wd + callback + 1 β€ 8 * S := by
dsimp [boundary, S]
omega
have hC := candidateSpace_le (boundary A md) md wd callback
have hmd : md β€ S := by dsimp [S]; omega
have hm : max (56 * (boundary A md + candidateSpace (boundary A md) md wd callback) + 10)
(48 * boundary A md + 7 * (6 * md + 1) + 4) β€ 9000000 * S := by
apply max_le <;> omega
dsimp [spaceBudget]
change _ β€ 10000000 * S
omega
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchBudgets
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchBudgets
open SparseCodeSearch CodeChecks
/-- Actual local-search storage is quadratic in ordinary dimensions and words. -/
theorem localCodeSpace_polynomial (A t D d : β) :
localSpace A t D d β€ 100000000000000 * (A + t + D + d + 1) ^ 2 := by
have h := streamedCodeSpace_le A (t * D) D (OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.callbackBudget t D d)
let S := A + t + D + d + 1
have ht : t β€ S := by dsimp [S]; omega
have hD : D β€ S := by dsimp [S]; omega
have hd : d β€ S := by dsimp [S]; omega
have hA : A β€ S := by dsimp [S]; omega
have hS : 1 β€ S := by dsimp [S]; omega
have hp : S β€ S ^ 2 := by nlinarith
have hm : t * D β€ S ^ 2 := by nlinarith [Nat.mul_le_mul ht hD]
change _ β€ 100000000000000 * S ^ 2
simpa only [localSpace] using (show spaceBudget (t * D) (boundary A (t * D))
(candidateSpace (boundary A (t * D)) (t * D) D
(OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.callbackBudget t D d)) β€
100000000000000 * S ^ 2 by
calc
_ β€ _ := h
_ β€ _ := by rw [local_budget]; nlinarith)
/-- Graph-word comparisons contribute only a fixed quadratic storage bound. -/
theorem graphCodeSpace_polynomial (A D r ql Dl : β) :
graphSpace A D r ql Dl β€ 100000000000000 * (A + D + r + ql + Dl + 1) ^ 2 := by
have h := streamedCodeSpace_le A (D * r) r
(OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.graphCallbackBudget D r ql Dl)
let S := A + D + r + ql + Dl + 1
have hD : D β€ S := by dsimp [S]; omega
have hr : r β€ S := by dsimp [S]; omega
have hq : ql β€ S := by dsimp [S]; omega
have hd : Dl β€ S := by dsimp [S]; omega
have hA : A β€ S := by dsimp [S]; omega
have hS : 1 β€ S := by dsimp [S]; omega
have hp : S β€ S ^ 2 := by nlinarith
have hm : D * r β€ S ^ 2 := by nlinarith [Nat.mul_le_mul hD hr]
have hs : 2 * (ql + Dl + D) + 4 β€ 6 * S := by dsimp [S]; omega
have hsq : (2 * (ql + Dl + D) + 4) ^ 2 β€ 36 * S ^ 2 := by nlinarith
change _ β€ 100000000000000 * S ^ 2
simpa only [graphSpace] using (show spaceBudget (D * r) (boundary A (D * r))
(candidateSpace (boundary A (D * r)) (D * r) r
(OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.graphCallbackBudget D r ql Dl)) β€
100000000000000 * S ^ 2 by
calc
_ β€ _ := h
_ β€ _ := by rw [graph_budget]; nlinarith)
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchBudgets
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchBudgets
open SparseCodeSearch CodeChecks
open OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSetupCost
private theorem localNumeric_lower (a w t D d U P Q : β) (hP : 1 β€ P) (hQ : 1 β€ Q) :
U + D + localCallback U t D d + 1 β€ 2 * localNumeric a w t D d U P Q β§
Q * P β€ localNumeric a w t D d U P Q := by
let c := localCallback U t D d
have hc : U + D + 1 β€ c := by dsimp [c, localCallback, localWord, matrix2]; omega
have hi : P * (c + 1) β€ localCandidate U t D d P := by
dsimp [localCandidate, localVerifier, c]
nlinarith
have ho : Q * localCandidate U t D d P β€ localNumeric a w t D d U P Q := by
unfold localNumeric
nlinarith
have hb : Q * P * (c + 1) β€ localNumeric a w t D d U P Q := by
have hm := Nat.mul_le_mul_left Q hi
nlinarith
have hpq : 1 β€ Q * P := by nlinarith
have hcs : c + 1 β€ Q * P * (c + 1) := by nlinarith
have hd : Q * P β€ Q * P * (c + 1) := by nlinarith
constructor
Β· change U + D + c + 1 β€ _
omega
Β· omega
private theorem graphNumeric_lower (a w D r ql Dl U P Q : β)
(hP : 1 β€ P) (hQ : 1 β€ Q) :
U + r + graphCallback U D r ql Dl + 1 β€ 2 * graphNumeric a w D r ql Dl U P Q β§
Q * P β€ graphNumeric a w D r ql Dl U P Q := by
let c := graphCallback U D r ql Dl
have hc : U + r + 1 β€ c := by dsimp [c, graphCallback, graphWord, matrix2]; omega
have hi : P * (c + 1) β€ graphCandidate U D r ql Dl P := by
dsimp [graphCandidate, graphVerifier, c]
nlinarith
have ho : Q * graphCandidate U D r ql Dl P β€ graphNumeric a w D r ql Dl U P Q := by
unfold graphNumeric
nlinarith
have hb : Q * P * (c + 1) β€ graphNumeric a w D r ql Dl U P Q := by
have hm := Nat.mul_le_mul_left Q hi
nlinarith
have hpq : 1 β€ Q * P := by nlinarith
have hcs : c + 1 β€ Q * P * (c + 1) := by nlinarith
have hd : Q * P β€ Q * P * (c + 1) := by nlinarith
constructor
Β· change U + r + c + 1 β€ _
omega
Β· omega
private theorem localCallback_eq (t D d : β) :
OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.callbackBudget t D d = localCallback (t * D) t D d := by
rw [local_budget]
unfold localCallback localWord matrix2
ring
private theorem graphCallback_eq (D r ql Dl : β) :
OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.graphCallbackBudget D r ql Dl =
graphCallback (D * r) D r ql Dl := by
rw [graph_budget]
unfold graphCallback graphWord matrix2
ring
/-- The entire new local search is dominated by a fixed cubic power of the
original explicit worst-case budget, not by the old successful execution time. -/
theorem localCodeTime_le_numeric (A a w t D d : β) :
localTime A t D d β€
8000000 * (A + localNumeric a w t D d (t * D) (3 ^ D) (3 ^ (t * D)) + 1) ^ 3 := by
let N := localNumeric a w t D d (t * D) (3 ^ D) (3 ^ (t * D))
have hl := localNumeric_lower a w t D d (t * D) (3 ^ D) (3 ^ (t * D))
(Nat.one_le_pow _ _ (by decide)) (Nat.one_le_pow _ _ (by decide))
have hs : A + t * D + D + OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.callbackBudget t D d + 1 β€
2 * (A + N + 1) := by rw [localCallback_eq]; dsimp [N]; omega
have hd : 4 ^ (t * D) * 4 ^ D β€ N ^ 2 :=
(local_attempts_le_square t D).trans (Nat.pow_le_pow_left hl.2 2)
calc
_ β€ 4000000 * (A + t * D + D + OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.callbackBudget t D d + 1) *
(4 ^ (t * D) * 4 ^ D) := streamedCodeTime_le A (t * D) D _
_ β€ 4000000 * (2 * (A + N + 1)) * (A + N + 1) ^ 2 := by
exact Nat.mul_le_mul (Nat.mul_le_mul_left 4000000 hs)
(hd.trans (Nat.pow_le_pow_left (by omega) 2))
_ = _ := by dsimp [N]; ring
/-- Both graph tuple domains are charged, including all rejected candidates. -/
theorem graphCodeTime_le_numeric (A a w D r ql Dl : β) :
graphTime A D r ql Dl β€
8000000 * (A + graphNumeric a w D r ql Dl (D * r) (2 ^ r) (2 ^ (D * r)) + 1) ^ 3 := by
let N := graphNumeric a w D r ql Dl (D * r) (2 ^ r) (2 ^ (D * r))
have hl := graphNumeric_lower a w D r ql Dl (D * r) (2 ^ r) (2 ^ (D * r))
(Nat.one_le_pow _ _ (by decide)) (Nat.one_le_pow _ _ (by decide))
have hs : A + D * r + r + OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.graphCallbackBudget D r ql Dl + 1 β€
2 * (A + N + 1) := by rw [graphCallback_eq]; dsimp [N]; omega
have hd : 4 ^ (D * r) * 4 ^ r β€ N ^ 2 := by
rw [graph_attempts_eq_square]
exact Nat.pow_le_pow_left hl.2 2
calc
_ β€ 4000000 * (A + D * r + r + OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSearchProgram.graphCallbackBudget D r ql Dl + 1) *
(4 ^ (D * r) * 4 ^ r) := streamedCodeTime_le A (D * r) r _
_ β€ 4000000 * (2 * (A + N + 1)) * (A + N + 1) ^ 2 := by
exact Nat.mul_le_mul (Nat.mul_le_mul_left 4000000 hs)
(hd.trans (Nat.pow_le_pow_left (by omega) 2))
_ = _ := by dsimp [N]; ring
end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchBudgets
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.CodeSearchBudgets
open SparseCodeSearch CodeChecks
open OAI.Algorithms.SubexponentialSAT.SqrtLog.CodeSetupCost
open OAI.Algorithms.SubexponentialSAT.SqrtLog.Statement
open Filter
open scoped Topology
/-- One fixed envelope covers both complete native code searches and their
retained outputs. No accepting candidate is a hypothesis. -/
theorem codeTime_le_envelope (A t D d r ql Dl H W : β)
(ht : t β€ H) (hD : D β€ H) (hd : d β€ H) (hr : r β€ H)
(hq : ql β€ W) (hDl : Dl β€ W) :
localTime A t D d + graphTime A D r ql Dl + 1 β€
16000001 * (A + envelope 3000000000000 H W + 1) ^ 3 := by
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 hl := localCodeTime_le_numeric A 0 0 t D d
have hg := graphCodeTime_le_numeric A 0 0 D r ql Dl
have hle : A + localNumeric 0 0 t D d (t * D) (3 ^ D) (3 ^ (t * D)) + 1 β€
A + envelope 3000000000000 H W + 1 := by omega
have hge : A + graphNumeric 0 0 D r ql Dl (D * r) (2 ^ r) (2 ^ (D * r)) + 1 β€
A + envelope 3000000000000 H W + 1 := by omega
have hl' := hl.trans (Nat.mul_le_mul_left 8000000 (Nat.pow_le_pow_left hle 3))
have hg' := hg.trans (Nat.mul_le_mul_left 8000000 (Nat.pow_le_pow_left hge 3))
have hp : 1 β€ (A + envelope 3000000000000 H W + 1) ^ 3 :=
Nat.one_le_pow _ _ (by omega)
omega
/-- Fixed cubic numerical overhead preserves the supplied exponent scale. -/
theorem cubic_cost_runtimeBound (cost A E n C : β)
(hc : cost β€ C * (A + E + 1) ^ 3)
(he : (E : β) β€ (2 : β) ^ runtimeScale n) :
(cost : β) β€ runtimeBound (8 * (C : β)) 3 3 A n := by
let R : β := (2 : β) ^ runtimeScale n
have hr1 : 1 β€ R := Real.one_le_rpow (by norm_num) (runtimeScale_nonneg n)
have hsum : (A : β) + E + 1 β€ 2 * ((A : β) + 1) * R := by
have hA : 0 β€ (A : β) := Nat.cast_nonneg A
change (E : β) β€ R at he
nlinarith
have hc' : (cost : β) β€ (C : β) * ((A : β) + E + 1) ^ 3 := by exact_mod_cast hc
calc
_ β€ (C : β) * ((A : β) + E + 1) ^ 3 := hc'
_ β€ (C : β) * (2 * ((A : β) + 1) * R) ^ 3 :=
mul_le_mul_of_nonneg_left (pow_le_pow_leftβ
(add_nonneg (add_nonneg (Nat.cast_nonneg A) (Nat.cast_nonneg E)) zero_le_one) hsum 3)
(Nat.cast_nonneg C)
_ = runtimeBound (8 * (C : β)) 3 3 A n := by
unfold runtimeBound R
rw [mul_pow, mul_pow, β Real.rpow_mul_natCast (by norm_num)]
norm_num
rw [mul_comm (runtimeScale n) 3]
ring
/-- The input-independent cubic comparison preserves the original runtime
scale. Arbitrarily large physical input words remain in an explicit polynomial. -/
theorem eventually_codeTime (heightCoefficient heightDegree wordDegree : β) :
βαΆ n : β in atTop, β A t D d r ql Dl H : β,
t β€ H β D β€ H β d β€ H β r β€ H β
H β€ heightCoefficient * OAI.Algorithms.SubexponentialSAT.SqrtLog.Asymptotic.L n ^ heightDegree β
ql β€ (n + 1) ^ wordDegree β Dl β€ (n + 1) ^ wordDegree β
((localTime A t D d + graphTime A D r ql Dl + 1 : β) : β) β€
runtimeBound 128000008 3 3 A n := by
filter_upwards [eventually_envelope 3000000000000 heightCoefficient heightDegree wordDegree]
with n hn A t D d r ql Dl H ht hD hd hr hH hq hDl
have h := cubic_cost_runtimeBound
(localTime A t D d + graphTime A D r ql Dl + 1) A
(envelope 3000000000000 H (max ql Dl)) n 16000001
(codeTime_le_envelope A t D d r ql Dl H (max ql Dl)
ht hD hd hr (le_max_left _ _) (le_max_right _ _))
(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.CodeSearchBudgets
|