diff --git a/.github/workflows/c8-theorem-a-constants-planar.yml b/.github/workflows/c8-theorem-a-constants-planar.yml new file mode 100644 index 000000000..104e5e501 --- /dev/null +++ b/.github/workflows/c8-theorem-a-constants-planar.yml @@ -0,0 +1,66 @@ +name: C8 planar Theorem A constants (certified replay) + +'on': + pull_request: + paths: + - 'frontiers/c8_theorem_a_constants_planar_20260930/**' + - '.github/workflows/c8-theorem-a-constants-planar.yml' + - 'imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md' + - 'imports/lifetime_parent_20260925/MARKED_CYLINDER_CAP_PROOF.md' + workflow_dispatch: + +permissions: + contents: read + +jobs: + certified-replay: + runs-on: ubuntu-latest + timeout-minutes: 120 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Verify manifest and main-resident pins, replay every band and the C table in both interpreter modes, reject mutants + env: + PYTHONDONTWRITEBYTECODE: '1' + run: | + set -euo pipefail + python -B -S - <<'PY' + import hashlib, json, pathlib, subprocess, sys + root = pathlib.Path('frontiers/c8_theorem_a_constants_planar_20260930').resolve() + manifest = json.loads((root / 'SOURCE_FILES.json').read_text())['files'] + present = sorted(p.name for p in root.iterdir()) + if present != sorted([e['path'] for e in manifest] + ['SOURCE_FILES.json']): + raise ValueError('packet tree differs from manifest: ' + repr(present)) + for entry in manifest: + path = root / entry['path'] + if pathlib.PurePosixPath(entry['path']).name != entry['path'] or path.is_symlink(): + raise ValueError('flat regular source required: ' + entry['path']) + data = path.read_bytes() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256']: + raise ValueError('source identity mismatch: ' + entry['path']) + pins = json.loads((root / 'SOURCE_MAP.json').read_text()) + for entry in pins['sources']: + if not entry['current_required']: + continue + data = pathlib.Path(entry['path']).read_bytes() + blob = hashlib.sha1(b'blob %d\0' % len(data) + data).hexdigest() + if len(data) != entry['bytes'] or hashlib.sha256(data).hexdigest() != entry['sha256'] or blob != entry['git_blob']: + raise ValueError('consumed source identity mismatch on this tree: ' + entry['path']) + script = str(root / 'theorem_a.py') + # every one of the 153 bands in one mode, the sampled replay in the other + for flags, mode in ((['-B', '-S'], '--check-full'), (['-B', '-O', '-S'], '--check')): + out = subprocess.run([sys.executable, *flags, script, mode, '--procs', '2'], cwd=root, capture_output=True, timeout=3600) + if out.returncode != 0: + raise RuntimeError(mode + ' failed under ' + ' '.join(flags) + ': ' + out.stdout.decode()[-400:] + out.stderr.decode()[-400:]) + print(flags, mode, out.stdout.decode().strip()[-400:]) + for m in ('no-delta', 'cap-half', 'no-zfloor-correction', 'no-om-term'): + rc = subprocess.run([sys.executable, '-B', '-S', script, '--check', '--procs', '2', '--mutant', m], cwd=root, capture_output=True, timeout=1800).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + print(json.dumps({'scientific_effect': 'NONE', 'bands_replayed': 153, 'mutants_rejected': 4})) + PY + git diff --exit-code diff --git a/frontiers/c8_theorem_a_constants_planar_20260930/NOTE.md b/frontiers/c8_theorem_a_constants_planar_20260930/NOTE.md new file mode 100644 index 000000000..49ebecf43 --- /dev/null +++ b/frontiers/c8_theorem_a_constants_planar_20260930/NOTE.md @@ -0,0 +1,512 @@ +# Explicit cap-route constants for Theorem A in the plane: `Q^W(G_r^c) <= C r^3` with certified `C` + +**Object:** `CL-C8-THEOREM-A-CONSTANTS-PLANAR-20260930-v1`. **Author lane:** Anthropic / Claude. +**Kind:** author-side theorem (Theorem E), proved with explicit constants and certified by exact rational interval +arithmetic (standard library only). **Scientific effect:** NONE. Catalog entry C8 (`reviews/candidates_pending_20260928/CANDIDATES.md`: +"explicit finite `C`, `r_*`, `z_*`, `c_{B,K}`, `c_{d,L}` on a declared compact-mark / torus band; OPEN") stays OPEN, and no +catalog edit is made. What this packet supplies, in `d = 2`: +- on the band `B = [0, 1]`, `K = [1/2, 2]`, uniformly over frames and torus sides `L >= 10`, explicit cap-route pairs + `(C, r_*)` for [LP] (7.8), and therefore for [LP] Theorem A (1.1); +- a normalizer floor `z_*` on `(0, r_*]`; +- (v1.1) the same at the single fixed-axis SIDE24 point `(b, k) = (6/5, 1/6)` of [CAP] section 1 (Theorem E'). There the only + constant on record, `2.4 x 10^23`, is replaced by `39322.8` for `r <= 1/4096`. + +No STATUS, PROOF_INDEX, GRAPH or catalog edit. Same GitHub account as every lane; zero organizational-independence credit. +The author will not merge. + +**Sources** (pins in `SOURCE_MAP.json`): +- [LP] `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md`, sections 1, 3, 7 and 8: + - the model and the law `Q`, `W_r`, `Z_r`; + - the contact frame (3.1)–(3.3); + - the good event `G_r`, Theorem A (1.1) and the cap bound (7.8); + - the §8 implication "on `G_r` the global elder partner of `M` is `S`". +- [CAP] `imports/lifetime_parent_20260925/MARKED_CYLINDER_CAP_PROOF.md`, section 1: the cylinder `D`, the norms `M_3`, `M_4` + and condition (1). +- [G] Math-#203 at `a388580`, read-only: Theorem G and the sharp cap coefficient `c_G(0, 2)`, used for the lower-bound sanity + check and the comparison. +- [Z] Math-#195 at `6e7746b`, read-only: the floor on `[1/64, 1/2]`, comparison only. + +Unlike [G], this packet does **not** consume [LP] (4.1), (4.2), (5.4), (5.5) or (7.5)–(7.7). Every estimate below is proved +here with its constant. From [LP] it uses only the definitions, the pins, and (for the consequence on `1 - p_r` alone) the §8 +implication. + +## 0. Statement + +**Setting** ([LP] section 1, `d = 2`; as in [G] section 0): +- The torus `X = (R / L Z)^2` and the kernel + `K_L(z) = sum_n exp(-|z + Ln|^2/2) / sum_n exp(-|Ln|^2/2)`. +- An orthonormal frame `R` with axial unit vector `u`, and the pins `M = -(r/2) u`, `S = (r/2) u`, `f(M) = b`, + `f(S) = b - k r^3`, `grad f(M) = grad f(S) = 0`. +- The Gaussian regression law `Q = Q_{r,b,k,R}`, the typed weight `W_r = |det H_M det H_S| 1{H_M < 0, det H_S < 0}`, + `Z_r = E_Q W_r`, and `dQ^W = (W_r / Z_r) dQ`. +- In frame coordinates `(x, y)`: `D = [-2r, 2r]^2`, `M_j = max_{a + c = j} sup_D |partial_x^a partial_y^c f|`, and the good + event `G_r = {-f_yy(M) > (4/(3k)) r M_3^2, r M_4 <= 3k/10}` ([LP] section 7, [CAP] (1)). +- Theorem A of [LP] is `0 <= 1 - p_r <= C r^3` ([LP] (1.1)). Its proof bounds the larger probability `Q^W(G_r^c)` in (7.8) and + uses `1 - p_r <= Q^W(G_r^c)` (§8). +- A **cap-route constant** is any `C` with `Q^W(G_r^c) <= C r^3` for `0 < r <= r_*`. Every cap-route constant is a constant + for [LP] (1.1); the converse fails (see [G] v1.2, section 5, item 1). + +**Theorem E.** Let `B = [0, 1]` and `K = [1/2, 2]`. For every torus side `L >= 10`, every orthonormal frame `R`, every +`b in B`, `k in K`, every `r_*` in the table, and every `0 < r <= r_*`, + + Q^W(G_r^c) <= C(r_*) r^3 and Z_r / r^2 >= z(r_*). + +The same holds for the reference kernel `exp(-|z|^2/2)` on `R^2`, since every enclosure below contains the case +`M_1 = 0`, `Theta = 1` of section 2. The table lists, for each `r_*`: +- `C(r_*)`, an exact rational, with its decimal; +- upper bounds for `C / c_G(0, 2)` and `C r_*^3`, and the floor `z(r_*)`; +- the cell (`r`-band; `b`; `k`) at which the maximum is attained. + +| `r_*` | `C(r_*)` | `C / c_G(0,2) <=` | `C r_*^3 <=` | `z(r_*)` | maximizing cell | +|---|---|---|---|---|---| +| `1/4096` | `26776575319/5000 = 5355315.0638` | `1.005814` | `0.0000779301` | `8.995379` | `[31/131072, 1/4096]`; `[0, 1/64]`; `[63/32, 2]` | +| `1/2048` | `53623024479/10000 = 5362302.4479` | `1.007127` | `0.0006242542` | `8.990755` | `[31/65536, 1/2048]`; `[0, 1/64]`; `[63/32, 2]` | +| `1/1024` | `2151134031/400 = 5377835.0775` | `1.010044` | `0.0050084993` | `8.981500` | `[31/32768, 1/1024]`; `[0, 1/64]`; `[63/32, 2]` | +| `1/512` | `54156592391/10000 = 5415659.2391` | `1.017148` | `0.0403498057` | `8.962953` | `[31/16384, 1/512]`; `[0, 1/64]`; `[63/32, 2]` | +| `1/256` | `93707999311/10000 = 9370799.9311` | `1.759987` | `0.5585432012` | `8.921798` | `[15/4096, 1/256]`; `[1/4, 1]`; `[1/2, 1]` | +| `1/128` | `87390113247/250 = 349560452.9880` | `65.653041` | `166.6834130230` | `8.841791` | `[5/1024, 11/2048]`; `[1/4, 1]`; `[1/2, 1]` | +| `1/64` | `14397396179923/10000 = 1439739617.9923` | `270.406115` | `5492.1707839673` | `8.676320` | `[15/1024, 1/64]`; `[1/4, 1]`; `[1/2, 1]` | + +`c_G(0, 2)` is replaced by its certified lower end `5324360.4426` ([G]). v1 had `C(1/256) = 34071677.7914`; the Hölder exponents of +section 7 bring it below `16777216 = 256^3`. All other entries are equal to v1's or below them by less than `10^-7` +relative. + +**Theorem E' (the SIDE24 point).** The same holds at the single point `(b, k) = (6/5, 1/6)`, for every `L >= 10`, every frame +and the reference kernel. That point lies outside the band (`k < 1/2`). It is the parameter point of the fixed-x-axis +SIDE24 law of [CAP] section 1 (torus side 24, `0 < r <= 1/20`). + +| `r_*` | `C'(r_*)` | `C' / c_G(6/5, 1/6) <=` | `C' r_*^3 <=` | `z'(r_*)` | +|---|---|---|---|---| +| `1/4096` | `19661409/500 = 39322.8180` | `1.100348` | `5.8 x 10^-7` | `3.226690` | +| `1/2048` | `215461191/5000 = 43092.2382` | `1.205825` | `5.1 x 10^-6` | `3.222401` | +| `1/1024` | `1604824613/1250 = 1283859.6904` | `35.93` | `0.0012` | `3.213821` | +| `1/512` | `1173169654911/10000 = 117316965.4911` | `3283` | `0.8741` | `3.196649` | +| `1/256`, `1/128` | `815443379659/5000 = 163088675.9318` | `4564` | `> 1` | `3.162091`, `3.092963` | +| `1/64` | `5553365927589/5000 = 1110673185.5178` | `31080` | `> 1` | `2.953979` | + +`c_G(6/5, 1/6)` is replaced by its certified lower end `35736.7352` ([G]). The contact value of the floor at this point is +`z_0 = 36 k^2 E[w^2 1{w < 0}] = 3.2310`. + +**Corollary (explicit Theorem A on the band).** +- **Explicit pairs.** Since `0 <= 1 - p_r <= Q^W(G_r^c)` ([LP] §8), [LP] (1.1) holds on `B x K`, uniformly over frames and + `L >= 10`, with every pair `(C(r_*), r_*)` of the table. The pairs that are informative at `r = r_*` (`C r_*^3 < 1`) are those + with `r_* <= 1/256`. Examples: `(C, r_*) = (5415659.2391, 1/512)`, where the bound at `r = r_*` is below `0.0404`, and + `(9370799.9311, 1/256)`, where it is below `0.559`. +- **What was missing.** [LP] §16 lists "a numerical `r_*` or `C` on a prescribed band" among the items it does not supply. + The only explicit constant on record before this packet is [CAP] (2)–(3): `1 - p_elder(r) <= min(1, 2.4 x 10^23 r^3)` for + the fixed-axis SIDE24 law, nontrivial only below `r = 1.6 x 10^-8`. +- **The SIDE24 law (Theorem E').** For that law, `1 - p_elder(r) <= 39322.8180 r^3` for `r <= 1/4096` and + `<= 43092.2382 r^3` for `r <= 1/2048`, within `10.1%` and `21%` of the sharp cap coefficient `c_G(6/5, 1/6) = 35736.8`. The + bound stays below `1` up to `r = 1/512` (`C' r_*^3 <= 0.874`). +- **Near-optimal for the cap route.** The constants are within `0.6%`–`1.8%` of the smallest possible cap-route constant on + the band for `r_* <= 1/512`. Every cap-route constant valid for the reference kernel at `(b, k) = (0, 2)` is at least + `c_G(0, 2) > 5324360.44` ([G] Theorem G, v1.2 section 5 item 1), and this certificate's scope includes the reference kernel. + This statement concerns the cap route only. The true elder-failure coefficient at `(0, 2)` is + `alpha_1 + alpha_2 = 2.18` ([G] section 5 from [S]/[NUM]), so the cap criterion overstates the failure rate by about + `2.4 x 10^6`; this certificate cannot remove that slack. +- **Normalizer floor.** `z(r_*)` is an explicit `z_*` for [LP] (5.5) on `(0, r_*]`. The contact value at the band's + weakest corner, `(b, k) = (0, 1/2)`, is `36 k^2 E[w^2 1{w < 0}] = 9`, and `z(1/4096) = 8.9954` lies within `0.06%` of it. + [Z] gives `Z_r / r^2 >= 3.5044` on `[1/64, 1/2]` for `L >= 12`. Together: `Z_r / r^2 >= 3.5044` on all of `(0, 1/2]` for + `L >= 12`, and `Z_r / r^2 >= 8.6763` on `(0, 1/64]` already for `L >= 10`. + +## 1. Coordinates and exact identities + +In frame coordinates `M = (-h, 0)`, `S = (h, 0)` with `h = r/2`, and the midpoint is `0`. The six pins are the +preconditioned functionals of [LP] (3.1): `U0 = (f(M) + f(S))/2`, `U1 = (f(S) - f(M))/r`, `U2 = (f_x(S) - f_x(M))/r`, +`U3 = (6/r^2)[f_x(M) + f_x(S) - 2(f(S) - f(M))/r]`, `V0 = (f_y(M) + f_y(S))/2`, `V1 = (f_y(S) - f_y(M))/r`. Under `Q` their +values are exactly `(b - k r^3/2, -k r^2, 0, 12k, 0, 0)` ([LP] (3.3)). The twelve targets are: + + w = f_yy(M), + v = f_xy(M)/r + (f_y(M) - f_y(S))/r^2, + om = (f_yy(S) - f_yy(M))/r, + Y = f_yyy(0), + T = f_xx(M)/r^2 + (4 f_x(M) + 2 f_x(S))/r^3 + 6 (f(M) - f(S))/r^4, + tau = (f_xx(S) - f_xx(M))/r^3 - 6 (f_x(M) + f_x(S))/r^4 - 12 (f(M) - f(S))/r^5, + nu = (f_xy(M) + f_xy(S))/r^2 + 2 (f_y(M) - f_y(S))/r^3, + X_alpha = partial^alpha f(0), |alpha| = 4. + +Each functional is a sum of terms `c r^p partial_x^a partial_y^e f(x_0 r, 0)` with a common **weight** `a - p`. Since the pins +hold exactly under `Q`, almost surely: + + f_xx(M) = r^2 T - 6kr, f_xx(S) = r^2 (T + r tau) + 6kr, f_xy(M) = r v, f_xy(S) = r (r nu - v), f_yy(S) = w + r om. (I1) + +Write `lambda = -w`, `c1 = 6k - rT`, `c2 = 6k + rT + r^2 tau` and `e = (r nu - v)^2`. Then `det H_M = r P1` and +`det H_S = -r P2`, with + + P1 = c1 lambda - r v^2, P2 = c2 (lambda - r om) + r e, (I2) + +so `H_M < 0, det H_S < 0` holds exactly when `c1 > 0, P1 > 0, P2 > 0`, and then `W_r = r^2 P1 P2`. (`f_xx(M) = -r c1`.) + +## 2. The Gaussian law on an `r`-band (Lemma 1) + +**(a) Exact series.** Let `F`, `F'` be functionals of weights `w_F`, `w_F'`, with `w = w_F + w_F'`. For the reference kernel +`G(z) = exp(-|z|^2/2)`, + + Cov(F, F') = sum_gamma h(g_x) h(g_y) pi_gamma r^(g_x - w). + +- `h(n) = (d/dt)^n exp(-t^2/2)` at `t = 0`, which is `(-1)^(n/2) (n-1)!!` for even `n` and `0` for odd `n`. +- `pi_gamma` is the exact rational `sum c c' (-1)^(a'+e') (x_0 - x_0')^m / m!`. The sum runs over pairs of terms with + `g_y = e + e'` and `m = g_x - a - a' >= 0`. +- **Regularity:** `pi_gamma = 0` for every `g_x < w`. This is checked exactly for all 252 ordered pairs of the 18 functionals, + so no negative power of `r` occurs. + +**(b) Truncation at `g_x <= NX = 60`.** For one pair with `A = a + a'`, the `g_x`-th term is at most +`|c c'| |h(g_y)| (g_x^A / g_x!!) r^(g_x - w)`, because `|h(n)|/(n - A)! <= n^A / n!!`. For `r <= 1/64` the terms with +`g_x > 60` therefore sum to at most `2 |c c'| |h(g_y)| 61^A r^(61 - w)`. + +**(c) Torus remainder, uniform in `L >= 10`, the frame and `r`.** +- **Decomposition.** `K_L = (G + rho) / Theta` with `rho(z) = sum_{n != 0} G(z + p_n)`, where `p_n` runs over the rotated + lattice `L R^T Z^2`, and `Theta = 1 + sum_{n != 0} exp(-|p_n|^2/2)`, which lies in `[1, 1 + theta_1(L)]`. +- **Bound on `rho`.** `rho` is entire. On the complex polydisc `{|z_1|, |z_2| <= 1}`: + - `|exp(-(z + p)^2/2)| <= e exp(-|Re z + p|^2/2)`; + - at most `8j` lattice points have sup-norm index `j`, each at distance `>= jL`; + - `|Re z| <= 3/2`. + + Hence `|rho| <= M_1(L) := e sum_{j >= 1} 8j exp(-(jL - 3/2)^2/2)`, independently of the frame. +- **Cauchy estimates** give `|partial^gamma rho(0)| <= g_x! g_y! M_1`. +- **Effect on the covariance.** The regularity in (a) is an identity in the Taylor coefficients of any kernel, so the + `rho`-part of the covariance is `sum_{g_x >= w} partial^gamma rho(0) pi_gamma r^(g_x - w)`. Using + `g_x!/(g_x - A)! <= w^A e^(g_x - w)` (valid because `A <= w`: every power `p` is `<= 0`), it is bounded by + `sum |c c'| g_y! max(w, 1)^A M_1 / (1 - e r)`. +- **Values.** `M_1(10) < 4.46 x 10^-15` and `theta_1(10) < 1.55 x 10^-21`. Both decrease in `L`, so the enclosures computed + at `L = 10` hold for every `L >= 10`, for every frame, and for the reference kernel (`rho = 0`, `Theta = 1`). +- **Why no `r^-10`.** The remainder is applied to the regular series, not to the raw pin functionals. This removes the + `r^-10` amplification that forces `L >= 12` in [Z]. + +**(d) Regression.** Interval Gaussian elimination on the six pins gives, uniformly over `r in [r_0, r_1]` (each power `r^p` +is enclosed by `[r_0^p, r_1^p]`): +- the `Q`-means `mu_F = b alpha_F + k beta_F` of the twelve targets; +- their `Q`-covariance `C`, scaled by `Theta^-1 in [1/(1 + theta_1), 1]`; +- the pin energy `E = v_r^T Sigma_r^-1 v_r = e_bb b^2 + 2 e_bk b k + e_kk k^2`, scaled by `Theta in [1, 1 + theta_1]`. + +At contact (reference kernel) these reduce to `w ~ N(-b, 2)`, `v ~ N(0, 1/2)`, `om ~ N(0, 2)`, `Y ~ N(0, 6)` (as in [G] +section 2.2) and `E -> 3b^2/2 + 24 k^2`. + +The **regression on `w`**: `beta_F = C(F, w)/C(w, w)` and `F_g = F - beta_F (w - mu_w)`. Then `F_g` is independent of `w` +under `Q`, with mean `mu_F` and covariance `C - C(., w) C(w, .)/C(w, w)`. The `g`-block of `(v, om, Y)` is factored by an +interval Cholesky decomposition with lower-triangular entries `l_ij`. + +## 3. Third and fourth derivatives on `D` (Lemmas 2 and 3) + +Write `A_alpha = sup_D |partial^alpha f|` for `|alpha| = 4`. + +**Lemma 2 (averaging identities).** For every `C^4` function satisfying the pins, and every `z in D`: + + |f_xxx(z)| <= 12k + r Delta_1, Delta_1 = (5/2) A_40 + 2 A_31, + |f_xxy(z)| <= 2|v| + r Delta_2, Delta_2 = (5/2) A_31 + 2 A_22, + |f_xyy(z)| <= |om| + r Delta_3, Delta_3 = (5/2) A_22 + 2 A_13, + |f_yyy(z)| <= |Y| + r Delta_4, Delta_4 = 2 A_13 + 2 A_04, + +so `M_3 <= max_i (B_i + r Delta_i)` with `B = (12k, 2|v|, |om|, |Y|)`. + +*Proof.* Let `g(t) = f(t, 0)` and `q(t) = f_y(t, 0)`. +- **`f_xxx`.** `U3` annihilates quadratics and equals `g'''` on cubics. Its Peano kernel is + `U3 = integral_{-h}^{h} K(t) g'''(t) dt` with `K(t) = 3(h^2 - t^2)/(4h^3) >= 0` and `integral K = 1`; under `Q`, + `U3 = 12k`. +- **`f_xxy`.** The pins give `q(+-h) = 0`, so Taylor's formula at `-h` yields + `-2v = integral_{-h}^{h} (2(h - t)/r^2) q''(t) dt`, an average of `f_xxy(t, 0)` (weights `>= 0` with total `1`). +- **`f_xyy`.** `om = (1/r) integral_{-h}^{h} f_xyy(t, 0) dt`. +- **`f_yyy`.** `Y = f_yyy(0)`. + +In each case `|partial^beta f(z) - partial^beta f(t, 0)| <= |z_x - t| A_{beta + e_x} + |z_y| A_{beta + e_y}` along the segment, +which stays in the convex set `D`. Use `|z_x - t| <= 5r/2` and `|z_y| <= 2r` (and `|z_x| <= 2r` for `Y`). + +**Lemma 3 (fourth derivatives).** +- **Entire field.** Under `Q` the field is almost surely entire. The torus field is + `sum_m sqrt(lambda_m)(xi_m cos + eta_m sin)(2 pi m.z/L)` with `lambda_m` decaying like `exp(-2 pi^2 |m|^2/L^2)`, which + converges on compacts of `C^2`, and the regression adds finitely many entire functions. +- **Taylor bound.** Hence `A_alpha <= |X_alpha| + T_alpha`, where + `T_alpha = sum_{beta != 0} |partial^(alpha+beta) f(0)| (2r)^|beta| / beta!`. +- **Gaussian bounds.** For every `gamma`, the `Q`-law of `partial^gamma f(0)` is Gaussian with standard deviation at most + `s_gamma` and `|mean| <= s_gamma sqrt(E)` (Cauchy–Schwarz in the `Sigma_r^-1` inner product), where + `s_gamma^2 = (2g_x - 1)!!(2g_y - 1)!! + (2g_x)!(2g_y)! M_1` bounds the unconditioned variance. +- **Norm bound.** Therefore `||T_alpha||_p <= S_alpha (sqrt(E) + ||N(0,1)||_p)`, with + + S_alpha(r_1) = sum_{1 <= |beta| <= 24} s_{alpha+beta} (2r_1)^|beta| / beta! + 2^(|alpha|+1) 26 . 29^8 (4r_1)^25 / (1 - 8r_1). + + The tail term uses `s_gamma <= 2^|gamma| gamma! sqrt(1 + M_1)` and `(alpha+beta)!/beta! <= (n + 4)^4` at `|beta| = n`, and + requires `4 r_1 <= 1/16`. +- **Dependence on `w`.** The regression coefficient of `partial^gamma f(0)` on `w` is at most `s_gamma / sigma_w`. So + `A_alpha <= A_alpha^g + B_alpha |w - mu_w|`, with `B_alpha = |beta_{X_alpha}| + S_alpha / sigma_w`, where `A_alpha^g` is the + same bound for the `w`-independent field. The `g`-part of each jet has the same mean and a smaller variance. + +## 4. Regression on `w` and the failure set (Lemma 4) + +**The `g`-measurable bound on `M_3`.** By Lemmas 2–3 and the regression, + + M_3 <= max_i (y_i + bar-beta_i |w - mu_w|), + +with the `g`-measurable parts + + y_1 = 12k + r Delta_1^g, y_2 = 2|v_g| + r Delta_2^g, y_3 = |om_g| + r Delta_3^g, y_4 = |Y_g| + r Delta_4^g, + +and the coefficients + + bar-beta_1 = r((5/2) B_40 + 2 B_31), + bar-beta_2 = 2|beta_v| + r((5/2) B_31 + 2 B_22), + bar-beta_3 = |beta_om| + r((5/2) B_22 + 2 B_13), + bar-beta_4 = |beta_Y| + r(2 B_13 + 2 B_04). + +On `lambda >= 0`, `|w - mu_w| <= lambda + |mu_w|`. Put `y_i' = y_i + bar-beta_i |mu_w|`, `a = 4/(3k)` and +`x_i = a r bar-beta_i y_i'`. + +**Lemma 4.** If `lambda <= a r M_3^2`, then for some `i`, `lambda <= a r (y_i' + bar-beta_i lambda)^2`. For `x_i <= 1/4` the two +roots of this quadratic satisfy + + lambda_-^(i) <= a r y_i'^2 / (1 - 3 x_i), lambda_+^(i) >= (1 - 3x_i) / (a r bar-beta_i^2) >= 1 / (4 a r bar-beta_i^2). + +*Proof.* `lambda_- = 2 a r y'^2 / (1 - 2x + sqrt(1 - 4x))` and `lambda_+ = (1 - 2x + sqrt(1 - 4x)) / (2 a r bar-beta^2)`. +Then use `sqrt(1 - 4x) >= 1 - 4x`. + +**The cover.** Put `X_0 = 1/64` and `kappa = 3/(1 - 3X_0)`, so that `1/(1 - 3x) <= 1 + kappa x` for `x <= X_0`. On the typed +support, + + G_r^c subset N u F u X u A, + N = {lambda <= r U, x_i <= X_0 for all i}, U = max_i a y_i'^2 (1 + kappa x_i), + F = {lambda >= lambda_far}, lambda_far = 1/(4 a r bar-beta^2), bar-beta = max_i bar-beta_i, + X = {x_i > X_0 for some i}, A = {r M_4 > 3k/10}. + +`U` is `g`-measurable, so on `N` the failure is a `lambda`-interval `[0, rU]` that depends only on the `g`-parts. + +## 5. The main term + +On `N`, every target `F` is bounded by its `g`-measurable majorant `bar-F = |F_g| + |beta_F| (|mu_w| + rU)`. + +**Density of `lambda` (v1.1).** Two bounds hold for the density `p` of `lambda` on the failure window `[0, rU]`: +- `p <= bar-p = phi(max(0, mu_w)/sigma_w)/sigma_w`, its supremum on `[0, infinity)`; +- `p(lambda) <= p_0 + lambda L_p`, where: + - `p_0 = phi(m_0/sigma_hi)/sigma_lo` bounds `p(0)` over the box, with `m_0` the smallest `|mu_w|` in the box (`0` if the + enclosure of `mu_w` contains `0`); + - `L_p = 0.24198/sigma_lo^2 >= phi(1)/sigma_w^2 = sup |p'|`. + +The second bound matters when `-mu_w = b > 0` is far from `0`: at `b = 6/5` the first gives `0.2821` while `p(0) = 0.1967`. The +term `lambda L_p` costs one more power of `U`. From (I2), + + W_r <= r^2 |c1| lambda (|c2| (lambda + r |om|) + r e) + +on the typed support (positive parts; this covers both signs of `c1`, `c2`). Integrating over `lambda = r u in [0, rU]` +gives + + E_Q[W_r 1_N] <= r^5 bar-p E_g[ |bar-c1 bar-c2| (U^3/3 + bar-om U^2/2) + |bar-c1| bar-e U^2/2 ], + +and, with the linear density bound, the same integral with one more factor `lambda <= rU`: + + E_Q[W_r 1_N] <= r^5 p_0 E_g[ ... as above ... ] + r^6 L_p E_g[ |bar-c1 bar-c2| (U^4/4 + bar-om U^3/3) + |bar-c1| bar-e U^3/3 ]. + +The certificate uses the smaller of the two. + +**Normalization by `K = 12k`.** Write `U = a K^2 tilde-U` with `a K^2 = 192k`, and +`|c1 c2|/(36k^2) <= 1 + eps`, where `eps <= (2r|T| + r^2|tau|)/(6k) + r|T|(r|T| + r^2|tau|)/(36k^2)`. Then + + E_Q[W_r 1_N] / (36 k^2 r^5) <= min( bar-p (A + B + C), p_0 (A + B + C) + r L_p (A' + B' + C') ), + A = (aK^2)^3/3 . E[tilde-U^3 (1 + eps)], B = (aK^2)^2/2 . E[bar-om tilde-U^2 (1 + eps)], + C = (aK^2)^2/(12k) . E[(1 + r|bar-T|/(6k)) bar-e tilde-U^2], + A' = (aK^2)^4/4 . E[tilde-U^4 (1 + eps)], B' = (aK^2)^3/3 . E[bar-om tilde-U^3 (1 + eps)], + C' = (aK^2)^3/(18k) . E[(1 + r|bar-T|/(6k)) bar-e tilde-U^3]. + +**Moments of `tilde-U`.** With `tilde-y_i = y_i'/K`, `F_k = 1 + kappa X_0`, `eta_1 = 16 kappa r bar-beta_1` and +`Z_1 = tilde-y_1^2 (1 + eta_1 tilde-y_1)`: +- `tilde-U <= max(Z_1, F_k tilde-y_i^2)` for `i = 2, 3, 4`. +- Since `tilde-y_1 >= 1`, + `max(Z_1, F_k tilde-y_i^2)^p <= Z_1^p + F_k^p sum_i (tilde-y_i^(2p) - c^(2p))_+` with `c = 1 - kappa X_0/2 <= F_k^(-1/2)`. +- Each `tilde-y_i <= u_i + delta_i` (`i >= 2`), where `u_i` is the half-normal of the `i`-th Cholesky variable and + `delta_i` collects the means, the off-diagonal Cholesky terms, `bar-beta_i |mu_w|` and `r Delta_i^g`. +- With a parameter `theta > 0`: + `(u + delta)^n - c^n <= (1 + theta)^(n-1) (u^n - (c(1 - theta))^n)_+ + (1 + 1/theta)^(n-1) delta^n`. +- `E[u^q (u^n - c'^n)_+]` is in closed form through the incomplete Gaussian moments + `M_j(x) = integral_x^infinity t^j phi(t) dt = x^(j-1) phi(x) + (j - 1) M_(j-2)(x)`. +- `tilde-y_1 = 1 + bar-beta_1 |mu_w|/K + (r/K) Delta_1^g` is expanded binomially. +- The `delta`-terms and every cross term are bounded by Hölder's inequality, with Gaussian `L^p` norms + (`||N||_p <= ((p - 1)!!)^(1/p)` for `p` a power of two, `||N||_1 <= 4/5`) and the bounds of Lemma 3. + +**Parameter choices (v1.1).** Every pair in the proved domain `0 < X_0 < 2/9`, `0 < theta < 1` gives a valid bound; both +pairs used below lie in that domain. Each box uses the smaller of the bounds for +`(X_0, theta) = (1/64, 1/32)` and `(1/1024, 1/256)`. The second pair matters at small `k`, where the free third derivatives +`2|v|, |om|, |Y|` often exceed `12k`, so the factor `F_k^3 = (1 + kappa X_0)^3` and the split loss `(1 + theta)^5` multiply +the leading term. In v1 these were `1.155` and `1.166`; with the second pair they are `1.009` and `1.020`. + +**The factors `bar-om` and `bar-e`.** +- In `bar-om`, the part that shares its Gaussian variable with `u_3` is integrated exactly; the rest goes through Hölder. +- `bar-e = (r |bar-nu| + |bar-v|)^2`. Write `|bar-v| <= v_0 + d_v`, where `v_0 = l_11 |z_1|` is the Cholesky part, the + variable of `u_2`, and `d_v = |mu_v| + |beta_v| (|mu_w| + rU)`. With `theta_E = 1/16`: + + bar-e <= (1 + theta_E)^2 v_0^2 + (1 + theta_E)(1 + 1/theta_E) d_v^2 + (1 + 1/theta_E) r^2 bar-nu^2. + + The `v_0^2` term is integrated exactly against `u_2`; the rest goes through Hölder. + +## 6. The normalizer floor (Lemma 5) + +Let `G_0 = {r|T| <= 3k/2, r^2|tau| <= 3k/2}`. On `G_0`: + + c1 >= 9k/2, 3k <= c2 <= 9k, c1 c2 >= 36k^2 (1 - (2r|T| + r^2|tau|)/(6k)), + +and, pointwise, + + W_r / r^2 >= 1_{G_0} { 36k^2 [ lambda_+^2 - r om_+ lambda_+ - ((2r|T| + r^2|tau|)/(6k)) lambda_+^2 ] - r c2 v^2 lambda_+ }. + +*Proof.* By (I2), `W_r/r^2 >= 1_{G_0} c2 (c1 lambda - r v^2)_+ (lambda - r om_+)_+`. If `lambda <= r om_+`, the right side +above is at most `0`. Otherwise use `(x - y)_+ z >= xz - yz` and `c1 c2 lambda (lambda - r om_+) >= 36k^2 (1 - ...) lambda (lambda - r om_+)`. + +Taking expectations, with Cauchy–Schwarz on `G_0^c` and Hölder on the `T`, `tau` terms: + + Z_r / (36 k^2 r^2) >= E[lambda_+^2] - ||lambda||_4^2 P(G_0^c)^(1/2) - (2r||T||_2 + r^2||tau||_2) ||lambda||_4^2/(6k) + - r E[|om| lambda_+] - (r/(3k)) E[v^2 lambda_+] + +(the certificate uses `1/(3k)` where `c2 <= 9k` would allow `1/(4k)`). +- `E[lambda_+^2] = E[(sigma z + m)_+^2]` is increasing in `m` and `sigma`, so it is evaluated at the lower endpoints. +- `E[|om| lambda_+]` and `E[v^2 lambda_+]` are split by the regression; the `g`-parts are independent of `lambda`. +- `P(G_0^c)` is bounded by Gaussian tails of `T` and `tau`. + +The bound of the main term is divided by this floor. + +## 7. Rare branches + +**Weight bound.** For `q in {2, 4, 8, 16}`, by Hölder, + + ||W_r 1_typed||_q <= r^2 g_1(q) g_2(q), + g_1(q) = (6k + r||T||_{4q}) ||lambda||_{4q}, + g_2(q) = (6k + r||T||_{4q} + r^2||tau||_{4q})(||lambda||_{4q} + r||om||_{4q}) + r (r||nu||_{4q} + ||v||_{4q})^2. + +Then `E_Q[W_r 1_E] <= ||W_r 1_typed||_q P(E)^(1 - 1/q)` for `E = F, X, A`, and each box uses the smallest of the four bounds. +v1 used `q = 2` only. A larger `q` gains when the probabilities are small and loses when they are not, because `||W||_q` +grows with `q`. +- `P(A) <= sum_alpha [P(|X_alpha| > (7/8) t) + P(T_alpha > t/8)]` with `t = 3k/(10r)`: a Gaussian tail plus Markov's + inequality at `p = 32` with Lemma 3. +- `P(F) <= bar-Phi((lambda_far - |mu_w|)/sigma_w)`. +- `P(X) <= sum_i P(y_i' > X_0/(a r bar-beta_i))`: Markov at `p = 32` on `r Delta_1` for `i = 1`; a Gaussian tail of `u_i` + plus Markov on `delta_i` for `i >= 2`. + +`bar-Phi(x)` is computed from its series for `x <= 12`, and beyond that from Mills' bound `phi(x)/x` with +`e^(-y) <= 40!/y^40`. + +## 8. Bands, boxes, and the last band + +**Bands.** `(0, 1/64]` is covered by `[0, 2^-29]` and 152 bands. Each octave `[2^-(j+1), 2^-j]` is split into equal +sub-bands: +- 8 sub-bands for `j = 6, 7, 8`; +- 16 for `j = 9, ..., 12`; +- 4 for `j = 13, ..., 28`. + +**Per band.** On each band `[r_0, r_1]`: +- the law is enclosed uniformly (Lemma 1); +- every `r`-monotone quantity is taken at its worst endpoint: thresholds and `S_alpha` at `r_1`, the tail divided by `r_0^3`. + +**Boxes.** 28 boxes per band: + + b in {[0, 1/64], [1/64, 1/16], [1/16, 1/4], [1/4, 1]}, + k in {[1/2, 1], [1, 3/2], [3/2, 7/4], [7/4, 15/8], [15/8, 31/16], [31/16, 63/32], [63/32, 2]}. + +That makes 4284 box bounds. `C(r_*)` is their maximum over the bands with `r_1 <= r_*`, and `z(r_*)` is the minimum over +the same boxes of `36 k_lo^2` times the floor of Lemma 5. The SIDE24 point is evaluated on every band as a degenerate box +`b = 6/5`, `k = 1/6`, which gives `C'(r_*)` and `z'(r_*)` in the same way. + +**The last band `[0, R]`, `R = 2^-29`.** The main term does not depend on `r`, and the tail is divided by `(R/2)^3`. This is +justified as follows: +- every Gaussian-tail argument is `>= 3` at `R` (checked), and it at least doubles when `r` halves; +- no tail probability reaches `1` at `R` (checked); +- every Markov piece scales like `r^32` or faster. + +So each halving of `r` divides each probability by more than `64`. After the power `1 - 1/q` with `q >= 2` it still divides +each piece by more than `8`, for the `q` chosen at `R`. The tail term over `r^3` therefore attains its supremum over `(0, R]` +on `[R/2, R]`. + +## 9. Arithmetic + +- **Representation:** exact rationals. +- **Transcendentals:** `exp`, `Phi`, `pi` and `sqrt` are enclosed with outward rounding to `2^-160`, by series with explicit + remainders (`exp` as a fixed-point series; `pi` from Machin's formula). +- **Upper bounds:** rounded upward to 200 significant bits (dyadic). +- **Square roots of upper bounds:** taken without an absolute rounding floor. +- **Matrices:** interval Gaussian elimination with midpoint pivoting, and an interval Cholesky decomposition whose pivots + must be positive. + +Each failed precondition exits through `require`. Standard library only. + +## 10. Controls (floating point; not part of the certificate) + +`theorem_a.py --mc R B K N SEED` evaluates `Q^W(G_r^c)/r^3` and `Z_r/r^2` end to end from the definitions: +- the degree-8 jet at `0` is sampled under `Q` for the reference kernel; +- the field near `D` is rebuilt from it; +- `W_r`, `M_3` and `M_4` are evaluated directly (maxima over a `9 x 9` grid of `D`). + +Means over seeds, with the standard error of the mean: + +| `(r, b, k)` | seeds x samples | `Q^W(G_r^c)/r^3` | `Z_r/r^2` | certified (cell containing the point) | +|---|---|---|---|---| +| `(1/512, 0, 2)` | `4 x 20000` | `4.840e6 +- 0.035e6` | `144.2 +- 0.8` | `C <= 5415659.24`; `Z/r^2 >= 139.21` | +| `(1/1024, 0, 2)` | `6 x 20000` | `5.192e6 +- 0.053e6` | `144.7 +- 0.6` | `C <= 5377835.08`; `Z/r^2 >= 139.37` | +| `(1/512, 0, 1/2)` | `6 x 20000` | `8.74e4 +- 0.19e4` | `9.04 +- 0.04` | cell bound `<= 724033.37` (the cell reaches `k = 1`); `Z/r^2 >= 8.9629` | + +The limits as `r -> 0` are `c_G(0, 2) = 5324360.44`, `c_G(0, 1/2) = 85120.5` and `z_0 = 144`, `9`. + +Two biases point the same way: +- the grid maxima slightly underestimate `M_3` and `M_4`; +- at finite `r` the density of `lambda` decreases across the failure window (by about `8%` at `r = 1/512`, `(0, 2)`). + +Both explain why the finite-`r` estimates at `k = 2` sit below `c_G`, and why the estimate approaches `c_G` as `r` halves. +The certified `C` must exceed `c_G` (it holds as `r -> 0`), and it does by the margins in the table. The controls only check +that no gross error separates the certificate from the definitions. + +## 11. What this does not do + +- **Proofs and reviews of sources.** Not a proof or a review of [LP]'s proof of Theorem A or of [CAP]. The consequence for + `1 - p_r` uses [LP] §8, which rests on the deterministic cap theorem of [CAP], as a statement. +- **Scope.** Planar only (`d = 2`); `d >= 3` would need the eigenvalue boundary layer of [LP] section 7. The band + `b in [0, 1]`, `k in [1/2, 2]`, and the single SIDE24 point `(6/5, 1/6)`. No other `k < 1/2`: a smaller `k` lowers every + threshold `3k/(10r)` and `12k`, and at the SIDE24 point the tail branches already dominate for `r > 1/2048`. +- **Lower bounds.** No lower bound for the constant of [LP] (1.1) itself (see [G] v1.2). +- **Large `r_*`.** For `r_* >= 1/128` (band) and `r_* >= 1/256` (SIDE24 point) the table values are certified but exceed `1` + at `r = r_*`. There the tail branches `A` and `X` dominate, and the method stops being informative. +- **Other C8 constants.** `c_{B,K}` and `c_{d,L}` are not addressed (Math-#197 and the SIDE24 coefficient packets). +- **Controls.** The Monte Carlo controls are floating point and are not part of the certificate. There is none at the SIDE24 + point: there the failure probability (`c_G r^3 < 5 x 10^-6` for `r <= 1/2048`) is beyond reach of sampling. +- **C8.** C8 stays OPEN; this packet changes no catalog entry. Nonauthor reads are requested on the PR. + +## 12. Verification and provenance + +- `python3 -B -S theorem_a.py --check --procs N` (also with `-B -O -S`) replays exactly, and compares with `RESULTS.json`: + - the parameters, the band list, and 11 sampled bands (the last band and the band ending at each `r_*` among them); + - both `C` tables as the maxima of the stored records; + - `C > c_G(0, 2)` and `C' > c_G(6/5, 1/6)` for every `r_*`; + - the canonical layout of `RESULTS.json` (one line per band record). + + It takes about one minute on four cores. +- `--check-full` replays all 153 bands (about ten minutes on four cores). +- Mutants `no-delta` (drop the fourth-derivative terms of Lemma 2), `cap-half` (halve the cap constant `4/(3k)`), + `no-zfloor-correction` (drop the corrections of Lemma 5) and `no-om-term` (drop the `om` terms `B`, `B'`) exit 1. +- Without flags, the script regenerates `RESULTS.json` (about ten minutes on four cores). +- Workflow `.github/workflows/c8-theorem-a-constants-planar.yml` checks: + - the manifest and the main-resident pins ([LP], [CAP]); + - `--check-full` and `--check` in the two interpreter modes; + - the four mutants; + - a clean tree. + +**Revisions.** v1 (`f3d41b5`): Theorem E on the band. + +v1.1 adds: +- Theorem E' at the fixed-axis SIDE24 point; +- the linear density bound for `lambda` (section 5); +- the per-box choice between two `(X_0, theta)` pairs (section 5); +- the Hölder exponents `q in {2, 4, 8, 16}` for the rare branches (section 7); +- `RESULTS.json` regenerated. + +The band constants change only in the last digits, except `C(1/256)`, which drops from `3.41 x 10^7` to `9.37 x 10^6`. + +v1.2 is documentation only: two docstrings in `theorem_a.py`, byte-identical copies of which are carried by Math-#215 and +Math-#227. The AST with docstrings removed is unchanged, and so are `RESULTS.json` and every constant. +- `sqrt_up` promised a relative error below `2^-200`; at `x = 49/100` the excess is `(8/7) 2^-200` (C59-DOC-01). The + stated bound is now `2^-198`: the root step adds less than `2^-209` and the rounding to 200 bits less than `2^-199`. +- `box_bound` said "every choice gives a valid bound". It now states the proved domain: `0 < x0 < 2/9` and + `0 < theta < 1` (C61). Both `COMBOS` pairs, `(1/64, 1/32)` and `(1/1024, 1/256)`, lie inside it. + +v1.2.1 is one wording fix in section 0, from the Slice C review 5397446329 (C206-C-01). The SIDE24 constant +`39322.8180` exceeds the certified lower end `35736.7352` of `c_G(6/5, 1/6)` by the factor `1.100348` (`RESULTS.json`), +so "within `10%`" now reads "within `10.1%`". The `21%` statement (factor `1.205825`) was already correct. No code, +`RESULTS.json` or constant changed. + +v1.2.2 is one wording fix in section 5, from the Slice A review 5397500398 (C206-A-01). "Every pair `(X_0, theta)` +gives a valid bound" now names the proved domain `0 < X_0 < 2/9`, `0 < theta < 1`, matching the `box_bound` docstring +since v1.2; both `COMBOS` pairs, `(1/64, 1/32)` and `(1/1024, 1/256)`, lie inside it. No code, `RESULTS.json` or constant +changed. + +Author lane Anthropic / Claude, 30 September – 2 October 2026. Scientific effect NONE. The author will not merge. diff --git a/frontiers/c8_theorem_a_constants_planar_20260930/README.md b/frontiers/c8_theorem_a_constants_planar_20260930/README.md new file mode 100644 index 000000000..bb03e4d15 --- /dev/null +++ b/frontiers/c8_theorem_a_constants_planar_20260930/README.md @@ -0,0 +1,57 @@ +# Explicit cap-route constants for Theorem A in the plane (C8: certified `C`, `r_*`, `z_*` on a declared band) + +**Object:** `CL-C8-THEOREM-A-CONSTANTS-PLANAR-20260930-v1`. **Author lane:** Anthropic / Claude. **Kind:** author-side theorem +with explicit constants, certified by exact rational interval arithmetic (standard library only). **Scientific effect:** +NONE: no register, catalog, GRAPH or STATUS change, and catalog entry C8 stays OPEN. + +**Setting.** The planar six-pin law of [LP] with the good event +`G_r = {lambda_min(-A_M) > (4/(3k)) r M_3^2, r M_4 <= 3k/10}` of [LP] section 7 / [CAP] (1). Theorem E (`NOTE.md`) holds on +the band `b in [0, 1]`, `k in [1/2, 2]`, uniformly over frames and torus sides `L >= 10`, and for the reference kernel: + + Q^W(G_r^c) <= C(r_*) r^3 and Z_r / r^2 >= z(r_*) for 0 < r <= r_*, + +| `r_*` | `C(r_*)` | `C r_*^3` | `z(r_*)` | +|---|---|---|---| +| `1/4096` | `5355315.0638` | `7.8e-5` | `8.9953` | +| `1/2048` | `5362302.4479` | `6.3e-4` | `8.9907` | +| `1/1024` | `5377835.0775` | `5.1e-3` | `8.9815` | +| `1/512` | `5415659.2391` | `0.0404` | `8.9629` | +| `1/256` | `9370799.9311` | `0.559` | `8.9217` | + +(`1/128` and `1/64` are also certified, with `C r_*^3 > 1`.) + +**Theorem E' (v1.1).** The same holds at the fixed-axis SIDE24 point `(b, k) = (6/5, 1/6)` of [CAP] §1: + +| `r_*` | `C'(r_*)` | `C' / c_G(6/5, 1/6)` | `C' r_*^3` | +|---|---|---|---| +| `1/4096` | `39322.818` | `1.100` | `5.8e-7` | +| `1/2048` | `43092.238` | `1.206` | `5.1e-6` | +| `1/1024` | `1283859.690` | `35.9` | `0.0012` | +| `1/512` | `117316965.49` | `3283` | `0.874` | + +This replaces [CAP]'s `2.4 x 10^23`, which is nontrivial only below `r = 1.6 x 10^-8`. + +**What follows.** +- **Explicit Theorem A.** Since `1 - p_r <= Q^W(G_r^c)` ([LP] §8), [LP] Theorem A (1.1) holds on this band with explicit + pairs, for example `(C, r_*) = (5415659.2391, 1/512)` or `(9370799.9311, 1/256)`. [LP] §16 lists such a pair among the items + it does not supply. For the SIDE24 law, `1 - p_elder(r) <= 39322.818 r^3` for `r <= 1/4096`. +- **Near-optimal for the cap route.** The constants are within `0.6%`–`1.8%` of the sharp cap coefficient + `c_G(0, 2) = 5324360.44` of Math-#203, below which no cap-route constant can go. +- **Normalizer floor.** Together with Math-#195, `Z_r / r^2 >= 3.5044` on all of `(0, 1/2]` for `L >= 12`. + +**Files.** +- `NOTE.md`: statement, the exact identities, Lemmas 1–5 (exact covariance series with a frame- and `L`-uniform torus + remainder; averaging identities for `M_3`; the Taylor bound for `M_4`; the root bounds after regression on `f_yy(M)`; the + normalizer floor), the main term, the rare branches, bands, values, Monte Carlo controls, and non-claims. +- `theorem_a.py`: the certificate and its replay. + - `--check --procs N` replays the parameters, 11 sampled bands and both `C` tables exactly against `RESULTS.json`. + - `--check-full` replays all 153 bands, in about ten minutes on four cores. + - `--mutant {no-delta, cap-half, no-zfloor-correction, no-om-term}` must exit 1. + - With no flags it regenerates `RESULTS.json`. + - `--mc R B K N SEED` is the floating Monte Carlo control. +- `RESULTS.json` (one line per band: 28 box bounds, 28 floors, the largest tail part, the SIDE24 bound and floor), + `SOURCE_MAP.json` (pins [LP] and [CAP] on `main`; read-only references to Math-#203 and Math-#195), `SOURCE_FILES.json`. +- Workflow `.github/workflows/c8-theorem-a-constants-planar.yml` replays the manifest, the pins, `--check-full` and `--check` + in the two interpreter modes, the four mutants, and a clean tree. + +Same GitHub account as every other lane; zero organizational-independence credit. The author will not merge. diff --git a/frontiers/c8_theorem_a_constants_planar_20260930/RESULTS.json b/frontiers/c8_theorem_a_constants_planar_20260930/RESULTS.json new file mode 100644 index 000000000..ed35fc61a --- /dev/null +++ b/frontiers/c8_theorem_a_constants_planar_20260930/RESULTS.json @@ -0,0 +1,474 @@ +{ + "C_table": { + "1/1024": { + "C": "2151134031/400", + "C_over_cG02": "1.010044", + "C_rstar3": "0.0050084993", + "argmax": { + "b": [ + "0", + "1/64" + ], + "k": [ + "63/32", + "2" + ], + "r": [ + "31/32768", + "1/1024" + ] + }, + "z_star": "17963/2000" + }, + "1/128": { + "C": "87390113247/250", + "C_over_cG02": "65.653041", + "C_rstar3": "166.6834130230", + "argmax": { + "b": [ + "1/4", + "1" + ], + "k": [ + "1/2", + "1" + ], + "r": [ + "5/1024", + "11/2048" + ] + }, + "z_star": "8841791/1000000" + }, + "1/2048": { + "C": "53623024479/10000", + "C_over_cG02": "1.007127", + "C_rstar3": "0.0006242542", + "argmax": { + "b": [ + "0", + "1/64" + ], + "k": [ + "63/32", + "2" + ], + "r": [ + "31/65536", + "1/2048" + ] + }, + "z_star": "1798151/200000" + }, + "1/256": { + "C": "93707999311/10000", + "C_over_cG02": "1.759987", + "C_rstar3": "0.5585432012", + "argmax": { + "b": [ + "1/4", + "1" + ], + "k": [ + "1/2", + "1" + ], + "r": [ + "15/4096", + "1/256" + ] + }, + "z_star": "4460899/500000" + }, + "1/4096": { + "C": "26776575319/5000", + "C_over_cG02": "1.005814", + "C_rstar3": "0.0000779301", + "argmax": { + "b": [ + "0", + "1/64" + ], + "k": [ + "63/32", + "2" + ], + "r": [ + "31/131072", + "1/4096" + ] + }, + "z_star": "8995379/1000000" + }, + "1/512": { + "C": "54156592391/10000", + "C_over_cG02": "1.017148", + "C_rstar3": "0.0403498057", + "argmax": { + "b": [ + "0", + "1/64" + ], + "k": [ + "63/32", + "2" + ], + "r": [ + "31/16384", + "1/512" + ] + }, + "z_star": "8962953/1000000" + }, + "1/64": { + "C": "14397396179923/10000", + "C_over_cG02": "270.406115", + "C_rstar3": "5492.1707839673", + "argmax": { + "b": [ + "1/4", + "1" + ], + "k": [ + "1/2", + "1" + ], + "r": [ + "15/1024", + "1/64" + ] + }, + "z_star": "54227/6250" + } + }, + "C_table_side24": { + "1/1024": { + "C": "1604824613/1250", + "C_over_cG": "35.925490", + "C_rstar3": "0.0011956876", + "argmax_r": [ + "31/32768", + "1/1024" + ], + "z_star": "3213821/1000000" + }, + "1/128": { + "C": "815443379659/5000", + "C_over_cG": "4563.614304", + "C_rstar3": "77.7667407665", + "argmax_r": [ + "1/512", + "9/4096" + ], + "z_star": "3092963/1000000" + }, + "1/2048": { + "C": "215461191/5000", + "C_over_cG": "1.205825", + "C_rstar3": "0.0000050166", + "argmax_r": [ + "31/65536", + "1/2048" + ], + "z_star": "3222401/1000000" + }, + "1/256": { + "C": "815443379659/5000", + "C_over_cG": "4563.614304", + "C_rstar3": "9.7208425959", + "argmax_r": [ + "1/512", + "9/4096" + ], + "z_star": "3162091/1000000" + }, + "1/4096": { + "C": "19661409/500", + "C_over_cG": "1.100348", + "C_rstar3": "0.0000005723", + "argmax_r": [ + "31/131072", + "1/4096" + ], + "z_star": "322669/100000" + }, + "1/512": { + "C": "1173169654911/10000", + "C_over_cG": "3282.811506", + "C_rstar3": "0.8740795068", + "argmax_r": [ + "31/16384", + "1/512" + ], + "z_star": "3196649/1000000" + }, + "1/64": { + "C": "5553365927589/5000", + "C_over_cG": "31079.313186", + "C_rstar3": "4236.8819637978", + "argmax_r": [ + "15/1024", + "1/64" + ], + "z_star": "2953979/1000000" + } + }, + "L_min": 10, + "band": { + "b": [ + "0", + "1" + ], + "k": [ + "1/2", + "2" + ] + }, + "certified": true, + "mutant": null, + "object": "CL-C8-THEOREM-A-CONSTANTS-PLANAR-20260930-v1", + "parameters": { + "B_BOXES": [ + [ + "0", + "1/64" + ], + [ + "1/64", + "1/16" + ], + [ + "1/16", + "1/4" + ], + [ + "1/4", + "1" + ] + ], + "COMBOS_X0_THETA": [ + [ + "1/64", + "1/32" + ], + [ + "1/1024", + "1/256" + ] + ], + "HIGH_OCTAVES": 3, + "K_BOXES": [ + [ + "1/2", + "1" + ], + [ + "1", + "3/2" + ], + [ + "3/2", + "7/4" + ], + [ + "7/4", + "15/8" + ], + [ + "15/8", + "31/16" + ], + [ + "31/16", + "63/32" + ], + [ + "63/32", + "2" + ] + ], + "LOW_OCTAVES": 16, + "NB": 24, + "NX": 60, + "PBITS": 160, + "QS": [ + 2, + 4, + 8, + 16 + ], + "R_LAST": "1/536870912", + "R_STARS": [ + "1/4096", + "1/2048", + "1/1024", + "1/512", + "1/256", + "1/128", + "1/64" + ], + "THETA_E": "1/16", + "TOP_OCTAVES": 4 + }, + "schema": 1, + "scientific_effect": "NONE", + "side24_point": { + "b": "6/5", + "k": "1/6" + }, + "bands": [ + {"bound": ["688669.0013", "2260517.0655", "3585872.5655", "4408747.4482", "4863642.2266", "5102380.2144", "5348823.2086", "676614.8681", "2220950.1759", "3523107.4584", "4331579.2618", "4778511.8571", "5013071.1318", "5255200.5507", "641489.0702", "2105651.7204", "3340208.7798", "4106709.5595", "4530440.0859", "4752822.4450", "4982381.9518", "515657.2978", "1692616.0096", "2685007.5875", "3301154.8228", "3641768.1650", "3820528.9432", "4005059.0303"], "r": ["0", "1/536870912"], "side24": ["37767.8416", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999998", "110.249998", "126.562498", "135.140623", "139.535154", "9.159780", "36.639120", "82.438020", "112.207305", "128.809406", "137.539822", "142.012371", "9.652497", "38.609991", "86.872480", "118.243098", "135.738251", "144.938288", "149.651421", "11.833305", "47.333222", "106.499749", "144.957992", "166.405858", "177.684478", "183.462459"]}, + {"bound": ["688669.0031", "2260517.0583", "3585872.5455", "4408747.4196", "4863642.1928", "5102380.1779", "5348823.1694", "676614.8899", "2220950.2648", "3523107.6162", "4331579.4672", "4778512.0903", "5013071.3798", "5255200.8145", "641489.0914", "2105651.8055", "3340208.9303", "4106709.7552", "4530440.3079", "4752822.6812", "4982382.2029", "515657.3168", "1692616.0818", "2685007.7131", "3301154.9853", "3641768.3490", "3820529.1387", "4005059.2381"], "r": ["1/536870912", "5/2147483648"], "side24": ["37767.8445", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999999", "110.249999", "126.562499", "135.140624", "139.535155", "9.159780", "36.639120", "82.438021", "112.207306", "128.809408", "137.539823", "142.012372", "9.652497", "38.609991", "86.872481", "118.243099", "135.738252", "144.938289", "149.651423", "11.833305", "47.333222", "106.499750", "144.957993", "166.405860", "177.684479", "183.462460"]}, + {"bound": ["688669.0082", "2260517.0671", "3585872.5552", "4408747.4300", "4863642.2036", "5102380.1889", "5348823.1808", "676614.9149", "2220950.3694", "3523107.8032", "4331579.7112", "4778512.3673", "5013071.6746", "5255201.1281", "641489.1156", "2105651.9057", "3340209.1087", "4106709.9878", "4530440.5720", "4752822.9621", "4982382.5018", "515657.3384", "1692616.1665", "2685007.8619", "3301155.1786", "3641768.5681", "3820529.3716", "4005059.4858"], "r": ["5/2147483648", "3/1073741824"], "side24": ["37767.8474", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999999", "110.249999", "126.562499", "135.140624", "139.535155", "9.159780", "36.639120", "82.438021", "112.207306", "128.809408", "137.539823", "142.012372", "9.652497", "38.609991", "86.872481", "118.243099", "135.738252", "144.938289", "149.651423", "11.833305", "47.333222", "106.499750", "144.957993", "166.405860", "177.684479", "183.462460"]}, + {"bound": ["688669.0132", "2260517.0759", "3585872.5649", "4408747.4404", "4863642.2144", "5102380.1999", "5348823.1922", "676614.9400", "2220950.4741", "3523107.9902", "4331579.9551", "4778512.6444", "5013071.9695", "5255201.4418", "641489.1399", "2105652.0060", "3340209.2872", "4106710.2204", "4530440.8360", "4752823.2430", "4982382.8006", "515657.3599", "1692616.2513", "2685008.0108", "3301155.3719", "3641768.7872", "3820529.6045", "4005059.7334"], "r": ["3/1073741824", "7/2147483648"], "side24": ["37767.8502", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999999", "110.249999", "126.562499", "135.140624", "139.535155", "9.159780", "36.639120", "82.438021", "112.207306", "128.809407", "137.539823", "142.012372", "9.652497", "38.609991", "86.872481", "118.243099", "135.738252", "144.938289", "149.651423", "11.833305", "47.333222", "106.499750", "144.957993", "166.405859", "177.684479", "183.462460"]}, + {"bound": ["688669.0183", "2260517.0847", "3585872.5746", "4408747.4508", "4863642.2253", "5102380.2109", "5348823.2036", "676614.9650", "2220950.5787", "3523108.1772", "4331580.1991", "4778512.9214", "5013072.2643", "5255201.7554", "641489.1642", "2105652.1062", "3340209.4657", "4106710.4530", "4530441.1000", "4752823.5240", "4982383.0994", "515657.3814", "1692616.3361", "2685008.1597", "3301155.5651", "3641769.0062", "3820529.8375", "4005059.9811"], "r": ["7/2147483648", "1/268435456"], "side24": ["37767.8531", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999999", "110.249999", "126.562499", "135.140624", "139.535155", "9.159780", "36.639120", "82.438021", "112.207306", "128.809407", "137.539823", "142.012372", "9.652497", "38.609991", "86.872481", "118.243099", "135.738252", "144.938289", "149.651422", "11.833305", "47.333222", "106.499750", "144.957993", "166.405859", "177.684479", "183.462460"]}, + {"bound": ["688669.0295", "2260517.1077", "3585872.6038", "4408747.4846", "4863642.2617", "5102380.2488", "5348823.2432", "676615.0160", "2220950.7933", "3523108.5609", "4331580.6999", "4778513.4902", "5013072.8696", "5255202.3993", "641489.2137", "2105652.3117", "3340209.8320", "4106710.9305", "4530441.6421", "4752824.1008", "4982383.7130", "515657.4253", "1692616.5099", "2685008.4653", "3301155.9620", "3641769.4561", "3820530.3158", "4005060.4896"], "r": ["1/268435456", "5/1073741824"], "side24": ["37767.8589", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999999", "110.249998", "126.562498", "135.140623", "139.535154", "9.159780", "36.639120", "82.438020", "112.207306", "128.809407", "137.539822", "142.012371", "9.652497", "38.609991", "86.872480", "118.243099", "135.738251", "144.938288", "149.651422", "11.833305", "47.333222", "106.499749", "144.957992", "166.405859", "177.684478", "183.462459"]}, + {"bound": ["688669.0397", "2260517.1254", "3585872.6232", "4408747.5054", "4863642.2833", "5102380.2709", "5348823.2660", "676615.0661", "2220951.0026", "3523108.9349", "4331581.1878", "4778514.0443", "5013073.4593", "5255203.0266", "641489.2622", "2105652.5122", "3340210.1889", "4106711.3957", "4530442.1702", "4752824.6627", "4982384.3106", "515657.4684", "1692616.6795", "2685008.7631", "3301156.3486", "3641769.8942", "3820530.7817", "4005060.9849"], "r": ["5/1073741824", "3/536870912"], "side24": ["37767.8647", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999999", "110.249998", "126.562498", "135.140623", "139.535154", "9.159780", "36.639120", "82.438020", "112.207305", "128.809407", "137.539822", "142.012371", "9.652497", "38.609991", "86.872480", "118.243098", "135.738251", "144.938288", "149.651422", "11.833305", "47.333221", "106.499749", "144.957992", "166.405858", "177.684478", "183.462459"]}, + {"bound": ["688669.0498", "2260517.1430", "3585872.6426", "4408747.5262", "4863642.3049", "5102380.2929", "5348823.2888", "676615.1161", "2220951.2119", "3523109.3089", "4331581.6757", "4778514.5984", "5013074.0489", "5255203.6539", "641489.3108", "2105652.7127", "3340210.5459", "4106711.8609", "4530442.6983", "4752825.2246", "4982384.9083", "515657.5115", "1692616.8490", "2685009.0609", "3301156.7351", "3641770.3324", "3820531.2475", "4005061.4802"], "r": ["3/536870912", "7/1073741824"], "side24": ["37767.8705", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999998", "110.249998", "126.562498", "135.140623", "139.535154", "9.159780", "36.639120", "82.438020", "112.207305", "128.809407", "137.539822", "142.012371", "9.652497", "38.609991", "86.872480", "118.243098", "135.738251", "144.938288", "149.651421", "11.833305", "47.333221", "106.499749", "144.957992", "166.405858", "177.684477", "183.462458"]}, + {"bound": ["688669.0600", "2260517.1606", "3585872.6620", "4408747.5470", "4863642.3266", "5102380.3149", "5348823.3116", "676615.1661", "2220951.4212", "3523109.6829", "4331582.1636", "4778515.1525", "5013074.6386", "5255204.2811", "641489.3593", "2105652.9131", "3340210.9028", "4106712.3261", "4530443.2264", "4752825.7865", "4982385.5059", "515657.5546", "1692617.0186", "2685009.3587", "3301157.1217", "3641770.7705", "3820531.7134", "4005061.9755"], "r": ["7/1073741824", "1/134217728"], "side24": ["37767.8762", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999998", "110.249998", "126.562498", "135.140623", "139.535154", "9.159780", "36.639120", "82.438020", "112.207305", "128.809407", "137.539822", "142.012371", "9.652497", "38.609991", "86.872480", "118.243098", "135.738251", "144.938288", "149.651421", "11.833305", "47.333221", "106.499749", "144.957991", "166.405858", "177.684477", "183.462458"]}, + {"bound": ["688669.0824", "2260517.2066", "3585872.7205", "4408747.6146", "4863642.3995", "5102380.3907", "5348823.3909", "676615.2683", "2220951.8504", "3523110.4504", "4331583.1652", "4778516.2899", "5013075.8492", "5255205.5689", "641489.4584", "2105653.3242", "3340211.6354", "4106713.2811", "4530444.3106", "4752826.9401", "4982386.7331", "515657.6424", "1692617.3661", "2685009.9698", "3301157.9154", "3641771.6702", "3820532.6701", "4005062.9927"], "r": ["1/134217728", "5/536870912"], "side24": ["37767.8878", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999998", "110.249997", "126.562497", "135.140622", "139.535153", "9.159779", "36.639119", "82.438019", "112.207304", "128.809405", "137.539821", "142.012370", "9.652497", "38.609991", "86.872479", "118.243097", "135.738249", "144.938286", "149.651420", "11.833305", "47.333221", "106.499748", "144.957990", "166.405856", "177.684475", "183.462456"]}, + {"bound": ["688669.1027", "2260517.2419", "3585872.7592", "4408747.6562", "4863642.4427", "5102380.4348", "5348823.4365", "676615.3683", "2220952.2690", "3523111.1984", "4331584.1410", "4778517.3981", "5013077.0285", "5255206.8235", "641489.5555", "2105653.7251", "3340212.3493", "4106714.2115", "4530445.3668", "4752828.0639", "4982387.9284", "515657.7286", "1692617.7053", "2685010.5654", "3301158.6885", "3641772.5465", "3820533.6018", "4005063.9833"], "r": ["5/536870912", "3/268435456"], "side24": ["37767.8993", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999998", "110.249997", "126.562497", "135.140621", "139.535152", "9.159779", "36.639119", "82.438019", "112.207304", "128.809405", "137.539821", "142.012369", "9.652497", "38.609990", "86.872479", "118.243097", "135.738249", "144.938286", "149.651420", "11.833305", "47.333220", "106.499747", "144.957990", "166.405855", "177.684475", "183.462456"]}, + {"bound": ["688669.1230", "2260517.2772", "3585872.7980", "4408747.6978", "4863642.4859", "5102380.4788", "5348823.4820", "676615.4683", "2220952.6876", "3523111.9465", "4331585.1168", "4778518.5063", "5013078.2079", "5255208.0781", "641489.6525", "2105654.1261", "3340213.0632", "4106715.1419", "4530446.4229", "4752829.1877", "4982389.1237", "515657.8147", "1692618.0444", "2685011.1610", "3301159.4617", "3641773.4228", "3820534.5335", "4005064.9738"], "r": ["3/268435456", "7/536870912"], "side24": ["37767.9109", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999999", "80.999997", "110.249997", "126.562496", "135.140621", "139.535152", "9.159779", "36.639119", "82.438019", "112.207304", "128.809405", "137.539820", "142.012369", "9.652497", "38.609990", "86.872479", "118.243097", "135.738249", "144.938286", "149.651419", "11.833304", "47.333220", "106.499747", "144.957989", "166.405855", "177.684474", "183.462455"]}, + {"bound": ["688669.1433", "2260517.3125", "3585872.8368", "4408747.7394", "4863642.5291", "5102380.5229", "5348823.5276", "676615.5684", "2220953.1063", "3523112.6945", "4331586.0927", "4778519.6145", "5013079.3872", "5255209.3326", "641489.7496", "2105654.5270", "3340213.7771", "4106716.0723", "4530447.4791", "4752830.3114", "4982390.3190", "515657.9008", "1692618.3836", "2685011.7566", "3301160.2348", "3641774.2991", "3820535.4652", "4005065.9644"], "r": ["7/536870912", "1/67108864"], "side24": ["37767.9224", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999998", "80.999997", "110.249996", "126.562496", "135.140621", "139.535152", "9.159779", "36.639119", "82.438019", "112.207304", "128.809405", "137.539820", "142.012369", "9.652497", "38.609990", "86.872479", "118.243096", "135.738249", "144.938285", "149.651419", "11.833304", "47.333220", "106.499746", "144.957988", "166.405854", "177.684473", "183.462454"]}, + {"bound": ["688669.1882", "2260517.4044", "3585872.9538", "4408747.8748", "4863642.6750", "5102380.6744", "5348823.6862", "676615.7727", "2220953.9646", "3523114.2295", "4331588.0958", "4778521.8895", "5013081.8083", "5255211.9082", "641489.9478", "2105655.3491", "3340215.2422", "4106717.9823", "4530449.6475", "4752832.6187", "4982392.7733", "515658.0765", "1692619.0787", "2685012.9789", "3301161.8222", "3641776.0985", "3820537.3786", "4005067.9987"], "r": ["1/67108864", "5/268435456"], "side24": ["37767.9456", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999998", "80.999996", "110.249995", "126.562494", "135.140619", "139.535150", "9.159779", "36.639119", "82.438018", "112.207302", "128.809403", "137.539818", "142.012366", "9.652497", "38.609990", "86.872477", "118.243095", "135.738246", "144.938283", "149.651417", "11.833304", "47.333219", "106.499744", "144.957986", "166.405851", "177.684470", "183.462451"]}, + {"bound": ["688669.2288", "2260517.4750", "3585873.0313", "4408747.9579", "4863642.7614", "5102380.7626", "5348823.7774", "676615.9728", "2220954.8018", "3523115.7255", "4331590.0475", "4778524.1059", "5013084.1670", "5255214.4174", "641490.1419", "2105656.1510", "3340216.6700", "4106719.8431", "4530451.7598", "4752834.8663", "4982395.1639", "515658.2488", "1692619.7570", "2685014.1701", "3301163.3685", "3641777.8511", "3820539.2420", "4005069.9799"], "r": ["5/268435456", "3/134217728"], "side24": ["37767.9686", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999998", "80.999996", "110.249994", "126.562494", "135.140618", "139.535149", "9.159779", "36.639118", "82.438017", "112.207301", "128.809402", "137.539817", "142.012366", "9.652497", "38.609989", "86.872477", "118.243094", "135.738246", "144.938282", "149.651416", "11.833304", "47.333219", "106.499744", "144.957985", "166.405850", "177.684469", "183.462450"]}, + {"bound": ["688669.2693", "2260517.5456", "3585873.1088", "4408748.0411", "4863642.8479", "5102380.8507", "5348823.8685", "676616.1729", "2220955.6390", "3523117.2215", "4331591.9991", "4778526.3223", "5013086.5257", "5255216.9265", "641490.3361", "2105656.9529", "3340218.0978", "4106721.7039", "4530453.8722", "4752837.1139", "4982397.5545", "515658.4211", "1692620.4352", "2685015.3612", "3301164.9148", "3641779.6037", "3820541.1055", "4005071.9611"], "r": ["3/134217728", "7/268435456"], "side24": ["37767.9917", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999998", "80.999995", "110.249994", "126.562493", "135.140618", "139.535149", "9.159779", "36.639118", "82.438017", "112.207301", "128.809402", "137.539817", "142.012365", "9.652497", "38.609989", "86.872477", "118.243093", "135.738245", "144.938282", "149.651415", "11.833304", "47.333218", "106.499743", "144.957984", "166.405849", "177.684468", "183.462448"]}, + {"bound": ["688669.3099", "2260517.6162", "3585873.1864", "4408748.1243", "4863642.9343", "5102380.9389", "5348823.9597", "676616.3729", "2220956.4763", "3523118.7175", "4331593.9508", "4778528.5387", "5013088.8844", "5255219.4356", "641490.5302", "2105657.7549", "3340219.5255", "4106723.5647", "4530455.9845", "4752839.3614", "4982399.9451", "515658.5934", "1692621.1135", "2685016.5524", "3301166.4611", "3641781.3562", "3820542.9690", "4005073.9423"], "r": ["7/268435456", "1/33554432"], "side24": ["37768.0148", "3.230978"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999997", "80.999995", "110.249993", "126.562493", "135.140617", "139.535148", "9.159779", "36.639118", "82.438017", "112.207301", "128.809401", "137.539816", "142.012365", "9.652497", "38.609989", "86.872476", "118.243093", "135.738244", "144.938281", "149.651415", "11.833304", "47.333218", "106.499742", "144.957983", "166.405848", "177.684466", "183.462447"]}, + {"bound": ["688669.3998", "2260517.8001", "3585873.4205", "4408748.3950", "4863643.2260", "5102381.2419", "5348824.2769", "676616.7816", "2220958.1929", "3523121.7876", "4331597.9570", "4778533.0886", "5013093.7266", "5255224.5868", "641490.9266", "2105659.3990", "3340222.4558", "4106727.3847", "4530460.3213", "4752843.9760", "4982404.8536", "515658.9448", "1692622.5037", "2685018.9970", "3301169.6358", "3641784.9550", "3820546.7956", "4005078.0109"], "r": ["1/33554432", "5/134217728"], "side24": ["37768.0611", "3.230977"], "tail_max": "0.000000000001", "zfloor": ["8.999999", "35.999996", "80.999993", "110.249990", "126.562489", "135.140613", "139.535144", "9.159779", "36.639117", "82.438014", "112.207297", "128.809397", "137.539812", "142.012360", "9.652496", "38.609988", "86.872473", "118.243089", "135.738240", "144.938276", "149.651410", "11.833303", "47.333216", "106.499738", "144.957977", "166.405841", "177.684460", "183.462440"]}, + {"bound": ["688669.4809", "2260517.9412", "3585873.5755", "4408748.5614", "4863643.3989", "5102381.4182", "5348824.4592", "676617.1818", "2220959.8674", "3523124.7796", "4331601.8604", "4778537.5214", "5013098.4440", "5255229.6051", "641491.3149", "2105661.0028", "3340225.3114", "4106731.1063", "4530464.5460", "4752848.4711", "4982409.6349", "515659.2894", "1692623.8603", "2685021.3794", "3301172.7284", "3641788.4602", "3820550.5226", "4005081.9733"], "r": ["5/134217728", "3/67108864"], "side24": ["37768.1072", "3.230977"], "tail_max": "0.000000000001", "zfloor": ["8.999998", "35.999996", "80.999992", "110.249989", "126.562488", "135.140612", "139.535143", "9.159779", "36.639117", "82.438013", "112.207296", "128.809396", "137.539811", "142.012359", "9.652496", "38.609987", "86.872473", "118.243088", "135.738239", "144.938275", "149.651408", "11.833303", "47.333215", "106.499736", "144.957975", "166.405839", "177.684457", "183.462438"]}, + {"bound": ["688669.5621", "2260518.0824", "3585873.7305", "4408748.7278", "4863643.5718", "5102381.5945", "5348824.6415", "676617.5819", "2220961.5418", "3523127.7716", "4331605.7637", "4778541.9542", "5013103.1614", "5255234.6233", "641491.7031", "2105662.6066", "3340228.1670", "4106734.8279", "4530468.7707", "4752852.9662", "4982414.4161", "515659.6339", "1692625.2169", "2685023.7617", "3301175.8210", "3641791.9654", "3820554.2495", "4005085.9356"], "r": ["3/67108864", "7/134217728"], "side24": ["37768.1534", "3.230977"], "tail_max": "0.000000000001", "zfloor": ["8.999998", "35.999996", "80.999991", "110.249988", "126.562487", "135.140611", "139.535142", "9.159778", "36.639116", "82.438013", "112.207295", "128.809395", "137.539810", "142.012358", "9.652496", "38.609987", "86.872472", "118.243087", "135.738238", "144.938274", "149.651407", "11.833302", "47.333214", "106.499734", "144.957973", "166.405837", "177.684455", "183.462435"]}, + {"bound": ["688669.6432", "2260518.2235", "3585873.8856", "4408748.8942", "4863643.7447", "5102381.7708", "5348824.8238", "676617.9820", "2220963.2163", "3523130.7637", "4331609.6671", "4778546.3870", "5013107.8788", "5255239.6416", "641492.0914", "2105664.2105", "3340231.0225", "4106738.5495", "4530472.9954", "4752857.4613", "4982419.1974", "515659.9785", "1692626.5734", "2685026.1440", "3301178.9137", "3641795.4705", "3820557.9764", "4005089.8980"], "r": ["7/134217728", "1/16777216"], "side24": ["37768.1996", "3.230977"], "tail_max": "0.000000000001", "zfloor": ["8.999998", "35.999995", "80.999991", "110.249987", "126.562486", "135.140610", "139.535140", "9.159778", "36.639116", "82.438012", "112.207294", "128.809394", "137.539809", "142.012357", "9.652496", "38.609986", "86.872471", "118.243086", "135.738236", "144.938272", "149.651406", "11.833302", "47.333213", "106.499733", "144.957971", "166.405834", "177.684452", "183.462432"]}, + {"bound": ["688669.8229", "2260518.5913", "3585874.3539", "4408749.4354", "4863644.3281", "5102382.3768", "5348825.4582", "676618.7994", "2220966.6495", "3523136.9037", "4331617.6794", "4778555.4869", "5013117.5632", "5255249.9440", "641492.8842", "2105667.4988", "3340236.8830", "4106746.1894", "4530481.6690", "4752866.6905", "4982429.0144", "515660.6813", "1692629.3539", "2685031.0333", "3301185.2631", "3641802.6681", "3820565.6298", "4005098.0352"], "r": ["1/16777216", "5/67108864"], "side24": ["37768.2921", "3.230977"], "tail_max": "0.000000000001", "zfloor": ["8.999998", "35.999993", "80.999986", "110.249981", "126.562478", "135.140601", "139.535131", "9.159778", "36.639114", "82.438007", "112.207287", "128.809386", "137.539800", "142.012348", "9.652495", "38.609984", "86.872465", "118.243078", "135.738227", "144.938263", "149.651396", "11.833301", "47.333209", "106.499725", "144.957960", "166.405822", "177.684439", "183.462419"]}, + {"bound": ["688669.9852", "2260518.8736", "3585874.6639", "4408749.7682", "4863644.6739", "5102382.7294", "5348825.8228", "676619.5997", "2220969.9985", "3523142.8878", "4331625.4862", "4778564.3525", "5013126.9980", "5255259.9806", "641493.6607", "2105670.7064", "3340242.5942", "4106753.6327", "4530490.1184", "4752875.6808", "4982438.5769", "515661.3705", "1692632.0670", "2685035.7980", "3301191.4483", "3641809.6784", "3820573.0836", "4005105.9600"], "r": ["5/67108864", "3/33554432"], "side24": ["37768.3844", "3.230976"], "tail_max": "0.000000000001", "zfloor": ["8.999997", "35.999993", "80.999984", "110.249979", "126.562476", "135.140599", "139.535129", "9.159778", "36.639113", "82.438006", "112.207285", "128.809384", "137.539798", "142.012345", "9.652495", "38.609983", "86.872464", "118.243076", "135.738225", "144.938260", "149.651393", "11.833300", "47.333208", "106.499722", "144.957956", "166.405817", "177.684434", "183.462413"]}, + {"bound": ["688670.1475", "2260519.1559", "3585874.9739", "4408750.1010", "4863645.0197", "5102383.0820", "5348826.1874", "676620.4000", "2220973.3474", "3523148.8719", "4331633.2930", "4778573.2181", "5013136.4328", "5255270.0171", "641494.4372", "2105673.9141", "3340248.3054", "4106761.0759", "4530498.5678", "4752884.6710", "4982448.1394", "515662.0596", "1692634.7801", "2685040.5626", "3301197.6335", "3641816.6888", "3820580.5374", "4005113.8847"], "r": ["3/33554432", "7/67108864"], "side24": ["37768.4768", "3.230976"], "tail_max": "0.000000000001", "zfloor": ["8.999997", "35.999992", "80.999983", "110.249977", "126.562474", "135.140597", "139.535127", "9.159777", "36.639112", "82.438004", "112.207284", "128.809382", "137.539795", "142.012343", "9.652495", "38.609982", "86.872462", "118.243074", "135.738223", "144.938258", "149.651390", "11.833299", "47.333206", "106.499718", "144.957951", "166.405812", "177.684429", "183.462408"]}, + {"bound": ["688670.3098", "2260519.4382", "3585875.2840", "4408750.4338", "4863645.3655", "5102383.4347", "5348826.5521", "676621.2003", "2220976.6964", "3523154.8560", "4331641.0998", "4778582.0838", "5013145.8676", "5255280.0536", "641495.2137", "2105677.1217", "3340254.0166", "4106768.5192", "4530507.0172", "4752893.6612", "4982457.7019", "515662.7488", "1692637.4932", "2685045.3273", "3301203.8188", "3641823.6991", "3820587.9913", "4005121.8095"], "r": ["7/67108864", "1/8388608"], "side24": ["37768.5691", "3.230976"], "tail_max": "0.000000000001", "zfloor": ["8.999997", "35.999991", "80.999982", "110.249975", "126.562472", "135.140595", "139.535125", "9.159777", "36.639111", "82.438003", "112.207282", "128.809380", "137.539793", "142.012341", "9.652494", "38.609981", "86.872460", "118.243072", "135.738220", "144.938255", "149.651388", "11.833298", "47.333204", "106.499715", "144.957947", "166.405808", "177.684424", "183.462403"]}, + {"bound": ["688670.6691", "2260520.1739", "3585876.2206", "4408751.5164", "4863646.5324", "5102384.6467", "5348827.8209", "676622.8351", "2220983.5629", "3523167.1361", "4331657.1243", "4778600.2835", "5013165.2366", "5255300.6585", "641496.7995", "2105683.6984", "3340265.7376", "4106783.7990", "4530524.3644", "4752912.1197", "4982477.3360", "515664.1544", "1692643.0542", "2685055.1059", "3301216.5177", "3641838.0943", "3820603.2981", "4005138.0840"], "r": ["1/8388608", "5/33554432"], "side24": ["37768.7542", "3.230975"], "tail_max": "0.000000000001", "zfloor": ["8.999996", "35.999987", "80.999972", "110.249962", "126.562456", "135.140578", "139.535107", "9.159776", "36.639107", "82.437993", "112.207268", "128.809363", "137.539775", "142.012323", "9.652493", "38.609977", "86.872449", "118.243056", "135.738202", "144.938236", "149.651368", "11.833296", "47.333197", "106.499699", "144.957926", "166.405783", "177.684397", "183.462376"]}, + {"bound": ["688670.9937", "2260520.7385", "3585876.8407", "4408752.1820", "4863647.2239", "5102385.3519", "5348828.5501", "676624.4357", "2220990.2608", "3523179.1043", "4331672.7379", "4778618.0148", "5013184.1061", "5255320.7316", "641498.3525", "2105690.1137", "3340277.1600", "4106798.6856", "4530541.2632", "4752930.1001", "4982496.4611", "515665.5327", "1692648.4805", "2685064.6353", "3301228.8882", "3641852.1150", "3820618.2058", "4005153.9335"], "r": ["5/33554432", "3/16777216"], "side24": ["37768.9389", "3.230975"], "tail_max": "0.000000000001", "zfloor": ["8.999995", "35.999986", "80.999969", "110.249958", "126.562452", "135.140574", "139.535103", "9.159775", "36.639106", "82.437990", "112.207264", "128.809359", "137.539771", "142.012318", "9.652492", "38.609975", "86.872446", "118.243052", "135.738197", "144.938231", "149.651362", "11.833295", "47.333193", "106.499692", "144.957917", "166.405773", "177.684387", "183.462365"]}, + {"bound": ["688671.3183", "2260521.3031", "3585877.4608", "4408752.8476", "4863647.9155", "5102386.0572", "5348829.2794", "676626.0362", "2220996.9588", "3523191.0725", "4331688.3515", "4778635.7461", "5013202.9757", "5255340.8047", "641499.9055", "2105696.5290", "3340288.5824", "4106813.5721", "4530558.1621", "4752948.0806", "4982515.5862", "515666.9110", "1692653.9067", "2685074.1646", "3301241.2587", "3641866.1358", "3820633.1135", "4005169.7831"], "r": ["3/16777216", "7/33554432"], "side24": ["37769.1235", "3.230974"], "tail_max": "0.000000000001", "zfloor": ["8.999995", "35.999984", "80.999967", "110.249955", "126.562448", "135.140570", "139.535099", "9.159775", "36.639104", "82.437987", "112.207261", "128.809355", "137.539767", "142.012314", "9.652492", "38.609973", "86.872443", "118.243048", "135.738192", "144.938226", "149.651357", "11.833293", "47.333189", "106.499685", "144.957908", "166.405764", "177.684377", "183.462355"]}, + {"bound": ["688671.6430", "2260521.8678", "3585878.0809", "4408753.5132", "4863648.6071", "5102386.7625", "5348830.0086", "676627.6368", "2221003.6567", "3523203.0407", "4331703.9652", "4778653.4774", "5013221.8453", "5255360.8778", "641501.4585", "2105702.9443", "3340300.0048", "4106828.4586", "4530575.0609", "4752966.0611", "4982534.7113", "515668.2893", "1692659.3330", "2685083.6940", "3301253.6292", "3641880.1566", "3820648.0212", "4005185.6326"], "r": ["7/33554432", "1/4194304"], "side24": ["37769.3082", "3.230974"], "tail_max": "0.000000000001", "zfloor": ["8.999994", "35.999983", "80.999964", "110.249952", "126.562444", "135.140566", "139.535095", "9.159774", "36.639103", "82.437984", "112.207257", "128.809351", "137.539763", "142.012310", "9.652491", "38.609971", "86.872439", "118.243043", "135.738188", "144.938220", "149.651352", "11.833292", "47.333185", "106.499679", "144.957900", "166.405754", "177.684367", "183.462345"]}, + {"bound": ["688672.3617", "2260523.3391", "3585879.9542", "4408755.6784", "4863650.9409", "5102389.1865", "5348832.5464", "676630.9065", "2221017.3898", "3523227.6011", "4331736.0144", "4778689.8770", "5013260.5835", "5255402.0878", "641504.6300", "2105716.0977", "3340323.4469", "4106859.0185", "4530609.7555", "4753002.9782", "4982573.9796", "515671.1006", "1692670.4551", "2685103.2514", "3301279.0271", "3641908.9469", "3820678.6350", "4005218.1818"], "r": ["1/4194304", "5/16777216"], "side24": ["37769.6783", "3.230973"], "tail_max": "0.000000000001", "zfloor": ["8.999992", "35.999974", "80.999944", "110.249924", "126.562412", "135.140531", "139.535058", "9.159772", "36.639094", "82.437964", "112.207229", "128.809318", "137.539727", "142.012272", "9.652488", "38.609962", "86.872417", "118.243012", "135.738152", "144.938182", "149.651312", "11.833288", "47.333171", "106.499647", "144.957857", "166.405704", "177.684314", "183.462289"]}, + {"bound": ["688673.0109", "2260524.4684", "3585881.1944", "4408757.0096", "4863652.3241", "5102390.5972", "5348834.0050", "676634.1076", "2221030.7857", "3523251.5376", "4331767.2418", "4778725.3397", "5013298.3228", "5255442.2341", "641507.7360", "2105728.9284", "3340346.2918", "4106888.7917", "4530643.5533", "4753038.9393", "4982612.2298", "515673.8573", "1692681.3077", "2685122.3102", "3301303.7682", "3641936.9886", "3820708.4505", "4005249.8810"], "r": ["5/16777216", "3/8388608"], "side24": ["37770.0477", "3.230972"], "tail_max": "0.000000000001", "zfloor": ["8.999991", "35.999972", "80.999939", "110.249917", "126.562404", "135.140523", "139.535050", "9.159771", "36.639091", "82.437959", "112.207222", "128.809310", "137.539719", "142.012264", "9.652487", "38.609958", "86.872410", "118.243004", "135.738142", "144.938172", "149.651301", "11.833284", "47.333163", "106.499634", "144.957840", "166.405685", "177.684294", "183.462269"]}, + {"bound": ["688673.6601", "2260525.5977", "3585882.4347", "4408758.3409", "4863653.7074", "5102392.0078", "5348835.4636", "676637.3088", "2221044.1817", "3523275.4741", "4331798.4692", "4778760.8024", "5013336.0622", "5255482.3805", "641510.8421", "2105741.7592", "3340369.1367", "4106918.5649", "4530677.3512", "4753074.9005", "4982650.4802", "515676.6139", "1692692.1603", "2685141.3690", "3301328.5094", "3641965.0303", "3820738.2662", "4005281.5803"], "r": ["3/8388608", "7/16777216"], "side24": ["37770.4170", "3.230971"], "tail_max": "0.000000000001", "zfloor": ["8.999990", "35.999969", "80.999934", "110.249910", "126.562397", "135.140515", "139.535042", "9.159770", "36.639088", "82.437953", "112.207214", "128.809302", "137.539710", "142.012255", "9.652486", "38.609954", "86.872404", "118.242995", "135.738132", "144.938161", "149.651291", "11.833281", "47.333155", "106.499620", "144.957823", "166.405666", "177.684274", "183.462248"]}, + {"bound": ["688674.3094", "2260526.7270", "3585883.6749", "4408759.6722", "4863655.0906", "5102393.4185", "5348836.9222", "676640.5100", "2221057.5777", "3523299.4107", "4331829.6966", "4778796.2652", "5013373.8016", "5255522.5269", "641513.9481", "2105754.5900", "3340391.9817", "4106948.3382", "4530711.1491", "4753110.8617", "4982688.7306", "515679.3705", "1692703.0130", "2685160.4279", "3301353.2506", "3641993.0720", "3820768.0819", "4005313.2796"], "r": ["7/16777216", "1/2097152"], "side24": ["37770.7864", "3.230970"], "tail_max": "0.000000000001", "zfloor": ["8.999989", "35.999966", "80.999929", "110.249904", "126.562389", "135.140507", "139.535034", "9.159769", "36.639085", "82.437948", "112.207207", "128.809294", "137.539702", "142.012246", "9.652484", "38.609950", "86.872397", "118.242986", "135.738123", "144.938151", "149.651280", "11.833278", "47.333148", "106.499606", "144.957805", "166.405647", "177.684254", "183.462228"]}, + {"bound": ["688675.7469", "2260529.6699", "3585887.4217", "4408764.0029", "4863659.7586", "5102398.2668", "5348841.9980", "676647.0495", "2221085.0442", "3523336.7079", "4331859.3222", "4778820.0382", "5013394.0770", "5255538.9367", "641520.2914", "2105780.8971", "3340438.8663", "4107009.4584", "4530780.5387", "4753184.6964", "4982767.2678", "515684.9934", "1692725.2574", "2685199.5431", "3301404.0469", "3642050.6533", "3820829.3098", "4005378.3785"], "r": ["1/2097152", "5/8388608"], "side24": ["37771.5267", "3.230967"], "tail_max": "0.000000000001", "zfloor": ["8.999985", "35.999949", "80.999889", "110.249848", "126.562325", "135.140437", "139.534961", "9.159765", "36.639068", "82.437907", "112.207151", "128.809228", "137.539631", "142.012172", "9.652479", "38.609932", "86.872353", "118.242925", "135.738051", "144.938074", "149.651200", "11.833270", "47.333119", "106.499544", "144.957720", "166.405548", "177.684147", "183.462117"]}, + {"bound": ["688677.0455", "2260531.9286", "3585889.9025", "4408766.6657", "4863662.5253", "5102401.0884", "5348844.9154", "676653.4520", "2221100.3152", "3523339.2117", "4331862.0096", "4778822.8305", "5013396.9245", "5255541.8810", "641526.5036", "2105806.5589", "3340484.5566", "4107069.0053", "4530848.1349", "4753256.6192", "4982843.7690", "515690.5068", "1692746.9630", "2685237.6612", "3301453.5297", "3642106.7372", "3820888.9416", "4005441.7776"], "r": ["5/8388608", "3/4194304"], "side24": ["37772.2654", "3.230965"], "tail_max": "0.000000000001", "zfloor": ["8.999983", "35.999944", "80.999879", "110.249835", "126.562309", "135.140421", "139.534944", "9.159762", "36.639062", "82.437896", "112.207136", "128.809212", "137.539614", "142.012155", "9.652477", "38.609924", "86.872339", "118.242908", "135.738032", "144.938054", "149.651179", "11.833264", "47.333104", "106.499517", "144.957685", "166.405510", "177.684107", "183.462076"]}, + {"bound": ["688678.3441", "2260534.1875", "3585892.3833", "4408769.3285", "4863665.2921", "5102403.9101", "5348847.8330", "676659.8546", "2221102.5954", "3523341.7156", "4331864.6972", "4778825.6228", "5013399.7722", "5255544.8254", "641532.7159", "2105832.2209", "3340530.2471", "4107128.5524", "4530915.7314", "4753328.5423", "4982920.2704", "515696.0202", "1692768.6688", "2685275.7794", "3301503.0127", "3642162.8213", "3820948.5736", "4005505.1769"], "r": ["3/4194304", "7/8388608"], "side24": ["37773.0041", "3.230963"], "tail_max": "0.000000000001", "zfloor": ["8.999981", "35.999938", "80.999868", "110.249821", "126.562294", "135.140405", "139.534928", "9.159760", "36.639056", "82.437885", "112.207122", "128.809196", "137.539597", "142.012137", "9.652474", "38.609917", "86.872326", "118.242890", "135.738012", "144.938033", "149.651158", "11.833258", "47.333089", "106.499489", "144.957651", "166.405472", "177.684067", "183.462035"]}, + {"bound": ["688679.6427", "2260536.4464", "3585894.8642", "4408771.9915", "4863668.0590", "5102406.7319", "5348850.7506", "676666.2572", "2221104.8756", "3523344.2196", "4331867.3848", "4778828.4152", "5013402.6200", "5255547.7699", "641538.9282", "2105857.8830", "3340575.9378", "4107188.0998", "4530983.3280", "4753400.4655", "4982996.7721", "515701.5338", "1692790.3747", "2685313.8978", "3301552.4959", "3642218.9056", "3821008.2058", "4005568.5764"], "r": ["7/8388608", "1/1048576"], "side24": ["37773.7428", "3.230961"], "tail_max": "0.000000000001", "zfloor": ["8.999979", "35.999932", "80.999858", "110.249808", "126.562279", "135.140389", "139.534911", "9.159758", "36.639050", "82.437874", "112.207108", "128.809180", "137.539580", "142.012120", "9.652471", "38.609909", "86.872312", "118.242873", "135.737993", "144.938013", "149.651137", "11.833251", "47.333073", "106.499462", "144.957617", "166.405433", "177.684027", "183.461993"]}, + {"bound": ["688682.5180", "2260542.3328", "3585902.3586", "4408780.6537", "4863677.3958", "5102416.4295", "5348860.9033", "676669.7167", "2221110.7757", "3523351.7067", "4331876.0257", "4778837.7227", "5013412.2838", "5255557.8850", "641551.6153", "2105910.4986", "3340669.7087", "4107310.3422", "4531122.1095", "4753548.1371", "4983153.8489", "515712.7800", "1692834.8649", "2685392.1300", "3301654.0905", "3642334.0703", "3821130.6640", "4005698.7766"], "r": ["1/1048576", "5/4194304"], "side24": ["37775.2234", "3.230957"], "tail_max": "0.000000000001", "zfloor": ["8.999971", "35.999899", "80.999779", "110.249697", "126.562150", "135.140249", "139.534766", "9.159750", "36.639016", "82.437794", "112.206995", "128.809048", "137.539437", "142.011971", "9.652461", "38.609872", "86.872224", "118.242750", "135.737849", "144.937858", "149.650976", "11.833235", "47.333016", "106.499337", "144.957445", "166.405235", "177.683814", "183.461772"]}, + {"bound": ["688685.1155", "2260546.8511", "3585907.3210", "4408785.9804", "4863682.9304", "5102422.0738", "5348866.7394", "676672.3391", "2221115.3367", "3523356.7153", "4331881.4017", "4778843.3083", "5013417.9801", "5255563.7748", "641564.0403", "2105961.8238", "3340761.0912", "4107429.4382", "4531257.3043", "4753691.9853", "4983306.8539", "515723.8075", "1692878.2777", "2685468.3681", "3301753.0583", "3642446.2404", "3821249.9300", "4005825.5773"], "r": ["5/4194304", "3/2097152"], "side24": ["37776.7008", "3.230953"], "tail_max": "0.000000000001", "zfloor": ["8.999967", "35.999888", "80.999758", "110.249670", "126.562119", "135.140217", "139.534733", "9.159745", "36.639004", "82.437771", "112.206966", "128.809016", "137.539404", "142.011937", "9.652456", "38.609857", "86.872197", "118.242715", "135.737811", "144.937817", "149.650933", "11.833222", "47.332985", "106.499282", "144.957376", "166.405158", "177.683733", "183.461690"]}, + {"bound": ["688687.7131", "2260551.3698", "3585912.2838", "4408791.3075", "4863688.4654", "5102427.7186", "5348872.5760", "676674.9617", "2221119.8980", "3523361.7243", "4331886.7780", "4778848.8943", "5013423.6768", "5255569.6651", "641576.4656", "2106013.1496", "3340852.4745", "4107548.5351", "4531392.4999", "4753835.8343", "4983459.8598", "515734.8352", "1692921.6911", "2685544.6069", "3301852.0269", "3642558.4114", "3821369.1968", "4005952.3789"], "r": ["3/2097152", "7/4194304"], "side24": ["37778.1783", "3.230948"], "tail_max": "0.000000000001", "zfloor": ["8.999962", "35.999877", "80.999737", "110.249643", "126.562089", "135.140185", "139.534700", "9.159741", "36.638992", "82.437749", "112.206938", "128.808984", "137.539370", "142.011902", "9.652450", "38.609842", "86.872170", "118.242680", "135.737772", "144.937776", "149.650891", "11.833210", "47.332955", "106.499228", "144.957307", "166.405082", "177.683653", "183.461607"]}, + {"bound": ["688690.3108", "2260555.8887", "3585917.2469", "4408796.6350", "4863694.0008", "5102433.3638", "5348878.4131", "676677.5844", "2221124.4596", "3523366.7336", "4331892.1548", "4778854.4807", "5013429.3740", "5255575.5558", "641588.8912", "2106064.4759", "3340943.8584", "4107667.6327", "4531527.6963", "4753979.6841", "4983612.8666", "515745.8632", "1692965.1050", "2685620.8463", "3301950.9962", "3642670.5832", "3821488.4645", "4006079.1814"], "r": ["7/4194304", "1/524288"], "side24": ["37779.6557", "3.230944"], "tail_max": "0.000000000001", "zfloor": ["8.999958", "35.999865", "80.999716", "110.249616", "126.562059", "135.140153", "139.534667", "9.159736", "36.638980", "82.437727", "112.206909", "128.808952", "137.539336", "142.011867", "9.652444", "38.609827", "86.872143", "118.242646", "135.737733", "144.937735", "149.650849", "11.833198", "47.332924", "106.499173", "144.957239", "166.405006", "177.683573", "183.461525"]}, + {"bound": ["688696.0626", "2260567.6643", "3585932.2390", "4408813.9630", "4863712.6785", "5102452.7631", "5348898.7226", "676683.3743", "2221136.2625", "3523381.7110", "4331909.4402", "4778873.0996", "5013448.7057", "5255595.7900", "641614.2674", "2106169.7124", "3341131.4072", "4107912.1256", "4531805.2680", "4754275.0364", "4983927.0297", "515768.3579", "1693054.0908", "2685777.3175", "3302154.1934", "3642900.9211", "3821733.3897", "4006339.5911"], "r": ["1/524288", "5/2097152"], "side24": ["37782.6172", "3.230936"], "tail_max": "0.000000000001", "zfloor": ["8.999942", "35.999799", "80.999559", "110.249394", "126.561800", "135.139874", "139.534376", "9.159720", "36.638912", "82.437566", "112.206683", "128.808687", "137.539051", "142.011570", "9.652425", "38.609752", "86.871967", "118.242400", "135.737446", "144.937427", "149.650527", "11.833164", "47.332809", "106.498923", "144.956895", "166.404608", "177.683147", "183.461082"]}, + {"bound": ["688701.2591", "2260576.7043", "3585942.1678", "4408824.6208", "4863723.7523", "5102464.0565", "5348910.3999", "676688.6207", "2221145.3878", "3523391.7322", "4331920.1965", "4778884.2754", "5013460.1030", "5255607.5746", "641639.1202", "2106272.3691", "3341314.1801", "4108150.3266", "4532075.6671", "4754562.7425", "4984233.0500", "515790.4156", "1693140.9227", "2685929.8015", "3302352.1379", "3643125.2709", "3821971.9315", "4006593.2028"], "r": ["5/2097152", "3/1048576"], "side24": ["37785.5722", "3.230927"], "tail_max": "0.000000000001", "zfloor": ["8.999934", "35.999776", "80.999516", "110.249340", "126.561739", "135.139810", "139.534310", "9.159710", "36.638888", "82.437521", "112.206626", "128.808623", "137.538984", "142.011500", "9.652414", "38.609722", "86.871913", "118.242330", "135.737369", "144.937345", "149.650443", "11.833139", "47.332748", "106.498814", "144.956758", "166.404456", "177.682986", "183.460917"]}, + {"bound": ["688706.4560", "2260585.7455", "3585952.0980", "4408835.2802", "4863734.8278", "5102475.3518", "5348922.0790", "676693.8675", "2221154.5142", "3523401.7547", "4331930.9544", "4778895.4529", "5013471.5021", "5255619.3610", "641663.9739", "2106375.0280", "3341496.9558", "4108388.5308", "4532346.0694", "4754850.4519", "4984539.0739", "515812.4743", "1693227.7570", "2686082.2883", "3302550.0855", "3643349.6240", "3822210.4767", "4006846.8181"], "r": ["3/1048576", "7/2097152"], "side24": ["37788.5273", "3.230919"], "tail_max": "0.000000000001", "zfloor": ["8.999925", "35.999754", "80.999474", "110.249286", "126.561678", "135.139746", "139.534244", "9.159701", "36.638864", "82.437477", "112.206569", "128.808560", "137.538916", "142.011431", "9.652402", "38.609693", "86.871858", "118.242261", "135.737291", "144.937263", "149.650359", "11.833115", "47.332687", "106.498705", "144.956620", "166.404303", "177.682826", "183.460753"]}, + {"bound": ["688711.6535", "2260594.7879", "3585962.0297", "4408845.9412", "4863745.9050", "5102486.6487", "5348933.7600", "676699.1149", "2221163.6418", "3523411.7787", "4331941.7138", "4778906.6320", "5013482.9028", "5255631.1492", "641688.8285", "2106477.6891", "3341679.7341", "4108626.7380", "4532616.4751", "4755138.1648", "4984845.1013", "515834.5340", "1693314.5935", "2686234.7779", "3302748.0362", "3643573.9804", "3822449.0254", "4007100.4369"], "r": ["7/2097152", "1/262144"], "side24": ["37791.4825", "3.230911"], "tail_max": "0.000000000001", "zfloor": ["8.999916", "35.999731", "80.999432", "110.249232", "126.561618", "135.139682", "139.534178", "9.159692", "36.638840", "82.437432", "112.206511", "128.808496", "137.538849", "142.011362", "9.652391", "38.609663", "86.871804", "118.242191", "135.737213", "144.937181", "149.650275", "11.833090", "47.332626", "106.498596", "144.956483", "166.404151", "177.682665", "183.460588"]}, + {"bound": ["688723.1618", "2260618.3498", "3585992.0270", "4408880.6119", "4863783.2758", "5102525.4633", "5348974.3958", "676710.6994", "2221187.2584", "3523441.7464", "4331976.2992", "4778943.8850", "5013521.5821", "5255671.6343", "641739.5897", "2106688.1837", "3342054.8596", "4109115.7560", "4533171.6533", "4755728.9056", "4985473.4657", "515879.5325", "1693492.5865", "2686547.7477", "3303154.4623", "3644034.6902", "3822938.9112", "4007621.2936"], "r": ["1/262144", "5/1048576"], "side24": ["37797.4061", "3.230893"], "tail_max": "0.000000000001", "zfloor": ["8.999885", "35.999598", "80.999118", "110.248789", "126.561100", "135.139124", "139.533596", "9.159659", "36.638704", "82.437111", "112.206059", "128.807966", "137.538278", "142.010767", "9.652353", "38.609512", "86.871453", "118.241700", "135.736640", "144.936564", "149.649631", "11.833023", "47.332397", "106.498095", "144.955795", "166.403356", "177.681813", "183.459702"]}, + {"bound": ["688733.5605", "2260636.4430", "3586011.9004", "4408901.9452", "4863805.4422", "5102548.0696", "5348997.7706", "676721.1979", "2221205.5219", "3523461.8043", "4331997.8292", "4778966.2551", "5013544.3958", "5255695.2234", "641789.3056", "2106893.5220", "3342420.4365", "4109592.1936", "4533712.4895", "4756304.3571", "4986085.5476", "515923.6587", "1693666.2758", "2686852.7470", "3303550.3868", "3644483.4278", "3823416.0341", "4008128.5581"], "r": ["5/1048576", "3/524288"], "side24": ["37803.3168", "3.230876"], "tail_max": "0.000000000001", "zfloor": ["8.999868", "35.999553", "80.999033", "110.248681", "126.560979", "135.138996", "139.533464", "9.159641", "36.638656", "82.437022", "112.205945", "128.807839", "137.538144", "142.010628", "9.652330", "38.609453", "86.871344", "118.241561", "135.736484", "144.936400", "149.649463", "11.832973", "47.332275", "106.497877", "144.955521", "166.403050", "177.681492", "183.459373"]}, + {"bound": ["688743.9613", "2260654.5409", "3586031.7795", "4408923.2849", "4863827.6153", "5102570.6828", "5349021.1527", "676731.6984", "2221223.7901", "3523481.8678", "4332019.3655", "4778988.6319", "5013567.2163", "5255718.8197", "641839.0252", "2107098.8693", "3342786.0245", "4110068.6436", "4534253.3388", "4756879.8222", "4986697.6438", "515967.7888", "1693839.9741", "2687157.7574", "3303946.3238", "3644932.1787", "3823893.1707", "4008635.8371"], "r": ["3/524288", "7/1048576"], "side24": ["37809.2278", "3.230860"], "tail_max": "0.000000000001", "zfloor": ["8.999850", "35.999508", "80.998949", "110.248572", "126.560857", "135.138868", "139.533333", "9.159623", "36.638608", "82.436932", "112.205830", "128.807711", "137.538009", "142.010490", "9.652307", "38.609394", "86.871235", "118.241422", "135.736329", "144.936236", "149.649295", "11.832924", "47.332153", "106.497659", "144.955246", "166.402745", "177.681171", "183.459044"]}, + {"bound": ["688754.3643", "2260672.6436", "3586051.6643", "4408944.6310", "4863849.7952", "5102593.3030", "5349044.5421", "676742.2010", "2221242.0630", "3523501.9370", "4332040.9082", "4779011.0154", "5013590.0438", "5255742.4232", "641888.7486", "2107304.2254", "3343151.6233", "4110545.1059", "4534794.2013", "4757455.3009", "4987309.7542", "516011.9229", "1694013.6814", "2687462.7789", "3304342.2733", "3645380.9429", "3824370.3210", "4009143.1305"], "r": ["7/1048576", "1/131072"], "side24": ["37815.1391", "3.230843"], "tail_max": "0.000000000001", "zfloor": ["8.999833", "35.999462", "80.998864", "110.248464", "126.560736", "135.138739", "139.533201", "9.159605", "36.638560", "82.436843", "112.205716", "128.807583", "137.537874", "142.010351", "9.652285", "38.609334", "86.871126", "118.241283", "135.736174", "144.936072", "149.649127", "11.832874", "47.332031", "106.497441", "144.954972", "166.402440", "177.680850", "183.458715"]}, + {"bound": ["688777.4001", "2260719.8112", "3586111.7116", "4409014.0313", "4863924.5994", "5102670.9965", "5349125.8811", "676765.3892", "2221289.3394", "3523561.9244", "4332110.1370", "4779085.5830", "5013667.4657", "5255823.4598", "641990.3058", "2107725.3009", "3343720.1135", "4110996.8881", "4535156.9967", "4757764.9241", "4987560.6831", "516101.9561", "1694369.7541", "2688088.8285", "3305155.2523", "3646302.4991", "3825350.2343", "4010184.9927"], "r": ["1/131072", "5/524288"], "side24": ["37826.9887", "3.230808"], "tail_max": "0.000000000001", "zfloor": ["8.999770", "35.999197", "80.998237", "110.247579", "126.559701", "135.137624", "139.532037", "9.159539", "36.638287", "82.436201", "112.204811", "128.806525", "137.536733", "142.009161", "9.652208", "38.609032", "86.870425", "118.240300", "135.735027", "144.934837", "149.647839", "11.832740", "47.331571", "106.496439", "144.953597", "166.400850", "177.679145", "183.456942"]}, + {"bound": ["688798.2208", "2260756.0502", "3586151.5215", "4409056.7686", "4863969.0071", "5102716.2862", "5349172.7114", "676786.4091", "2221325.9184", "3523602.1026", "4332153.2668", "4779130.3972", "5013713.1693", "5255870.7177", "642089.7791", "2107959.6987", "3343762.4505", "4111042.3358", "4535204.2194", "4757813.0840", "4987610.4808", "516190.2520", "1694717.2338", "2688698.9524", "3305947.2437", "3647200.1263", "3826304.6373", "4011199.6868"], "r": ["5/524288", "3/262144"], "side24": ["37838.8131", "3.230775"], "tail_max": "0.000000000001", "zfloor": ["8.999736", "35.999106", "80.998067", "110.247362", "126.559458", "135.137367", "139.531773", "9.159503", "36.638192", "82.436022", "112.204582", "128.806269", "137.536463", "142.008884", "9.652163", "38.608914", "86.870207", "118.240022", "135.734716", "144.934510", "149.647503", "11.832641", "47.331327", "106.496003", "144.953047", "166.400240", "177.678503", "183.456284"]}, + {"bound": ["688819.0498", "2260792.3083", "3586191.3544", "4409099.5315", "4864013.4418", "5102761.6038", "5349219.5710", "676807.4373", "2221362.5163", "3523642.3033", "4332196.4219", "4779175.2381", "5013758.9003", "5255918.0044", "642189.2675", "2107998.2607", "3343804.8094", "4111087.8079", "4535251.4678", "4757861.2705", "4987660.3063", "516278.5636", "1695064.7497", "2689309.1207", "3306739.2852", "3648097.8069", "3827259.0953", "4012214.4386"], "r": ["3/262144", "7/524288"], "side24": ["37850.6385", "3.230742"], "tail_max": "0.000000000001", "zfloor": ["8.999701", "35.999015", "80.997898", "110.247145", "126.559215", "135.137111", "139.531510", "9.159466", "36.638096", "82.435844", "112.204354", "128.806013", "137.536193", "142.008607", "9.652117", "38.608796", "86.869989", "118.239744", "135.734406", "144.934182", "149.647167", "11.832542", "47.331083", "106.495567", "144.952498", "166.399629", "177.677861", "183.455626"]}, + {"bound": ["688839.8873", "2260828.5854", "3586231.2101", "4409142.3200", "4864057.9037", "5102806.9493", "5349266.4597", "676828.4740", "2221399.1330", "3523682.5266", "4332239.6023", "4779220.1057", "5013804.6590", "5255965.3199", "642288.7708", "2108036.8411", "3343847.1902", "4111133.3044", "4535298.7421", "4757909.4835", "4987710.1596", "516366.8909", "1695412.3019", "2689919.3334", "3307531.3768", "3648995.5409", "3828213.6085", "4013229.2481"], "r": ["7/524288", "1/65536"], "side24": ["37862.4651", "3.230708"], "tail_max": "0.000000000001", "zfloor": ["8.999667", "35.998925", "80.997728", "110.246927", "126.558972", "135.136854", "139.531246", "9.159430", "36.638000", "82.435665", "112.204125", "128.805758", "137.535924", "142.008330", "9.652072", "38.608677", "86.869771", "118.239466", "135.734095", "144.933855", "149.646831", "11.832444", "47.330839", "106.495131", "144.951949", "166.399019", "177.677219", "183.454968"]}, + {"bound": ["688886.0360", "2260923.0954", "3586351.5151", "4409281.3562", "4864207.7620", "5102962.5937", "5349429.4071", "676874.9268", "2221493.8586", "3523802.7092", "4332378.2925", "4779369.4877", "5013959.7569", "5256127.6589", "642345.3887", "2108134.1696", "3343969.2369", "4111273.3986", "4535449.2573", "4758065.5673", "4987873.3963", "516547.1022", "1696124.7939", "2691171.8732", "3309157.8428", "3650839.2001", "3830174.0027", "4015313.5696"], "r": ["1/65536", "5/262144"], "side24": ["37886.1736", "3.230639"], "tail_max": "0.000000000001", "zfloor": ["8.999541", "35.998395", "80.996474", "110.245158", "126.556902", "135.134623", "139.528918", "9.159298", "36.637455", "82.434380", "112.202315", "128.803641", "137.533642", "142.005949", "9.651919", "38.608073", "86.868368", "118.237499", "135.731801", "144.931385", "149.644255", "11.832174", "47.329920", "106.493127", "144.949199", "166.395839", "177.673810", "183.451422"]}, + {"bound": ["688927.7704", "2260995.7843", "3586431.3881", "4409367.1140", "4864296.8774", "5103053.4821", "5349523.3911", "676917.0589", "2221567.2251", "3523883.3154", "4332464.8317", "4779459.4122", "5014051.4688", "5256222.4937", "642389.7861", "2108211.4597", "3344054.1529", "4111364.5641", "4535543.9886", "4758162.1815", "4987973.2997", "516723.8680", "1696820.1591", "2692392.6232", "3310742.3963", "3652635.0642", "3832083.4389", "4017343.6189"], "r": ["5/262144", "3/131072"], "side24": ["37909.8341", "3.230572"], "tail_max": "0.000000000001", "zfloor": ["8.999472", "35.998213", "80.996135", "110.244724", "126.556416", "135.134110", "139.528391", "9.159226", "36.637263", "82.434023", "112.201858", "128.803130", "137.533103", "142.005395", "9.651828", "38.607836", "86.867932", "118.236943", "135.731180", "144.930730", "149.643582", "11.831977", "47.329432", "106.492255", "144.948100", "166.394619", "177.672525", "183.450106"]}, + {"bound": ["688969.5385", "2261068.5495", "3586511.3527", "4409452.9743", "4864386.1014", "5103144.4823", "5349617.4922", "676959.2246", "2221640.6670", "3523964.0121", "4332551.4720", "4779549.4437", "5014143.2912", "5256317.4439", "642434.2166", "2108288.8231", "3344139.1565", "4111455.8272", "4535638.8233", "4758258.9021", "4988073.3144", "516900.6967", "1697515.6695", "2693613.5512", "3312327.1508", "3654431.1424", "3833993.0961", "4019373.8997"], "r": ["3/131072", "7/262144"], "side24": ["37933.4988", "3.230505"], "tail_max": "0.000000000001", "zfloor": ["8.999403", "35.998031", "80.995796", "110.244290", "126.555930", "135.133597", "139.527864", "9.159153", "36.637071", "82.433666", "112.201401", "128.802618", "137.532563", "142.004841", "9.651737", "38.607600", "86.867496", "118.236387", "135.730559", "144.930074", "149.642910", "11.831780", "47.328944", "106.491384", "144.947001", "166.393398", "177.671241", "183.448789"]}, + {"bound": ["689011.3404", "2261141.3911", "3586591.4090", "4409538.9371", "4864475.4340", "5103235.5943", "5349711.7102", "677001.4238", "2221714.1844", "3524044.7992", "4332638.2135", "4779639.5825", "5014235.2238", "5256412.5097", "642478.6803", "2108366.2599", "3344224.2476", "4111547.1881", "4535733.7615", "4758355.7293", "4988173.4405", "517077.5884", "1698211.3253", "2694834.6572", "3313912.1065", "3656227.4349", "3835902.9744", "4021404.4123"], "r": ["7/262144", "1/32768"], "side24": ["37957.1677", "3.230438"], "tail_max": "0.000000000001", "zfloor": ["8.999335", "35.997850", "80.995457", "110.243855", "126.555443", "135.133083", "139.527337", "9.159080", "36.636880", "82.433309", "112.200944", "128.802107", "137.532023", "142.004287", "9.651646", "38.607363", "86.867060", "118.235831", "135.729937", "144.929419", "149.642238", "11.831582", "47.328456", "106.490512", "144.945902", "166.392177", "177.669957", "183.447473"]}, + {"bound": ["689103.9460", "2261331.1115", "3586832.8620", "4409817.9540", "4864776.1521", "5103547.9150", "5350038.6847", "677094.6353", "2221904.3279", "3524285.9968", "4332916.5263", "4779939.3350", "5014546.4378", "5256738.2531", "642575.8832", "2108561.5910", "3344469.1478", "4111828.2787", "4536035.7478", "4758668.8811", "4988500.9438", "517438.5929", "1699637.6998", "2697341.5043", "3317167.0768", "3659916.9475", "3839826.0402", "4025575.4503"], "r": ["1/32768", "5/131072"], "side24": ["38004.6237", "3.230299"], "tail_max": "0.000000000001", "zfloor": ["8.999082", "35.996789", "80.992949", "110.240317", "126.551304", "135.128621", "139.522679", "9.158817", "36.635789", "82.430739", "112.197323", "128.797873", "137.527460", "141.999525", "9.651341", "38.606154", "86.864254", "118.231899", "135.725349", "144.924480", "149.637086", "11.831044", "47.326617", "106.486503", "144.940402", "166.385817", "177.663138", "183.440382"]}, + {"bound": ["689187.7879", "2261477.3340", "3586993.6225", "4409990.6046", "4864955.5859", "5103730.9305", "5350227.9489", "677179.2700", "2222051.8958", "3524448.2108", "4333090.7248", "4780120.3709", "5014731.0841", "5256929.2016", "642665.0444", "2108716.9831", "3344639.9494", "4112011.6923", "4536226.3569", "4758863.2897", "4988701.9850", "517792.8237", "1701030.0586", "2699785.0205", "3320338.4755", "3663511.1241", "3843647.4440", "4029638.2043"], "r": ["5/131072", "3/65536"], "side24": ["38051.9925", "3.230166"], "tail_max": "0.000000000001", "zfloor": ["8.998944", "35.996426", "80.992271", "110.239448", "126.550332", "135.127595", "139.521625", "9.158672", "36.635406", "82.430025", "112.196409", "128.796851", "137.526381", "141.998416", "9.651159", "38.605681", "86.863382", "118.230786", "135.724107", "144.923169", "149.635741", "11.830649", "47.325641", "106.484759", "144.938205", "166.383375", "177.660569", "183.437749"]}, + {"bound": ["689271.7653", "2261623.8628", "3587154.7505", "4410163.6664", "4865135.4554", "5103914.3947", "5350417.6827", "677264.0390", "2222199.7664", "3524610.7876", "4333265.3291", "4780301.8367", "5014916.1730", "5257120.6132", "642754.3385", "2108872.6695", "3344811.1021", "4112195.4980", "4536417.3811", "4759058.1255", "4988903.4731", "518147.3085", "1702423.0017", "2702229.2525", "3323510.6829", "3667106.1622", "3847469.7371", "4033701.8900"], "r": ["3/65536", "7/131072"], "side24": ["38099.3799", "3.230032"], "tail_max": "0.000000000001", "zfloor": ["8.998807", "35.996063", "80.991593", "110.238580", "126.549359", "135.126568", "139.520571", "9.158526", "36.635022", "82.429311", "112.195495", "128.795828", "137.525302", "141.997308", "9.650976", "38.605208", "86.862509", "118.229674", "135.722864", "144.921859", "149.634396", "11.830254", "47.324664", "106.483015", "144.936007", "166.380933", "177.658001", "183.435116"]}, + {"bound": ["689355.8784", "2261770.6981", "3587316.2465", "4410337.1398", "4865315.7612", "5104098.3081", "5350607.8864", "677348.9428", "2222347.9398", "3524773.7276", "4333440.3396", "4780483.7329", "5015101.7051", "5257312.4885", "642843.7660", "2109028.6504", "3344982.6062", "4112379.6960", "4536608.8208", "4759253.3890", "4989105.4085", "518502.0485", "1703816.5300", "2704674.2017", "3326683.7008", "3670702.0634", "3851292.9211", "4037766.5095"], "r": ["7/131072", "1/16384"], "side24": ["38146.7871", "3.229898"], "tail_max": "0.000000000001", "zfloor": ["8.998670", "35.995700", "80.990915", "110.237711", "126.548387", "135.125542", "139.519517", "9.158381", "36.634639", "82.428597", "112.194581", "128.794805", "137.524222", "141.996200", "9.650794", "38.604735", "86.861637", "118.228561", "135.721621", "144.920548", "149.633051", "11.829859", "47.323688", "106.481272", "144.933809", "166.378491", "177.655432", "183.432483"]}, + {"bound": ["689542.3286", "2262152.9486", "3587802.5360", "4410898.9647", "4865921.2181", "5104727.0912", "5351266.1699", "677536.5957", "2222731.0046", "3525259.4639", "4334000.7074", "4781087.2063", "5015728.2208", "5257968.2529", "643039.3901", "2109422.0164", "3345475.6443", "4112945.4980", "4537216.6307", "4759883.6442", "4989764.5491", "519226.4137", "1706674.8736", "2709695.0077", "3333201.8445", "3678089.9190", "3859148.2182", "4046118.2253"], "r": ["1/16384", "5/65536"], "side24": ["38241.8796", "3.229621"], "tail_max": "0.000000000001", "zfloor": ["8.998164", "35.993579", "80.985898", "110.230634", "126.540108", "135.116617", "139.510201", "9.157854", "36.632458", "82.423457", "112.187339", "128.786337", "137.515096", "141.986676", "9.650184", "38.602315", "86.856025", "118.220696", "135.712445", "144.910668", "149.622747", "11.828782", "47.320010", "106.473254", "144.922808", "166.365771", "177.641793", "183.418299"]}, + {"bound": ["689711.5147", "2262448.7856", "3588128.1312", "4411248.8257", "4866284.9188", "5105098.0995", "5351649.9063", "677707.3564", "2223029.4928", "3525587.9144", "4334353.6045", "4781454.0472", "5016102.4242", "5258355.2880", "643219.1909", "2109736.0612", "3345821.1415", "4113316.6748", "4537602.4553", "4760277.2032", "4990171.5914", "519937.7323", "1709466.1543", "2714590.1669", "3339553.8815", "3685288.1448", "3866801.2339", "4054254.4419"], "r": ["5/65536", "3/32768"], "side24": ["38336.8719", "3.229353"], "tail_max": "0.000000000001", "zfloor": ["8.997889", "35.992853", "80.984541", "110.228896", "126.538163", "135.114564", "139.508093", "9.157563", "36.631691", "82.422028", "112.185511", "128.784291", "137.512937", "141.984459", "9.649819", "38.601369", "86.854281", "118.218471", "135.709959", "144.908047", "149.620057", "11.827992", "47.318057", "106.469765", "144.918412", "166.360886", "177.636655", "183.413032"]}, + {"bound": ["689881.2505", "2262745.8541", "3588455.2054", "4411600.3416", "4866650.3736", "5105470.9141", "5352035.5326", "677878.6632", "2223329.1982", "3525917.8247", "4334708.1347", "4781822.6186", "5016478.4096", "5258744.1875", "643399.5357", "2110051.2897", "3346168.0513", "4113689.4291", "4537989.9505", "4760672.4820", "4990580.4326", "520650.1283", "1712259.7993", "2719488.2222", "3345909.1923", "3692489.8580", "3874457.8499", "4062394.4317"], "r": ["3/32768", "7/65536"], "side24": ["38432.0161", "3.229086"], "tail_max": "0.000000000001", "zfloor": ["8.997615", "35.992126", "80.983185", "110.227158", "126.536218", "135.112511", "139.505985", "9.157273", "36.630924", "82.420600", "112.183682", "128.782245", "137.510778", "141.982242", "9.649455", "38.600423", "86.852536", "118.216245", "135.707473", "144.905425", "149.617366", "11.827202", "47.316105", "106.466277", "144.914015", "166.356001", "177.631516", "183.407765"]}, + {"bound": ["690051.5405", "2263044.1567", "3588783.7614", "4411953.5158", "4867017.5860", "5105845.5387", "5352423.0529", "678050.5213", "2223630.1233", "3526249.1978", "4335064.3012", "4782192.9243", "5016856.1808", "5259134.9554", "643580.4328", "2110367.7044", "3346516.3766", "4114063.7644", "4538379.1200", "4761069.4842", "4990991.0764", "521363.6490", "1715055.8193", "2724389.1846", "3352267.7898", "3699695.0727", "3882118.0810", "4070538.2098"], "r": ["7/65536", "1/8192"], "side24": ["38527.3786", "3.228819"], "tail_max": "0.000000000001", "zfloor": ["8.997341", "35.991400", "80.981829", "110.225420", "126.534272", "135.110457", "139.503876", "9.156982", "36.630157", "82.419171", "112.181853", "128.780199", "137.508619", "141.980025", "9.649090", "38.599477", "86.850791", "118.214020", "135.704987", "144.902804", "149.614676", "11.826412", "47.314152", "106.462788", "144.909619", "166.351115", "177.626378", "183.402497"]}, + {"bound": ["690119.0584", "2263106.0546", "3588786.3250", "4411916.9918", "4866958.2170", "5105773.8193", "5352340.9501", "678119.1979", "2223695.1780", "3526256.5896", "4335033.7795", "4782140.2395", "5016791.5117", "5259060.3094", "643654.7022", "2110445.7773", "3346542.0145", "4114055.2018", "4538350.5462", "4761030.0797", "4990943.0343", "521706.6695", "1716384.8136", "2726711.2407", "3355277.5940", "3703038.3083", "3884700.1637", "4072278.5268"], "r": ["1/8192", "17/131072"], "side24": ["38574.9590", "3.228695"], "tail_max": "0.000000000001", "zfloor": ["8.997436", "35.992432", "80.984812", "110.229891", "126.539633", "135.116303", "139.510031", "9.157072", "36.631187", "82.422169", "112.186353", "128.785598", "137.514507", "141.986225", "9.649154", "38.600477", "86.853787", "118.218548", "135.710435", "144.908753", "149.620945", "11.826305", "47.314902", "106.465574", "144.914027", "166.356509", "177.632311", "183.408782"]}, + {"bound": ["690204.5514", "2263255.9706", "3588951.5198", "4412094.6043", "4867142.9099", "5105962.2505", "5352535.8808", "678205.4737", "2223846.3962", "3526423.1810", "4335212.8745", "4782326.4642", "5016981.5009", "5259256.8478", "643745.5012", "2110604.7191", "3346717.0520", "4114243.3458", "4538546.1646", "4761229.6447", "4991149.4689", "522064.1722", "1717784.2614", "2729163.4368", "3357113.8621", "3703262.0482", "3884928.3820", "4072514.5647"], "r": ["17/131072", "9/65536"], "side24": ["38622.8473", "3.228562"], "tail_max": "0.000000000001", "zfloor": ["8.997299", "35.992069", "80.984134", "110.229022", "126.538661", "135.115276", "139.508976", "9.156927", "36.630804", "82.421455", "112.185438", "128.784575", "137.513427", "141.985117", "9.648971", "38.600004", "86.852914", "118.217435", "135.709192", "144.907442", "149.619600", "11.825910", "47.313925", "106.463830", "144.911829", "166.354066", "177.629742", "183.406148"]}, + {"bound": ["690290.1867", "2263406.1963", "3589117.0865", "4412272.6331", "4867328.0440", "5106151.1361", "5352731.2870", "678291.8915", "2223997.9205", "3526590.1396", "4335392.3802", "4782513.1242", "5017171.9383", "5259453.8552", "643836.4453", "2110763.9590", "3346892.4447", "4114431.8867", "4538742.2033", "4761429.6424", "4991356.3560", "522421.9980", "1719184.3093", "2731165.4876", "3357329.4719", "3703486.1580", "3885156.9804", "4072750.9997"], "r": ["9/65536", "19/131072"], "side24": ["38670.8508", "3.228428"], "tail_max": "0.000000000001", "zfloor": ["8.997162", "35.991705", "80.983456", "110.228153", "126.537688", "135.114249", "139.507922", "9.156781", "36.630420", "82.420741", "112.184524", "128.783552", "137.512348", "141.984008", "9.648789", "38.599531", "86.852042", "118.216323", "135.707949", "144.906131", "149.618255", "11.825515", "47.312949", "106.462085", "144.909630", "166.351624", "177.627172", "183.403515"]}, + {"bound": ["690375.9657", "2263556.7320", "3589283.0255", "4412451.0786", "4867513.6197", "5106340.4766", "5352927.1691", "678378.4529", "2224149.7514", "3526757.4656", "4335572.2971", "4782700.2200", "5017362.8246", "5259651.3322", "643927.5372", "2110923.4971", "3347068.1931", "4114620.8247", "4538938.6628", "4761630.0732", "4991563.6962", "522780.1628", "1720584.9592", "2731366.5156", "3357545.4325", "3703710.6380", "3885385.9593", "4072987.8323"], "r": ["19/131072", "5/32768"], "side24": ["38718.9927", "3.228294"], "tail_max": "0.000000000001", "zfloor": ["8.997025", "35.991342", "80.982778", "110.227284", "126.536715", "135.113223", "139.506868", "9.156636", "36.630037", "82.420027", "112.183610", "128.782529", "137.511268", "141.982900", "9.648607", "38.599058", "86.851170", "118.215210", "135.706706", "144.904820", "149.616909", "11.825120", "47.311972", "106.460341", "144.907432", "166.349181", "177.624603", "183.400881"]}, + {"bound": ["690461.8900", "2263707.5783", "3589449.3371", "4412629.9412", "4867699.6377", "5106530.2725", "5353123.5277", "678465.1597", "2224301.8891", "3526925.1595", "4335752.6256", "4782887.7520", "5017554.1601", "5259849.2792", "644018.7798", "2111083.3341", "3347244.2975", "4114810.1605", "4539135.5434", "4761830.9376", "4991771.4898", "523138.6851", "1721986.2131", "2731567.8599", "3357761.7444", "3703935.4888", "3885615.3193", "4073225.0629"], "r": ["5/32768", "21/131072"], "side24": ["38767.3002", "3.228161"], "tail_max": "0.000000000001", "zfloor": ["8.996888", "35.990979", "80.982099", "110.226415", "126.535742", "135.112196", "139.505814", "9.156490", "36.629653", "82.419312", "112.182695", "128.781506", "137.510188", "141.981792", "9.648424", "38.598585", "86.850297", "118.214097", "135.705463", "144.903510", "149.615564", "11.824725", "47.310996", "106.458596", "144.905234", "166.346738", "177.622033", "183.398247"]}, + {"bound": ["690547.9613", "2263858.7353", "3589616.0217", "4412809.2213", "4867886.0983", "5106720.5242", "5353320.3632", "678552.0140", "2224454.3341", "3527093.2217", "4335933.3661", "4783075.7208", "5017745.9453", "5260047.6968", "644110.1765", "2111243.4703", "3347420.7583", "4114999.8943", "4539332.8456", "4762032.2360", "4991979.7375", "523497.5863", "1723303.9290", "2731769.5209", "3357978.4079", "3704160.7107", "3885845.0608", "4073462.6920"], "r": ["21/131072", "11/65536"], "side24": ["38815.8048", "3.228027"], "tail_max": "0.000000000001", "zfloor": ["8.996750", "35.990616", "80.981421", "110.225546", "126.534770", "135.111169", "139.504760", "9.156345", "36.629270", "82.418598", "112.181781", "128.780483", "137.509109", "141.980683", "9.648242", "38.598112", "86.849425", "118.212984", "135.704220", "144.902199", "149.614219", "11.824330", "47.310019", "106.456852", "144.903035", "166.344295", "177.619464", "183.395613"]}, + {"bound": ["690634.1817", "2264010.2035", "3589783.0796", "4412988.9194", "4868073.0020", "5106911.2323", "5353517.6763", "678639.0181", "2224607.0867", "3527261.6524", "4336114.5191", "4783264.1268", "5017938.1807", "5260246.5853", "644201.7315", "2111403.9062", "3347597.5759", "4115190.0266", "4539530.5700", "4762233.9690", "4992188.4396", "523856.8912", "1723487.5519", "2731971.4991", "3358195.4235", "3704386.3042", "3886075.1842", "4073700.7201"], "r": ["11/65536", "23/131072"], "side24": ["38864.5431", "3.227893"], "tail_max": "0.000000000001", "zfloor": ["8.996613", "35.990252", "80.980743", "110.224677", "126.533797", "135.110143", "139.503705", "9.156199", "36.628886", "82.417884", "112.180866", "128.779459", "137.508029", "141.979575", "9.648060", "38.597638", "86.848552", "118.211871", "135.702977", "144.900888", "149.612873", "11.823935", "47.309043", "106.455107", "144.900836", "166.341852", "177.616894", "183.392979"]}, + {"bound": ["690720.5535", "2264161.9832", "3589950.5114", "4413169.0359", "4868260.3492", "5107102.3973", "5353715.4673", "678726.1745", "2224760.1474", "3527430.4522", "4336296.0849", "4783452.9704", "5018130.8669", "5260445.9454", "644293.4491", "2111564.6423", "3347774.7506", "4115380.5579", "4539728.7168", "4762436.1369", "4992397.5967", "524216.6279", "1723671.4560", "2732173.7946", "3358412.7918", "3704612.2699", "3886305.6901", "4073939.1476"], "r": ["23/131072", "3/16384"], "side24": ["38913.5567", "3.227759"], "tail_max": "0.000000000001", "zfloor": ["8.996476", "35.989889", "80.980065", "110.223808", "126.532824", "135.109116", "139.502651", "9.156054", "36.628502", "82.417169", "112.179952", "128.778436", "137.506949", "141.978466", "9.647877", "38.597165", "86.847680", "118.210759", "135.701733", "144.899577", "149.611528", "11.823540", "47.308066", "106.453363", "144.898638", "166.339409", "177.614324", "183.390345"]}, + {"bound": ["690807.0792", "2264314.0750", "3590118.3172", "4413349.5712", "4868448.1405", "5107294.0195", "5353913.7368", "678813.4863", "2224913.5166", "3527599.6213", "4336478.0641", "4783642.2521", "5018324.0042", "5260645.7775", "644385.3346", "2111725.6792", "3347952.2828", "4115571.4885", "4539927.2866", "4762638.7403", "4992607.2093", "524576.8287", "1723855.6432", "2732376.4078", "3358630.5131", "3704838.6080", "3886536.5788", "4074177.9750"], "r": ["3/16384", "25/131072"], "side24": ["38962.8934", "3.227626"], "tail_max": "0.000000000001", "zfloor": ["8.996339", "35.989526", "80.979387", "110.222939", "126.531851", "135.108089", "139.501597", "9.155908", "36.628119", "82.416455", "112.179038", "128.777413", "137.505870", "141.977357", "9.647695", "38.596692", "86.846807", "118.209646", "135.700490", "144.898266", "149.610183", "11.823145", "47.307090", "106.451618", "144.896439", "166.336965", "177.611755", "183.387710"]}, + {"bound": ["690893.7620", "2264466.4792", "3590286.4976", "4413530.5258", "4868636.3763", "5107486.0995", "5354112.4852", "678900.9569", "2225067.1948", "3527769.1601", "4336660.4570", "4783831.9723", "5018517.5931", "5260846.0822", "644477.3938", "2111887.0175", "3348130.1729", "4115762.8188", "4540126.2799", "4762841.7796", "4992817.2777", "524937.5300", "1724040.1159", "2732579.3391", "3358848.5881", "3705065.3192", "3886767.8508", "4074417.2029"], "r": ["25/131072", "13/65536"], "side24": ["39012.6074", "3.227492"], "tail_max": "0.000000000001", "zfloor": ["8.996202", "35.989163", "80.978708", "110.222070", "126.530878", "135.107062", "139.500543", "9.155763", "36.627735", "82.415741", "112.178123", "128.776390", "137.504790", "141.976249", "9.647513", "38.596219", "86.845935", "118.208533", "135.699247", "144.896955", "149.608837", "11.822750", "47.306113", "106.449873", "144.894240", "166.334522", "177.609185", "183.385076"]}, + {"bound": ["690980.6049", "2264619.1962", "3590455.0529", "4413711.9001", "4868825.0570", "5107678.6378", "5354311.7132", "678988.5901", "2225221.1823", "3527939.0691", "4336843.2641", "4784022.1316", "5018711.6342", "5261046.8599", "644569.6331", "2112048.6577", "3348308.4214", "4115954.5494", "4540325.6970", "4763045.2552", "4993027.8027", "525298.7731", "1724224.8766", "2732782.5886", "3359067.0171", "3705292.4040", "3886999.5068", "4074656.8317"], "r": ["13/65536", "27/131072"], "side24": ["39062.7600", "3.227358"], "tail_max": "0.000000000001", "zfloor": ["8.996065", "35.988799", "80.978030", "110.221201", "126.529905", "135.106035", "139.499488", "9.155617", "36.627352", "82.415026", "112.177209", "128.775367", "137.503710", "141.975140", "9.647331", "38.595746", "86.845062", "118.207420", "135.698004", "144.895644", "149.607492", "11.822355", "47.305136", "106.448128", "144.892042", "166.332079", "177.606615", "183.382442"]}, + {"bound": ["691067.6118", "2264772.2266", "3590623.9836", "4413893.6946", "4869014.1832", "5107871.6350", "5354511.4213", "679076.3900", "2225375.4798", "3528109.3486", "4337026.4859", "4784212.7304", "5018906.1279", "5261248.1111", "644662.0600", "2112210.6006", "3348487.0286", "4116146.6806", "4540525.5385", "4763249.1678", "4993238.7845", "525660.6044", "1724409.9281", "2732986.1568", "3359285.7963", "3705519.8628", "3887231.5471", "4074896.8620"], "r": ["27/131072", "7/32768"], "side24": ["39113.4200", "3.227225"], "tail_max": "0.000000000001", "zfloor": ["8.995928", "35.988436", "80.977352", "110.220331", "126.528933", "135.105009", "139.498434", "9.155472", "36.626968", "82.414312", "112.176294", "128.774343", "137.502630", "141.974032", "9.647148", "38.595273", "86.844190", "118.206307", "135.696760", "144.894333", "149.606146", "11.821960", "47.304160", "106.446384", "144.889843", "166.329636", "177.604045", "183.379807"]}, + {"bound": ["691154.7867", "2264925.5709", "3590793.2899", "4414075.9097", "4869203.7553", "5108065.0913", "5354711.6098", "679164.3613", "2225530.0878", "3528279.9991", "4337210.1227", "4784403.7692", "5019101.0747", "5261449.8363", "644754.6826", "2112372.8469", "3348665.9949", "4116339.2128", "4540725.8049", "4763453.5177", "4993450.2238", "526023.0755", "1724595.2735", "2733190.0440", "3359504.9294", "3705747.6962", "3887463.9723", "4075137.2943"], "r": ["7/32768", "29/131072"], "side24": ["39164.6646", "3.227091"], "tail_max": "0.000000000001", "zfloor": ["8.995790", "35.988073", "80.976674", "110.219462", "126.527960", "135.103982", "139.497380", "9.155326", "36.626584", "82.413598", "112.175380", "128.773320", "137.501550", "141.972923", "9.646966", "38.594799", "86.843317", "118.205194", "135.695517", "144.893022", "149.604801", "11.821565", "47.303183", "106.444639", "144.887644", "166.327192", "177.601475", "183.377173"]}, + {"bound": ["691242.1342", "2265079.2295", "3590962.9723", "4414258.5458", "4869393.7738", "5108259.0075", "5354912.2794", "679252.5094", "2225685.0067", "3528451.0208", "4337394.1749", "4784595.2484", "5019296.4752", "5261652.0362", "644847.5100", "2112535.3973", "3348845.3208", "4116532.1466", "4540926.4964", "4763658.3054", "4993662.1210", "526386.2444", "1724780.9162", "2733394.2504", "3359724.4166", "3705975.9047", "3887696.7830", "4075378.1292"], "r": ["29/131072", "15/65536"], "side24": ["39216.5800", "3.226957"], "tail_max": "0.000000000001", "zfloor": ["8.995653", "35.987710", "80.975995", "110.218593", "126.526987", "135.102955", "139.496325", "9.155181", "36.626201", "82.412883", "112.174465", "128.772297", "137.500471", "141.971814", "9.646784", "38.594326", "86.842444", "118.204081", "135.694274", "144.891711", "149.603455", "11.821170", "47.302206", "106.442894", "144.885445", "166.324749", "177.598905", "183.374538"]}, + {"bound": ["691329.6593", "2265233.2031", "3591133.0312", "4414441.6034", "4869584.2392", "5108453.3839", "5355113.4306", "679340.8401", "2225840.2373", "3528622.4143", "4337578.6432", "4784787.1685", "5019492.3297", "5261854.7111", "644940.5524", "2112698.2528", "3349025.0067", "4116725.4824", "4541127.6138", "4763863.5314", "4993874.4766", "526750.1754", "1724966.8600", "2733598.7763", "3359944.2585", "3706204.4890", "3887929.9797", "4075619.3672"], "r": ["15/65536", "31/131072"], "side24": ["39269.2623", "3.226824"], "tail_max": "0.000000000001", "zfloor": ["8.995516", "35.987346", "80.975317", "110.217724", "126.526014", "135.101928", "139.495271", "9.155036", "36.625817", "82.412169", "112.173551", "128.771274", "137.499391", "141.970706", "9.646601", "38.593853", "86.841572", "118.202968", "135.693030", "144.890400", "149.602110", "11.820775", "47.301230", "106.441149", "144.883246", "166.322305", "177.596334", "183.371904"]}, + {"bound": ["691417.3677", "2265387.4922", "3591303.4670", "4414625.0829", "4869775.1520", "5108648.2211", "5355315.0638", "679429.3596", "2225995.7801", "3528794.1799", "4337763.5278", "4784979.5300", "5019688.6387", "5262057.8616", "645033.8209", "2112861.4141", "3349205.0530", "4116919.2206", "4541329.1573", "4764069.1962", "4994087.2911", "527114.9396", "1725153.1091", "2733803.6221", "3360164.4554", "3706433.4456", "3888163.5630", "4075861.0090"], "r": ["31/131072", "1/4096"], "side24": ["39322.8180", "3.226690"], "tail_max": "0.000000000001", "zfloor": ["8.995379", "35.986983", "80.974639", "110.216855", "126.525041", "135.100901", "139.494216", "9.154890", "36.625434", "82.411454", "112.172636", "128.770250", "137.498311", "141.969597", "9.646419", "38.593380", "86.840699", "118.201855", "135.691787", "144.889089", "149.600764", "11.820380", "47.300253", "106.439404", "144.881047", "166.319861", "177.593764", "183.369269"]}, + {"bound": ["691611.2475", "2265784.8789", "3591807.9362", "4415207.2728", "4870402.2058", "5109299.2508", "5355996.6261", "679624.5075", "2226393.8144", "3529297.8686", "4338343.9978", "4785604.3181", "5020337.1085", "5262736.5973", "645237.5309", "2113269.3878", "3349715.4882", "4117504.4693", "4541957.5724", "4764720.6679", "4994768.6252", "527385.6625", "1725589.1314", "2734330.7323", "3360759.2586", "3707067.2542", "3888818.1842", "4076543.8906"], "r": ["1/4096", "17/65536"], "side24": ["39433.2500", "3.226412"], "tail_max": "0.000000000001", "zfloor": ["8.994872", "35.984861", "80.969620", "110.209776", "126.516760", "135.091974", "139.484898", "9.154363", "36.623252", "82.406312", "112.165392", "128.761780", "137.489182", "141.960070", "9.645808", "38.590959", "86.835085", "118.193987", "135.682608", "144.879205", "149.590456", "11.819302", "47.296573", "106.431382", "144.870040", "166.307135", "177.580118", "183.355078"]}, + {"bound": ["691788.0600", "2266095.6931", "3592151.4762", "4415577.2201", "4870787.2002", "5109692.1894", "5356403.3081", "679802.9985", "2226707.1141", "3529644.0349", "4338716.7165", "4785992.1683", "5020732.9478", "5263146.2683", "645425.8722", "2113597.8858", "3350078.1354", "4117894.7985", "4542363.6818", "4765135.1093", "4995197.5091", "527612.4068", "1725963.1286", "2734742.6947", "3361202.1743", "3707527.8276", "3889288.0825", "4077030.0365"], "r": ["17/65536", "9/32768"], "side24": ["39548.5349", "3.226145"], "tail_max": "0.000000000001", "zfloor": ["8.994598", "35.984135", "80.968263", "110.208037", "126.514814", "135.089920", "139.482789", "9.154072", "36.622484", "82.404883", "112.163563", "128.759733", "137.487022", "141.957852", "9.645444", "38.590013", "86.833340", "118.191761", "135.680121", "144.876583", "149.587765", "11.818512", "47.294619", "106.427891", "144.865641", "166.302247", "177.574977", "183.349808"]}, + {"bound": ["691965.7551", "2266407.7834", "3592496.5324", "4415948.8644", "4871173.9939", "5110086.9813", "5356811.9291", "679982.4174", "2227021.6780", "3529991.6984", "4339091.1101", "4786381.7939", "5021130.6154", "5263557.8522", "645615.4188", "2113927.6295", "3350442.2338", "4118286.7469", "4542771.5059", "4765551.3159", "4995628.2391", "527843.9055", "1726338.2236", "2735155.9430", "3361646.5172", "3707989.9085", "3889759.5307", "4077517.7954"], "r": ["9/32768", "19/65536"], "side24": ["39670.2062", "3.225877"], "tail_max": "0.000000000001", "zfloor": ["8.994323", "35.983408", "80.966906", "110.206299", "126.512868", "135.087866", "139.480680", "9.153781", "36.621717", "82.403454", "112.161733", "128.757686", "137.484862", "141.955634", "9.645079", "38.589066", "86.831594", "118.189534", "135.677633", "144.873960", "149.585073", "11.817722", "47.292665", "106.424401", "144.861242", "166.297359", "177.569835", "183.344538"]}, + {"bound": ["692144.4129", "2266721.1564", "3592843.1084", "4416322.2094", "4871562.5907", "5110483.6303", "5357222.4932", "680162.8565", "2227337.5135", "3530340.8628", "4339467.1822", "4786773.1988", "5021530.1154", "5263971.3531", "645806.3324", "2114258.6304", "3350807.7847", "4118680.3183", "4543181.0487", "4765969.2918", "4996060.8196", "528081.1924", "1726714.4182", "2735570.4796", "3362092.2902", "3708453.5002", "3890232.5323", "4078007.1769"], "r": ["19/65536", "5/16384"], "side24": ["39799.8366", "3.225610"], "tail_max": "0.000000000001", "zfloor": ["8.994049", "35.982681", "80.965549", "110.204560", "126.510921", "135.085811", "139.478570", "9.153490", "36.620949", "82.402025", "112.159904", "128.755639", "137.482702", "141.953416", "9.644714", "38.588119", "86.829848", "118.187308", "135.675146", "144.871337", "149.582381", "11.816932", "47.290711", "106.420910", "144.856843", "166.292470", "177.564694", "183.339267"]}, + {"bound": ["692324.1279", "2267035.8198", "3593191.2080", "4416697.2591", "4871952.9947", "5110882.1408", "5357635.0047", "680344.4245", "2227654.6289", "3530691.5319", "4339844.9366", "4787166.3869", "5021931.4520", "5264386.7754", "645998.8034", "2114590.9012", "3351174.7761", "4119075.5168", "4543592.3143", "4766389.0411", "4996495.2548", "528325.4848", "1727091.7145", "2735986.3070", "3362539.4962", "3708918.6057", "3890707.0904", "4078498.1845"], "r": ["5/16384", "21/65536"], "side24": ["39939.2902", "3.225343"], "tail_max": "0.000000000001", "zfloor": ["8.993774", "35.981954", "80.964192", "110.202821", "126.508975", "135.083757", "139.476461", "9.153199", "36.620182", "82.400596", "112.158074", "128.753592", "137.480541", "141.951199", "9.644349", "38.587173", "86.828103", "118.185081", "135.672659", "144.868714", "149.579689", "11.816141", "47.288757", "106.417419", "144.852443", "166.287582", "177.559551", "183.333996"]}, + {"bound": ["692505.0102", "2267351.7820", "3593540.8349", "4417074.0172", "4872345.2100", "5111282.5168", "5358049.4680", "680527.2483", "2227973.0337", "3531043.7097", "4340224.3774", "4787561.3623", "5022334.6293", "5264804.1233", "646193.0540", "2114924.4567", "3351543.2229", "4119472.3466", "4544005.3069", "4766810.5683", "4996931.5491", "528578.2043", "1727470.1144", "2736403.4278", "3362988.1383", "3709385.2282", "3891183.2084", "4078990.8217"], "r": ["21/65536", "11/32768"], "side24": ["40090.7618", "3.225075"], "tail_max": "0.000000000001", "zfloor": ["8.993500", "35.981228", "80.962835", "110.201082", "126.507029", "135.081703", "139.474352", "9.152908", "36.619414", "82.399167", "112.156244", "128.751545", "137.478381", "141.948981", "9.643985", "38.586226", "86.826357", "118.182855", "135.670171", "144.866091", "149.576997", "11.815351", "47.286803", "106.413928", "144.848044", "166.282693", "177.554409", "183.328725"]}, + {"bound": ["692687.1876", "2267669.0526", "3593891.9933", "4417452.4877", "4872739.2407", "5111684.7626", "5358465.8875", "680711.4750", "2228292.7383", "3531397.4002", "4340605.5086", "4787958.1292", "5022739.6516", "5265223.4011", "646389.3423", "2115259.2920", "3351913.1282", "4119870.8120", "4544420.0310", "4767233.8776", "4997369.7071", "528841.0000", "1727849.6199", "2736821.8444", "3363438.2192", "3709853.3709", "3891660.8894", "4079485.0919"], "r": ["11/32768", "23/65536"], "side24": ["40256.8214", "3.224808"], "tail_max": "0.000000000001", "zfloor": ["8.993226", "35.980501", "80.961478", "110.199344", "126.505082", "135.079648", "139.472242", "9.152617", "36.618647", "82.397737", "112.154415", "128.749498", "137.476221", "141.946762", "9.643620", "38.585279", "86.824611", "118.180628", "135.667684", "144.863468", "149.574305", "11.814561", "47.284849", "106.410437", "144.843644", "166.277804", "177.549267", "183.323453"]}, + {"bound": ["692870.8074", "2267987.6421", "3594244.6872", "4417832.6748", "4873135.0910", "5112088.8824", "5358884.2676", "680897.2743", "2228613.7549", "3531752.6077", "4340988.3342", "4788356.6918", "5023146.5230", "5265644.6135", "646587.9657", "2115594.9557", "3352284.4947", "4120270.9176", "4544836.4909", "4767658.9734", "4997809.7334", "529115.7727", "1728230.2329", "2737241.5594", "3363889.7419", "3710323.0368", "3892140.1368", "4079980.9985"], "r": ["23/65536", "3/8192"], "side24": ["40440.4625", "3.224540"], "tail_max": "0.000000000001", "zfloor": ["8.992951", "35.979774", "80.960121", "110.197605", "126.503136", "135.077594", "139.470133", "9.152326", "36.617879", "82.396308", "112.152585", "128.747451", "137.474060", "141.944544", "9.643255", "38.584332", "86.822865", "118.178401", "135.665196", "144.860845", "149.571613", "11.813771", "47.282894", "106.406945", "144.839244", "166.272914", "177.544124", "183.318182"]}, + {"bound": ["693056.0384", "2268307.5627", "3594598.9211", "4418214.5826", "4873532.7651", "5112494.8807", "5359304.6128", "681084.8407", "2228936.0966", "3532109.3182", "4341372.8584", "4788757.0543", "5023555.2480", "5266067.7648", "646789.2652", "2115931.8406", "3352657.3253", "4120672.6680", "4545254.6912", "4768085.8605", "4998251.6327", "529404.7008", "1728611.9555", "2737662.5754", "3364342.7094", "3710794.2292", "3892620.9540", "4080478.5449"], "r": ["3/8192", "25/65536"], "side24": ["40645.1575", "3.224273"], "tail_max": "0.000000000001", "zfloor": ["8.992677", "35.979047", "80.958764", "110.195866", "126.501189", "135.075539", "139.468023", "9.152035", "36.617112", "82.394878", "112.150755", "128.745403", "137.471900", "141.942326", "9.642890", "38.583385", "86.821119", "118.176174", "135.662708", "144.858222", "149.568920", "11.812980", "47.280940", "106.403453", "144.834843", "166.268025", "177.538981", "183.312910"]}, + {"bound": ["693243.0731", "2268628.8275", "3594954.6898", "4418598.2154", "4873932.2674", "5112902.7618", "5359726.9278", "681274.3959", "2229259.5308", "3532467.5345", "4341759.0857", "4789159.2212", "5023965.8310", "5266492.8597", "646993.6298", "2116269.9486", "3353031.6228", "4121076.0682", "4545674.6367", "4768514.5436", "4998695.4099", "529710.2678", "1728994.7895", "2738084.8947", "3364797.1246", "3711266.9513", "3893103.3440", "4080977.7345"], "r": ["25/65536", "13/32768"], "side24": ["40874.9192", "3.224006"], "tail_max": "0.000000000001", "zfloor": ["8.992402", "35.978320", "80.957407", "110.194127", "126.499242", "135.073485", "139.465913", "9.151744", "36.616344", "82.393449", "112.148925", "128.743356", "137.469739", "141.940108", "9.642525", "38.582438", "86.819373", "118.173947", "135.660220", "144.855598", "149.566228", "11.812190", "47.278986", "106.399962", "144.830443", "166.263135", "177.533837", "183.307637"]}, + {"bound": ["693432.1303", "2268951.0544", "3595311.9772", "4418983.5775", "4874333.6024", "5113312.5302", "5360151.2171", "681466.1920", "2229584.0302", "3532827.2700", "4342147.0204", "4789563.1969", "5024378.2766", "5266919.9029", "647201.5010", "2116609.2820", "3353407.3902", "4121481.1233", "4546096.3323", "4768945.0275", "4999141.0699", "530035.2912", "1729378.7370", "2738508.5200", "3365252.9904", "3711741.2061", "3893587.3103", "4081478.5709"], "r": ["13/32768", "27/65536"], "side24": ["41134.3703", "3.223738"], "tail_max": "0.000000000001", "zfloor": ["8.992128", "35.977593", "80.956049", "110.192387", "126.497296", "135.071430", "139.463804", "9.151453", "36.615576", "82.392019", "112.147095", "128.741308", "137.467578", "141.937889", "9.642161", "38.581491", "86.817627", "118.171720", "135.657732", "144.852975", "149.563535", "11.811399", "47.277031", "106.396470", "144.826042", "166.258244", "177.528694", "183.302365"]}, + {"bound": ["693623.4570", "2269274.4882", "3595670.8066", "4419370.6735", "4874736.7745", "5113724.1905", "5360577.4855", "681660.5135", "2229909.7920", "3533188.5276", "4342536.6673", "4789968.9860", "5024792.5894", "5267348.8991", "647413.3777", "2116949.8430", "3353784.6302", "4121887.8012", "4546519.7831", "4769377.3172", "4999588.6179", "530382.9539", "1729763.8000", "2738933.4538", "3365710.3097", "3712216.9970", "3894072.8562", "4081981.0574"], "r": ["27/65536", "7/16384"], "side24": ["41428.8221", "3.223471"], "tail_max": "0.000000000001", "zfloor": ["8.991853", "35.976866", "80.954692", "110.190648", "126.495349", "135.069375", "139.461694", "9.151162", "36.614809", "82.390590", "112.145265", "128.739260", "137.465418", "141.935671", "9.641796", "38.580544", "86.815881", "118.169493", "135.655244", "144.850351", "149.560843", "11.810609", "47.275076", "106.392977", "144.821641", "166.253354", "177.523550", "183.297092"]}, + {"bound": ["693817.3315", "2269599.2017", "3596031.1810", "4419759.5081", "4875141.7884", "5114137.7475", "5361005.7378", "681857.6809", "2230236.8184", "3533551.3103", "4342928.0311", "4790376.5933", "5025208.7741", "5267779.8531", "647629.8217", "2117291.6336", "3354163.3458", "4122296.1227", "4546944.9945", "4769811.4181", "5000038.0594", "530756.8363", "1730149.9805", "2739359.6987", "3366169.0855", "3712694.3269", "3894559.9848", "4082485.1975"], "r": ["7/16384", "29/65536"], "side24": ["41764.3631", "3.223203"], "tail_max": "0.000000000001", "zfloor": ["8.991579", "35.976139", "80.953335", "110.188909", "126.493402", "135.067320", "139.459584", "9.150871", "36.614041", "82.389160", "112.143435", "128.737213", "137.463257", "141.933453", "9.641431", "38.579597", "86.814134", "118.167265", "135.652756", "144.847728", "149.558150", "11.809818", "47.273122", "106.389485", "144.817240", "166.248463", "177.518406", "183.291819"]}, + {"bound": ["694014.0658", "2269925.1971", "3596393.1032", "4420150.0860", "4875548.6489", "5114553.2058", "5361435.9789", "682058.0537", "2230565.1117", "3533915.6211", "4343321.1168", "4790786.0236", "5025626.8355", "5268212.7701", "647851.4625", "2117634.6560", "3354543.5399", "4122706.0995", "4547371.9720", "4770247.3354", "5000489.3997", "531160.9515", "1730537.2805", "2739787.2571", "3366629.3208", "3713173.1992", "3895048.6997", "4082990.9946"], "r": ["29/65536", "15/32768"], "side24": ["42147.9587", "3.222936"], "tail_max": "0.000000000001", "zfloor": ["8.991304", "35.975412", "80.951977", "110.187170", "126.491455", "135.065265", "139.457474", "9.150580", "36.613273", "82.387731", "112.141605", "128.735165", "137.461096", "141.931234", "9.641066", "38.578650", "86.812388", "118.165038", "135.650268", "144.845104", "149.555457", "11.809028", "47.271167", "106.385992", "144.812838", "166.243572", "177.513261", "183.286546"]}, + {"bound": ["694214.0084", "2270252.4765", "3596756.5765", "4420542.4122", "4875957.3609", "5114970.5703", "5361868.2139", "682262.0333", "2230894.6741", "3534281.4629", "4343715.9295", "4791197.2819", "5026046.7787", "5268647.6550", "648079.0036", "2117978.9124", "3354925.2153", "4123117.7348", "4547800.7213", "4770685.0750", "5000942.6445", "531599.7817", "1730925.7019", "2740216.1317", "3367091.0185", "3713653.6171", "3895539.0039", "4083498.4523"], "r": ["15/32768", "31/65536"], "side24": ["42587.5625", "3.222668"], "tail_max": "0.000000000001", "zfloor": ["8.991030", "35.974685", "80.950620", "110.185430", "126.489508", "135.063210", "139.455364", "9.150288", "36.612505", "82.386301", "112.139775", "128.733117", "137.458935", "141.929015", "9.640701", "38.577703", "86.810642", "118.162810", "135.647779", "144.842480", "149.552764", "11.808237", "47.269212", "106.382500", "144.808437", "166.238681", "177.508117", "183.281272"]}, + {"bound": ["694417.5478", "2270581.0422", "3597121.6038", "4420936.4920", "4876367.9293", "5115389.8461", "5362302.4479", "682470.0670", "2231225.5078", "3534648.8388", "4344112.4746", "4791610.3733", "5026468.6087", "5269084.5132", "648313.2283", "2118324.4050", "3355308.3749", "4123531.0321", "4548231.1902", "4771124.6425", "5001397.8000", "532078.3179", "1731315.2468", "2740646.3249", "3367554.1815", "3714135.5836", "3896030.9010", "4084007.5739"], "r": ["31/65536", "1/2048"], "side24": ["43092.2382", "3.222401"], "tail_max": "0.000000000001", "zfloor": ["8.990755", "35.973958", "80.949263", "110.183691", "126.487561", "135.061155", "139.453254", "9.149997", "36.611738", "82.384871", "112.137945", "128.731069", "137.456774", "141.926796", "9.640336", "38.576756", "86.808895", "118.160583", "135.645291", "144.839856", "149.550071", "11.807447", "47.267257", "106.379007", "144.804035", "166.233790", "177.502972", "183.275998"]}, + {"bound": ["694873.2053", "2271418.3665", "3598182.0990", "4422158.8528", "4877683.5071", "5116755.2240", "5363731.8198", "682935.6099", "2232063.6244", "3535707.1216", "4345330.6137", "4792920.6392", "5027828.0540", "5270507.3757", "648838.4710", "2119181.1973", "3356378.5445", "4124756.7808", "4549546.6252", "4772488.0358", "5002823.7504", "533203.5451", "1732224.4456", "2741744.5336", "3368792.7119", "3715454.9289", "3897393.3343", "4085428.9164"], "r": ["1/2048", "17/32768"], "side24": ["44340.0204", "3.221845"], "tail_max": "0.000000000001", "zfloor": ["8.989741", "35.969712", "80.939220", "110.169527", "126.470992", "135.043294", "139.434609", "9.148943", "36.607371", "82.374582", "112.123450", "128.714122", "137.438508", "141.907734", "9.639114", "38.571912", "86.797661", "118.144839", "135.626923", "144.820079", "149.529446", "11.805289", "47.259890", "106.362951", "144.782006", "166.208319", "177.475661", "183.247597"]}, + {"bound": ["695313.0656", "2272084.6098", "3598923.1785", "4422959.3891", "4878517.8502", "5117607.3701", "5364614.5054", "683388.8103", "2232734.2982", "3536452.7581", "4346135.8342", "4793759.8682", "5028685.1402", "5271395.1316", "649369.0115", "2119880.9448", "3357155.4015", "4125595.1839", "4550420.0696", "4773379.9794", "5003747.4985", "534535.9703", "1733011.5144", "2742614.3027", "3369729.4735", "3716429.8955", "3898388.4782", "4086459.0181"], "r": ["17/32768", "9/16384"], "side24": ["45995.9803", "3.221310"], "tail_max": "0.000000000001", "zfloor": ["8.989192", "35.968257", "80.936504", "110.166047", "126.467097", "135.039182", "139.430388", "9.148361", "36.605835", "82.371722", "112.119788", "128.710025", "137.434185", "141.903295", "9.638384", "38.570017", "86.794167", "118.140383", "135.621945", "144.814830", "149.524058", "11.803708", "47.255979", "106.355964", "144.773199", "166.198534", "177.465368", "183.237046"]}, + {"bound": ["695777.9947", "2272756.0436", "3599670.5354", "4423766.9164", "4879359.7305", "5118467.2710", "5365505.2993", "683870.5275", "2233410.1020", "3537204.5912", "4346948.0087", "4794606.5208", "5029549.8868", "5272290.8956", "649947.8126", "2120585.6807", "3357938.2540", "4126440.3037", "4551300.6375", "4774279.2612", "5004678.9037", "536164.5489", "1733803.1179", "2743489.3982", "3370672.1565", "3717411.1217", "3899390.0604", "4087495.8459"], "r": ["9/16384", "19/32768"], "side24": ["48573.7852", "3.220775"], "tail_max": "0.000000000001", "zfloor": ["8.988643", "35.966803", "80.933789", "110.162567", "126.463202", "135.035071", "139.426166", "9.147778", "36.604299", "82.368861", "112.116127", "128.705928", "137.429861", "141.898856", "9.637654", "38.568122", "86.790673", "118.135926", "135.616966", "144.809580", "149.518670", "11.802126", "47.252068", "106.348975", "144.764392", "166.188747", "177.455074", "183.226494"]}, + {"bound": ["696273.8586", "2273432.6859", "3600424.1942", "4424581.5198", "4880209.1569", "5119334.9752", "5366404.2506", "684387.5156", "2234091.0534", "3537962.6452", "4347767.1655", "4795460.4421", "5030422.3442", "5273194.7188", "650586.6885", "2121295.4224", "3358727.1251", "4127292.1674", "4552188.3585", "4775185.9118", "5005618.0165", "538164.8061", "1734599.2727", "2744369.8408", "3371620.7847", "3718398.6330", "3900398.1075", "4088539.4276"], "r": ["19/32768", "5/8192"], "side24": ["54851.2852", "3.220241"], "tail_max": "0.000000000001", "zfloor": ["8.988093", "35.965348", "80.931072", "110.159087", "126.459306", "135.030959", "139.421944", "9.147196", "36.602763", "82.366000", "112.112465", "128.701831", "137.425538", "141.894417", "9.636924", "38.566227", "86.787178", "118.131469", "135.611987", "144.804330", "149.513282", "11.800544", "47.248156", "106.341986", "144.755584", "166.178960", "177.444780", "183.215941"]}, + {"bound": ["696807.6477", "2274114.5548", "3601184.1793", "4425403.2282", "4881065.9727", "5120210.5345", "5367311.4118", "684947.8224", "2234777.1705", "3538726.9441", "4348593.3331", "4796321.8055", "5031302.3019", "5274106.5611", "651299.7166", "2122010.1873", "3359522.0383", "4128150.8026", "4553083.2624", "4776099.9622", "5006564.8694", "539824.5403", "1735399.9950", "2745255.6511", "3372575.3821", "3719392.4554", "3901412.6463", "4089589.7913"], "r": ["5/8192", "21/32768"], "side24": ["55144.2465", "3.219706"], "tail_max": "0.000000000001", "zfloor": ["8.987544", "35.963893", "80.928356", "110.155607", "126.455410", "135.026847", "139.417722", "9.146613", "36.601226", "82.363139", "112.108802", "128.697733", "137.421213", "141.889977", "9.636194", "38.564332", "86.783684", "118.127011", "135.607008", "144.799079", "149.507893", "11.798963", "47.244244", "106.334996", "144.746775", "166.169171", "177.434484", "183.205387"]}, + {"bound": ["697387.6316", "2274801.6684", "3601950.5152", "4426232.0705", "4881930.3633", "5121093.7040", "5368226.7363", "685560.9687", "2235468.4712", "3539497.5121", "4349426.5400", "4797190.6419", "5032189.9452", "5275026.3081", "652103.5546", "2122729.9932", "3360323.0168", "4129016.2367", "4553985.3788", "4777021.4435", "5007519.4947", "540281.1804", "1736205.3014", "2746146.8498", "3373535.9727", "3720392.6146", "3902433.7037", "4090646.9650"], "r": ["21/32768", "11/16384"], "side24": ["55507.5157", "3.219171"], "tail_max": "0.000000000001", "zfloor": ["8.986995", "35.962438", "80.925640", "110.152126", "126.451514", "135.022735", "139.413500", "9.146031", "36.599690", "82.360278", "112.105140", "128.693635", "137.416889", "141.885537", "9.635464", "38.562436", "86.780188", "118.122554", "135.602028", "144.793828", "149.502503", "11.797381", "47.240331", "106.328006", "144.737965", "166.159381", "177.424186", "183.194832"]}, + {"bound": ["698023.5309", "2275494.0451", "3602723.2265", "4427068.0758", "4882802.3602", "5121984.6979", "5369150.0872", "686238.1460", "2236164.9736", "3540274.3736", "4350266.8147", "4798066.9824", "5033085.3224", "5275954.1468", "653017.7919", "2123454.8577", "3361130.0843", "4129888.4972", "4554894.7377", "4777950.3866", "5008481.9250", "540740.0954", "1737015.2087", "2747043.4578", "3374502.5806", "3721399.1365", "3903461.3065", "4091710.9768"], "r": ["11/16384", "23/32768"], "side24": ["56169.3661", "3.218636"], "tail_max": "0.000000000001", "zfloor": ["8.986445", "35.960983", "80.922923", "110.148645", "126.447617", "135.018622", "139.409277", "9.145448", "36.598153", "82.357417", "112.101477", "128.689536", "137.412564", "141.881097", "9.634734", "38.560540", "86.776693", "118.118095", "135.597047", "144.788576", "149.497113", "11.795799", "47.236418", "106.321015", "144.729155", "166.149591", "177.413888", "183.184275"]}, + {"bound": ["698726.7060", "2276191.7030", "3603502.3379", "4427911.2729", "4883681.9949", "5122883.5646", "5370081.6757", "686992.4360", "2236866.6957", "3541057.5528", "4351114.1860", "4798950.8580", "5033988.4660", "5276890.1111", "654065.3391", "2124184.7985", "3361943.2642", "4130767.6118", "4555811.3689", "4778886.8227", "5009452.1927", "541201.3000", "1737829.7334", "2747945.4958", "3375475.2298", "3722412.0472", "3904495.4817", "4092781.8550"], "r": ["23/32768", "3/4096"], "side24": ["57856.3655", "3.218101"], "tail_max": "0.000000000001", "zfloor": ["8.985896", "35.959528", "80.920206", "110.145164", "126.443721", "135.014509", "139.405054", "9.144865", "36.596616", "82.354555", "112.097814", "128.685438", "137.408239", "141.876656", "9.634003", "38.558645", "86.773197", "118.113637", "135.592067", "144.783324", "149.491723", "11.794216", "47.232505", "106.314023", "144.720343", "166.139799", "177.403589", "183.173718"]}, + {"bound": ["699510.3675", "2276894.6606", "3604287.8741", "4428761.6911", "4884569.2989", "5123790.3369", "5371021.5361", "687839.0529", "2237573.6558", "3541847.0742", "4351968.6825", "4799842.2998", "5034899.4084", "5277834.2350", "655272.8512", "2124919.8333", "3362762.5801", "4131653.6081", "4556735.3024", "4779830.7830", "5010430.3305", "541664.8096", "1738648.8926", "2748852.9849", "3376453.9446", "3723431.3728", "3905536.2564", "4093859.6278"], "r": ["3/4096", "25/32768"], "side24": ["62479.9574", "3.217566"], "tail_max": "0.000000000001", "zfloor": ["8.985347", "35.958072", "80.917489", "110.141682", "126.439824", "135.010396", "139.400831", "9.144283", "36.595079", "82.351694", "112.094150", "128.681339", "137.403913", "141.872215", "9.633273", "38.556749", "86.769702", "118.109178", "135.587086", "144.778072", "149.486332", "11.792634", "47.228591", "106.307030", "144.711530", "166.130006", "177.393289", "183.163159"]}, + {"bound": ["700389.8071", "2277602.9362", "3605079.8599", "4429619.3594", "4885464.3038", "5124705.0479", "5371969.7028", "688795.6103", "2238285.8720", "3542642.9622", "4352830.3329", "4800741.3391", "5035818.1821", "5278786.5523", "656671.1775", "2125659.9802", "3363588.0558", "4132546.5139", "4557666.5684", "4780782.2987", "5011416.3712", "542130.6406", "1739472.7032", "2749765.9460", "3377438.7491", "3724457.1393", "3906583.6578", "4094944.3236"], "r": ["25/32768", "13/16384"], "side24": ["74317.3464", "3.217031"], "tail_max": "0.000000001279", "zfloor": ["8.984797", "35.956617", "80.914772", "110.138201", "126.435926", "135.006283", "139.396607", "9.143700", "36.593542", "82.348831", "112.090487", "128.677239", "137.399588", "141.867774", "9.632543", "38.554852", "86.766205", "118.104719", "135.582104", "144.772819", "149.480941", "11.791052", "47.224677", "106.300037", "144.702717", "166.120213", "177.382988", "183.152600"]}, + {"bound": ["701382.6507", "2278316.5484", "3605878.3200", "4430484.3072", "4886367.0416", "5125627.7306", "5372926.2104", "689882.4109", "2239003.3627", "3543445.2413", "4353699.1662", "4801648.0072", "5036744.8197", "5279747.0972", "658295.8195", "2126405.2569", "3364419.7148", "4133446.3570", "4558605.1968", "4781741.4012", "5012410.3475", "542598.8109", "1740301.1823", "2750684.4002", "3378429.6679", "3725489.3729", "3907637.7129", "4096035.9707"], "r": ["13/16384", "27/32768"], "side24": ["101703.1100", "3.216496"], "tail_max": "0.000000680214", "zfloor": ["8.984248", "35.955161", "80.912054", "110.134719", "126.432029", "135.002169", "139.392383", "9.143117", "36.592005", "82.345969", "112.086823", "128.673140", "137.395261", "141.863332", "9.631812", "38.552956", "86.762709", "118.100259", "135.577122", "144.767565", "149.475550", "11.789469", "47.220762", "106.293043", "144.693903", "166.110418", "177.372686", "183.142039"]}, + {"bound": ["702509.1300", "2279035.5157", "3606683.2795", "4431356.5638", "4887277.5438", "5126558.4181", "5373891.0936", "691122.7521", "2239726.1463", "3544253.9361", "4354575.2112", "4802562.3353", "5037679.3537", "5280715.9039", "660187.3779", "2127155.6816", "3365257.5810", "4134353.1652", "4559551.2179", "4782708.1220", "5013412.2923", "543069.3390", "1741134.3471", "2751608.3687", "3379426.7252", "3726528.1000", "3908698.4492", "4097134.5977"], "r": ["27/32768", "7/8192"], "side24": ["159055.5442", "3.215961"], "tail_max": "0.000123959488", "zfloor": ["8.983698", "35.953706", "80.909337", "110.131236", "126.428131", "134.998055", "139.388159", "9.142534", "36.590468", "82.343107", "112.083158", "128.669040", "137.390935", "141.858890", "9.631082", "38.551060", "86.759212", "118.095799", "135.572140", "144.762312", "149.470158", "11.787887", "47.216848", "106.286048", "144.685088", "166.100623", "177.362382", "183.131477"]}, + {"bound": ["703792.3733", "2279759.8567", "3607494.7633", "4432236.1585", "4888195.8424", "5127497.1436", "5374864.3871", "692543.2477", "2240454.2411", "3545069.0713", "4355458.4970", "4803484.3549", "5038621.8169", "5281693.0064", "661866.1130", "2127911.2723", "3366101.6782", "4135266.9665", "4560504.6620", "4783682.4925", "5014422.2385", "543542.2453", "1741972.2151", "2752537.8727", "3380429.9456", "3727573.3469", "3909765.8939", "4098240.2332"], "r": ["7/8192", "29/32768"], "side24": ["268871.4732", "3.215426"], "tail_max": "0.009553559093", "zfloor": ["8.983149", "35.952250", "80.906619", "110.127754", "126.424233", "134.993941", "139.383934", "9.141951", "36.588931", "82.340244", "112.079494", "128.664940", "137.386608", "141.854448", "9.630351", "38.549163", "86.755715", "118.091339", "135.567157", "144.757058", "149.464765", "11.786304", "47.212932", "106.279053", "144.676272", "166.090826", "177.352078", "183.120915"]}, + {"bound": ["705259.0092", "2280489.5901", "3608312.7964", "4433123.1208", "4889121.9693", "5128443.9402", "5375846.1257", "694174.4517", "2241187.6658", "3545890.6716", "4356349.0525", "4804414.0975", "5039572.2420", "5282678.4393", "662286.7593", "2128672.0472", "3366952.0304", "4136187.7890", "4561465.5593", "4784664.5442", "5015440.2191", "544017.5512", "1742814.8038", "2753472.9334", "3381439.3535", "3728625.1400", "3910840.0744", "4099352.9057"], "r": ["29/32768", "15/16384"], "side24": ["463221.6931", "3.214891"], "tail_max": "0.366922067207", "zfloor": ["8.982599", "35.950794", "80.903901", "110.124271", "126.420335", "134.989826", "139.379709", "9.141368", "36.587393", "82.337381", "112.075829", "128.660840", "137.382281", "141.850006", "9.629621", "38.547266", "86.752218", "118.086878", "135.562174", "144.751803", "149.459372", "11.784721", "47.209017", "106.272057", "144.667455", "166.081029", "177.341772", "183.110351"]}, + {"bound": ["706945.6882", "2281224.7348", "3609137.4039", "4434017.4802", "4890055.9565", "5129398.8414", "5376836.3441", "696057.3766", "2241926.4388", "3546718.7617", "4357246.9068", "4805351.5947", "5040530.6620", "5283672.2367", "662709.7740", "2129438.0246", "3367808.6615", "4137115.6606", "4562433.9404", "4785654.3088", "5016466.2672", "544495.2800", "1743662.1309", "2754413.5724", "3382454.9737", "3729683.5058", "3911921.0183", "4100472.6441"], "r": ["15/16384", "31/32768"], "side24": ["784314.8687", "3.214356"], "tail_max": "7.987844572971", "zfloor": ["8.982049", "35.949338", "80.901183", "110.120788", "126.416436", "134.985711", "139.375484", "9.140785", "36.585855", "82.334518", "112.072164", "128.656739", "137.377954", "141.845563", "9.628890", "38.545369", "86.748720", "118.082417", "135.557190", "144.746548", "149.453979", "11.783138", "47.205101", "106.265060", "144.658637", "166.071230", "177.331466", "183.099786"]}, + {"bound": ["708972.1197", "2281965.3094", "3609968.6110", "4434919.2663", "4890997.8361", "5130361.8805", "5377835.0775", "697564.0818", "2242670.5789", "3547553.3665", "4358152.0893", "4806296.8781", "5041497.1098", "5284674.4332", "663135.1685", "2130209.2228", "3368671.5956", "4138050.6096", "4563409.8356", "4786651.8180", "5017500.4160", "544975.4564", "1744514.2143", "2755359.8109", "3383476.8308", "3730748.4709", "3913008.7531", "4101599.4771"], "r": ["31/32768", "1/1024"], "side24": ["1283859.6904", "3.213821"], "tail_max": "109.136432047527", "zfloor": ["8.981500", "35.947882", "80.898464", "110.117305", "126.412537", "134.981596", "139.371259", "9.140202", "36.584318", "82.331655", "112.068499", "128.652638", "137.373627", "141.841120", "9.628159", "38.543472", "86.745222", "118.077956", "135.552207", "144.741293", "149.448585", "11.781555", "47.201185", "106.258063", "144.649818", "166.061430", "177.321158", "183.089220"]}, + {"bound": ["710534.4314", "2283818.0950", "3612306.0757", "4437607.3760", "4893887.7922", "5133359.6711", "5380973.5631", "698459.3398", "2244522.9155", "3549883.6767", "4360828.6486", "4809172.7471", "5044479.3267", "5287795.7382", "664061.1959", "2132094.2481", "3371018.9698", "4140734.5839", "4566287.5366", "4789632.8563", "5020618.2164", "545996.9319", "1746489.1213", "2757740.8764", "3386159.6576", "3733604.9309", "3915957.7371", "4104676.3507"], "r": ["1/1024", "17/16384"], "side24": ["3350650.9229", "3.212708"], "tail_max": "0.000000000001", "zfloor": ["8.979468", "35.939380", "80.878361", "110.088954", "126.379373", "134.945842", "139.333933", "9.138091", "36.575575", "82.311058", "112.039485", "128.618716", "137.337066", "141.802964", "9.625712", "38.533772", "86.722730", "118.046437", "135.515437", "144.701703", "149.407297", "11.777232", "47.186428", "106.225904", "144.605698", "166.010420", "177.266464", "183.032342"]}, + {"bound": ["711361.9279", "2285337.8788", "3614015.5303", "4439463.9291", "4895828.6174", "5135344.8958", "5383032.9381", "699292.0839", "2246049.3872", "3551599.3278", "4362691.2980", "4811118.8899", "5046469.5340", "5289860.0984", "664928.9514", "2133673.8170", "3372789.7971", "4142655.0090", "4568292.9953", "4791683.2003", "5022744.3879", "546975.0045", "1748227.2305", "2759673.3787", "3388247.9945", "3735782.0985", "3918181.8271", "4106980.8169"], "r": ["17/16384", "9/8192"], "side24": ["6599172.0850", "3.211638"], "tail_max": "0.000000000001", "zfloor": ["8.978368", "35.936466", "80.872921", "110.081984", "126.371556", "134.937586", "139.325455", "9.136924", "36.572498", "82.305328", "112.032151", "128.610509", "137.328406", "141.794073", "9.624250", "38.529976", "86.715730", "118.037509", "135.505464", "144.691187", "149.396504", "11.774065", "47.178591", "106.211902", "144.588050", "165.990809", "177.245836", "183.011197"]}, + {"bound": ["712199.2771", "2286879.7680", "3615751.8963", "4441351.6653", "4897802.0323", "5137363.4698", "5385127.2074", "700134.6213", "2247597.7089", "3553341.5442", "4364583.8542", "4813096.8217", "5048492.5229", "5291958.7564", "665806.4752", "2135274.6447", "3374586.3269", "4144604.3172", "4570329.1315", "4793765.1684", "5024903.6377", "547963.4901", "1749984.7370", "2761628.7183", "3390361.7833", "3737986.2053", "3920433.6430", "4109314.2491"], "r": ["9/8192", "19/16384"], "side24": ["11363859.5016", "3.210568"], "tail_max": "0.000000000001", "zfloor": ["8.977268", "35.933552", "80.867481", "110.074996", "126.363731", "134.929326", "139.316973", "9.135758", "36.569420", "82.299597", "112.024815", "128.602302", "137.319745", "141.785180", "9.622787", "38.526179", "86.708729", "118.028580", "135.495489", "144.680668", "149.385709", "11.770897", "47.170753", "106.197896", "144.570399", "165.971195", "177.225205", "182.990048"]}, + {"bound": ["713046.5706", "2288443.9174", "3617515.3787", "4443270.1605", "4899808.0440", "5139415.6647", "5387256.6551", "700987.0464", "2249168.0341", "3555110.5282", "4366506.5546", "4815106.7996", "5050548.5609", "5294091.9922", "666693.8792", "2136896.8826", "3376408.7552", "4146582.7377", "4572396.1932", "4795879.0186", "5027096.2352", "548962.7053", "1751761.7943", "2763607.0714", "3392501.2256", "3740217.4681", "3922713.4096", "4111676.8821"], "r": ["19/16384", "5/4096"], "side24": ["17831802.0485", "3.209497"], "tail_max": "0.000000000001", "zfloor": ["8.976168", "35.930637", "80.862040", "110.068003", "126.355903", "134.921063", "139.308488", "9.134591", "36.566342", "82.293866", "112.017479", "128.594093", "137.311083", "141.776287", "9.621325", "38.522381", "86.701727", "118.019650", "135.485512", "144.670148", "149.374912", "11.767728", "47.162913", "106.183888", "144.552745", "165.951576", "177.204570", "182.968895"]}, + {"bound": ["713903.9050", "2290030.4833", "3619307.0217", "4445219.5525", "4901846.9146", "5141501.7532", "5389421.5665", "701849.4592", "2250760.5176", "3556906.4837", "4368459.6377", "4817149.0821", "5052637.9168", "5296260.0869", "667591.2849", "2138540.6839", "3378257.2794", "4148590.5008", "4574494.4293", "4798025.0097", "5029322.4516", "549973.0151", "1753558.5602", "2765608.6158", "3394666.5247", "3742476.1051", "3925021.3530", "4114068.9521"], "r": ["5/4096", "21/16384"], "side24": ["25945850.0953", "3.208427"], "tail_max": "0.000000000011", "zfloor": ["8.975067", "35.927722", "80.856583", "110.061007", "126.348071", "134.912796", "139.299999", "9.133424", "36.563263", "82.288134", "112.010141", "128.585883", "137.302419", "141.767392", "9.619862", "38.518583", "86.694724", "118.010718", "135.475534", "144.659627", "149.364113", "11.764559", "47.155072", "106.169877", "144.535086", "165.931954", "177.183930", "182.947737"]}, + {"bound": ["714771.3827", "2291639.6233", "3621126.3688", "4447200.0843", "4903918.9077", "5143622.0095", "5391622.2283", "702721.9663", "2252375.3160", "3558729.6152", "4370443.3434", "4819223.9288", "5054760.8609", "5298463.3233", "668498.8237", "2140206.2032", "3380132.0980", "4150627.8382", "4576624.0904", "4800203.4021", "5031582.5589", "550994.8393", "1755375.1969", "2767633.5308", "3396857.8853", "3744762.3357", "3927357.7009", "4116490.6969"], "r": ["21/16384", "11/8192"], "side24": ["35493845.4799", "3.207357"], "tail_max": "0.000000000800", "zfloor": ["8.973967", "35.924806", "80.851122", "110.054009", "126.340235", "134.904526", "139.291507", "9.132257", "36.560184", "82.282401", "112.002803", "128.577672", "137.293754", "141.758496", "9.618399", "38.514784", "86.687720", "118.001784", "135.465554", "144.649103", "149.353312", "11.761390", "47.147230", "106.155863", "144.517425", "165.912328", "177.163286", "182.926575"]}, + {"bound": ["715649.1124", "2293271.4966", "3622973.5441", "4449212.0006", "4906024.2879", "5145776.7090", "5393858.9289", "703604.6814", "2254012.5871", "3560580.1289", "4372457.9128", "4821331.6006", "5056917.6644", "5300701.9851", "669416.6388", "2141893.5973", "3382033.4109", "4152694.9828", "4578785.4280", "4802414.4575", "5033876.8309", "552028.6596", "1757211.8717", "2769681.9977", "3399075.5134", "3747076.3811", "3929722.6823", "4118942.3556"], "r": ["11/8192", "23/16384"], "side24": ["46154269.0100", "3.206286"], "tail_max": "0.000000033898", "zfloor": ["8.972866", "35.921890", "80.845660", "110.047007", "126.332397", "134.896252", "139.283011", "9.131089", "36.557105", "82.276667", "111.995463", "128.569460", "137.285088", "141.749598", "9.616936", "38.510985", "86.680715", "117.992849", "135.455573", "144.638579", "149.342510", "11.758220", "47.139385", "106.141847", "144.499759", "165.892697", "177.142638", "182.905409"]}, + {"bound": ["716537.2100", "2294926.2639", "3624848.7575", "4451255.5471", "4908163.3213", "5147966.1284", "5396131.9576", "704497.7263", "2255672.4906", "3562458.2320", "4374503.5883", "4823472.3599", "5059108.6003", "5302976.3578", "670344.8866", "2143603.0248", "3383961.4192", "4154792.1686", "4580978.6953", "4804658.4389", "5036205.5425", "553075.0281", "1759068.7574", "2771754.1992", "3401319.6168", "3749418.4637", "3932116.5275", "4121424.1688"], "r": ["23/16384", "3/2048"], "side24": ["57548668.4389", "3.205215"], "tail_max": "0.000000897243", "zfloor": ["8.971765", "35.918974", "80.840195", "110.040002", "126.324555", "134.887975", "139.274511", "9.129922", "36.554025", "82.270932", "111.988122", "128.561246", "137.276421", "141.740700", "9.615473", "38.507185", "86.673708", "117.983913", "135.445590", "144.628052", "149.331706", "11.755050", "47.131540", "106.127828", "144.482090", "165.873063", "177.121986", "182.884239"]}, + {"bound": ["717435.7999", "2296604.0877", "3626752.2203", "4453330.9711", "4910336.2755", "5150190.5461", "5398441.6055", "705401.2322", "2257355.1877", "3564364.1330", "4376580.6135", "4825646.4701", "5061333.9428", "5305286.7283", "671283.7384", "2145334.6464", "3385916.3253", "4156919.6313", "4583204.1466", "4806935.6107", "5038568.9704", "554134.5756", "1760946.0332", "2773850.3203", "3403590.4047", "3751788.8077", "3934539.4687", "4123936.3788"], "r": ["3/2048", "25/16384"], "side24": ["69288851.9666", "3.204145"], "tail_max": "0.000015977582", "zfloor": ["8.970664", "35.916057", "80.834727", "110.032995", "126.316710", "134.879694", "139.266008", "9.128754", "36.550944", "82.265197", "111.980780", "128.553032", "137.267753", "141.731800", "9.614009", "38.503384", "86.666701", "117.974975", "135.435605", "144.617524", "149.320901", "11.751879", "47.123693", "106.113806", "144.464418", "165.853424", "177.101329", "182.863064"]}, + {"bound": ["718345.0153", "2298305.2583", "3628684.1451", "4455438.5209", "4912543.4192", "5152450.2416", "5400788.1651", "706315.3404", "2259060.8416", "3566298.0417", "4378689.2335", "4827854.1964", "5063593.9673", "5307633.3846", "672233.3819", "2147088.6252", "3387898.3329", "4159077.6077", "4585462.0377", "4809246.2387", "5040967.3924", "555208.0211", "1762843.8849", "2775970.5479", "3405888.0880", "3754187.6386", "3936991.7395", "4126479.2296"], "r": ["25/16384", "13/8192"], "side24": ["81012773.3784", "3.203074"], "tail_max": "0.000203325860", "zfloor": ["8.969563", "35.913138", "80.829257", "110.025984", "126.308861", "134.871409", "139.257501", "9.127586", "36.547863", "82.259460", "111.973437", "128.544816", "137.259083", "141.722898", "9.612545", "38.499583", "86.659692", "117.966036", "135.425619", "144.606994", "149.310093", "11.748708", "47.115844", "106.099781", "144.446742", "165.833782", "177.080668", "182.841884"]}, + {"bound": ["719264.9997", "2300030.5689", "3630644.7458", "4457578.4464", "4914785.0227", "5154745.4960", "5403171.9304", "707240.2038", "2260789.6174", "3568260.1693", "4380829.6946", "4830095.8052", "5065888.9510", "5310016.6166", "673194.0238", "2148865.1266", "3389907.6472", "4161266.3360", "4587752.6258", "4811590.5902", "5043401.0879", "556296.1831", "1764762.5061", "2778115.0711", "3408212.8796", "3756615.1840", "3939473.5751", "4129052.9666"], "r": ["13/8192", "27/16384"], "side24": ["89808544.0713", "3.202004"], "tail_max": "0.001942631134", "zfloor": ["8.968462", "35.910209", "80.823785", "110.018970", "126.301010", "134.863122", "139.248990", "9.126418", "36.544781", "82.253723", "111.966093", "128.536599", "137.250412", "141.713996", "9.611081", "38.495780", "86.652682", "117.957095", "135.415632", "144.596462", "149.299284", "11.745536", "47.107994", "106.085753", "144.429062", "165.814136", "177.060003", "182.820701"]}, + {"bound": ["720195.9091", "2301779.5005", "3632634.2376", "4459750.9988", "4917061.3577", "5157076.5917", "5405593.1969", "708175.9891", "2262541.6824", "3570250.7283", "4383002.2446", "4832371.5642", "5068219.1723", "5312436.7155", "674165.8930", "2150664.3187", "3391944.4750", "4163486.0560", "4590076.1695", "4813968.9338", "5045870.3380", "557399.9973", "1766702.0987", "2780284.0811", "3410564.9938", "3759071.6727", "3941985.2125", "4131657.8373"], "r": ["27/16384", "7/4096"], "side24": ["97163653.0117", "3.200933"], "tail_max": "0.014513146498", "zfloor": ["8.967360", "35.907279", "80.818311", "110.011954", "126.293154", "134.854830", "139.240476", "9.125250", "36.541699", "82.247985", "111.958748", "128.528381", "137.241740", "141.705092", "9.609617", "38.491978", "86.645671", "117.948153", "135.405642", "144.585929", "149.288474", "11.742363", "47.100142", "106.071723", "144.411379", "165.794485", "177.039334", "182.799513"]}, + {"bound": ["721137.9171", "2303552.2233", "3634652.8373", "4461956.4308", "4919372.6972", "5159443.8127", "5408052.2616", "709122.8830", "2264317.2058", "3572269.9326", "4385207.1326", "4834681.7428", "5070584.9110", "5314893.9741", "675149.2499", "2152486.3725", "3394009.0242", "4165737.0088", "4592432.9290", "4816381.5398", "5048375.4252", "558520.5613", "1768662.8737", "2782477.7719", "3412944.6473", "3761557.3358", "3944526.8905", "4134294.0907"], "r": ["7/4096", "29/16384"], "side24": ["103590455.2086", "3.199862"], "tail_max": "0.087691119641", "zfloor": ["8.966259", "35.904348", "80.812834", "110.004934", "126.285296", "134.846536", "139.231958", "9.124081", "36.538617", "82.242246", "111.951402", "128.520162", "137.233067", "141.696187", "9.608152", "38.488174", "86.638658", "117.939210", "135.395652", "144.575394", "149.277661", "11.739191", "47.092289", "106.057689", "144.393693", "165.774831", "177.018661", "182.778320"]}, + {"bound": ["722091.2347", "2305348.9099", "3636700.7628", "4464194.9965", "4921719.3160", "5161847.4447", "5410549.4231", "710081.1135", "2266116.3595", "3574317.9976", "4387444.6093", "4837026.6118", "5072986.4488", "5317388.6867", "676144.4180", "2154331.4617", "3396101.5046", "4168019.4369", "4594823.1660", "4818828.6799", "5050916.6334", "559659.2759", "1770645.0522", "2784696.3398", "3415352.0584", "3764072.4060", "3947098.8496", "4136961.9779"], "r": ["29/16384", "15/8192"], "side24": ["109073970.1569", "3.198791"], "tail_max": "0.440764995609", "zfloor": ["8.965157", "35.901415", "80.807355", "109.997912", "126.277434", "134.838237", "139.223437", "9.122913", "36.535534", "82.236506", "111.944055", "128.511941", "137.224392", "141.687281", "9.606687", "38.484370", "86.631645", "117.930265", "135.385659", "144.564857", "149.266847", "11.736017", "47.084434", "106.043653", "144.376002", "165.755173", "176.997984", "182.757124"]}, + {"bound": ["723056.1768", "2307169.7351", "3638778.2339", "4466466.9515", "4924101.4902", "5164287.7745", "5413084.9817", "711051.0228", "2267939.3175", "3576395.1401", "4389714.9269", "4839406.4433", "5075424.0684", "5319921.1493", "677151.8895", "2156199.7636", "3398222.1274", "4170333.5846", "4597247.1434", "4821310.6273", "5053494.2485", "560818.2839", "1772648.8667", "2786939.9842", "3417787.4478", "3766617.1181", "3949701.3322", "4139661.7519"], "r": ["15/8192", "31/16384"], "side24": ["113634292.4414", "3.197720"], "tail_max": "1.887110534968", "zfloor": ["8.964055", "35.898482", "80.801874", "109.990886", "126.269569", "134.829935", "139.214912", "9.121744", "36.532450", "82.230765", "111.936707", "128.503719", "137.215717", "141.678373", "9.605222", "38.480566", "86.624631", "117.921318", "135.375665", "144.554319", "149.256031", "11.732844", "47.076578", "106.029615", "144.358309", "165.735511", "176.977302", "182.735923"]}, + {"bound": ["724033.3618", "2309014.8764", "3640885.4715", "4468772.5529", "4926519.4975", "5166765.0909", "5415659.2391", "712033.2841", "2269786.2567", "3578501.5784", "4392018.3389", "4841821.5113", "5077898.0545", "5322491.6594", "678172.6329", "2158091.4589", "3400371.1056", "4172679.6976", "4599705.1263", "4823827.6570", "5056108.5578", "562001.6717", "1774674.5616", "2789208.9072", "3420251.0383", "3769191.7087", "3952334.5830", "4142393.6675"], "r": ["31/16384", "1/512"], "side24": ["117316965.4911", "3.196649"], "tail_max": "7.021277153340", "zfloor": ["8.962953", "35.895547", "80.796390", "109.983858", "126.261701", "134.821630", "139.206383", "9.120575", "36.529366", "82.225024", "111.929358", "128.495497", "137.207040", "141.669465", "9.603757", "38.476760", "86.617615", "117.912371", "135.365669", "144.543779", "149.245213", "11.729669", "47.068720", "106.015573", "144.340611", "165.715844", "176.956616", "182.714718"]}, + {"bound": ["728622.4190", "2318815.0407", "3653604.2855", "4483577.1744", "4942523.8045", "5183409.6287", "5433120.7285", "716643.0186", "2279546.7605", "3591132.0494", "4406702.6659", "4857687.1952", "5094394.1651", "5339794.3028", "682963.5906", "2167900.2223", "3412929.4865", "4187216.2562", "4615379.6210", "4840109.3036", "5073174.7143", "567877.6982", "1784585.2418", "2801433.5449", "3434186.9479", "3784113.1176", "3967781.5825", "4158546.4991"], "r": ["1/512", "9/4096"], "side24": ["163088675.9318", "3.192109"], "tail_max": "587.264765954447", "zfloor": ["8.952930", "35.850210", "80.686349", "109.827296", "126.077880", "134.623123", "138.998907", "9.110206", "36.482958", "82.112699", "111.769686", "128.308091", "137.004693", "141.458001", "9.591959", "38.426021", "86.496411", "117.740794", "135.164639", "144.326894", "149.018682", "11.709993", "46.995601", "105.850132", "144.110541", "165.448276", "176.668932", "182.414948"]}, + {"bound": ["734972.7841", "2326856.0937", "3662842.9481", "4493716.1985", "4953172.7647", "5194327.6521", "5444473.3736", "723174.3579", "2287586.3819", "3600355.1753", "4416818.4478", "4868308.7378", "5105282.5919", "5351114.8569", "690478.5235", "2176104.4742", "3422298.0151", "4197472.9226", "4626140.1330", "4851135.7750", "5084634.4889", "583235.6661", "1793296.3321", "2811201.7098", "3444814.0055", "3795230.5276", "3979158.2550", "4170355.6135"], "r": ["9/4096", "5/2048"], "side24": ["157294243.7930", "3.187823"], "tail_max": "10479.431578779650", "zfloor": ["8.948513", "35.838422", "80.664321", "109.799062", "126.046270", "134.589757", "138.964642", "9.105521", "36.470592", "82.089673", "111.740211", "128.275111", "136.969891", "141.422268", "9.586087", "38.410763", "86.468275", "117.704907", "135.124548", "144.284618", "148.975291", "11.697275", "46.964098", "105.793823", "144.039564", "165.369399", "176.585963", "182.329894"]}, + {"bound": ["757538.3668", "2335314.6107", "3672591.5890", "4504432.5542", "4964437.0990", "5205881.1297", "5456490.8763", "746980.4139", "2296038.1960", "3610080.3643", "4427502.2162", "4879535.5309", "5116795.9429", "5363089.2052", "720604.2693", "2184712.9912", "3432152.8963", "4208278.4134", "4637484.9078", "4862765.2375", "5096724.9354", "662808.0108", "1802406.0775", "2821406.8533", "3455927.0012", "3806862.5731", "3991064.8601", "4182718.2156"], "r": ["5/2048", "11/4096"], "side24": ["138086211.8602", "3.183536"], "tail_max": "83865.840862006541", "zfloor": ["8.944088", "35.826615", "80.642257", "109.770779", "126.014606", "134.556335", "138.930320", "9.100834", "36.458217", "82.066633", "111.710719", "128.242112", "136.935069", "141.386515", "9.580212", "38.395494", "86.440121", "117.668997", "135.084431", "144.242316", "148.931873", "11.684549", "46.932572", "105.737470", "143.968530", "165.290458", "176.502927", "182.244770"]}, + {"bound": ["847880.1116", "2344204.8723", "3682865.7527", "4515744.0247", "4976335.9195", "5218089.8848", "5469193.9570", "842556.1174", "2304916.6677", "3620323.0133", "4438771.5382", "4891386.4394", "5128953.7787", "5375737.7909", "842379.7985", "2193741.6914", "3442509.3675", "4219649.8819", "4649432.2937", "4875016.6868", "5109465.8941", "977035.3222", "1811946.4239", "2832065.3968", "3467542.5640", "3819026.5021", "4003519.0412", "4195652.6410"], "r": ["11/4096", "3/1024"], "side24": ["121402495.2111", "3.179248"], "tail_max": "390872.791844536046", "zfloor": ["8.939643", "35.814787", "80.620154", "109.742449", "125.982889", "134.522856", "138.895940", "9.096144", "36.445835", "82.043580", "111.681209", "128.209095", "136.900228", "141.350741", "9.574333", "38.380215", "86.411948", "117.633063", "135.044288", "144.199987", "148.888427", "11.671816", "46.901021", "105.681072", "143.897439", "165.211453", "176.419823", "182.159577"]}, + {"bound": ["1112281.1866", "2353542.8307", "3693681.6131", "4527668.9509", "4988888.8868", "5230974.2889", "5482603.9024", "1121924.8995", "2314238.0770", "3631099.1693", "4450644.5467", "4903880.8816", "5141776.2117", "5389081.6264", "1195846.3847", "2203209.0824", "3453383.4423", "4231605.1116", "4662001.2395", "4887909.7100", "5122877.8124", "1843156.2276", "1821959.3273", "2843195.7221", "3479678.5620", "3831740.6153", "4016539.4262", "4209178.2114"], "r": ["3/1024", "13/4096"], "side24": ["109179359.9899", "3.174960"], "tail_max": "1248289.492828789073", "zfloor": ["8.935191", "35.802939", "80.598015", "109.714071", "125.951119", "134.489321", "138.861501", "9.091451", "36.433444", "82.020513", "111.651683", "128.176058", "136.865366", "141.314947", "9.568451", "38.364925", "86.383757", "117.597106", "135.004120", "144.157630", "148.844954", "11.659075", "46.869447", "105.624629", "143.826291", "165.132384", "176.336652", "182.074314"]}, + {"bound": ["1643546.3532", "2363346.6377", "3705056.0882", "4540226.3067", "5002116.2756", "5244555.3231", "5496742.6275", "1680814.0394", "2324021.0994", "3642425.6530", "4463140.0209", "4917038.8978", "5155283.9702", "5403142.3580", "1890673.4527", "2213137.1196", "3464792.0819", "4244162.6213", "4675211.3814", "4901464.5672", "5136981.8262", "3430774.0758", "1832500.1016", "2854818.7558", "3492354.4263", "3845024.5202", "4030145.8542", "4223315.4567"], "r": ["13/4096", "7/2048"], "side24": ["100225974.2201", "3.170671"], "tail_max": "2825088.135914730132", "zfloor": ["8.930733", "35.791072", "80.575838", "109.685646", "125.919295", "134.455730", "138.827004", "9.086755", "36.421046", "81.997432", "111.622140", "128.143003", "136.830485", "141.279133", "9.562565", "38.349625", "86.355547", "117.561126", "134.963926", "144.115247", "148.801452", "11.646325", "46.837848", "105.568141", "143.755085", "165.053251", "176.253413", "181.988981"]}, + {"bound": ["2548516.3994", "2373637.3325", "3717006.9858", "4553435.7924", "5016039.0531", "5258854.6518", "5511632.7494", "2629527.2307", "2334287.5618", "3654320.2158", "4476277.4855", "4930881.2342", "5169498.4762", "5417942.3443", "3053707.6651", "2223552.3168", "3476753.4132", "4257341.7976", "4689083.1533", "4915702.2914", "5151799.8602", "5939869.2496", "1843641.6658", "2866958.7078", "3505591.5607", "3858899.4505", "4044359.6617", "4238086.3957"], "r": ["7/2048", "15/4096"], "side24": ["103203083.5125", "3.166381"], "tail_max": "5320376.680835779318", "zfloor": ["8.926269", "35.779184", "80.553624", "109.657172", "125.887418", "134.422082", "138.792449", "9.082057", "36.408639", "81.974338", "111.592579", "128.109929", "136.795584", "141.243298", "9.556675", "38.334314", "86.327319", "117.525123", "134.923706", "144.072837", "148.757923", "11.633569", "46.806225", "105.511609", "143.683822", "164.974054", "176.170107", "181.903579"]}, + {"bound": ["3873059.4850", "2384439.7781", "3729553.1880", "4567317.9507", "5030678.9767", "5273894.7129", "5527297.6781", "4013656.6813", "2345063.4703", "3666801.7397", "4490077.3347", "4945429.4462", "5184441.9415", "5433504.7515", "4728902.8481", "2234487.2448", "3489287.0066", "4271163.0617", "4703637.9215", "4930644.8130", "5167354.7512", "9370799.9311", "1855480.1951", "2879643.9968", "3519413.8539", "3873388.6661", "4059204.0385", "4253514.8861"], "r": ["15/4096", "1/256"], "side24": ["108741431.2585", "3.162091"], "tail_max": "8733328.464174829131", "zfloor": ["8.921798", "35.767276", "80.531373", "109.628651", "125.855487", "134.388378", "138.757836", "9.077356", "36.396224", "81.951229", "111.563001", "128.076836", "136.760663", "141.207443", "9.550782", "38.318993", "86.299073", "117.489097", "134.883461", "144.030400", "148.714365", "11.620804", "46.774578", "105.455031", "143.612503", "164.894794", "176.086734", "181.818107"]}, + {"bound": ["9216857.6073", "2410753.4367", "3762029.3622", "4604412.5197", "5070419.8094", "5315042.8379", "5570366.6733", "9571030.2410", "2371267.3711", "3699018.0127", "4526836.4056", "4984793.1174", "5225190.9381", "5476149.6359", "11335649.0314", "2260917.7475", "3521258.8470", "4307496.2363", "4742479.1671", "4970820.9140", "5209376.5823", "22145000.9765", "1884097.4829", "2910850.6600", "3554223.9635", "3910334.5215", "4097294.6767", "4293268.5975"], "r": ["1/256", "9/2048"], "side24": ["99603490.4813", "3.153154"], "tail_max": "21451621.824411967345", "zfloor": ["8.905311", "35.698476", "80.369044", "109.399901", "125.588003", "134.100070", "138.456929", "9.060308", "36.325784", "81.785510", "111.329685", "127.804114", "136.466760", "140.900737", "9.531016", "38.240774", "86.117956", "117.235435", "134.587607", "143.711891", "148.382218", "11.585855", "46.655300", "105.195374", "143.256435", "164.483211", "175.645472", "181.359268"]}, + {"bound": ["70392553.2100", "2436851.7035", "3791690.0201", "4637311.1340", "5105167.5323", "5350768.8911", "5607601.2968", "71376704.2074", "2397341.5349", "3728493.8468", "4559497.6218", "5019276.5341", "5260638.8706", "5513089.6770", "77974784.2791", "2287631.7225", "3550762.0671", "4340066.5213", "4776818.3547", "5006098.3544", "5246122.2016", "138739464.0997", "1916172.9361", "2940739.8051", "3586520.7397", "3944142.2687", "4131920.1267", "4329264.8043"], "r": ["9/2048", "5/1024"], "side24": ["76477228.1149", "3.144565"], "tail_max": "137948188.384036479994", "zfloor": ["8.896313", "35.674477", "80.324191", "109.342404", "125.523630", "134.032121", "138.387143", "9.050874", "36.300853", "81.739095", "111.270272", "127.737637", "136.396610", "140.828707", "9.519191", "38.210004", "86.061217", "117.163061", "134.506754", "143.626632", "148.294704", "11.560249", "46.591748", "105.081716", "143.113136", "164.323946", "175.477936", "181.187508"]}, + {"bound": ["236493352.2043", "2504383.1176", "3824227.3530", "4673395.5764", "5143295.7434", "5389980.8116", "5648479.0799", "241049641.4172", "2465055.6415", "3760819.9637", "4595304.1062", "5057095.1086", "5299535.0659", "5553640.3333", "263405472.5044", "2357522.7133", "3583108.2136", "4375721.5392", "4814411.4429", "5044723.3355", "5286362.8293", "349560452.9880", "2009240.2874", "2973860.2475", "3621912.7644", "3981094.9408", "4169733.7350", "4368568.3638"], "r": ["5/1024", "11/2048"], "side24": ["59961347.3233", "3.135972"], "tail_max": "348597827.703293976785", "zfloor": ["8.887290", "35.650398", "80.279189", "109.284716", "125.459043", "133.963945", "138.317123", "9.041429", "36.275889", "81.692625", "111.210789", "127.671060", "136.326141", "140.756201", "9.507352", "38.179191", "86.004402", "117.090593", "134.425796", "143.541263", "148.207079", "11.534611", "46.528100", "104.967878", "142.969608", "164.164423", "175.310128", "181.015468"]}, + {"bound": ["186662014.1646", "6371738.4165", "3860362.9152", "4712936.0434", "5185061.2791", "5432935.0133", "5693264.9666", "190259705.4498", "6370705.6322", "3796725.4605", "4634551.3504", "5098551.6122", "5342162.8862", "5598080.4677", "207940078.8593", "6496743.3897", "3619085.3042", "4414760.9184", "4855535.2633", "5086968.5456", "5330378.6670", "276372862.2302", "7710321.8134", "3011558.1163", "3660937.7737", "4021643.1358", "4211157.6415", "4411603.3497"], "r": ["11/2048", "3/512"], "side24": ["47964242.0333", "3.127377"], "tail_max": "275116796.415051871848", "zfloor": ["8.878242", "35.626239", "80.234036", "109.226836", "125.394241", "133.895543", "138.246869", "9.031973", "36.250892", "81.646099", "111.150827", "127.603517", "136.254845", "140.682974", "9.495498", "38.148337", "85.947513", "117.018032", "134.344734", "143.455785", "148.119340", "11.508942", "46.464354", "104.853860", "142.825849", "164.004642", "175.142049", "180.843147"]}, + {"bound": ["153099074.8039", "76715635.0789", "3940321.8181", "4757841.6549", "5231149.4936", "5480128.2524", "5742440.2558", "156054064.3931", "78096923.5750", "3876557.0974", "4679155.6740", "5144298.2067", "5388993.6148", "5646870.9995", "170602709.7302", "84967957.3235", "3700545.7342", "4459160.7206", "4900915.6606", "5133363.8273", "5378682.5243", "227299213.2902", "111290279.5655", "3108877.0942", "3706268.6276", "4066867.6111", "4257003.7710", "4459151.5067"], "r": ["3/512", "13/2048"], "side24": ["39275049.5575", "3.118778"], "tail_max": "225553286.486894331092", "zfloor": ["8.869168", "35.601999", "80.188734", "109.168764", "125.329225", "133.826914", "138.176381", "9.022506", "36.225863", "81.599323", "111.090296", "127.535746", "136.183308", "140.609499", "9.483631", "38.117439", "85.890549", "116.945376", "134.263569", "143.370198", "148.031489", "11.483242", "46.400512", "104.739662", "142.681860", "163.844603", "174.973697", "180.670546"]}, + {"bound": ["128768824.2444", "61444007.6907", "5952744.2126", "4902367.5130", "5306745.0041", "5545259.2632", "5808168.1177", "131262753.9515", "62532619.3627", "5908011.3134", "4823589.8685", "5219586.2428", "5453764.2355", "5712209.2447", "143568459.6522", "67974358.9968", "5858874.4407", "4606755.2823", "4976703.4208", "5198142.5139", "5443911.1035", "192063737.3563", "88884417.8616", "6051806.3137", "3883146.3740", "4150132.4411", "4324756.6573", "4526556.8746"], "r": ["13/2048", "7/1024"], "side24": ["33149756.8913", "3.110176"], "tail_max": "189520808.712141846330", "zfloor": ["8.860068", "35.577678", "80.143282", "109.110501", "125.263993", "133.758058", "138.105659", "9.013027", "36.200802", "81.551946", "111.029562", "127.467747", "136.111529", "140.535775", "9.471748", "38.086500", "85.833510", "116.872628", "134.182299", "143.284502", "147.943525", "11.457511", "46.336572", "104.625283", "142.537640", "163.684306", "174.805073", "180.497663"]}, + {"bound": ["110031113.9726", "50643654.2336", "29596901.6148", "8050844.1011", "6342668.7808", "6153555.0071", "6354703.5556", "112177437.5755", "51525588.8128", "30032436.0046", "8001965.9289", "6264632.6813", "6062789.3026", "6259304.4089", "122796883.1251", "55958618.3806", "32451663.2706", "7980919.3398", "6082786.5306", "5824923.4694", "6006441.4058", "165428853.3824", "73070845.5888", "44691753.1179", "8472715.4194", "5549055.3045", "5098973.9093", "5216665.1061"], "r": ["7/1024", "15/2048"], "side24": ["29158637.9980", "3.101571"], "tail_max": "161620443.608548377601", "zfloor": ["8.850942", "35.553276", "80.097679", "109.052045", "125.198547", "133.688975", "138.034703", "9.003538", "36.175708", "81.504410", "110.968623", "127.399519", "136.039510", "140.461802", "9.459852", "38.055518", "85.776396", "116.799785", "134.100925", "143.198696", "147.855448", "11.431749", "46.272536", "104.510724", "142.393189", "163.523751", "174.636176", "180.324499"]}, + {"bound": ["95048207.8128", "42913937.2245", "27096367.4368", "24298001.8409", "17574703.3928", "14058390.3311", "13753019.2200", "96927830.2397", "43648659.4279", "27472211.6641", "24588117.0711", "17723365.5199", "14129317.4444", "13808174.9193", "106260213.4475", "47364186.0869", "29459421.8917", "26182885.9988", "18696563.6020", "14711357.1319", "14318637.3377", "144866746.9513", "61809599.9026", "37138257.9904", "32360280.9496", "23946629.8916", "17999703.0705", "17247142.1959"], "r": ["15/2048", "1/128"], "side24": ["27113888.5123", "3.092963"], "tail_max": "139093736.673713274067", "zfloor": ["8.841791", "35.528794", "80.051927", "108.993397", "125.132885", "133.619666", "137.963513", "8.994037", "36.150582", "81.456714", "110.907481", "127.331063", "135.967249", "140.387580", "9.447941", "38.024493", "85.719208", "116.726848", "134.019447", "143.112781", "147.767258", "11.405956", "46.208402", "104.395985", "142.248508", "163.362938", "174.467007", "180.151054"]}, + {"bound": ["87233347.4272", "39127155.8223", "23719000.1517", "21274091.7896", "20578732.6222", "20324274.4206", "20588389.5867", "89051044.8079", "39793959.1455", "24027579.1162", "21502526.9666", "20775706.9724", "20506890.3717", "20766099.9840", "98154265.2476", "43186278.3535", "25690579.4756", "22800724.4160", "21935979.2818", "21605451.5180", "21850081.7112", "139341598.8148", "56666957.2326", "32183795.0187", "27877689.8421", "26484555.8823", "25919034.2259", "26111809.1783"], "r": ["1/128", "9/1024"], "side24": ["32132666.6723", "3.074986"], "tail_max": "126070612.362236931991", "zfloor": ["8.808174", "35.389112", "79.723326", "108.530828", "124.592240", "133.037057", "137.355518", "8.959531", "36.007637", "81.120853", "110.435018", "126.779018", "135.372438", "139.766916", "9.407905", "37.866394", "85.353766", "116.215368", "133.423073", "142.470830", "147.097876", "11.335080", "45.966570", "103.870234", "141.527975", "162.530304", "173.574455", "179.223023"]}, + {"bound": ["68574404.9987", "31239625.1234", "18827530.1542", "16973187.9388", "16517002.9837", "16373640.2418", "16632155.3201", "70226583.2739", "31771706.0899", "19042761.8511", "17117547.2977", "16633763.1056", "16477848.9667", "16731120.4047", "78628952.7035", "34509050.8813", "20251548.6771", "18007484.4799", "17405034.2476", "17196442.3809", "17433699.0463", "124186920.2755", "46023910.0286", "25106660.0545", "21580735.6984", "20512455.4700", "20099215.8227", "20278512.6544"], "r": ["9/1024", "5/512"], "side24": ["44016755.8880", "3.057737"], "tail_max": "94848385.579618371758", "zfloor": ["8.789647", "35.339407", "79.630395", "108.411678", "124.458828", "132.896225", "137.210848", "8.940402", "35.955823", "81.023960", "110.310779", "126.639903", "135.225585", "139.616060", "9.383926", "37.803825", "85.238379", "116.068174", "133.258625", "142.297416", "146.919856", "11.283180", "45.837257", "103.638703", "141.235926", "162.205640", "173.232895", "178.872801"]}, + {"bound": ["58831278.8553", "26198498.2662", "15988089.8987", "14522808.3825", "14201974.3224", "14118044.2950", "14373082.1080", "60693885.8233", "26669612.4528", "16152107.3775", "14619604.8963", "14272532.6063", "14176664.8733", "14426095.1171", "70346438.9588", "29119999.3224", "17114669.9320", "15281330.1898", "14822501.7865", "14677111.9086", "14908978.3537", "134695904.6049", "40604140.9690", "21212578.1723", "18083736.7262", "17162993.6728", "16816452.0270", "16982946.4239"], "r": ["5/512", "11/1024"], "side24": ["71245216.6950", "3.040475"], "tail_max": "72792037.273509825844", "zfloor": ["8.771016", "35.289378", "79.536859", "108.291752", "124.324547", "132.754476", "137.065232", "8.921229", "35.903664", "80.926425", "110.185717", "126.499866", "135.077758", "139.464198", "9.359890", "37.741085", "85.122687", "115.920598", "133.093751", "142.123555", "146.741376", "11.231155", "45.707553", "103.406443", "140.942942", "161.879930", "172.890231", "178.521439"]}, + {"bound": ["58437995.5723", "23292914.9103", "14294821.0417", "13119397.4161", "12897455.5414", "12855298.6036", "13115812.6038", "61063703.7848", "23780892.9475", "14435795.1959", "13191683.7954", "12943223.6567", "12889031.0928", "13143653.8934", "74884234.9058", "26336085.8049", "15291968.0661", "13739454.6050", "13378000.9072", "13273920.6006", "13509837.8804", "181637843.7278", "40254686.0374", "19328505.6297", "16294291.0706", "15423355.2995", "15100316.3532", "15263577.8877"], "r": ["11/1024", "3/256"], "side24": ["125192393.6928", "3.023201"], "tail_max": "56894395.676666194973", "zfloor": ["8.752283", "35.239023", "79.442718", "108.171051", "124.189397", "132.611809", "136.918668", "8.902010", "35.851161", "80.828246", "110.059830", "126.358906", "134.928956", "139.311330", "9.335796", "37.678173", "85.006691", "115.772638", "132.928452", "141.949247", "146.562433", "11.179004", "45.577457", "103.173453", "140.649023", "161.553173", "172.546461", "178.168935"]}, + {"bound": ["70460913.8568", "22655040.8773", "13432686.0019", "12402434.0348", "12242075.1568", "12227610.6280", "12501410.9521", "74742348.8371", "23270424.0669", "13578383.8253", "12469553.2226", "12280045.5561", "12252528.9886", "12520176.6029", "97501817.5300", "26488694.2939", "14466619.6938", "12999631.5974", "12684225.5724", "12601914.8718", "12849834.7573", "291799430.5635", "46673260.6193", "19257794.9753", "15828867.5578", "14875901.5757", "14525802.0844", "14691887.6308"], "r": ["3/256", "13/1024"], "side24": ["222506462.0847", "3.005914"], "tail_max": "50753990.862953230154", "zfloor": ["8.733447", "35.188343", "79.347969", "108.049572", "124.053377", "132.468225", "136.771157", "8.882746", "35.798313", "80.729423", "109.933117", "126.217021", "134.779178", "139.157454", "9.311644", "37.615088", "84.890390", "115.624293", "132.762726", "141.774489", "146.383028", "11.126728", "45.446969", "102.939733", "140.354167", "161.225367", "172.201585", "177.815289"]}, + {"bound": ["103895943.7846", "25076129.5648", "13434797.7788", "12304870.1963", "12139197.6424", "12127231.6123", "12419041.1539", "111360787.8506", "25994480.9531", "13622999.1123", "12390103.2241", "12188590.5911", "12160984.4765", "12446290.4728", "151148391.0329", "30762254.8181", "14731680.8200", "13018372.6615", "12657851.3175", "12562753.9294", "12826862.3394", "488982450.8345", "63478012.4326", "21487307.1055", "16829278.5999", "15564208.4744", "15099118.9840", "15266488.2491"], "r": ["13/1024", "7/512"], "side24": ["389382570.1699", "2.988615"], "tail_max": "40277977.100153607759", "zfloor": ["8.714507", "35.137338", "79.252615", "107.927316", "123.916486", "132.323721", "136.622696", "8.863176", "35.745121", "80.629957", "109.805579", "126.074212", "134.628423", "139.002570", "9.287434", "37.551831", "84.773782", "115.475565", "132.596573", "141.599283", "146.203158", "11.074327", "45.316089", "102.705280", "140.058374", "160.896512", "171.855600", "177.460498"]}, + {"bound": ["164651976.7307", "34175384.4205", "14603428.6730", "12973110.8816", "12687412.8982", "12633495.2008", "12946569.5762", "177679326.7487", "35721723.1916", "14892881.2049", "13111024.1193", "12775920.4978", "12701100.4228", "13007112.2268", "247114140.0112", "43674283.5164", "16514164.3500", "14009034.7033", "13447682.4187", "13279422.9042", "13561703.5255", "840522641.1101", "99922523.6846", "27161356.7609", "19896323.0061", "17931276.0116", "17201157.3829", "17361243.1719"], "r": ["7/512", "15/1024"], "side24": ["665682803.3222", "2.971303"], "tail_max": "32437943.055629717362", "zfloor": ["8.695465", "35.086008", "79.156653", "107.804282", "123.778725", "132.178298", "136.473286", "8.843325", "35.691583", "80.529846", "109.677215", "125.930477", "134.476692", "138.846678", "9.263166", "37.488401", "84.656869", "115.326451", "132.429991", "141.423626", "146.022823", "11.021801", "45.184816", "102.470096", "139.761641", "160.566605", "171.508505", "177.104561"]}, + {"bound": ["275662660.4746", "48231390.4447", "18831453.3504", "14767668.8440", "14172057.9906", "14001708.6915", "14340097.3411", "298191422.9914", "50822675.9935", "19340960.3015", "15013131.2884", "14343272.2294", "14142352.1540", "14472782.9214", "418166472.6723", "64061012.3863", "22063238.5220", "16452143.1348", "15432936.5051", "15090852.1211", "15393289.6337", "1439739617.9923", "159456398.8572", "40164606.1630", "26162050.7164", "22862884.6501", "21621084.1759", "21759116.3365"], "r": ["15/1024", "1/64"], "side24": ["1110673185.5178", "2.953979"], "tail_max": "26528833.012071387911", "zfloor": ["8.676320", "35.034352", "79.060084", "107.680469", "123.640092", "132.031955", "136.322926", "8.823365", "35.637701", "80.429090", "109.548024", "125.785816", "134.323983", "138.689775", "9.238841", "37.424799", "84.539649", "115.176951", "132.262981", "141.247518", "145.842023", "10.969149", "45.053151", "102.234179", "139.463970", "160.235645", "171.160298", "176.747477"]} + ] +} diff --git a/frontiers/c8_theorem_a_constants_planar_20260930/SOURCE_FILES.json b/frontiers/c8_theorem_a_constants_planar_20260930/SOURCE_FILES.json new file mode 100644 index 000000000..95e857a06 --- /dev/null +++ b/frontiers/c8_theorem_a_constants_planar_20260930/SOURCE_FILES.json @@ -0,0 +1,40 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "certified": true, + "review_status": "AUTHOR_SIDE_THEOREM_WITH_CERTIFIED_CONSTANTS", + "object": "CL-C8-THEOREM-A-CONSTANTS-PLANAR-20260930-v1", + "files": [ + { + "path": "NOTE.md", + "bytes": 32994, + "sha256": "b651692df5658e45c29da4356b0b06ee3e3ca6b1ec784c58416d829658da6e17", + "git_blob": "49ebecf43c0e28d1c7d494ee4dc58f81dd405331" + }, + { + "path": "README.md", + "bytes": 3687, + "sha256": "7f93e5f11d97367314d70148935308e714398eee2f8261a79c860101af663405", + "git_blob": "bb03e4d1577f69a72d1e1a4241a80fcf0b76c133" + }, + { + "path": "RESULTS.json", + "bytes": 150257, + "sha256": "b4a77fd298297f6dfe077748d32b66f1fd209130443d2eaceea4463ef063c0fe", + "git_blob": "ed35fc61af4b5b9af5f07a2526015882343645d9" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 5221, + "sha256": "161a5ca87f7f068c8d0fe28196b37800b60c6adf5185eef0262e8a79a28a35a8", + "git_blob": "ea718b5293ef8bc109e1c5fa1e954fd4b6f59353" + }, + { + "path": "theorem_a.py", + "bytes": 52864, + "sha256": "c5ea8bf87c54761866315f28f6c93c6ce5c1e0f99d47c5a03f14d095d06871cc", + "git_blob": "ae279e9015483a666ece8deb2544cbc458a5e270" + } + ], + "nonauthor_reads": [] +} diff --git a/frontiers/c8_theorem_a_constants_planar_20260930/SOURCE_MAP.json b/frontiers/c8_theorem_a_constants_planar_20260930/SOURCE_MAP.json new file mode 100644 index 000000000..ea718b529 --- /dev/null +++ b/frontiers/c8_theorem_a_constants_planar_20260930/SOURCE_MAP.json @@ -0,0 +1,73 @@ +{ + "schema": 1, + "object": "CL-C8-THEOREM-A-CONSTANTS-PLANAR-20260930-v1", + "scientific_effect": "NONE", + "certified": true, + "review_status": "AUTHOR_SIDE_THEOREM_WITH_CERTIFIED_CONSTANTS", + "source_repository": "d6g8k5htny-coder/Math-", + "main_at_creation": "3e0a91b69892b9717564c592e7a966492a81566a", + "note": "Theorem E: for the planar six-pin law of [LP] and the good event G_r of [LP] section 7 / [CAP] (1), on the band b in [0, 1], k in [1/2, 2], uniformly over frames and torus sides L >= 10 (and for the reference kernel), Q^W(G_r^c) <= C(r_*) r^3 and Z_r / r^2 >= z(r_*) for 0 < r <= r_*, with C(1/512) = 5415659.2391, C(1/256) = 9370799.9311 (C r_*^3 <= 0.559), z(1/512) = 8.962953 and five further certified pairs. Theorem E' (v1.1): the same at the fixed-axis SIDE24 point (b, k) = (6/5, 1/6) of [CAP] section 1, C'(1/4096) = 39322.818 (1.100 c_G), C'(1/2048) = 43092.2382, C'(1/512) r^3 <= 0.874, replacing [CAP]'s recorded 2.4e23. The proof is self-contained apart from the definitions and the pins of [LP] (3.1)-(3.3): it does not consume [LP] (4.1), (4.2), (5.4), (5.5) or (7.5)-(7.7). With [LP] section 8 (1 - p_r <= Q^W(G_r^c)) this gives explicit pairs (C, r_*) for [LP] Theorem A (1.1). Every C here is a cap-route constant (a constant for [LP] (7.8)). C8 stays OPEN: no catalog edit; c_{B,K}, c_{d,L} and d >= 3 are not addressed.", + "sources": [ + { + "path": "imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md", + "bytes": 40261, + "sha256": "9350ad6eaba6626b93c3dedeef9e2ff816e5cdf1c8318e85fb27499141c84bc7", + "git_blob": "dfed3b8d318a3ab1950957f393307733a4bef3f2", + "id": "LP", + "commit": "3e0a91b69892b9717564c592e7a966492a81566a", + "role": "section 1: the model (torus kernel K_L, pins, Q, W_r, Z_r, Q^W) and Theorem A (1.1); section 3: the preconditioned pins (3.1) and their values (3.3); section 7: the good event G_r and the cap bound (7.8); section 8: on G_r the global elder partner of M is S, so 1 - p_r <= Q^W(G_r^c) (used only for the consequence on 1 - p_r); section 16: a numerical r_*, C on a prescribed band is listed as not supplied", + "current_required": true, + "on_main": true + }, + { + "path": "imports/lifetime_parent_20260925/MARKED_CYLINDER_CAP_PROOF.md", + "bytes": 15160, + "sha256": "0bf922b9203c29088b12388807aa0e2ecd020485eb0f6e919679841b5b2636fc", + "git_blob": "0633aca3c2a2882b0de4399da0a75d64c2e6b2e1", + "id": "CAP", + "commit": "3e0a91b69892b9717564c592e7a966492a81566a", + "role": "section 1: the cylinder D, the partial-block norms M_3, M_4 (coordinate partials in d = 2) and condition (1) defining G_r; the deterministic cap theorem behind [LP] section 8 (consumed as a statement); the probabilistic corollary (2)-(3): the fixed-axis SIDE24 law (b = 6/5, kappa = 1/6, 0 < r <= 1/20), whose parameter point is Theorem E', and its recorded constant 2.4e23, quoted for comparison", + "current_required": true, + "on_main": true + }, + { + "path": "frontiers/c8_cap_failure_coefficient_planar_20260930/NOTE.md", + "bytes": 28432, + "sha256": "0cb75475d9ee387a4045ff01ab9edb43a73c8c4edb6fc78d30518ced5bb02c5a", + "git_blob": "0b64f1c2828dfae7e6c104bac044004fc72c221d", + "id": "G", + "commit": "a388580eee356a88ce31aeed3999ab3fdc302312", + "pull_request": "Math-#203", + "role": "Theorem G and the certified lower ends c_G(0, 2) >= 5324360.4426 and c_G(6/5, 1/6) >= 35736.7352; v1.2 section 5 item 1: every cap-route constant is >= c_G. Used only for the --check sanity rules C > c_G (necessary conditions) and for the comparisons in NOTE section 0; not consumed by the proof", + "current_required": false, + "on_main": false + }, + { + "path": "frontiers/c8_normalizer_floor_planar_20260930/NOTE.md", + "bytes": 17915, + "sha256": "3dffe22dc58bf4262ab580197b3fd5ef0f1ba71e0a2e3f7030748c4574fd9eab", + "git_blob": "d321d52e83e9fa6cd2467f82310b6267c8be4e29", + "id": "Z", + "commit": "6e7746bdacd04f45810638f7c612fc8cfba39d1e", + "pull_request": "Math-#195", + "role": "the certified floor Z_r / r^2 >= 3.5044 on [1/64, 1/2] at L >= 12, combined with z(1/64) in NOTE section 0; comparison only", + "current_required": false, + "on_main": false + } + ], + "catalog_reference": { + "path": "reviews/candidates_pending_20260928/CANDIDATES.md", + "entry": "C8. Numerical constants (still open as of 2026-09-29): explicit finite C, r_*, z_*, c_{B,K}, c_{d,L} on a declared compact-mark / torus band; disposition OPEN", + "effect_here": "none; this packet supplies certified cap-route pairs (C, r_*) and z_* on (0, r_*] for d = 2 on the band b in [0, 1], k in [1/2, 2], L >= 10; no catalog edit; C8 stays OPEN pending nonauthor reads and its other entries" + }, + "related_records": [ + "Math-#203 (sharp cap coefficient c_G; lower bound for every cap-route constant)", + "Math-#195 (z_* on [1/64, 1/2])", + "Math-#197 (c_{B,K})", + "Math-#199, Math-#200, Math-#204 (c_{d,L} coefficients)" + ], + "nonauthor_reads": [], + "nonauthor_acceptance": false, + "governing_status_changed": false, + "main_at_update": "3e0a91b69892b9717564c592e7a966492a81566a" +} diff --git a/frontiers/c8_theorem_a_constants_planar_20260930/theorem_a.py b/frontiers/c8_theorem_a_constants_planar_20260930/theorem_a.py new file mode 100644 index 000000000..ae279e901 --- /dev/null +++ b/frontiers/c8_theorem_a_constants_planar_20260930/theorem_a.py @@ -0,0 +1,1249 @@ +#!/usr/bin/env python3 +"""Explicit constants for Theorem A of [LP] in the plane (d = 2), for the torus kernel K_L with L >= 10 in every frame: +for 0 < r <= r_*, b in [0, 1], k in [1/2, 2], + + 1 - p_r(b, k, R) <= Q^W(G_r^c) <= C(r_*) r^3, + +with G_r the good event of [LP] section 7 / [CAP] (1) and C(r_*) certified here (NOTE.md Theorem E); the same at the single +fixed-axis SIDE24 point (b, k) = (6/5, 1/6) of [CAP] section 1 (Theorem E'). The proof bounds +Q^W(G_r^c) = E_Q[W_r 1{G_r^c}] / Z_r from above by an exact Gaussian regression near r = 0: + + * covariances of the preconditioned pin and target functionals are exact power series in r, obtained from the Taylor + coefficients of the kernel at 0 (every negative power cancels identically, checked); the torus remainder is bounded + uniformly in r and in the frame by Cauchy estimates on a polydisc; + * the failure event is reduced to {lambda <= (4/(3k)) r M_3^2} u {r M_4 > 3k/10}; M_3 is bounded through exact averaging + identities of the pinned jets and M_4 through the Taylor series at the midpoint; + * the main term is integrated in lambda = -f_yy(M) against its Gaussian density after an exact regression on w = f_yy(M); + the remaining expectations are closed-form incomplete Gaussian moments plus Hoelder-controlled perturbations; + * the normalizer Z_r is bounded below in closed form; the rare branches are Gaussian tails. +All arithmetic is exact rational interval arithmetic (outward rounding to 2^-160); standard library only. +""" +import argparse +import json +import math +import multiprocessing +import os +import sys +from fractions import Fraction as Fr + +HERE = os.path.dirname(os.path.abspath(__file__)) +MUTANTS = ('no-delta', 'cap-half', 'no-zfloor-correction', 'no-om-term') +MUT = None +PBITS = 160 +L_MIN = 10 +NX = 60 # Taylor order in x of the covariance series (exact); the rest is a bounded tail +NB = 24 # truncation order of the Taylor tails of the 4-jets at the midpoint (the rest is bounded) +X0 = Fr(1, 64) # default threshold for the quadratic near-branch analysis (records use COMBOS) +THETA = Fr(1, 32) # default splitting parameter in the max-moment lemma (records use COMBOS) +THETA_E = Fr(1, 16) # splitting parameter for the (r nu + v)^2 factor +QS = (2, 4, 8, 16) # Hoelder exponents of the rare branches: E[W 1_E] <= ||W||_q P(E)^(1 - 1/q), smallest bound used +R_STARS = (Fr(1, 4096), Fr(1, 2048), Fr(1, 1024), Fr(1, 512), Fr(1, 256), Fr(1, 128), Fr(1, 64)) +BAND_B = (Fr(0), Fr(1)) +BAND_K = (Fr(1, 2), Fr(2)) + + +def require(cond, msg): + if not cond: + print(json.dumps({'check': 'FAIL', 'reason': msg, 'mutant': MUT})) + sys.exit(1) + + +# ----------------------------------------------------------------------------- rational intervals (from Math-#195 / #203) +def rdown(x): + return Fr(x.numerator * (1 << PBITS) // x.denominator, 1 << PBITS) + + +def rup(x): + return Fr(-((-x.numerator) * (1 << PBITS) // x.denominator), 1 << PBITS) + + +class IV: + __slots__ = ('lo', 'hi') + + def __init__(self, lo, hi=None): + lo = Fr(lo) + hi = lo if hi is None else Fr(hi) + if hi < lo: + raise ValueError('empty interval') + self.lo, self.hi = rdown(lo), rup(hi) + + def __repr__(self): + return 'IV(%s, %s)' % (float(self.lo), float(self.hi)) + + def __add__(self, o): + o = o if isinstance(o, IV) else IV(o) + return IV(self.lo + o.lo, self.hi + o.hi) + __radd__ = __add__ + + def __neg__(self): + return IV(-self.hi, -self.lo) + + def __sub__(self, o): + return self + (-(o if isinstance(o, IV) else IV(o))) + + def __rsub__(self, o): + return IV(o) - self + + def __mul__(self, o): + o = o if isinstance(o, IV) else IV(o) + c = (self.lo * o.lo, self.lo * o.hi, self.hi * o.lo, self.hi * o.hi) + return IV(min(c), max(c)) + __rmul__ = __mul__ + + def inv(self): + if self.lo <= 0 <= self.hi: + raise ZeroDivisionError('interval contains zero') + return IV(1 / self.hi, 1 / self.lo) + + def __truediv__(self, o): + o = o if isinstance(o, IV) else IV(o) + return self * o.inv() + + def __rtruediv__(self, o): + return IV(o) * self.inv() + + def sq(self): + if self.lo >= 0: + return IV(self.lo * self.lo, self.hi * self.hi) + if self.hi <= 0: + return IV(self.hi * self.hi, self.lo * self.lo) + return IV(0, max(self.lo * self.lo, self.hi * self.hi)) + + def meet(self, o): + lo, hi = max(self.lo, o.lo), min(self.hi, o.hi) + if hi < lo: + raise ValueError('inconsistent enclosures') + return IV(lo, hi) + + def width(self): + return self.hi - self.lo + + def mid(self): + return (self.lo + self.hi) / 2 + + def contains(self, x): + return self.lo <= x <= self.hi + + +def isqrt_iv(x): + """Enclosure of sqrt(x) for an interval x with x.lo > 0.""" + if x.lo <= 0: + raise ValueError('sqrt of interval reaching zero: %r' % x) + + def lo_root(v): + n = v.numerator * (1 << (2 * PBITS)) // v.denominator + s = math.isqrt(n) + return Fr(s, 1 << PBITS) + + def hi_root(v): + n = -((-v.numerator * (1 << (2 * PBITS))) // v.denominator) + s = math.isqrt(n) + 1 + return Fr(s, 1 << PBITS) + return IV(lo_root(x.lo), hi_root(x.hi)) + + +def exp_neg_point(t): + """Enclosure of exp(-t) for a rational t >= 0: halve t to t <= 1/2, evaluate the alternating series in fixed point + (ulp = 2^-(PBITS+40)) with an integer bound on the accumulated rounding error, then square back.""" + t = Fr(t) + m = 0 + while t > Fr(1, 2): + t /= 2 + m += 1 + P2 = PBITS + 40 + ONE = 1 << P2 + X = t.numerator * ONE // t.denominator # X / ONE <= t < (X + 1) / ONE + # series at x_lo = X / ONE: exp(-x_lo) = sum (-1)^n x_lo^n / n! (alternating, terms decreasing for x_lo <= 1/2) + S = ONE + T = ONE + E = 0 # error bound of T in ulps + Etot = 0 + n = 0 + while T > 0: + n += 1 + T = (T * X) // (ONE * n) + E = (E * X) // (ONE * n) + 2 + S += (-1) ** n * T + Etot += E + Etot += E + 1 # first omitted exact term is below (T_n + E) <= E + 1 ulps + # exp(-t) in [exp(-(X + 1)/ONE), exp(-X/ONE)] and exp(-(X + 1)/ONE) >= exp(-X/ONE) - 1/ONE (Lipschitz 1) + v = IV(Fr(S - Etot - 1, ONE), Fr(S + Etot, ONE)) + for _ in range(m): + v = v.sq() + return v + + +def exp_neg(t): + """exp(-t) on an interval t with t.lo >= 0 (monotone decreasing).""" + return IV(exp_neg_point(t.hi).lo, exp_neg_point(t.lo).hi) + + +def _atan_inv(n): + """Enclosure of arctan(1/n), n >= 2, alternating series.""" + x = Fr(1, n) + s = Fr(0) + term = x + k = 0 + while True: + s += term / (2 * k + 1) + k += 1 + term = term * (-x * x) + if abs(term) / (2 * k + 1) < Fr(1, 1 << (PBITS + 8)): + break + return IV(s - abs(term), s + abs(term)) + + +PI = 4 * (4 * _atan_inv(5) - _atan_inv(239)) +SQRT2 = isqrt_iv(IV(2)) +SQRT2PI = isqrt_iv(2 * PI) + + +def phi_point(x): + """Enclosure of Phi(x) = P(N(0,1) <= x) for a rational x with |x| <= 12, from the series + Phi(x) = 1/2 + (1/sqrt(2 pi)) sum_n (-1)^n x^(2n+1) / (2^n n! (2n+1)), evaluated in fixed point (ulp = 2^-(PBITS+40)) + with an explicit integer bound E on the accumulated rounding error (in ulps) and the alternating-tail bound.""" + x = Fr(x) + if x < 0: + p = phi_point(-x) + return IV(1 - p.hi, 1 - p.lo) + if x > 12: + raise ValueError('phi_point range') + P2 = PBITS + 40 + ONE = 1 << P2 + X = x.numerator * ONE // x.denominator # x_lo = X / ONE <= x < (X + 1) / ONE ; |Phi(x) - Phi(x_lo)| <= 1 ulp + if X == 0: # 0 <= x < 1 ulp: Phi(x) in [1/2, 1/2 + ulp] + return IV(Fr(1, 2), Fr(1, 2) + Fr(1, ONE)) + X2u = (X + 1) * (X + 1) # upper bound of x^2 ONE^2 + S = 0 + T = X # T_n ~ x^(2n+1) / (2^n n!) in ulps + E = 1 # error bound of T_n in ulps + Etot = 1 # error of S in ulps (starts with the x rounding) + n = 0 + while T > 0: + S += (-1) ** n * (T // (2 * n + 1)) + Etot += E + 1 + n += 1 + T = (T * X * X) // (ONE * ONE * 2 * n) + E = (E * X2u) // (ONE * ONE * 2 * n) + 2 + # once T == 0 in fixed point the remaining terms are each below 1 ulp; if x^2 >= 2 n they are still growing in + # exact arithmetic, so continue counting until they decrease: bound the tail by the first omitted exact term + # <= (T_n + E) ulps <= (E + 1) ulps when T_n == 0 ... but growth may resume; require the decreasing regime. + if x * x > 2 * n: + raise ValueError('series terminated before the decreasing regime') + Etot += E + 1 + core = IV(Fr(S - Etot, ONE), Fr(S + Etot, ONE)) / SQRT2PI + return IV(Fr(1, 2) + core.lo, Fr(1, 2) + core.hi) + + +def Phi(x): + """Phi on an interval (monotone); arguments clipped to [-12, 12] (clipping only widens).""" + lo = min(max(x.lo, Fr(-12)), Fr(12)) + hi = max(min(x.hi, Fr(12)), Fr(-12)) + if x.lo < -12: + plo = Fr(0) + else: + plo = phi_point(lo).lo + if x.hi > 12: + phi_ = Fr(1) + else: + phi_ = phi_point(hi).hi + return IV(plo, phi_) + + + + +def phi_pt(x): + """phi(x) for rational x (interval).""" + x = Fr(x) + return exp_neg_point(x * x / 2) / SQRT2PI + + +def Phibar_pt(x): + """1 - Phi(x) for rational x (interval).""" + p = phi_point(Fr(x)) if abs(Fr(x)) <= 12 else None + if p is None: + if x > 0: + # Mills: Phibar(x) <= phi(x)/x + return IV(0, (phi_pt(x) / x).hi) + return IV(1 - (phi_pt(-x) / (-x)).hi, 1) + return IV(1 - p.hi, 1 - p.lo) + + +def upper_moments(x, J): + """[M_0(x), ..., M_J(x)], M_j(x) = integral_x^inf t^j phi(t) dt, for rational x >= 0 (intervals).""" + x = Fr(x) + require(x >= 0, 'upper moment at negative point') + ph = phi_pt(x) + M = [Phibar_pt(x), ph] + for j in range(2, J + 1): + M.append(ph * x ** (j - 1) + M[j - 2] * (j - 1)) + return M + + +def dfact(n): + """(n)!! for n >= -1.""" + return math.prod(range(n, 0, -2)) if n > 0 else 1 + + +def rup_rel(x, bits=200): + """Round a rational x >= 0 up to a dyadic with `bits` significant bits (upper bounds stay upper bounds).""" + x = Fr(x) + if x <= 0: + return x + e = x.numerator.bit_length() - x.denominator.bit_length() + sh = bits - e + if sh >= 0: + return Fr(-((-x.numerator << sh) // x.denominator), 1 << sh) + return Fr(-((-x.numerator) // (x.denominator << -sh)) << -sh) + + +def sqrt_up(x): + """Rational upper bound of sqrt(x), x >= 0 rational, relative excess below 2^-198 (no absolute rounding floor): the root + step adds less than 2^-209 and rup_rel(., 200) less than 2^-199. (The earlier '2^-200' was too sharp: at x = 49/100 the + excess is (8/7) 2^-200, review C59-DOC-01.)""" + x = Fr(x) + if x == 0: + return Fr(0) + n, d = x.numerator, x.denominator + nd = n * d + m = max(0, (420 - nd.bit_length()) // 2 + 1) + return rup_rel(Fr(math.isqrt(nd << (2 * m)) + 1, d << m)) + + +def iroot(x, p): + """Upper bound (rational) of x^(1/p) for rational x >= 0 and p a power of two.""" + v = Fr(x) + while p > 1: + v = sqrt_up(v) + p //= 2 + return v + + +def pow2(p): + q = 1 + while q < p: + q *= 2 + return q + + +ZN = {} + + +def znorm(p): + """Upper bound of ||N(0,1)||_p for p a power of two (p = 1 uses sqrt(2/pi) < 4/5).""" + if p == 1: + return Fr(4, 5) + if p not in ZN: + ZN[p] = iroot(Fr(dfact(p - 1)), p) + return ZN[p] + + +def habs_moment(j): + """E|zeta|^j (interval).""" + if j % 2 == 0: + return IV(dfact(j - 1)) + return SQRT2 / isqrt_iv(PI) * (2 ** ((j - 1) // 2) * math.factorial((j - 1) // 2)) + + +# ----------------------------------------------------------------------------- functionals and exact covariance series +HALF = Fr(1, 2) +XM, XS, X0PT = -HALF, HALF, Fr(0) + + +def term(c, p, a, b, x0): + """c r^p d_x^a d_y^b f(x0 r, 0).""" + return (Fr(c), p, a, b, Fr(x0)) + + +def functionals(): + pins = { + 'p1': [term(HALF, 0, 0, 0, XM), term(HALF, 0, 0, 0, XS)], + 'p2': [term(-1, -1, 0, 0, XM), term(1, -1, 0, 0, XS)], + 'p3p': [term(6, -2, 1, 0, XM), term(6, -2, 1, 0, XS), term(12, -3, 0, 0, XM), term(-12, -3, 0, 0, XS)], + 'p4': [term(-1, -1, 1, 0, XM), term(1, -1, 1, 0, XS)], + 'q1': [term(HALF, 0, 0, 1, XM), term(HALF, 0, 0, 1, XS)], + 'q2': [term(-1, -1, 0, 1, XM), term(1, -1, 0, 1, XS)], + } + targets = { + 'w': [term(1, 0, 0, 2, XM)], + 'v': [term(1, -1, 1, 1, XM), term(1, -2, 0, 1, XM), term(-1, -2, 0, 1, XS)], + 'om': [term(1, -1, 0, 2, XS), term(-1, -1, 0, 2, XM)], + 'Y': [term(1, 0, 0, 3, X0PT)], + 'T': [term(1, -2, 2, 0, XM), term(4, -3, 1, 0, XM), term(2, -3, 1, 0, XS), term(6, -4, 0, 0, XM), term(-6, -4, 0, 0, XS)], + 'tau': [term(1, -3, 2, 0, XS), term(-1, -3, 2, 0, XM), term(-6, -4, 1, 0, XM), term(-6, -4, 1, 0, XS), + term(-12, -5, 0, 0, XM), term(12, -5, 0, 0, XS)], + 'nu': [term(1, -2, 1, 1, XM), term(1, -2, 1, 1, XS), term(2, -3, 0, 1, XM), term(-2, -3, 0, 1, XS)], + 'X40': [term(1, 0, 4, 0, X0PT)], 'X31': [term(1, 0, 3, 1, X0PT)], 'X22': [term(1, 0, 2, 2, X0PT)], + 'X13': [term(1, 0, 1, 3, X0PT)], 'X04': [term(1, 0, 0, 4, X0PT)], + } + return pins, targets + + +PIN_NAMES = ('p1', 'p2', 'p3p', 'p4', 'q1', 'q2') +TARGET_NAMES = ('w', 'v', 'om', 'Y', 'T', 'tau', 'nu', 'X40', 'X31', 'X22', 'X13', 'X04') +JET4 = ('X40', 'X31', 'X22', 'X13', 'X04') +JET4_IDX = {'X40': (4, 0), 'X31': (3, 1), 'X22': (2, 2), 'X13': (1, 3), 'X04': (0, 4)} + + +def weight(F): + """Scaling weight a - (power of r), common to all terms of a preconditioned functional.""" + ws = {t[2] - t[1] for t in F} + require(len(ws) == 1, 'functional not homogeneous') + return ws.pop() + + +def hcoef(n): + """d^n/dx^n exp(-x^2/2) at 0.""" + if n % 2: + return 0 + return (-1) ** (n // 2) * dfact(n - 1) + + +PAIR_CACHE = {} + + +def pair_series(F, G, key): + """Exact data of Cov_K(F, G) = sum_gamma kappa_gamma pi_gamma r^(gx - wF - wG): + returns (reference series {power: rational}, weight w, list of (|c c'|, a+a', b+b') for the remainder bounds).""" + if key in PAIR_CACHE: + return PAIR_CACHE[key] + wF, wG = weight(F), weight(G) + w = wF + wG + pi = {} + absterms = [] + for (cf, pf, af, bf, xf) in F: + for (cg, pg, ag, bg, xg) in G: + gy = bf + bg + sgn = (-1) ** (ag + bg) + d = xf - xg + absterms.append((abs(cf * cg), af + ag, gy)) + for gx in range(af + ag, NX + 1): + m = gx - af - ag + val = cf * cg * sgn * d ** m / math.factorial(m) + if val != 0: + pi[(gx, gy)] = pi.get((gx, gy), Fr(0)) + val + for (gx, gy), v in pi.items(): + require(v == 0 or gx - w >= 0, 'negative power of r in a covariance (regularity fails)') + ser = {} + for (gx, gy), v in pi.items(): + kap = hcoef(gx) * hcoef(gy) + if kap and v: + ser[gx - w] = ser.get(gx - w, Fr(0)) + kap * v + out = ({p: c for p, c in ser.items() if c != 0}, w, absterms) + PAIR_CACHE[key] = out + return out + + +def torus_M1(L): + """Bound of |sum_{n != 0} G(z + p_n)| on the polydisc |z_1|, |z_2| <= 1 (every frame, |p_n| = |n| L): + exp(1) * sum_{j >= 1} 8 j exp(-(j L - 3/2)^2 / 2).""" + L = Fr(L) + tot = Fr(0) + for j in range(1, 6): + tot += 8 * j * exp_neg_point((j * L - Fr(3, 2)) ** 2 / 2).hi + tail = 8 * 7 * exp_neg_point((6 * L - Fr(3, 2)) ** 2 / 2).hi * 4 # j >= 6, very crude + return Fr(27183, 10000) * (tot + tail) + + +def theta_minus_one(L): + L = Fr(L) + tot = Fr(0) + for j in range(1, 6): + tot += 8 * j * exp_neg_point((j * L) ** 2 / 2).hi + return tot + 8 * 7 * exp_neg_point((6 * L) ** 2 / 2).hi * 4 + + +def cov_band(F, G, key, r0, r1, M1): + """Enclosure of the covariance (unnormalized torus kernel sum_n G(z + p_n)) of F and G, for r in [r0, r1].""" + ser, w, absterms = pair_series(F, G, key) + val = IV(0) + for p, c in ser.items(): + val = val + IV(r0 ** p, r1 ** p) * c + A = max((t[1] for t in absterms), default=0) + # Taylor truncation tail of the reference kernel (orders gx > NX) + tail = Fr(0) + for (acc, aa, gy) in absterms: + tail += acc * abs(hcoef(gy)) + tail *= 2 * Fr(NX + 1) ** A * r1 ** (NX + 1 - w) + # torus remainder: Cauchy estimates |rho_gamma| <= gx! gy! M1 on the unit polydisc + tor = Fr(0) + if True: + for (acc, aa, gy) in absterms: + tor += acc * math.factorial(gy) * Fr(max(w, 1)) ** aa + tor = tor * M1 / (1 - Fr(27183, 10000) * r1) + err = tail + tor + return val + IV(-err, err) + + +# ----------------------------------------------------------------------------- interval linear algebra +def solve_iv(A, B): + """Interval Gaussian elimination with partial pivoting on midpoints: X[c] solves A X[c] = B[c].""" + n = len(A) + M = [[A[i][j] for j in range(n)] + [B[c][i] for c in range(len(B))] for i in range(n)] + for col in range(n): + p = max(range(col, n), key=lambda i: abs(M[i][col].mid())) + M[col], M[p] = M[p], M[col] + piv = M[col][col] + for i in range(col + 1, n): + f = M[i][col] / piv + for j in range(col, len(M[i])): + M[i][j] = M[i][j] - f * M[col][j] + X = [] + for c in range(len(B)): + x = [None] * n + for i in reversed(range(n)): + s = M[i][n + c] + for j in range(i + 1, n): + s = s - M[i][j] * x[j] + x[i] = s / M[i][i] + X.append(x) + return X + + +def cholesky3(C): + """Interval Cholesky of a 3 x 3 SPD interval matrix.""" + L = [[IV(0)] * 3 for _ in range(3)] + for i in range(3): + for j in range(i + 1): + s = C[i][j] - sum((L[i][l] * L[j][l] for l in range(j)), IV(0)) + if i == j: + require(s.lo > 0, 'Cholesky pivot not positive') + L[i][j] = isqrt_iv(s) + else: + L[i][j] = s / L[j][j] + return L + + +def absup(x): + return max(abs(x.lo), abs(x.hi)) + + +# ----------------------------------------------------------------------------- the conditional law on an r-band +class Law: + pass + + +def band_law(r0, r1, L=L_MIN): + """Interval enclosures, uniform over r in [r0, r1], every frame and every torus side >= L, of the Q-law of the + targets: mean = b alpha + k beta, covariance C (normalized kernel), and the pin energy coefficients.""" + pins, targets = functionals() + P = [pins[n] for n in PIN_NAMES] + T = [targets[n] for n in TARGET_NAMES] + M1 = torus_M1(L) + th1 = theta_minus_one(L) + nt = len(T) + Spp = [[cov_band(P[i], P[j], ('p', i, j), r0, r1, M1) for j in range(6)] for i in range(6)] + Stp = [[cov_band(T[i], P[j], ('tp', i, j), r0, r1, M1) for j in range(6)] for i in range(nt)] + Stt = [[cov_band(T[i], T[j], ('tt', i, j), r0, r1, M1) for j in range(nt)] for i in range(nt)] + r = IV(r0, r1) + kvec = [-(r * r * r) * HALF, -(r * r), IV(12), IV(0), IV(0), IV(0)] + e1 = [IV(1), IV(0), IV(0), IV(0), IV(0), IV(0)] + W = solve_iv(Spp, Stp) + xs = solve_iv(Spp, [e1, kvec]) + law = Law() + law.r0, law.r1, law.L, law.M1, law.th1 = r0, r1, L, M1, th1 + law.alpha = {n: W[i][0] for i, n in enumerate(TARGET_NAMES)} + law.beta = {n: sum((W[i][j] * kvec[j] for j in range(6)), IV(0)) for i, n in enumerate(TARGET_NAMES)} + scale = IV(1 / (1 + th1), 1) # K_L = (unnormalized) / Theta, Theta in [1, 1 + th1] + C = {} + for i, a in enumerate(TARGET_NAMES): + for j, c in enumerate(TARGET_NAMES): + if j < i: + continue + v = Stt[i][j] - sum((W[i][l] * Stp[j][l] for l in range(6)), IV(0)) + if i != j: + v2 = Stt[j][i] - sum((W[j][l] * Stp[i][l] for l in range(6)), IV(0)) + v = v.meet(v2) + C[(a, c)] = C[(c, a)] = v * scale + law.C = C + escale = IV(1, 1 + th1) + law.e_bb = xs[0][0] * escale + law.e_bk = sum((kvec[j] * xs[0][j] for j in range(6)), IV(0)) * escale + law.e_kk = sum((kvec[j] * xs[1][j] for j in range(6)), IV(0)) * escale + # regression on w and the g-parts + sw2 = C[('w', 'w')] + require(sw2.lo > 0, 'Var w not positive') + law.sw2 = sw2 + law.sw = isqrt_iv(sw2) + law.bw = {n: C[(n, 'w')] / sw2 for n in TARGET_NAMES if n != 'w'} + Cg = {} + for a in TARGET_NAMES: + for c in TARGET_NAMES: + if a != 'w' and c != 'w': + Cg[(a, c)] = C[(a, c)] - C[(a, 'w')] * C[(c, 'w')] / sw2 + law.Cg = Cg + law.L3 = cholesky3([[Cg[(a, c)] for c in ('v', 'om', 'Y')] for a in ('v', 'om', 'Y')]) + law.sdg = {n: isqrt_iv(IV(max(Cg[(n, n)].lo, Fr(0)), Cg[(n, n)].hi)) if Cg[(n, n)].lo > 0 else IV(0, isqrt_iv(IV(Cg[(n, n)].hi)).hi) + for n in TARGET_NAMES if n != 'w'} + law.sdQ = {n: isqrt_iv(C[(n, n)]) for n in TARGET_NAMES} + # crude higher jets: Taylor-tail coefficients S_alpha(r1) = sum_{beta != 0} sd0_{alpha+beta} (2 r1)^{|beta|} / beta! + law.S = {n: taylor_tail_coefficient(JET4_IDX[n], r1, M1) for n in JET4} + return law + + +def sd0_bound(gx, gy, M1): + """Upper bound of sqrt(Var d^gamma f(0)) = sqrt(|d^{2 gamma} K_L(0)|) (normalized, every frame, L >= L_MIN).""" + v = dfact(2 * gx - 1) * dfact(2 * gy - 1) + math.factorial(2 * gx) * math.factorial(2 * gy) * M1 + return isqrt_iv(IV(v)).hi + + +def taylor_tail_coefficient(alpha, r1, M1): + ax, ay = alpha + tot = Fr(0) + for n in range(1, NB + 1): + for bx in range(n + 1): + by = n - bx + tot += sd0_bound(ax + bx, ay + by, M1) * (2 * r1) ** n / (math.factorial(bx) * math.factorial(by)) + # tail |beta| > NB: sd0_gamma <= 2^|gamma| gx! gy! sqrt(1 + M1) (binom(2m, m) <= 4^m), so a term is at most + # 2^|alpha| (4 + n)^4 (4 r1)^n 2 per multi-index; n + 1 multi-indices of order n + q = 4 * r1 + require(q <= Fr(1, 16), 'Taylor tail ratio too large') + tail = Fr(0) + base = 2 ** (ax + ay) * 2 + n = NB + 1 + # sum_{n > NB} (n + 1)(n + 4)^8 q^n <= (NB + 2)(NB + 5)^8 q^(NB+1) / (1 - 2 q) (consecutive ratio <= 2q for these n) + tail = base * (NB + 2) * Fr(NB + 5) ** 8 * q ** (NB + 1) / (1 - 2 * q) + return tot + tail + + +# ----------------------------------------------------------------------------- moment calculus (normalized by K = 12 k) +def binom(n, k): + return math.comb(n, k) + + +def gauss_norm(mu_abs, sd, p): + """Upper bound of ||X||_p for X Gaussian with |mean| <= mu_abs and sd <= sd.""" + return rup_rel(mu_abs + sd * znorm(pow2(p))) + + +def pos_part_moments(s, c, nmax, extra_max): + """P[n][e] = upper bound of E[u^e (u^n - c^n)_+], u = s |zeta|, for 1 <= n <= nmax, 0 <= e <= extra_max.""" + x = c / s + M = upper_moments(x, nmax + extra_max) + out = {} + for n in range(1, nmax + 1): + for e in range(extra_max + 1): + out[(n, e)] = rup_rel(((M[n + e] * s ** (n + e) - M[e] * c ** n * s ** e) * 2).hi) + return out + + +def normalized_moments(q, nmax, theta): + """Component moments, normalized by K = 12 k (K >= Klo), for n <= nmax: + E1[n], E1o[n], E1v[n] : upper bounds of E[y1^n], E[o0 y1^n], E[v0^2 y1^n], y1 = 1 + cmu1/K + (r1/K) Delta1; + Tn[n], To[n], Tv[n] : upper bounds of sum_{i=2,3,4} E[(y_i^n - c^n)_+] (and with the factors o0, v0^2), + y_i <= u_i + delta_i (u_i = s_i |zeta| independent half-normals), threshold c = q['c']. + o0 = s3 |z2| and v0^2 = s2^2 z1^2 / 4 are unnormalized.""" + th = theta + cp = q['c'] * (1 - th) # <= c (1 + th)^{-(n-1)/n} for every n (Bernoulli) + PP = {i: pos_part_moments(q['s'][i], cp, nmax, 2) for i in (2, 3, 4)} + Eu3 = (habs_moment(1) * q['s3']).hi + Eu2sq = (habs_moment(2) * q['s2'] * q['s2']).hi + n_o0_2 = q['s3'] * znorm(2) + n_u2sq_2 = q['s2'] * q['s2'] * znorm(4) ** 2 + r3 = q['s3'] / q['s'][3] + r2sq = (q['s2'] / q['s'][2]) ** 2 + E1, E1o, E1v, Tn, To, Tv = {}, {}, {}, {}, {}, {} + base = 1 + q['cmt1'] + for n in range(0, nmax + 1): + ey = base ** n + eo = base ** n * Eu3 + ev = base ** n * Eu2sq + for j in range(1, n + 1): + coef = binom(n, j) * base ** (n - j) * q['rK'] ** j + ey += coef * q['nD1'](pow2(j)) ** j + eo += coef * n_o0_2 * q['nD1'](pow2(2 * j)) ** j + ev += coef * n_u2sq_2 * q['nD1'](pow2(2 * j)) ** j + E1[n], E1o[n], E1v[n] = rup_rel(ey), rup_rel(eo), rup_rel(ev / 4) + if n == 0: + continue + f1 = (1 + th) ** (n - 1) + f2 = (1 + 1 / th) ** (n - 1) + tn = to = tv = Fr(0) + for i in (2, 3, 4): + P = PP[i] + dn = q['nd'](i, pow2(n)) ** n + dn2 = q['nd'](i, pow2(2 * n)) ** n + tn += f1 * P[(n, 0)] + f2 * dn + to += (f1 * r3 * P[(n, 1)] if i == 3 else f1 * Eu3 * P[(n, 0)]) + f2 * n_o0_2 * dn2 + tv += (f1 * r2sq * P[(n, 2)] if i == 2 else f1 * Eu2sq * P[(n, 0)]) + f2 * n_u2sq_2 * dn2 + Tn[n], To[n], Tv[n] = rup_rel(tn), rup_rel(to), rup_rel(tv / 4) + return E1, E1o, E1v, Tn, To, Tv + + +def elam_pos(m, s): + """E[(s z + m)_+] at a point (rational m, s > 0).""" + x = Fr(m) / s + return m * Phi(IV(x)) + phi_pt(x) * s + + +def elam2_pos(m, s): + """E[(s z + m)_+^2] at a point.""" + x = Fr(m) / s + return (m * m + s * s) * Phi(IV(x)) + phi_pt(x) * (m * s) + + +def box_bound(law, bb, kb, r0, r1, last_band=False, x0=None, theta=None): + """Certified upper bound of sup_{r in [r0, r1]} Q^W(G_r^c) / r^3 over b in bb, k in kb, with its pieces, for the near-branch + threshold x0 (X_0 of NOTE section 4) and the split parameter theta (section 5). The bound is proved for 0 < x0 < 2/9 and + 0 < theta < 1: then 3 x0 < 1, x0 <= 1/4 (root bounds), kappa = 3/(1 - 3 x0), c = 1 - kappa x0/2 > 0 and + (1 + kappa x0) c^2 <= 1. No claim is made outside that domain. Both COMBOS pairs, and the (1/64, 1/32) of Math-#215's + caller, lie inside it (review C61).""" + x0 = X0 if x0 is None else Fr(x0) + theta = THETA if theta is None else Fr(theta) + b = IV(bb[0], bb[1]) + k = IV(kb[0], kb[1]) + klo, khi = kb[0], kb[1] + Klo = 12 * klo + mu = {n: b * law.alpha[n] + k * law.beta[n] for n in TARGET_NAMES} + mabs = {n: absup(mu[n]) for n in TARGET_NAMES} + E = b * b * law.e_bb + b * k * law.e_bk * 2 + k * k * law.e_kk + require(E.hi > 0, 'energy') + sqE = isqrt_iv(IV(E.hi)).hi + sw_lo, sw_hi = law.sw.lo, law.sw.hi + muw_abs = mabs['w'] + bw = {n: absup(law.bw[n]) for n in law.bw} + t = {n: law.S[n] / sw_lo for n in JET4} + a_fac = Fr(1, 2) if MUT == 'cap-half' else Fr(1) # the cap constant 4/(3k) (mutant: halved) + B = lambda n: bw[n] + t[n] + bbars = {1: r1 * (Fr(5, 2) * B('X40') + 2 * B('X31')), + 2: 2 * bw['v'] + r1 * (Fr(5, 2) * B('X31') + 2 * B('X22')), + 3: bw['om'] + r1 * (Fr(5, 2) * B('X22') + 2 * B('X13')), + 4: bw['Y'] + r1 * (2 * B('X13') + 2 * B('X04'))} + bbars = {i: rup_rel(v) for i, v in bbars.items()} + bbar = max(bbars.values()) + L3 = law.L3 + s2, s3, s4 = 2 * L3[0][0].hi, L3[1][1].hi, L3[2][2].hi + l21, l31, l32 = absup(L3[1][0]), absup(L3[2][0]), absup(L3[2][1]) + + memo = {} + + def nA(n, p): # ||A_alpha^g||_p, A_alpha^g = |X_alpha,g| + T_alpha^g + key = ('A', n, p) + if key not in memo: + memo[key] = rup_rel(gauss_norm(mabs[n], law.sdg[n].hi, p) + law.S[n] * (sqE + znorm(pow2(p)))) + return memo[key] + + def nDelta(i, p): + key = ('D', i, p) + if key not in memo: + memo[key] = rup_rel(nDelta0(i, p)) + return memo[key] + + def nDelta0(i, p): + if MUT == 'no-delta': + return Fr(0) + if i == 1: + return Fr(5, 2) * nA('X40', p) + 2 * nA('X31', p) + if i == 2: + return Fr(5, 2) * nA('X31', p) + 2 * nA('X22', p) + if i == 3: + return Fr(5, 2) * nA('X22', p) + 2 * nA('X13', p) + return 2 * nA('X13', p) + 2 * nA('X04', p) + + def nd(i, p): + key = ('d', i, p) + if key not in memo: + memo[key] = rup_rel(nd0(i, p)) + return memo[key] + + def nd0(i, p): # ||delta_i||_p / Klo, delta_i including beta_i |mu_w| + zp = znorm(pow2(p)) + cm = bbars[i] * muw_abs + if i == 2: + v = 2 * mabs['v'] + cm + r1 * nDelta(2, p) + elif i == 3: + v = mabs['om'] + l21 * zp + cm + r1 * nDelta(3, p) + else: + v = mabs['Y'] + (l31 + l32) * zp + cm + r1 * nDelta(4, p) + return v / Klo + + kappa = 3 / (1 - 3 * x0) + Fk = 1 + kappa * x0 # (1 + kappa x_i) <= Fk on the event {x_i <= x0} + cth = 1 - kappa * x0 / 2 # <= Fk^{-1/2} + NMAX = 24 + q = {'cmt1': bbars[1] * muw_abs / Klo, 'rK': r1 / Klo, 'nD1': lambda p: nDelta(1, p), + 's': {2: s2 / Klo, 3: s3 / Klo, 4: s4 / Klo}, 'nd': nd, 's3': s3, 's2': s2, 'c': cth} + E1, E1o, E1v, Tn, To, Tv = normalized_moments(q, NMAX, theta) + et1 = rup_rel(16 * kappa * r1 * bbars[1] * a_fac) # eta_1 K, k-free + aK2_hi = 192 * khi * a_fac # a K^2 = 192 k + + # moments of Ut = U / (a K^2) <= max(Z1, Fk y_i^2), Z1 = y1^2 (1 + et1 y1) + def EUt(p): # upper bound of E[Ut^p] + key = ('U', p) + if key not in memo: + memo[key] = rup_rel(sum(binom(p, l) * et1 ** l * E1[2 * p + l] for l in range(p + 1)) + Fk ** p * Tn[2 * p]) + return memo[key] + + def EoUt2(): + return sum(binom(2, l) * et1 ** l * E1o[4 + l] for l in range(3)) + Fk ** 2 * To[4] + + def EvUt2(): + return sum(binom(2, l) * et1 ** l * E1v[4 + l] for l in range(3)) + Fk ** 2 * Tv[4] + + def sq(x): + return isqrt_iv(IV(x)).hi + + U3_2 = sq(EUt(6)) # ||Ut^3||_2 + U2_2 = sq(EUt(4)) # ||Ut^2||_2 + + def nU(p): # ||U||_p <= a K^2 Fk ||max_i y_i||_2p^2 (on the event x_i <= X0) + require(2 * p <= NMAX and pow2(p) == p, 'norm order') + key = ('nU', p) + if key not in memo: + memo[key] = rup_rel(aK2_hi * Fk * iroot(E1[2 * p] + Tn[2 * p], p)) + return memo[key] + + def nbar(n, p): # ||F_bar||_p, F_bar = |F_g| + |beta_F| (|mu_w| + r1 U) + return gauss_norm(mabs[n], law.sdg[n].hi, p) + bw[n] * (muw_abs + r1 * nU(p)) + + six_klo = 6 * klo + nT2, nT4, nt2, nt4 = nbar('T', 2), nbar('T', 4), nbar('tau', 2), nbar('tau', 4) + epsc2 = (2 * r1 * nT2 + r1 * r1 * nt2) / six_klo + (r1 * nT4) * (r1 * nT4 + r1 * r1 * nt4) / six_klo ** 2 + nT8, nt8 = nbar('T', 8), nbar('tau', 8) + epsc4 = (2 * r1 * nT4 + r1 * r1 * nt4) / six_klo + (r1 * nT8) * (r1 * nT8 + r1 * r1 * nt8) / six_klo ** 2 + # Term A / (36 k^2) + A_n = EUt(3) + epsc2 * U3_2 + termA = aK2_hi ** 3 / 3 * A_n + # Term B / (36 k^2) + ndo = lambda p: l21 * znorm(pow2(p)) + mabs['om'] + bw['om'] * (muw_abs + r1 * nU(p)) + no4 = s3 * znorm(4) + ndo(4) + B_n = EoUt2() + (ndo(2) + epsc4 * no4) * U2_2 + termB = aK2_hi ** 2 / 2 * B_n + if MUT == 'no-om-term': + termB = Fr(0) + # Term C / (36 k^2) = (a K^2)^2 / (12 k) * E[(1 + r T/(6k)) e Ut^2] + th = THETA_E + dv = lambda p: mabs['v'] + bw['v'] * (muw_abs + r1 * nU(p)) + ebar4 = (r1 * nbar('nu', 8) + L3[0][0].hi * znorm(8) + dv(8)) ** 2 + C_n = ((1 + th) ** 2 * EvUt2() + + ((1 + th) * (1 + 1 / th) * dv(4) ** 2 + (1 + 1 / th) * r1 * r1 * nbar('nu', 4) ** 2) * U2_2 + + r1 * nT4 / six_klo * ebar4 * U2_2) + termC = aK2_hi ** 2 / (12 * klo) * C_n + # one more power of U for the density refinement: the same three terms with lambda inserted, divided by r + # (int_0^{rU} lambda W dlambda <= r^6 |c1| [|c2| (U^4/4 + om U^3/3) + e U^3/3]) + U3_2_ = U3_2 + termAp = aK2_hi ** 4 / 4 * (EUt(4) + epsc2 * sq(EUt(8))) + EoUt3 = sum(binom(3, l) * et1 ** l * E1o[6 + l] for l in range(4)) + Fk ** 3 * To[6] + EvUt3 = sum(binom(3, l) * et1 ** l * E1v[6 + l] for l in range(4)) + Fk ** 3 * Tv[6] + termBp = aK2_hi ** 3 / 3 * (EoUt3 + (ndo(2) + epsc4 * no4) * U3_2_) + if MUT == 'no-om-term': + termBp = Fr(0) + termCp = aK2_hi ** 3 / (18 * klo) * ((1 + th) ** 2 * EvUt3 + + ((1 + th) * (1 + 1 / th) * dv(4) ** 2 + (1 + 1 / th) * r1 * r1 * nbar('nu', 4) ** 2) * U3_2_ + + r1 * nT4 / six_klo * ebar4 * U3_2_) + # density of lambda = -w: pbar = its supremum on [0, inf); on the failure window [0, rU] also p(lambda) <= p0 + lambda Lp + # with p0 = sup over the box of the density at 0 and Lp = sup |p'| <= phi(1)/sigma^2, phi(1) < 0.24198 + mlo = max(Fr(0), mu['w'].lo) + pbar = (phi_pt(mlo / sw_hi) / sw_lo).hi + m0 = Fr(0) if mu['w'].lo <= 0 <= mu['w'].hi else min(abs(mu['w'].lo), abs(mu['w'].hi)) + p0 = (phi_pt(m0 / sw_hi) / sw_lo).hi + Lp = Fr(24198, 100000) / (sw_lo * sw_lo) + # ---- normalizer floor Z_r / (36 k^2 r^2) >= El2 - corr + m_lam = -mu['w'] + El2 = elam2_pos(m_lam.lo, sw_lo).lo + Elp = elam_pos(m_lam.hi, sw_hi).hi + lam_n = lambda p: muw_abs + sw_hi * znorm(pow2(p)) + sdT, sdtau = law.sdQ['T'].hi, law.sdQ['tau'].hi + q_bad = gauss_tail2(mabs['T'], sdT, 3 * klo / (2 * r1)) + gauss_tail2(mabs['tau'], sdtau, 3 * klo / (2 * r1 * r1)) + Eom_g = mabs['om'] + law.sdg['om'].hi * Fr(4, 5) + Evg2 = mabs['v'] ** 2 + law.sdg['v'].hi ** 2 + E_om_lam = Eom_g * Elp + bw['om'] * (muw_abs * lam_n(1) + lam_n(2) ** 2) + E_v2_lam = 2 * Evg2 * Elp + 2 * bw['v'] ** 2 * (sw_hi * znorm(4)) ** 2 * lam_n(2) + corr = (lam_n(4) ** 2 * iroot(q_bad, 2) if q_bad > 0 else Fr(0)) \ + + (2 * r1 * gauss_norm(mabs['T'], sdT, 2) + r1 * r1 * gauss_norm(mabs['tau'], sdtau, 2)) * lam_n(4) ** 2 / six_klo \ + + r1 * (E_v2_lam / (3 * klo) + E_om_lam) + if MUT == 'no-zfloor-correction': + corr = Fr(0) + zt = El2 - corr + require(zt > 0, 'normalizer floor not positive') + main = min(pbar * (termA + termB + termC), p0 * (termA + termB + termC) + r1 * Lp * (termAp + termBp + termCp)) / zt + # ---- rare branches at the band top: E[W 1_E] <= ||W 1_typed||_q P(E)^(1 - 1/q) (Hoelder), ||W 1_typed||_q / r^2 <= g1 g2, + # for each q in QS; the smallest resulting bound is used + six_khi = 6 * khi + + def wnorm(q): + p4 = 4 * q + nTQ = gauss_norm(mabs['T'], sdT, p4) + ntauQ = gauss_norm(mabs['tau'], sdtau, p4) + g1 = (six_khi + r1 * nTQ) * lam_n(p4) + g2 = (six_khi + r1 * nTQ + r1 * r1 * ntauQ) * (lam_n(p4) + r1 * gauss_norm(mabs['om'], law.sdQ['om'].hi, p4)) \ + + r1 * (r1 * gauss_norm(mabs['nu'], law.sdQ['nu'].hi, p4) + gauss_norm(mabs['v'], law.sdQ['v'].hi, p4)) ** 2 + return g1 * g2 + thr = 3 * klo / (10 * r1) + qA2 = Fr(0) + args = [] + for n in JET4: + args.append((thr * Fr(7, 8) - mabs[n]) / law.sdQ[n].hi) + qA2 += gauss_tail2(mabs[n], law.sdQ[n].hi, thr * Fr(7, 8)) + qA2 += (law.S[n] * (sqE + znorm(32)) / (thr / 8)) ** 32 + a_hi = Fr(4, 3) / klo * a_fac + qfar = Fr(0) + qx = Fr(0) + if bbar > 0: + lam_far = 1 / (4 * a_hi * r1 * bbar * bbar) + args.append((lam_far - muw_abs) / sw_hi) + qfar = gauss_tail1(muw_abs, sw_hi, lam_far) + for i in (1, 2, 3, 4): # x_i > X0 <=> y_i' > X0 / (a r1 beta_i) + if bbars[i] == 0: + continue + tx = x0 / (a_hi * r1 * bbars[i]) + if i == 1: + cb = 12 * khi + bbars[1] * muw_abs + qx += Fr(1) if tx <= cb else (r1 * nDelta(1, 32) / (tx - cb)) ** 32 + else: + s_i = {2: s2, 3: s3, 4: s4}[i] + args.append(tx / (2 * s_i)) + qx += gauss_tail2(0, s_i, tx / 2) + (nd(i, 32) * Klo / (tx / 2)) ** 32 + qs = [min(Fr(1), x) for x in (qA2, qfar, qx)] + tail_num = min(wnorm(q) * sum(pow_tail(x, q) for x in qs) for q in QS) + if last_band: + # (0, R] is the union of [R 2^-(j+1), R 2^-j]; every Gaussian tail argument scales at least like 1/r and is >= 3 at R, + # so each Gaussian piece drops by more than 64 when r halves; every Markov piece is a power r^m with m >= 32; after the + # power 1 - 1/q (q >= 2) each piece still drops by more than 8, so for the q chosen at R the supremum of tail / r^3 + # over (0, R] is attained on [R/2, R] + require(min(args) >= 3, 'last-band tail arguments') + # no piece is capped at 1, so the factor-64 decrease of every piece per halving carries over to each sum + require(max(qA2, qfar, qx) < 1, 'last-band tail pieces') + rdiv = r1 / 2 + else: + rdiv = r0 + tail = tail_num / (36 * klo * klo * zt * rdiv ** 3) + total = main + tail + return {'total': total, 'main': main, 'tail': tail, 'zt': zt, 'pbar': pbar, 'termA': termA, 'termB': termB, + 'termC': termC, 'qA2': qA2, 'qfar': qfar, 'qx': qx, 'El2': El2, 'corr': corr, 'min_arg': min(args)} + + +def pow_tail(x, q): + """Upper bound of x^(1 - 1/q) for 0 <= x <= 1 (q a power of two).""" + if x <= 0: + return Fr(0) + return iroot(rup_rel(x, 64) ** (q - 1), q) + + +def phibar_upper(x): + """Rational upper bound of 1 - Phi(x) for rational x >= 0: the series value for x <= 12, and for x > 12 the Mills bound + phi(x)/x with exp(-y) <= m!/y^m (m = 40), which stays exact far below the 2^-160 rounding floor.""" + x = Fr(x) + if x <= 12: + return Phibar_pt(x).hi + y = x * x / 2 + m = 40 + return Fr(math.factorial(m)) / y ** m / (x * Fr(5, 2)) # sqrt(2 pi) > 5/2 + + +def gauss_tail2(mu_abs, sd, t): + """Upper bound of P(|X| > t) for X Gaussian with |mean| <= mu_abs, sd <= sd.""" + if t <= mu_abs: + return Fr(1) + return min(Fr(1), 2 * phibar_upper((t - mu_abs) / sd)) + + +def gauss_tail1(mu_abs, sd, t): + if t <= mu_abs: + return Fr(1) + return min(Fr(1), phibar_upper((t - mu_abs) / sd)) + + +# ----------------------------------------------------------------------------- bands, boxes, runs +B_BOXES = ((Fr(0), Fr(1, 64)), (Fr(1, 64), Fr(1, 16)), (Fr(1, 16), Fr(1, 4)), (Fr(1, 4), Fr(1))) +K_BOXES = ((Fr(1, 2), Fr(1)), (Fr(1), Fr(3, 2)), (Fr(3, 2), Fr(7, 4)), (Fr(7, 4), Fr(15, 8)), (Fr(15, 8), Fr(31, 16)), + (Fr(31, 16), Fr(63, 32)), (Fr(63, 32), Fr(2))) +HIGH_OCTAVES = 3 # octaves [2^-(j+1), 2^-j], j = 6..8 (r up to 1/64), split into 8 sub-bands +TOP_OCTAVES = 4 # octaves j = 9..12, split into 16 sub-bands +LOW_OCTAVES = 16 # octaves j = 13..28, split into 4 sub-bands +R_LAST = Fr(1, 2 ** 29) # last band [0, 2^-29] + + +def bands(): + """Sub-bands [r0, r1] covering (0, 1/64]; each octave split into equal sub-bands; the last band is [0, R_LAST].""" + out = [] + for j in range(6, 9 + TOP_OCTAVES + LOW_OCTAVES): + hi = Fr(1, 2 ** j) + lo = hi / 2 + m = 8 if j < 9 else (16 if j < 9 + TOP_OCTAVES else 4) + for i in range(m): + out.append((lo + (hi - lo) * i / m, lo + (hi - lo) * (i + 1) / m)) + out.append((Fr(0), R_LAST)) + require(min(b[0] for b in out) == 0 and max(b[1] for b in out) == Fr(1, 64), 'band cover') + return sorted(out) + + +def up(x, digits=6): + """Decimal string of a rational rounded UP to `digits` significant digits (as a string float).""" + x = Fr(x) + if x <= 0: + return '0' + e = len(str(x.numerator // x.denominator)) if x >= 1 else -len(str(x.denominator // x.numerator)) + scale = Fr(10) ** (digits - e) + n = -((-x.numerator * scale.numerator) // (x.denominator * scale.denominator)) + return str(Fr(n) / scale) if scale.denominator == 1 else '%s' % (Fr(n) / scale) + + +def dec_down(x, places=4): + x = Fr(x) + n = (x.numerator * 10 ** places) // x.denominator + s = str(abs(n)).rjust(places + 1, '0') + return ('-' if n < 0 else '') + s[:-places] + '.' + s[-places:] + + +def dec_up(x, places=4): + x = Fr(x) + n = -((-x.numerator * 10 ** places) // x.denominator) + s = str(abs(n)).rjust(places + 1, '0') + return ('-' if n < 0 else '') + s[:-places] + '.' + s[-places:] + + +BOXES = tuple((bb, kb) for bb in B_BOXES for kb in K_BOXES) # the order of the per-box lists in a band record +# (x0, theta) choices; each gives a valid bound and the record keeps the smaller one +COMBOS = ((Fr(1, 64), Fr(1, 32)), (Fr(1, 1024), Fr(1, 256))) +# the fixed-axis SIDE24 point of [CAP] section 1 (b = 6/5, kappa = 1/6), a single (b, k) point outside the band +SIDE24_B, SIDE24_K = (Fr(6, 5), Fr(6, 5)), (Fr(1, 6), Fr(1, 6)) +CG_02_LO, CG_SIDE24_LO = Fr('5324360.4426'), Fr('35736.7352') # certified lower ends of c_G at (0, 2), (6/5, 1/6) ([G]) + + +def best_box(law, bb, kb, r0, r1, last): + best = None + for x0, theta in COMBOS: + res = box_bound(law, bb, kb, r0, r1, last_band=last, x0=x0, theta=theta) + if best is None or res['total'] < best['total']: + best = res + return best + + +def band_record(args): + """Per band: the certified bound of sup Q^W(G_r^c)/r^3 (rounded up, 4 places) and the floor of Z_r/r^2 (rounded down, + 6 places) for each of the 28 boxes in BOXES order, the largest tail part (rounded up, 12 places), and the same two + numbers at the SIDE24 point.""" + r0, r1 = args + law = band_law(r0, r1) + last = (r0 == 0) + bound, zfloor, tails = [], [], [] + for bb, kb in BOXES: + res = best_box(law, bb, kb, r0, r1, last) + bound.append(dec_up(res['total'])) + zfloor.append(dec_down(36 * kb[0] * kb[0] * res['zt'], 6)) + tails.append(res['tail']) + s24 = best_box(law, SIDE24_B, SIDE24_K, r0, r1, last) + return {'r': [str(r0), str(r1)], 'bound': bound, 'zfloor': zfloor, 'tail_max': dec_up(max(tails), 12), + 'side24': [dec_up(s24['total']), dec_down(36 * SIDE24_K[0] ** 2 * s24['zt'], 6)]} + + +def full_run(procs): + bl = bands() + with multiprocessing.Pool(procs) as pool: + recs = pool.map(band_record, bl) + return assemble(recs) + + +def assemble(recs): + table = {} + for rs in R_STARS: + mx, arg, zmin = Fr(0), None, None + for rec in recs: + if Fr(rec['r'][1]) <= rs: + for (bb, kb), bs, zs in zip(BOXES, rec['bound'], rec['zfloor']): + v = Fr(bs) + if v > mx: + mx, arg = v, {'r': rec['r'], 'b': [str(bb[0]), str(bb[1])], 'k': [str(kb[0]), str(kb[1])]} + z = Fr(zs) + zmin = z if zmin is None or z < zmin else zmin + table[str(rs)] = {'C': str(mx), 'argmax': arg, 'C_over_cG02': dec_up(mx / CG_02_LO, 6), + 'C_rstar3': dec_up(mx * rs ** 3, 10), 'z_star': str(zmin)} + side = {} + for rs in R_STARS: + rows = [rec for rec in recs if Fr(rec['r'][1]) <= rs] + mx = max(Fr(rec['side24'][0]) for rec in rows) + arg = [rec['r'] for rec in rows if Fr(rec['side24'][0]) == mx][0] + zmin = min(Fr(rec['side24'][1]) for rec in rows) + side[str(rs)] = {'C': str(mx), 'argmax_r': arg, 'C_over_cG': dec_up(mx / CG_SIDE24_LO, 6), + 'C_rstar3': dec_up(mx * rs ** 3, 10), 'z_star': str(zmin)} + return {'schema': 1, 'object': 'CL-C8-THEOREM-A-CONSTANTS-PLANAR-20260930-v1', 'scientific_effect': 'NONE', + 'certified': True, 'mutant': MUT, 'L_min': L_MIN, + 'band': {'b': [str(BAND_B[0]), str(BAND_B[1])], 'k': [str(BAND_K[0]), str(BAND_K[1])]}, + 'side24_point': {'b': str(SIDE24_B[0]), 'k': str(SIDE24_K[0])}, + 'parameters': params(), 'C_table': table, 'C_table_side24': side, 'bands': recs} + + +def params(): + return {'PBITS': PBITS, 'NX': NX, 'NB': NB, 'COMBOS_X0_THETA': [[str(a), str(b)] for a, b in COMBOS], 'THETA_E': str(THETA_E), 'QS': list(QS), + 'R_STARS': [str(x) for x in R_STARS], 'HIGH_OCTAVES': HIGH_OCTAVES, 'TOP_OCTAVES': TOP_OCTAVES, + 'LOW_OCTAVES': LOW_OCTAVES, 'R_LAST': str(R_LAST), + 'B_BOXES': [[str(a), str(b)] for a, b in B_BOXES], 'K_BOXES': [[str(a), str(b)] for a, b in K_BOXES]} + + +def results_text(res): + """RESULTS.json layout: the summary indented, then one line per band record.""" + head = json.dumps({key: val for key, val in res.items() if key != 'bands'}, indent=1, sort_keys=True) + lines = ',\n'.join(' ' + json.dumps(rec, sort_keys=True) for rec in res['bands']) + return head[:-2] + ',\n "bands": [\n' + lines + '\n ]\n}\n' + + +def write_results(res): + with open(os.path.join(HERE, 'RESULTS.json'), 'w') as fh: + fh.write(results_text(res)) + + +def load_results(): + with open(os.path.join(HERE, 'RESULTS.json')) as fh: + return json.load(fh) + + +def replay_sample(): + """Band indices replayed by --check: the band ending at each r_*, the bands ending at 2^-14, 2^-20, 2^-26, the last band.""" + bl = bands() + idx = [] + for rs in R_STARS: + j = max(i for i, b in enumerate(bl) if b[1] == rs) + idx.append(j) + idx += [i for i, b in enumerate(bl) if b[1] in (Fr(1, 2 ** 14), Fr(1, 2 ** 20), Fr(1, 2 ** 26))] + idx.append(0) + return sorted(set(idx)) + + +def check_run(procs, full=False): + ref = load_results() + with open(os.path.join(HERE, 'RESULTS.json')) as fh: + require(fh.read() == results_text(ref), 'RESULTS.json is not in the canonical layout') + require(ref['parameters'] == params(), 'parameters differ from RESULTS.json') + require(ref['mutant'] is None, 'RESULTS.json produced under a mutant') + require(abs(PI.mid() - Fr('3.14159265358979323846')) < Fr(1, 10 ** 19) and PI.width() < Fr(1, 10 ** 30), 'pi enclosure') + require(abs(Phi(IV(1)).mid() - Fr('0.841344746068542948585')) < Fr(1, 10 ** 19), 'Phi(1) enclosure') + bl = bands() + require([rec['r'] for rec in ref['bands']] == [[str(a), str(b)] for a, b in bl], 'band list differs') + idx = list(range(len(bl))) if full else replay_sample() + with multiprocessing.Pool(procs) as pool: + recs = pool.map(band_record, [bl[i] for i in idx]) + for i, rec in zip(idx, recs): + require(rec == ref['bands'][i], 'band %d (%s) differs from RESULTS.json' % (i, rec['r'])) + # the table is the maximum over the stored records + asm = assemble(ref['bands']) + require(asm['C_table'] == ref['C_table'] and asm['C_table_side24'] == ref['C_table_side24'], + 'C tables are not the maxima of the stored bounds') + # sanity: every C exceeds the sharp reference-kernel cap coefficient c_G(0, 2) of Math-#203 (a lower bound for every + # cap-route constant valid for all L >= 10, since c_G^{L,R} -> c_G^{ref} as L -> infinity) + for rs, row in ref['C_table'].items(): + require(Fr(row['C']) > CG_02_LO, 'C below the sharp cap coefficient') + for rs, row in ref['C_table_side24'].items(): + require(Fr(row['C']) > CG_SIDE24_LO, 'SIDE24 C below the sharp cap coefficient') + print(json.dumps({'check': 'ok', 'bands_replayed': len(idx), 'C_table': {rs: row['C'] for rs, row in ref['C_table'].items()}, + 'C_table_side24': {rs: row['C'] for rs, row in ref['C_table_side24'].items()}, 'mutant': MUT})) + + +def main(): + global MUT + ap = argparse.ArgumentParser() + ap.add_argument('--check', action='store_true') + ap.add_argument('--check-full', action='store_true') + ap.add_argument('--mutant', choices=MUTANTS) + ap.add_argument('--procs', type=int, default=4) + ap.add_argument('--mc', nargs=5, metavar=('R', 'B', 'K', 'N', 'SEED'), help='floating end-to-end control') + args = ap.parse_args() + MUT = args.mutant + if args.mc: + rr, bb, kk, nn, sd = args.mc + print(json.dumps(mc_event(float(Fr(rr)), float(Fr(bb)), float(Fr(kk)), int(nn), int(sd)))) + return + if args.check or args.check_full: + check_run(args.procs, full=args.check_full) + return + res = full_run(args.procs) + write_results(res) + print(json.dumps({'band': {rs: row['C'] for rs, row in res['C_table'].items()}, + 'side24': {rs: row['C'] for rs, row in res['C_table_side24'].items()}})) + + + +# ----------------------------------------------------------------------------- floating control (not part of the certificate) +def mc_event(r, b, k, n, seed, deg=8, grid=9): + """End-to-end Monte Carlo of Q^W(G_r^c) / r^3 and Z_r / r^2 for the reference kernel (floating point): the Taylor jet of + order deg at the midpoint is sampled under Q, the field near D is rebuilt from it, W_r and G_r (M_3, M_4 on a grid of D) + are evaluated directly from the definitions.""" + import random + pins, _ = functionals() + P = [pins[nm] for nm in PIN_NAMES] + jets = [(i, m - i) for m in range(deg + 1) for i in range(m, -1, -1)] + J = [[term(1, 0, a, bb, X0PT)] for (a, bb) in jets] + + def ev(F, G, key): + ser, w, _ = pair_series(F, G, key) + return sum(float(c) * r ** p for p, c in ser.items()) + Spp = [[ev(P[i], P[j], ('p', i, j)) for j in range(6)] for i in range(6)] + Sjp = [[ev(J[i], P[j], ('jp', deg, i, j)) for j in range(6)] for i in range(len(J))] + Sjj = [[ev(J[i], J[j], ('jj', deg, i, j)) for j in range(len(J))] for i in range(len(J))] + + def solve(A, bv): + m = len(A) + M = [A[i][:] + [bv[i]] for i in range(m)] + for c in range(m): + p = max(range(c, m), key=lambda i: abs(M[i][c])) + M[c], M[p] = M[p], M[c] + for i in range(c + 1, m): + f = M[i][c] / M[c][c] + for j in range(c, m + 1): + M[i][j] -= f * M[c][j] + x = [0.0] * m + for i in reversed(range(m)): + x[i] = (M[i][m] - sum(M[i][j] * x[j] for j in range(i + 1, m))) / M[i][i] + return x + vr = [b - k * r ** 3 / 2, -k * r * r, 12 * k, 0, 0, 0] + Wt = [solve(Spp, Sjp[i]) for i in range(len(J))] + mu = [sum(Wt[i][j] * vr[j] for j in range(6)) for i in range(len(J))] + C = [[Sjj[i][j] - sum(Wt[i][l] * Sjp[j][l] for l in range(6)) for j in range(len(J))] for i in range(len(J))] + # symmetric square root (Jacobi) + m = len(J) + A = [row[:] for row in C] + V = [[float(i == j) for j in range(m)] for i in range(m)] + for _ in range(100): + off = sum(A[p][q] ** 2 for p in range(m) for q in range(p + 1, m)) + if off < 1e-26: + break + for p in range(m - 1): + for q in range(p + 1, m): + if abs(A[p][q]) < 1e-300: + continue + th = 0.5 * math.atan2(2 * A[p][q], A[q][q] - A[p][p]) + c, s = math.cos(th), math.sin(th) + for kk in range(m): + akp, akq = A[kk][p], A[kk][q] + A[kk][p], A[kk][q] = c * akp - s * akq, s * akp + c * akq + for kk in range(m): + apk, aqk = A[p][kk], A[q][kk] + A[p][kk], A[q][kk] = c * apk - s * aqk, s * apk + c * aqk + for kk in range(m): + vkp, vkq = V[kk][p], V[kk][q] + V[kk][p], V[kk][q] = c * vkp - s * vkq, s * vkp + c * vkq + lam = [max(A[i][i], 0.0) for i in range(m)] + S = [[sum(V[i][kk] * math.sqrt(lam[kk]) * V[j][kk] for kk in range(m)) for j in range(m)] for i in range(m)] + fact = [math.factorial(i) for i in range(deg + 2)] + pts = [(-2 * r + 4 * r * i / (grid - 1), -2 * r + 4 * r * j / (grid - 1)) for i in range(grid) for j in range(grid)] + + def deriv(cf, a0, b0, x, y): + tot = 0.0 + for idx, (a, bb) in enumerate(jets): + if a >= a0 and bb >= b0: + tot += cf[idx] * x ** (a - a0) * y ** (bb - b0) / (fact[a - a0] * fact[bb - b0]) + return tot + rng = random.Random(seed) + num = den = 0.0 + acap = 4 / (3 * k) + for _ in range(n): + z = [rng.gauss(0, 1) for _ in jets] + cf = [mu[i] + sum(S[i][j] * z[j] for j in range(m)) for i in range(m)] + hM = [deriv(cf, 2, 0, -r / 2, 0.0), deriv(cf, 1, 1, -r / 2, 0.0), deriv(cf, 0, 2, -r / 2, 0.0)] + hS = [deriv(cf, 2, 0, r / 2, 0.0), deriv(cf, 1, 1, r / 2, 0.0), deriv(cf, 0, 2, r / 2, 0.0)] + dM = hM[0] * hM[2] - hM[1] ** 2 + dS = hS[0] * hS[2] - hS[1] ** 2 + if not (hM[0] < 0 and dM > 0 and dS < 0): + continue + Wv = abs(dM * dS) + den += Wv + lamv = -hM[2] + M3 = max(abs(deriv(cf, a, 3 - a, x, y)) for (x, y) in pts for a in range(4)) + M4 = max(abs(deriv(cf, a, 4 - a, x, y)) for (x, y) in pts for a in range(5)) + if not (lamv > acap * r * M3 * M3 and r * M4 <= 3 * k / 10): + num += Wv + return {'r': r, 'b': b, 'k': k, 'n': n, 'seed': seed, 'QW_Gc_over_r3': num / den / r ** 3, 'Z_over_r2': den / n / r ** 2} + + +if __name__ == '__main__': + main()