From 280574c84e73bd5da5744fffea9321b3af20a29c Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Thu, 1 Oct 2026 03:21:36 +0000 Subject: [PATCH 1/4] C8: explicit cap-route constants for Theorem A in d = 3 (certified C3, z3 on the band; scientific effect NONE) Theorem E3: for the d = 3 eight-pin law of [LP] and the good event G_r of [LP] section 7 / [CAP] (1) (partial-block operator norms on D = [-2r, 2r] x ball(0, 2r)), on 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) <= C3(r_*) r^3 and Z_r / r^2 >= z3(r_*) for 0 < r <= r_*. - C3(1/4096) = 22754801.7964 (1.0148 c_G^(3)(0, 2) of Math-#208), C3(1/1024) = 22974134.2920, C3(1/512) = 23332922.4752 (C3 r_*^3 <= 0.174); z3(1/512) = 5.859005; three further certified, uninformative pairs. - With [LP] section 8 these are explicit pairs (C, r_*) for [LP] Theorem A (1.1) in d = 3. Every C3 is a cap-route constant. - Proof follows Math-#206 section by section: exact 3D covariance series with a polydisc torus bound; regression on the transverse Hessian; eigenvalue-coordinate main term with an angle-free density majorant; floor through closed-form contact moments and a Loewner coupling; angular nets for the fourth-derivative blocks. - Certificate theorem_a3.py (standard library, exact rational intervals): 121 bands x 39 boxes; --check, --check-full, five mutants; workflow c8-theorem-a-constants-d3.yml. No STATUS, PROOF_INDEX, GRAPH or catalog edit; C8 stays OPEN. The author will not merge. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../workflows/c8-theorem-a-constants-d3.yml | 67 + .../NOTE.md | 533 +++++ .../README.md | 47 + .../RESULTS.json | 445 +++++ .../SOURCE_FILES.json | 40 + .../SOURCE_MAP.json | 85 + .../theorem_a3.py | 1709 +++++++++++++++++ 7 files changed, 2926 insertions(+) create mode 100644 .github/workflows/c8-theorem-a-constants-d3.yml create mode 100644 frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md create mode 100644 frontiers/c8_theorem_a_constants_d3_20261001/README.md create mode 100644 frontiers/c8_theorem_a_constants_d3_20261001/RESULTS.json create mode 100644 frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json create mode 100644 frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_MAP.json create mode 100644 frontiers/c8_theorem_a_constants_d3_20261001/theorem_a3.py diff --git a/.github/workflows/c8-theorem-a-constants-d3.yml b/.github/workflows/c8-theorem-a-constants-d3.yml new file mode 100644 index 00000000..d96347b7 --- /dev/null +++ b/.github/workflows/c8-theorem-a-constants-d3.yml @@ -0,0 +1,67 @@ +name: C8 Theorem A constants in d = 3 (certified replay) + +'on': + pull_request: + paths: + - 'frontiers/c8_theorem_a_constants_d3_20261001/**' + - '.github/workflows/c8-theorem-a-constants-d3.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, os, pathlib, subprocess, sys + root = pathlib.Path('frontiers/c8_theorem_a_constants_d3_20261001').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_a3.py') + procs = str(max(2, os.cpu_count() or 2)) + # every one of the 121 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', procs], cwd=root, capture_output=True, timeout=5400) + 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()[-600:]) + for m in ('no-delta', 'cap-half', 'no-zfloor-correction', 'no-om-term', 'no-lambda2'): + rc = subprocess.run([sys.executable, '-B', '-S', script, '--check', '--procs', procs, '--mutant', m], cwd=root, capture_output=True, timeout=2400).returncode + if rc != 1: + raise RuntimeError('mutant ' + m + ' not rejected') + print(json.dumps({'scientific_effect': 'NONE', 'bands_replayed': 121, 'mutants_rejected': 5})) + PY + git diff --exit-code diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md b/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md new file mode 100644 index 00000000..e22b13df --- /dev/null +++ b/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md @@ -0,0 +1,533 @@ +# Explicit cap-route constants for Theorem A in dimension three: `Q^W(G_r^c) <= C3 r^3` with certified `C3` + +**Object:** `CL-C8-THEOREM-A-CONSTANTS-D3-20261001-v1`. **Author lane:** Anthropic / Claude. +**Kind:** author-side theorem (Theorem E3), 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 = 3`: +- on the band `B = [0, 1]`, `K = [1/2, 2]`, uniformly over frames and torus sides `L >= 10`, explicit cap-route pairs + `(C3, r_*)` for [LP] (7.8), and therefore for [LP] Theorem A (1.1); +- a normalizer floor `z3` on `(0, r_*]`. + +It is the three-dimensional counterpart of Math-#206 (the planar Theorem E). No STATUS, PROOF_INDEX, GRAPH or catalog edit. +Same GitHub account as every lane; zero organizational-independence credit. The author will not merge. Scope claim: Math-#208 +comment 5922961739. + +**Sources** (pins in `SOURCE_MAP.json`): +- [LP] `imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md`, sections 1, 3, 7 and 8 in `d = 3`: + - the model, the law `Q`, `W_r`, `Z_r`; + - the preconditioned pins (3.1) and their values (3.3), with `m = 2` transverse directions; + - 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 = [-2r, 2r] x ball(0, 2r)`, the + partial-block operator norms `M_3`, `M_4` (suprema over independently chosen transverse unit vectors) and condition (1). +- [G3] Math-#208 at `da48373`, read-only: Theorem G_d, the `d = 3` contact law (its Lemma 1) and the certified + `c_G^(3)(0, 2) >= 22424320.655069`, used for the lower-bound sanity check and the comparisons. +- [E] Math-#206 at `0cb8ad3`, read-only: the planar Theorem E, whose proof this packet follows section by section. + +Like [E], 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 with `d = 3`, `m = 2`; as in [G3] section 0): +- The torus `X = (R / L Z)^3` 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, index H_S = 2}`, + `Z_r = E_Q W_r`, and `dQ^W = (W_r / Z_r) dQ`. +- In frame coordinates `(x, y) in R x R^2`: the cylinder `D = [-2r, 2r] x ball(0, 2r)`, the partial-block norms + `M_j = max_{a + c = j} sup_D ||partial_x^a D_y^c f||_op` ([CAP] section 1), and the good event + `G_r = {lambda_1 > (4/(3k)) r M_3^2, r M_4 <= 3k/10}` with `lambda_1 = lambda_min(-D_y^2 f(M))`. +- 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 (Math-#203 v1.2, section 5, item 1). + +**Theorem E3.** Let `d = 3`, `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) <= C3(r_*) r^3 and Z_r / r^2 >= z3(r_*). + +The same holds for the reference kernel `exp(-|z|^2/2)` on `R^3`. Every enclosure below contains the case `M_1 = 0`, +`Theta = 1` of section 2. The table lists, for each `r_*`: +- `C3(r_*)`, an exact rational, with its decimal; +- upper bounds for `C3 / c_G^(3)(0, 2)` and `C3 r_*^3`, and the floor `z3(r_*)`; +- the cell (`r`-band; `b`; `k`) at which the maximum is attained. + +| `r_*` | `C3(r_*)` | `C3 / c_G^(3)(0,2) <=` | `C3 r_*^3 <=` | `z3(r_*)` | maximizing cell | +|---|---|---|---|---|---| +| `1/4096` | `56887004491/2500 = 22754801.7964` | `1.014738` | `0.0003311260` | `6.021091` | `[15/65536, 1/4096]`; `[0, 1/512]`; `[63/32, 2]` | +| `1/2048` | `57060167561/2500 = 22824067.0244` | `1.017827` | `0.0026570712` | `5.998005` | `[15/32768, 1/2048]`; `[0, 1/512]`; `[63/32, 2]` | +| `1/1024` | `5743533573/250 = 22974134.2920` | `1.024519` | `0.0213963299` | `5.951763` | `[15/16384, 1/1024]`; `[0, 1/512]`; `[63/32, 2]` | +| `1/512` | `14583076547/625 = 23332922.4752` | `1.040519` | `0.1738438195` | `5.859005` | `[15/8192, 1/512]`; `[439/1024, 421/512]`; `[31/16, 63/32]` | +| `1/256` | `3714819319587/625 = 5943710911.3392` | `265.06` | `354.3` | `5.672384` | `[7/2048, 15/4096]`; `[0, 1/2]`; `[1/2, 3/4]` | +| `1/128` | `69971360017.7629` | `3120.3` | `33365` | `5.294648` | `[15/2048, 1/128]`; `[1/2, 1]`; `[1/2, 3/4]` | +| `1/64` | `17254355056897.0472` | `769448` | `6.6 x 10^7` | `4.520628` | `[15/1024, 1/64]`; `[1/2, 1]`; `[1/2, 3/4]` | + +`c_G^(3)(0, 2)` is replaced by its certified lower end `22424320.655069` ([G3]). + +**Corollary (explicit Theorem A in `d = 3` on the band).** +- **Explicit pairs.** Since `0 <= 1 - p_r <= Q^W(G_r^c)` ([LP] §8), [LP] (1.1) holds in `d = 3` on `B x K`, uniformly over frames + and `L >= 10`, with every pair `(C3(r_*), r_*)` of the table. The pairs that are informative at `r = r_*` (`C3 r_*^3 < 1`) + are exactly those with `r_* <= 1/512`. Examples: + - `(C, r_*) = (23332922.4752, 1/512)`, where the bound at `r = r_*` is below `0.174`; + - `(22974134.2920, 1/1024)`, where it is below `0.0214`. +- **What was missing.** [LP] §16 lists "a numerical `r_*` or `C` on a prescribed band" among the items it does not supply. + [CAP]'s probabilistic corollary is planar only ("No 3D eight-pin matrix-boundary estimate ... is proved here"). Before + this packet no explicit constant was on record in any dimension `d >= 3`. +- **Near-optimal for the cap route.** + - Every `d = 3` cap-route constant valid for the reference kernel at `(b, k) = (0, 2)` is at least + `c_G^(3)(0, 2) > 22424320.65` ([G3] Corollary 1). + - This certificate's scope includes the reference kernel. + - The constants are within `1.5%`–`4.1%` of that limit for `r_* <= 1/512`. + - The cap route in `d = 3` can be informative only below `r = c_G^(3)(0, 2)^(-1/3) = 3.546 x 10^-3`, so `r_* = 1/256` + (`C3 r_*^3 >= c_G^(3) r_*^3 = 1.34`) is uninformative for every cap-route constant. At `1/256` and above, the certified + constants are dominated by the rare branches at `k near 1/2`. +- **Against the plane.** + - `C3(r_*)/C(r_*)` is `4.249` at `r_* = 1/4096` and `4.308` at `1/512` ([E] Theorem E). + - The sharp ratio is `c_G^(3)(0, 2)/c_G(0, 2) = R_3(0) = (32 + 28 sqrt2)/17 = 4.2116` ([G3]). +- **Normalizer floor.** `z3(r_*)` is an explicit `z_*` for [LP] (5.5) in `d = 3` on `(0, r_*]`. + - The contact value at the band's weakest corner `(b, k) = (0, 1/2)` is `36 k^2 m_(3,0) = 9 (7 - 4 sqrt2)/2 = 6.0442`. + - `z3(1/4096) = 6.0211` lies within `0.4%` of it; the last band `[0, 2^-29]` gives `6.044155`. + - `Z_r / r^2 >= 4.5206` on all of `(0, 1/64]`. + +## 1. Coordinates and exact identities + +In frame coordinates `(x, y) = (x, y_1, y_2)`, `M = (-h, 0, 0)` and `S = (h, 0, 0)` with `h = r/2`; the midpoint is `0`. + +**Pins.** The eight preconditioned pins are those 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]`; +- for `j = 1, 2`: `V_j0 = (f_yj(M) + f_yj(S))/2` and `V_j1 = (f_yj(S) - f_yj(M))/r`. + +Under `Q` their values are exactly `(b - k r^3/2, -k r^2, 0, 12k, 0, 0, 0, 0)` ([LP] (3.3)). + +**Targets.** The 31 targets are: + + A_ij = f_yiyj(M) (3; B = -A is the transverse Hessian of [LP] section 7), + v_j = f_xyj(M)/r + (f_yj(M) - f_yj(S))/r^2 (2), + O_ij = (f_yiyj(S) - f_yiyj(M))/r (3; the matrix Omega'), + Y_ijk = f_yiyjyk(0) (4), + T, tau as in [E] section 1 (2), + nu_j = (f_xyj(M) + f_xyj(S))/r^2 + 2 (f_yj(M) - f_yj(S))/r^3 (2), + X_alpha = partial^alpha f(0), |alpha| = 4 (15). + +Each is a sum of terms `c r^p partial_x^a partial_y1^e1 partial_y2^e2 f(x_0 r, 0, 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, grad_y f_x(M) = r v, grad_y f_x(S) = r (r nu - v), + D_y^2 f(S) = -B + r Omega'. (I1) + +Write `c1 = 6k - rT`, `c2 = 6k + rT + r^2 tau`, `e = r nu - v` (a vector) and `B_S = B - r Omega'`. The Hessians are +`H_M = [[-r c1, r v^T], [r v, -B]]` and `H_S = [[r c2, r e^T], [r e, -B_S]]`, and Schur complements give + + det H_M = -r P1, P1 = c1 det B - r v^T adj(B) v, + det H_S = r P2, P2 = c2 det B_S + r e^T adj(B_S) e. (I2) + +(For `2 x 2` matrices `det(-B) = det B` and `det(B) B^-1 = adj B`.) + +**The typed support.** `H_M < 0` holds exactly when `B > 0` and `c1 > r v^T B^-1 v`; then `c1 > 0` and `P1 > 0`. Index two +for `H_S` forces `det H_S > 0`, so `P2 > 0`. Hence, in every case, + + W_r <= r^2 P1 P2 1{B > 0, P1 > 0, P2 > 0}. (I3) + +Unlike the plane, (I3) is only an inequality: `det H_S > 0` also allows index zero. Conversely, `B > 0`, `B_S > 0`, +`c1 > r v^T B^-1 v` and `c2 > 0` imply the typed event with `W_r = r^2 P1 P2` (section 6). + +## 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_1) h(g_2) pi_gamma r^(g_x - w), gamma = (g_x, g_1, g_2). + +- `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' + e1' + e2') (x_0 - x_0')^m / m!` over pairs of terms with + `g_1 = e1 + e1'`, `g_2 = e2 + e2'` and `m = g_x - a - a' >= 0`. +- **Regularity:** `pi_gamma = 0` for every `g_x < w`. This is checked exactly for all 780 unordered pairs of the 39 functionals, + so no negative power of `r` occurs. + +**(b) Truncation at `g_x <= NX = 60`.** As in [E] section 2(b), with `|h(g_y)|` replaced by `|h(g_1) h(g_2)|`: for `r <= 1/64` +the terms with `g_x > 60` of one pair sum to at most `2 |c c'| |h(g_1) h(g_2)| 61^A r^(61 - w)`, `A = a + a'`. + +**(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)`, `p_n` in the rotated lattice `L R^T Z^3`, + and `Theta = 1 + sum_{n != 0} exp(-|p_n|^2/2)` in `[1, 1 + theta_1(L)]`. +- **Bound on `rho`.** `rho` is entire. On the complex polydisc `{|z_1|, |z_2|, |z_3| <= 1}`: + - `|exp(-(z + p).(z + p)/2)| <= e^(3/2) exp(-|Re z + p|^2/2)`, since `|Im z|^2 <= 3`; + - exactly `24 j^2 + 2` lattice points have sup-norm index `j`, each at distance `>= jL`; + - `|Re z| <= sqrt 3 < 7/4`. + + Hence `|rho| <= M_1(L) := e^(3/2) sum_{j >= 1} (24 j^2 + 2) exp(-(jL - 7/4)^2/2)`, independently of the frame. +- **Cauchy estimates** give `|partial^gamma rho(0)| <= g_x! g_1! g_2! M_1`, and the `rho`-part of a covariance is bounded by + `sum |c c'| g_1! g_2! max(w, 1)^A M_1 / (1 - e r)` exactly as in [E] section 2(c). +- **Values.** `M_1(10) < 1.94 x 10^-13` and `theta_1(10) < 5.1 x 10^-21`. Both decrease in `L`, so the enclosures computed at + `L = 10` hold for every `L >= 10`, every frame, and the reference kernel (`rho = 0`, `Theta = 1`). + +**(d) Regression on the pins.** Interval Gaussian elimination on the eight pins gives, uniformly over `r in [r_0, r_1]`: +- the `Q`-means `mu_F = b alpha_F + k beta_F` of the 31 targets; +- their `Q`-covariance, scaled by `Theta^-1 in [1/(1 + theta_1), 1]`; +- the pin energy `E = e_bb b^2 + 2 e_bk b k + e_kk k^2`, scaled by `Theta`. + +At contact (reference kernel) these reduce to the law of [G3] Lemma 1: +- `B ~ b I + GOE_2`; +- `v ~ N(0, I/2)`, `Omega' ~ GOE_2`; +- `Y` with independent entries of variances `6, 2, 2, 6`; +- all of them independent. + +The certificate's band laws reproduce this to `10^-9` on the last band. + +**(e) Regression on the transverse Hessian.** Use the Frobenius-isometric coordinates `b~ = (B_11, B_22, sqrt2 B_12)`, so that +`||b~ - b~'|| = ||B - B'||_F`, with `Q`-mean `mu~` and covariance `C~` (at contact `2 I`). +- For every other target, `beta~_F = Cov(F, b~) C~^-1` and `F_g = F - beta~_F . (b~ - mu~)`. Then `F_g` is independent of + `B` under `Q`, with the same mean and the covariance `C - Cov(., b~) C~^-1 Cov(b~, .)`. +- Gershgorin bounds give `lambda_min(C~) >= sigma_B^2` and `lambda_max(C~) <= sigma^2`, with `sigma` rational. +- By the `y_1`- and `y_2`-parities of the reference kernel, `beta~_v = beta~_Y = beta~_nu = 0` there; the certificate + carries their torus-sized enclosures. + +**(f) The free blocks.** In the coordinates `v`, `omega = (O_11, O_22, sqrt2 O_12)` and +`Y~ = (Y_111, sqrt3 Y_112, sqrt3 Y_122, Y_222)`, Euclidean norms are `||v||`, `||Omega'||_F` and `||Y||_F` (the Frobenius norm of +the symmetric 3-tensor). +- An interval Cholesky factor `L` of the `g`-covariance of these nine coordinates has blocks `L_vv`, `L_ov`, `L_oo`, `L_Yv`, + `L_Yo` and `L_YY`. +- Their operator norms are bounded by `max |diagonal|` plus the Frobenius norm of the strictly lower part (square blocks), + and by the Frobenius norm otherwise. +- At contact `L_vv = I/sqrt2`, `L_oo = sqrt2 I`, `L_YY = sqrt6 I`, and the off-diagonal blocks vanish. + +## 3. Third and fourth derivatives on `D` (Lemmas 2 and 3) + +Write `A_(a,c) = sup_D ||partial_x^a D_y^c f||_op` for `a + c = 4`, so that `M_4 = max A_(a,c)`. + +**Lemma 2 (averaging identities, blockwise).** 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_(4,0) + 2 A_(3,1), + ||grad_y f_xx(z)|| <= 2 ||v|| + r Delta_2, Delta_2 = (5/2) A_(3,1) + 2 A_(2,2), + ||D_y^2 f_x(z)||_op <= ||Omega'|| + r Delta_3, Delta_3 = (5/2) A_(2,2) + 2 A_(1,3), + ||D_y^3 f(z)||_op <= ||Y||_op + r Delta_4, Delta_4 = 2 A_(1,3) + 2 A_(0,4), + +so `M_3 <= max_i (B_i + r Delta_i)` with `B = (12k, 2||v||, ||Omega'||_op, ||Y||_op) <= (12k, 2||v||, ||omega||, ||Y~||)`. + +*Proof.* Let `g(t) = f(t, 0, 0)` and `q(t) = grad_y f(t, 0, 0)`. The four averages are: +- `U3 = integral K(t) g'''(t) dt` with the Peano kernel `K(t) = 3(h^2 - t^2)/(4h^3) >= 0`, `integral K = 1`, and `U3 = 12k`; +- `-2v = integral (2(h - t)/r^2) q''(t) dt` (each component; `q(+-h) = 0` by the pins), weights `>= 0` with total `1`; +- `Omega' = (1/r) integral D_y^2 f_x(t, 0, 0) dt`; +- `Y = D_y^3 f(0)`. + +The norm of an average is at most `sup_t` of the norm at `(t, 0, 0)`. Along the segment from `(t, 0, 0)` to `z`, the +derivative of `partial_x^a D_y^c f` is `(z_x - t) partial_x^(a+1) D_y^c f + D_y^(c+1) partial_x^a f [z_y, ...]`. Its operator +norm is at most `|z_x - t| A_(a+1,c) + ||z_y|| A_(a,c+1)`, for multilinear operator norms with independently chosen unit +vectors. Use `|z_x - t| <= 5r/2` and `||z_y|| <= 2r` (and `|z_x| <= 2r` for `Y`). The operator norm of a symmetric tensor is at +most its Frobenius norm (Cauchy-Schwarz). + +**Lemma 3 (fourth derivatives).** +- **Taylor bound.** The field is almost surely entire under `Q` ([E] Lemma 3). Hence, with `X_(a,c) = partial_x^a D_y^c f(0)`, + + A_(a,c) <= ||X_(a,c)||_F + T_(a,c), T_(a,c) = sum_{gamma != 0} ||partial_x^a D_y^c partial^gamma f(0)||_F (2r)^|gamma| / gamma!, + + where `||X||_F^2 = sum_beta (c!/beta!) X_beta^2` for a symmetric `c`-tensor in two variables. +- **Gaussian bounds.** For every `delta`, `s_delta^2 = prod_i (2 delta_i - 1)!! + (2 delta)! M_1` bounds the unconditioned + variance of `partial^delta f(0)`, and `|mean| <= s_delta sqrt(E)`. +- **Norm bound.** For a Gaussian vector, `|| ||X - EX|| ||_p <= sqrt(tr Cov) max(1, ||N(0,1)||_p)` (Minkowski in `L^(p/2)` on + the eigen-decomposition). Hence `||T_(a,c)||_p <= S_(a,c) (sqrt(E) + max(1, ||N||_p))` with + + S_(a,c)(r_1) = sum_{1 <= |gamma| <= 24} sigma_(a,c),gamma (2 r_1)^|gamma| / gamma! + (tail), + sigma_(a,c),gamma^2 = sum_beta (c!/beta!) s^2_(a + gamma_x, beta + gamma_y). + + The tail uses `s_delta <= 2^|delta| delta! sqrt(1 + M_1)`, `(alpha + gamma)!/gamma! <= (|gamma| + 4)^4` and + `(n + 1)(n + 2)/2` multi-indices of order `n`. It requires `4 r_1 <= 1/16`. +- **Dependence on `B`.** The regression coefficient of `partial^delta f(0)` on `b~` has norm at most `s_delta / sigma_B`. So + `A_(a,c) <= A^g_(a,c) + B_(a,c) ||B - mu_B||_F`, where + - `B_(a,c) = (sum_beta (c!/beta!) ||beta~_X(a,beta)||^2)^(1/2) + S_(a,c)/sigma_B`; + - `A^g_(a,c)` is the same bound for the `g`-field: same means, smaller variances. + +## 4. Regression on `B` and the failure set (Lemma 4) + +On the typed support `B > 0`. With `lambda_1 <= lambda_2` the eigenvalues of `B`, + + ||B - mu_B||_F <= ||B||_F + ||mu_B||_F <= lambda_1 + lambda_2 + ||mu_B||_F. + +**The `g`-measurable bound on `M_3`.** By Lemmas 2 and 3 and the regression, `M_3 <= max_i (y_i + bar-beta_i ||B - mu_B||_F)`, with + + y_1 = 12k + r Delta_1^g, y_2 = 2 ||v_g|| + r Delta_2^g, y_3 = ||omega_g|| + r Delta_3^g, y_4 = ||Y~_g|| + r Delta_4^g, + bar-beta_1 = r ((5/2) B_(4,0) + 2 B_(3,1)), + bar-beta_2 = 2 ||beta_v|| + r ((5/2) B_(3,1) + 2 B_(2,2)), + bar-beta_3 = ||beta_omega|| + r ((5/2) B_(2,2) + 2 B_(1,3)), + bar-beta_4 = ||beta_Y~|| + r (2 B_(1,3) + 2 B_(0,4)), + +where `||beta_v||^2 = sum_j ||beta~_vj||^2`, and similarly for `omega` and `Y~` with the Frobenius weights. + +**Lemma 4.** Put `y_i'' = y_i + bar-beta_i (||mu_B||_F + lambda_2)`, which is measurable in the `g`-variables and `lambda_2`. Put +`a = 4/(3k)` and `x_i = a r bar-beta_i y_i''`. If `lambda_1 <= a r M_3^2`, then for some `i`, +`lambda_1 <= a r (y_i'' + bar-beta_i lambda_1)^2`. For `x_i <= 1/4` the roots of this quadratic satisfy the bounds of [E] Lemma 4: + + lambda_-^(i) <= a r y_i''^2 / (1 - 3 x_i), lambda_+^(i) >= 1 / (4 a r bar-beta_i^2). + +**The cover.** With `X_0 = 1/64` and `kappa = 3/(1 - 3 X_0)`, on the typed support + + G_r^c subset N u F u X u A, + N = {lambda_1 <= r U, x_i <= X_0 for all i}, U = max_i a y_i''^2 (1 + kappa x_i), + F = {lambda_1 >= 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}. + +The threshold `U` is a function of the `g`-variables and of `lambda_2`. The `g`-variables are independent of `B`. The failure +window in `lambda_1` is `[0, r U]`. + +## 5. The main term + +**Eigenvalue coordinates.** Write `B = R_phi diag(lambda_1, lambda_2) R_phi^T` with `phi in [0, pi)`. Then +`dB_11 dB_22 dB_12 = (lambda_2 - lambda_1) d lambda_1 d lambda_2 d phi` (the Jacobian determinant is `-(lambda_2 - lambda_1)`). + +**An angle-free density majorant.** +- The density of `(B_11, B_22, B_12)` is `sqrt2` times that of `b~`, which is at most + `(2 pi)^(-3/2) det(C~)^(-1/2) exp(-||b~ - mu~||^2 / (2 sigma^2))`. +- Let `epsilon` be the supremum over the box of `||mu_B - b I||_F`. Since `||B - mu_B||_F >= ||B - b I||_F - epsilon`, we have + `||B - bI||_F^2 = (lambda_1 - b)^2 + (lambda_2 - b)^2` and `||B - bI||_F <= |lambda_1 - b| + |lambda_2 - b|`. +- Integrating over `phi` therefore bounds the joint density of `(lambda_1, lambda_2)` by + + p(lambda_1, lambda_2) <= K_B (lambda_2 - lambda_1) g(lambda_1) g(lambda_2), + K_B = pi sqrt2 (2 pi)^(-3/2) det(C~)^(-1/2), g(lambda) = exp(-(lambda - b)^2/(2 sigma^2) + epsilon |lambda - b| / sigma^2). + +- At contact (`epsilon = 0`, `C~ = 2I`) this is the exact `GOE_2` eigenvalue density + `(lambda_2 - lambda_1) exp(-((lambda_1 - b)^2 + (lambda_2 - b)^2)/4) / (4 sqrt(2 pi))` of [G3] section 1. + +**The weight on `N`.** Write `Omega = ||Omega'||_op`. On the typed support: +- `P1 <= |c1| lambda_1 lambda_2`, since `adj B >= 0`; +- `|det B_S| <= (lambda_1 + r Omega)(lambda_2 + r Omega)`, by Weyl's inequalities; +- `|e^T adj(B_S) e| <= ||e||^2 (lambda_2 + r Omega)`, since `adj B_S` has the eigenvalues of `B_S`. + +Hence + + W_r <= r^2 |c1| lambda_1 lambda_2 (lambda_2 + r Omega) [|c2| (lambda_1 + r Omega) + r ||e||^2], + +and with `lambda_1 = r u`, `W_r <= r^4 |c1| u lambda_2 (lambda_2 + r Omega) [|c2| (u + Omega) + ||e||^2]`. + +**Majorants.** On `N`, since `lambda_1 <= lambda_2`, every target satisfies +`|F| <= bar-F = |F_g| + ||beta~_F|| (||mu_B||_F + 2 lambda_2)`. In particular +`Omega <= bar-Omega = ||omega_g|| + ||beta_omega|| (||mu_B||_F + 2 lambda_2)` and `||e||^2 <= bar-e = (r ||bar-nu|| + ||bar-v||)^2`. + +**Integration.** Integrate `lambda_1 = r u` over `[0, r U]`, extend `lambda_2` to `(0, infinity)`, and use +`lambda_2 - lambda_1 <= lambda_2`: + + E_Q[W_r 1_N] <= K_B r^5 E_g integral_0^inf lambda_2^2 (lambda_2 + r bar-Omega) g(lambda_2) + integral_0^U g(r u) |bar-c1| u [|bar-c2| (u + bar-Omega) + bar-e] du d lambda_2. + +Write `lambda_2^2 (lambda_2 + r bar-Omega) g(lambda_2) d lambda_2 = I_3 nu(d lambda_2) + r bar-Omega I_2 nu'(d lambda_2)` with +`I_j = integral_0^inf lambda^j g(lambda) d lambda`, and the probability measures `nu ∝ lambda^3 g` and `nu' ∝ lambda^2 g`. +- Under `g x nu` and `g x nu'`, `lambda_2` is independent of the `g`-variables. +- `E_nu[lambda_2^p] = I_(3+p)/I_3`, and it dominates `E_nu'[lambda_2^p]` (Chebyshev's association inequality for the increasing + functions `lambda^p` and `lambda` under `nu'`). + +**Bounds on `I_j`.** For `lambda >= 0`, `epsilon |lambda - b| <= epsilon (lambda + b)`, so + + g(lambda) <= exp((4 b epsilon + epsilon^2)/(2 sigma^2)) exp(-(lambda - b - epsilon)^2/(2 sigma^2)), + +and `I_j <= exp((4 b_hi epsilon + epsilon^2)/(2 sigma^2)) J_j(b_hi + epsilon, sigma)`. +- Here `J_j(m, sigma) = integral_0^inf lambda^j exp(-(lambda - m)^2/(2 sigma^2)) d lambda` increases in `m`. +- It satisfies `J_0 = sigma sqrt(2 pi) Phi(m/sigma)`, `J_1 = m J_0 + sigma^2 exp(-m^2/(2 sigma^2))` and + `J_(j+1) = m J_j + j sigma^2 J_(j-1)`, by integration by parts. +- Also `I_3 >= J_3(b_lo, sigma)`. + +**Density in `lambda_1`.** Two bounds hold on the failure window: +- `g(lambda_1) <= bar-g = exp(epsilon^2/(2 sigma^2))`, the supremum of `g`; +- `g(lambda_1) <= g_0 + lambda_1 L`, where + - `g_0` is the supremum of `g(0)` over the box; + - `L = min(exp(-1/2) bar-g / sigma, g_0 c (x - 1)/log x)`, with `c = (b_hi + epsilon)/sigma^2` and `log x = log(bar-g/g_0)`. + + The second slope is the chord of `min(bar-g, g_0 exp(c lambda))`, valid because `g(lambda) <= g(0) exp((b + epsilon) lambda / sigma^2)` + for `lambda >= 0`. It matters at larger `b`, where `g` rises on the failure window. When `g_0 >= bar-g`, only the first + bound is used. + +**Normalization by `K = 12k`.** As in [E] section 5, `U = a K^2 tilde-U` with `a K^2 = 192k`, and +`|c1 c2|/(36k^2) <= 1 + eps_T` with `eps_T <= (2r|bar-T| + r^2|bar-tau|)/(6k) + r|bar-T|(r|bar-T| + r^2|bar-tau|)/(36k^2)`. Then + + E_Q[W_r 1_N] / (36 k^2 r^5) <= K_B min( bar-g Lambda, g_0 Lambda + r L Lambda' ), + Lambda = I_3 (A + B + C) + r I_2 D, Lambda' = I_3 (A' + B' + C') + r I_2 D'. + +- `A, B, C, A', B', C'` are the terms of [E] section 5, with the factor `bar-om` replaced by `bar-Omega` and the factor + `bar-e` by its vector form. +- `D` and `D'` bound `E[bar-Omega (integrand of A + B + C)]` and the same with one more power of `tilde-U`, under `g x nu'`. + - The part of `bar-Omega` sharing the variable `chi_3` of `u_3` is integrated exactly against `tilde-U^3` (resp. + `tilde-U^4`). + - The rest goes through Hölder's inequality. + +**Moments of `tilde-U`.** These follow [E] section 5, with three changes. +- **Chi variables.** The free variables are `u_2 = (2 ||L_vv||/K) chi_2`, `u_3 = (||L_oo||/K) chi_3` and + `u_4 = (||L_YY||/K) chi_4`, independent. Their positive-part moments are in closed form: + - `E[u^e (u^n - c^n)_+] = s^(n+e) E[chi^(n+e) 1{chi > c/s}] - c^n s^e E[chi^e 1{chi > c/s}]`; + - `E[chi_nu^j 1{chi_nu > x}] = C_nu sqrt(2 pi) M_(j+nu-1)(x)`, with `C_nu = 1/(2^(nu/2 - 1) Gamma(nu/2))` and the + incomplete Gaussian moments `M_j` of [E]. +- **Cross terms.** The cross-Cholesky terms `||L_ov|| chi_2` and `||L_Yv|| chi_2 + ||L_Yo|| chi_3` enter `delta_3` and + `delta_4`. +- **`lambda_2`.** It enters `tilde-y_1` through `(bar-beta_1/K) lambda_2` and each `delta_i` through `(bar-beta_i/K) lambda_2`, + with `L^p` norms under `nu`. Since `bar-beta_1 = O(r^2)`, this is invisible in the leading term. + +## 6. The normalizer floor (Lemma 5') + +**Pointwise bound.** Let `G_0 = {r|T| <= 3k/2, r^2|tau| <= 3k/2}`. On `G_0`: +- `c1 >= 9k/2`, `3k <= c2 <= 9k`, and `c1 c2 >= 36k^2 (1 - eps_T)` with `eps_T = (2r|T| + r^2|tau|)/(6k)`, as in [E]. +- Write `ell = (lambda_1)_+` and `Omega = ||Omega'||_op`. Pointwise, + + W_r / r^2 >= 1_{G_0} { 36k^2 [ (1 - eps_T) ell^2 lambda_2^2 - r Omega ell lambda_2 (ell + lambda_2) ] - c2 r ||v||^2 ell lambda_2^2 }. + +*Proof.* Suppose `B > 0`, `lambda_1 > r Omega`, `c1 lambda_1 > r ||v||^2` and `c2 > 0`. Then the event is typed and +`W_r = r^2 P1 P2`: +- `lambda_1 > r Omega` gives `B_S > 0` by Weyl; +- `c1 lambda_1 > r ||v||^2` gives `c1 > r v^T B^-1 v`; +- then `P1 >= lambda_2 (c1 lambda_1 - r ||v||^2)`, since `v^T adj(B) v <= lambda_2 ||v||^2`; +- and `P2 >= c2 (lambda_1 - r Omega)(lambda_2 - r Omega)`, since `adj(B_S) >= 0`. + +So `W_r / r^2 >= 1_{G_0} c2 lambda_2 (lambda_2 - r Omega)_+ (c1 lambda_1 - r ||v||^2)_+ (lambda_1 - r Omega)_+` in every case. +Then use: +- `(x - y)_+ z >= xz - yz`; +- `lambda_1 (lambda_1 - r Omega)_+ lambda_2 (lambda_2 - r Omega)_+ >= ell^2 lambda_2^2 - r Omega ell lambda_2 (ell + lambda_2)`; +- `c2 <= 9k`. + +**Taking expectations.** With `F = (det B)^2 1{B > 0} = ell^2 lambda_2^2` and `DT = det B tr B 1{B > 0}` (note +`ell lambda_2 (ell + lambda_2) = DT` and `ell lambda_2^2 <= DT`): + + Z_r / (36 k^2 r^2) >= E[F] - ||F||_2 P(G_0^c)^(1/2) - ||eps_T||_2 ||F||_2 - r E[Omega DT] - (r/(4k)) E[||v||^2 DT]. + +The regression splits the last two terms: +- `E[Omega DT] <= E||omega_g|| E[DT] + ||beta_omega|| E[(tr B + ||mu_B||_F) DT]`; +- `E[||v||^2 DT] <= (17/16) E||v_g||^2 E[DT] + 17 ||beta_v||^2 E[(tr B + ||mu_B||_F)^2 DT]`. + +**Contact moments in closed form.** For `B = m I + GOE_2`: +- The eigenvalues are `s -+ rho`, where `s = m + (G_11 + G_22)/2 ~ N(m, 1)` and + `rho = (((G_11 - G_22)/2)^2 + G_12^2)^(1/2)` is Rayleigh and independent of `s`. +- Hence `det B = s^2 - rho^2`, `tr B = 2s`, and `B > 0` exactly when `s > rho`. +- With `u = rho^2/2`, `integral_0^s (s^2 - rho^2)^a rho e^(-rho^2/2) d rho = P_a(s) - e^(-s^2/2) Q_a(s)` for explicit + polynomials `P_a`, `Q_a`. +- `E[s^n e^(-s^2/2) 1{s > 0}] = (e^(-m^2/4)/sqrt2) E[(m/2 + U/sqrt2)^n 1{U > -m/sqrt2}]` with `U ~ N(0, 1)`. + +So every `E[det(B)^a tr(B)^c 1{B > 0}]` is a finite combination of incomplete Gaussian moments. In particular + + m_(3,m) = E[(det B)^2 1{B > 0}] = E[(s^4 - 4 s^2 + 8) 1{s > 0}] - 4 sqrt2 e^(-m^2/4) Phi(m/sqrt2), + +which gives `m_(3,0) = (7 - 4 sqrt2)/2`, the value of [G3] section 1. The certificate checks this value. + +**Loewner coupling.** +- Write `b~ = mu~ + L~ z`, with `L~` the Cholesky factor of `C~` and `z` standard in `R^3`, and put `G = mat(sqrt2 z) ~ GOE_2`. +- Then `B - [(b - epsilon) I + G] >= -eta ||z|| I`, where `eta = ||L~ - sqrt2 I||`, because `||mat(y)||_op <= ||y||`. +- Every `h(B) = (det B)^a (tr B)^c 1{B > 0}` is monotone in the Loewner order. +- So on `{||z|| <= R_0 = 12}`, `h((b_lo - epsilon - eta R_0) I + G) <= h(B) <= h((b_hi + epsilon + eta R_0) I + G)`. + +Hence: +- `E[F] >= m_(3, b'_lo) - E[F((b'_lo) I + G)^2]^(1/2) P(chi_3 > 12)^(1/2)`; +- the correction moments are bounded at `b'' = b_hi + epsilon + eta R_0`, plus outside-ball terms; +- `m_(3,b)` and the correction moments increase in `b`. + +## 7. Rare branches + +**Weight bound.** On the typed support, with `D = det B 1{B > 0}`, + + W_r / r^2 <= |c1| D [ |c2| (D + r Omega tr B + r^2 Omega^2) + r ||e||^2 (tr B + r Omega) ]. + +Hölder gives `||W_r 1_typed||_q <= r^2 g_1(q) g_2(q)`. +- `||D||_p` (for `p = 4q <= 64`) comes from the contact moments at `b''` (Loewner coupling). +- The outside-ball part is bounded by `2^-p E[(||mu_B||_F + sigma chi_3)^(2p) 1{chi_3 > 12}]`, using `D <= ||B||_F^2/2`. + +Then `E_Q[W_r 1_E] <= ||W_r 1_typed||_q P(E)^(1 - 1/q)` for `E = F, X, A` and `q in {2, 4, 8, 16}`, the smallest bound being +used. + +**`P(A)`.** For each block `(a, c)`, the threshold `t = 3k/(10r)` is split as `f t + (1 - f) t`, `f in {7/8, 15/16}`, and the +smaller bound is used: +- `c = 0`: a Gaussian tail of `X_(4,0,0)`. +- `c = 1`: `||X_(3,.)|| <= ||mean|| + lambda_max^(1/2) chi_2`, a chi tail. +- `c >= 2`: `||X_(a,c)||_op = max_theta |Q(theta)|`, where `Q(theta) = partial_x^a partial_(u_theta)^c f(0)` is a trigonometric + polynomial of degree `c`. + - Bernstein's inequality gives `|Q'| <= c max|Q|`. + - A net of 258 rational unit vectors (`((1 - t^2), 2t)/(1 + t^2)`, `t = j/128`, and their rotations by `pi/2`) has angular + gaps at most `2/128`. + - Together these give `max|Q| <= max_j |Q(theta_j)| / (1 - c/128)`. + - The certificate uses the union bound with the largest net variance of the `Q`-law and `|mean| <= ||mean||_F`. +- In every case, plus Markov's inequality at `p = 32` on `T_(a,c)`. + +The Frobenius norm would be far too generous here. The bi-Laplacian direction of the quartic block carries Frobenius variance +`~ 144` against `~ 96` for any single direction. + +**`P(F)`.** `P(F) <= P(B_11 >= lambda_far)`, since `lambda_1 <= B_11`. + +**`P(X)`.** `P(X) <= sum_i P(y_i' + bar-beta_i lambda_2 > X_0/(a r bar-beta_i))`, split into: +- Markov's inequality on `r Delta_1` (`i = 1`), and chi tails of `u_i` plus Markov's inequality on `delta_i` (`i >= 2`); +- `P(lambda_2 > s) <= P(sigma chi_3 > s - ||mu_B||_F)`. + +## 8. Bands, boxes, and the last band + +**Bands.** `(0, 1/64]` is covered by `[0, 2^-29]` and 120 bands: the octaves `[2^-(j+1), 2^-j]` are split into 8 equal +sub-bands for `j = 6, ..., 12` and into 4 for `j = 13, ..., 28`. On each band the law is enclosed uniformly (Lemma 1), and every +`r`-monotone quantity is taken at its worst endpoint. + +**Boxes.** There are 39 boxes `(b, k)`, listed as `GRID` in `theorem_a3.py` and in `RESULTS.json`: +- the `k`-boxes are `[1/2, 3/4], [3/4, 1], [1, 5/4], [5/4, 3/2], [3/2, 13/8], [13/8, 7/4], [7/4, 15/8], [15/8, 31/16], [31/16, 63/32]` and + `[63/32, 2]`; +- each `k`-box has its own `b`-grid, refined toward the corner `(b, k) = (0, 2)`; the top `k`-box has 11 `b`-boxes, starting + with `[0, 1/512]`. + +The grids were chosen so that every box stays below the corner box at `r <= 1/4096` and `r <= 1/512`. This matters because +the bound grows with `b_hi` through `I_3` while `c_G^(3)` decreases in `b`. A box only affects how close `C3` comes to +`c_G^(3)`, never validity. + +`C3(r_*)` is the maximum of the box bounds over the bands with `r_1 <= r_*`. `z3(r_*)` is the minimum over the same boxes of +`36 k_lo^2` times the floor of Lemma 5'. + +**The last band `[0, R]`, `R = 2^-29`.** The argument of [E] section 8 carries over: +- every Gaussian or chi tail argument is `>= 3` at `R` (checked), and it scales at least like `1/r`; +- no tail probability reaches `1` at `R` (checked); +- for a `chi_nu` tail with `nu <= 5`, `P(chi_nu > 2x) <= 2^nu e^(-3x^2/2) P(chi_nu > x) < P(chi_nu > x)/64` when `x >= 3`; +- every Markov piece scales like `r^32` or faster. + +So the tail term over `r^3` attains its supremum over `(0, R]` on `[R/2, R]`. + +## 9. Arithmetic + +As in [E] section 9: +- exact rationals; +- `exp`, `Phi`, `pi` and `sqrt` enclosed with outward rounding to `2^-160`; +- upper bounds rounded upward to 200 significant bits; +- interval Gaussian elimination and Cholesky decompositions with positive pivots. + +In addition: +- The `chi` constants `C_nu sqrt(2 pi)` come from `Gamma` at integers and half-integers. +- The contact moments use exact polynomial coefficients. +- The `J_j` come from the stable three-term recursion. All its terms are positive for `m >= 0`. + +## 10. Controls (floating point; not part of the certificate) + +`theorem_a3.py --mc R B K N SEED` is an end-to-end control computed from the definitions. It works as follows: +- It samples the degree-7 Taylor jet at the midpoint under `Q`, from the exact pin series evaluated in floating point. +- It evaluates `W_r` from the Hessians at `M` and `S`. +- It evaluates `M_3`, `M_4` on a 23-point grid of `D`, maximizing the binary forms over 24 angles. + +Pooled over 16 seeds: + +| `(r, b, k)` | samples | `Q^W(G_r^c)/r^3` | `Z_r/r^2` | certified `C3(r)` | +|---|---|---|---|---| +| `(1/512, 0, 2)` | `320000` | `1.572e7 +- 0.026e7` | `95.7 +- 1.1` | `23332922.48` | +| `(1/1024, 0, 2)` | `640000` | `1.906e7 +- 0.028e7` | `97.5 +- 0.9` | `22974134.29` | + +- **The normalizer.** `Z_r/r^2` agrees with the contact value `36 k^2 m_(3,0) = 96.68`. +- **The failure probability.** + - `Q^W(G_r^c)/r^3` lies below `c_G^(3)(0, 2) = 2.2424e7` at these radii. + - It approaches the limit linearly: `2 x 1.903e7 - 1.569e7 = 2.237e7`, within `0.3%` of `c_G^(3)` ([G3]). + - The first-order correction is negative and about three times the planar one (the planar control of [E] at + `(1/512, 0, 2)` was `9%` below `c_G`). It comes from the eigenvalue Jacobian `lambda_2 - lambda_1`, which the certificate + bounds by `lambda_2`. +- **Caveats.** The grid suprema lie slightly below the true ones, so the Monte Carlo failure probability is, if anything, + underestimated. These are consistency checks, not part of the proof. + +## 11. What this does not do + +- **`d = 3` only.** The method extends to every `d` with `m = d - 1` transverse directions: `GOE_m` eigenvalue coordinates, and + `m`-variable blocks for `M_3` and `M_4`. This packet certifies `d = 3` only. +- **The band only.** No `k < 1/2`. In particular there is no three-dimensional SIDE24 point: the [CAP] SIDE24 law is planar. +- **No lower bound for the constant of (1.1).** Every bound here is for the cap route (7.8). As in [G3] Corollary 2, the + cap criterion overstates the true failure rate by the planar factor of Math-#203 (about `2.4 x 10^6` at `(0, 2)`). +- **Other C8 constants.** `c_{B,K}` and `c_{d,L}` are not addressed (see Math-#205 and Math-#209 for `c_{B,K}` in `d = 3, 4`). +- **Not a review.** This is not a review of [LP]'s proof or of [CAP]. The [LP] §8 implication and [CAP]'s deterministic + theorem are used as statements, only for the consequence on `1 - p_r`. +- **Precision.** The cap-route constants for `r_* >= 1/256` are valid but far from sharp, because the rare branches at small + `k` dominate there. A finer sweep or sign-aware weight bounds could improve them, but they cannot become informative, + since `c_G^(3) (1/256)^3 > 1`. +- **Status.** C8 stays OPEN. +- **Independence.** Same GitHub account as every lane; zero organizational-independence credit. The author will not merge. diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/README.md b/frontiers/c8_theorem_a_constants_d3_20261001/README.md new file mode 100644 index 00000000..bfd92f78 --- /dev/null +++ b/frontiers/c8_theorem_a_constants_d3_20261001/README.md @@ -0,0 +1,47 @@ +# Explicit cap-route constants for Theorem A in dimension three (C8: certified `C`, `r_*`, `z_*` on a declared band, `d = 3`) + +**Object:** `CL-C8-THEOREM-A-CONSTANTS-D3-20261001-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 eight-pin law of [LP] in `d = 3` with the good event `G_r = {lambda_1 > (4/(3k)) r M_3^2, r M_4 <= 3k/10}` of +[LP] section 7 / [CAP] (1) (partial-block operator norms on `D = [-2r, 2r] x ball(0, 2r)`). Theorem E3 (`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) <= C3(r_*) r^3 and Z_r / r^2 >= z3(r_*) for 0 < r <= r_*, + +| `r_*` | `C3(r_*)` | `C3 / c_G^(3)(0,2)` | `C3 r_*^3` | `z3(r_*)` | +|---|---|---|---|---| +| `1/4096` | `22754801.7964` | `1.0148` | `3.4e-4` | `6.0210` | +| `1/2048` | `22824067.0244` | `1.0179` | `2.7e-3` | `5.9980` | +| `1/1024` | `22974134.2920` | `1.0246` | `0.0214` | `5.9517` | +| `1/512` | `23332922.4752` | `1.0406` | `0.174` | `5.8590` | + +(`1/256`, `1/128` and `1/64` are also certified, with `C3 r_*^3 > 1`; every cap-route constant has `C r^3 > 1` at +`r = 1/256` in `d = 3`.) + +**What follows.** +- **Explicit Theorem A in `d = 3`.** Since `1 - p_r <= Q^W(G_r^c)` ([LP] §8), [LP] Theorem A (1.1) holds in `d = 3` on this band + with explicit pairs, for example `(C, r_*) = (23332922.4752, 1/512)` (the bound at `r = r_*` is below `0.174`) or `(22974134.2920, 1/1024)`. [LP] §16 lists such a pair among the items it does not supply. +- **Near-optimal for the cap route.** The constants are within `1.5%`–`4.1%` of the smallest possible `d = 3` cap-route constant for `r_* <= 1/512`. The sharp cap coefficient `c_G^(3)(0, 2) = 22424320.655` of Math-#208 is a + lower bound for every `d = 3` cap-route constant. +- **Normalizer floor.** `z3(1/4096) = 6.0210`, against the contact value `9 m_(3,0) = 6.0442` at `(b, k) = (0, 1/2)`. + +**Files.** +- `NOTE.md`: statement, the exact identities (I1)–(I3), Lemmas 1–5' (exact covariance series with a frame- and `L`-uniform torus + remainder on the polydisc in `C^3`; regression on the transverse Hessian; blockwise averaging identities for `M_3`; Frobenius + Taylor bounds for `M_4`; the root bounds; the normalizer floor through closed-form contact moments and a Loewner coupling), + the main term in eigenvalue coordinates, the rare branches (angular nets for the `M_4` blocks), bands, values, Monte Carlo + controls, and non-claims. +- `theorem_a3.py`: the certificate and its replay. + - `--check --procs N` replays the parameters, 11 sampled bands and the `C` table exactly against `RESULTS.json`. + - `--check-full` replays all 121 bands. + - `--mutant {no-delta, cap-half, no-zfloor-correction, no-om-term, no-lambda2}` 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: 39 box bounds, 39 floors, the largest tail part), `SOURCE_MAP.json` (pins [LP] and [CAP] + on `main`; read-only references to Math-#208 and Math-#206), `SOURCE_FILES.json`. +- Workflow `.github/workflows/c8-theorem-a-constants-d3.yml` replays the manifest, the pins, `--check-full` and `--check` in + the two interpreter modes, the five 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_d3_20261001/RESULTS.json b/frontiers/c8_theorem_a_constants_d3_20261001/RESULTS.json new file mode 100644 index 00000000..e227c1ac --- /dev/null +++ b/frontiers/c8_theorem_a_constants_d3_20261001/RESULTS.json @@ -0,0 +1,445 @@ +{ + "C_table": { + "1/1024": { + "C": "5743533573/250", + "C_over_cG3_02": "1.024519", + "C_rstar3": "0.0213963299", + "argmax": { + "b": [ + "0", + "1/512" + ], + "k": [ + "63/32", + "2" + ], + "r": [ + "15/16384", + "1/1024" + ] + }, + "z_star": "5951763/1000000" + }, + "1/128": { + "C": "699713600177629/10000", + "C_over_cG3_02": "3120.333548", + "C_rstar3": "33364.9444664779", + "argmax": { + "b": [ + "1/2", + "1" + ], + "k": [ + "1/2", + "3/4" + ], + "r": [ + "15/2048", + "1/128" + ] + }, + "z_star": "661831/125000" + }, + "1/2048": { + "C": "57060167561/2500", + "C_over_cG3_02": "1.017827", + "C_rstar3": "0.0026570712", + "argmax": { + "b": [ + "0", + "1/512" + ], + "k": [ + "63/32", + "2" + ], + "r": [ + "15/32768", + "1/2048" + ] + }, + "z_star": "1199601/200000" + }, + "1/256": { + "C": "3714819319587/625", + "C_over_cG3_02": "265.056454", + "C_rstar3": "354.2727775180", + "argmax": { + "b": [ + "0", + "1/2" + ], + "k": [ + "1/2", + "3/4" + ], + "r": [ + "7/2048", + "15/4096" + ] + }, + "z_star": "88631/15625" + }, + "1/4096": { + "C": "56887004491/2500", + "C_over_cG3_02": "1.014738", + "C_rstar3": "0.0003311260", + "argmax": { + "b": [ + "0", + "1/512" + ], + "k": [ + "63/32", + "2" + ], + "r": [ + "15/65536", + "1/4096" + ] + }, + "z_star": "6021091/1000000" + }, + "1/512": { + "C": "14583076547/625", + "C_over_cG3_02": "1.040519", + "C_rstar3": "0.1738438195", + "argmax": { + "b": [ + "439/1024", + "421/512" + ], + "k": [ + "31/16", + "63/32" + ], + "r": [ + "15/8192", + "1/512" + ] + }, + "z_star": "1171801/200000" + }, + "1/64": { + "C": "21567943821121309/1250", + "C_over_cG3_02": "769448.284401", + "C_rstar3": "65820141.0556680573", + "argmax": { + "b": [ + "1/2", + "1" + ], + "k": [ + "1/2", + "3/4" + ], + "r": [ + "15/1024", + "1/64" + ] + }, + "z_star": "1130157/250000" + } + }, + "L_min": 10, + "band": { + "b": [ + "0", + "1" + ], + "k": [ + "1/2", + "2" + ] + }, + "certified": true, + "dimension": 3, + "mutant": null, + "object": "CL-C8-THEOREM-A-CONSTANTS-D3-20261001-v1", + "parameters": { + "COMBO_X0_THETA": [ + "1/64", + "1/32" + ], + "GRID": [ + [ + [ + "1/2", + "3/4" + ], + [ + "0", + "1/2", + "1" + ] + ], + [ + [ + "3/4", + "1" + ], + [ + "0", + "1/2", + "1" + ] + ], + [ + [ + "1", + "5/4" + ], + [ + "0", + "1/2", + "1" + ] + ], + [ + [ + "5/4", + "3/2" + ], + [ + "0", + "1/2", + "1" + ] + ], + [ + [ + "3/2", + "13/8" + ], + [ + "0", + "243/512", + "1" + ] + ], + [ + [ + "13/8", + "7/4" + ], + [ + "0", + "309/1024", + "899/1024", + "1" + ] + ], + [ + [ + "7/4", + "15/8" + ], + [ + "0", + "37/256", + "105/256", + "933/1024", + "1" + ] + ], + [ + [ + "15/8", + "31/16" + ], + [ + "0", + "37/512", + "207/1024", + "225/512", + "113/128", + "1" + ] + ], + [ + [ + "31/16", + "63/32" + ], + [ + "0", + "37/1024", + "103/1024", + "111/512", + "439/1024", + "421/512", + "1" + ] + ], + [ + [ + "63/32", + "2" + ], + [ + "0", + "1/512", + "5/1024", + "5/512", + "19/1024", + "35/1024", + "1/16", + "29/256", + "209/1024", + "377/1024", + "685/1024", + "1" + ] + ] + ], + "LOW_OCTAVES": 16, + "NB": 24, + "NET_M": 128, + "NX": 60, + "PBITS": 160, + "QS": [ + 2, + 4, + 8, + 16 + ], + "R0_COUPLING": 12, + "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": 7 + }, + "schema": 1, + "scientific_effect": "NONE", + "bands": [ + {"bound": ["4077070.0864", "2212818.9267", "5449192.5212", "2957534.6637", "10460712.5278", "5677523.9120", "18025622.5087", "9783358.9983", "22203806.8663", "13191825.5965", "22404770.4380", "21644849.1278", "6361582.9498", "22549155.8276", "22349391.7620", "21369896.9678", "7229361.2521", "22640281.4216", "22558904.4870", "22291299.3896", "21317365.2173", "8525191.7959", "22647679.0575", "22618093.7273", "22544355.9404", "22293764.6146", "21434019.6236", "10316173.3404", "22689198.0656", "22672211.2855", "22661344.1376", "22662483.7879", "22657601.1265", "22661695.2738", "22641549.5232", "22563081.3998", "22357563.3368", "21751052.9962", "15521891.0145"], "r": ["0", "1/536870912"], "tail_max": "0.000000000001", "zfloor": ["6.044155", "18.521532", "13.599350", "41.673447", "24.176622", "74.086129", "37.775972", "115.759577", "54.397400", "157.982818", "63.841393", "127.520313", "418.629978", "74.040906", "103.774911", "187.362875", "517.352706", "84.995938", "100.771600", "135.854907", "229.042894", "562.596770", "90.756774", "98.857006", "114.934700", "149.946755", "239.005396", "534.378056", "93.708021", "94.143825", "94.800954", "95.905348", "97.922479", "101.602957", "108.592243", "122.214139", "150.443800", "216.525666", "407.002162"]}, + {"bound": ["4077070.0676", "2212818.9899", "5449192.4618", "2957534.7113", "10460712.3271", "5677523.9922", "18025622.0291", "9783359.1287", "22203806.1863", "13191825.7608", "22404769.6747", "21644849.3857", "6361583.0776", "22549154.9946", "22349391.4494", "21369897.2317", "7229361.4101", "22640280.5539", "22558903.8848", "22291299.0964", "21317365.4895", "8525191.9768", "22647678.1748", "22618092.9785", "22544355.3447", "22293764.2993", "21434019.8251", "10316173.5413", "22689197.1679", "22672210.3950", "22661343.2541", "22662482.9159", "22657600.2753", "22661694.4598", "22641548.7769", "22563080.7757", "22357562.9337", "21751052.9966", "15521891.2570"], "r": ["1/536870912", "5/2147483648"], "tail_max": "0.000000000001", "zfloor": ["6.044155", "18.521532", "13.599350", "41.673448", "24.176622", "74.086130", "37.775972", "115.759578", "54.397401", "157.982821", "63.841394", "127.520315", "418.629985", "74.040907", "103.774913", "187.362879", "517.352716", "84.995940", "100.771602", "135.854910", "229.042899", "562.596782", "90.756776", "98.857008", "114.934703", "149.946758", "239.005401", "534.378067", "93.708024", "94.143828", "94.800956", "95.905351", "97.922482", "101.602960", "108.592246", "122.214142", "150.443803", "216.525671", "407.002171"]}, + {"bound": ["4077070.1239", "2212819.1000", "5449192.5353", "2957534.8418", "10460712.4445", "5677524.2710", "18025622.2057", "9783359.6690", "22203806.3772", "13191826.5251", "22404769.8269", "21644850.6887", "6361583.5034", "22549155.1187", "22349392.1660", "21369898.5969", "7229361.9297", "22640280.6651", "22558904.2988", "22291299.8652", "21317366.8841", "8525192.5995", "22647678.2800", "22618093.2370", "22544355.7816", "22293765.0576", "21434021.1552", "10316174.2889", "22689197.2688", "22672210.5034", "22661343.3700", "22662483.0457", "22657600.4295", "22661694.6585", "22641549.0551", "22563081.1951", "22357563.6059", "21751054.1184", "15521892.3491"], "r": ["5/2147483648", "3/1073741824"], "tail_max": "0.000000000001", "zfloor": ["6.044155", "18.521532", "13.599350", "41.673448", "24.176622", "74.086130", "37.775972", "115.759578", "54.397400", "157.982820", "63.841394", "127.520315", "418.629984", "74.040907", "103.774913", "187.362878", "517.352715", "84.995940", "100.771602", "135.854910", "229.042898", "562.596781", "90.756776", "98.857008", "114.934703", "149.946758", "239.005400", "534.378066", "93.708024", "94.143828", "94.800956", "95.905351", "97.922482", "101.602960", "108.592246", "122.214142", "150.443803", "216.525670", "407.002170"]}, + {"bound": ["4077070.1803", "2212819.2101", "5449192.6088", "2957534.9724", "10460712.5618", "5677524.5498", "18025622.3823", "9783360.2094", "22203806.5682", "13191827.2894", "22404769.9790", "21644851.9917", "6361583.9293", "22549155.2429", "22349392.8825", "21369899.9622", "7229362.4493", "22640280.7763", "22558904.7128", "22291300.6340", "21317368.2786", "8525193.2222", "22647678.3852", "22618093.4954", "22544356.2184", "22293765.8158", "21434022.4854", "10316175.0366", "22689197.3698", "22672210.6118", "22661343.4860", "22662483.1754", "22657600.5837", "22661694.8571", "22641549.3332", "22563081.6146", "22357564.2781", "21751055.2402", "15521893.4411"], "r": ["3/1073741824", "7/2147483648"], "tail_max": "0.000000000001", "zfloor": ["6.044155", "18.521532", "13.599350", "41.673447", "24.176622", "74.086129", "37.775972", "115.759577", "54.397400", "157.982819", "63.841394", "127.520314", "418.629984", "74.040907", "103.774912", "187.362877", "517.352714", "84.995940", "100.771602", "135.854909", "229.042898", "562.596780", "90.756776", "98.857008", "114.934702", "149.946758", "239.005400", "534.378065", "93.708024", "94.143828", "94.800956", "95.905351", "97.922482", "101.602959", "108.592246", "122.214142", "150.443803", "216.525670", "407.002169"]}, + {"bound": ["4077070.2366", "2212819.3202", "5449192.6823", "2957535.1029", "10460712.6791", "5677524.8286", "18025622.5589", "9783360.7497", "22203806.7591", "13191828.0537", "22404770.1311", "21644853.2947", "6361584.3552", "22549155.3671", "22349393.5991", "21369901.3274", "7229362.9689", "22640280.8875", "22558905.1268", "22291301.4028", "21317369.6732", "8525193.8449", "22647678.4905", "22618093.7538", "22544356.6553", "22293766.5740", "21434023.8155", "10316175.7842", "22689197.4707", "22672210.7202", "22661343.6020", "22662483.3052", "22657600.7380", "22661695.0558", "22641549.6113", "22563082.0340", "22357564.9502", "21751056.3620", "15521894.5332"], "r": ["7/2147483648", "1/268435456"], "tail_max": "0.000000000001", "zfloor": ["6.044155", "18.521532", "13.599350", "41.673447", "24.176622", "74.086129", "37.775972", "115.759577", "54.397400", "157.982819", "63.841394", "127.520314", "418.629983", "74.040907", "103.774912", "187.362877", "517.352713", "84.995939", "100.771602", "135.854909", "229.042897", "562.596779", "90.756775", "98.857008", "114.934702", "149.946757", "239.005399", "534.378064", "93.708023", "94.143827", "94.800956", "95.905350", "97.922482", "101.602959", "108.592246", "122.214142", "150.443802", "216.525669", "407.002168"]}, + {"bound": ["4077070.3742", "2212819.5559", "5449192.8735", "2957535.3917", "10460713.0197", "5677525.4522", "18025623.1307", "9783361.9668", "22203807.4311", "13191829.7823", "22404770.7404", "21644856.2488", "6361585.3063", "22549155.9344", "22349395.3752", "21369904.4249", "7229364.1286", "22640281.4361", "22558906.2934", "22291303.2942", "21317372.8364", "8525195.2376", "22647679.0301", "22618094.6063", "22544357.8730", "22293768.4483", "21434026.8519", "10316177.4617", "22689198.0053", "22672211.2698", "22661344.1670", "22662483.8985", "22657601.3814", "22661695.7906", "22641550.5090", "22563083.2206", "22357566.6529", "21751058.9792", "15521897.0004"], "r": ["1/268435456", "5/1073741824"], "tail_max": "0.000000000001", "zfloor": ["6.044155", "18.521531", "13.599349", "41.673447", "24.176621", "74.086128", "37.775971", "115.759575", "54.397399", "157.982816", "63.841393", "127.520311", "418.629979", "74.040906", "103.774911", "187.362874", "517.352708", "84.995938", "100.771600", "135.854907", "229.042894", "562.596773", "90.756774", "98.857006", "114.934701", "149.946755", "239.005396", "534.378058", "93.708022", "94.143826", "94.800954", "95.905349", "97.922480", "101.602958", "108.592244", "122.214140", "150.443800", "216.525666", "407.002163"]}, + {"bound": ["4077070.4868", "2212819.7760", "5449193.0205", "2957535.6528", "10460713.2543", "5677526.0098", "18025623.4839", "9783363.0474", "22203807.8130", "13191831.3109", "22404771.0446", "21644858.8548", "6361586.1581", "22549156.1827", "22349396.8084", "21369907.1554", "7229365.1678", "22640281.6585", "22558907.1214", "22291304.8317", "21317375.6256", "8525196.4831", "22647679.2405", "22618095.1232", "22544358.7467", "22293769.9648", "21434029.5122", "10316178.9570", "22689198.2071", "22672211.4866", "22661344.3989", "22662484.1580", "22657601.6898", "22661696.1879", "22641551.0652", "22563084.0595", "22357567.9972", "21751061.2228", "15521899.1845"], "r": ["5/1073741824", "3/536870912"], "tail_max": "0.000000000001", "zfloor": ["6.044155", "18.521531", "13.599349", "41.673446", "24.176621", "74.086127", "37.775971", "115.759574", "54.397399", "157.982815", "63.841392", "127.520310", "418.629977", "74.040906", "103.774910", "187.362872", "517.352706", "84.995938", "100.771600", "135.854906", "229.042892", "562.596771", "90.756774", "98.857006", "114.934700", "149.946754", "239.005394", "534.378056", "93.708022", "94.143826", "94.800954", "95.905349", "97.922480", "101.602958", "108.592244", "122.214140", "150.443800", "216.525665", "407.002161"]}, + {"bound": ["4077070.5995", "2212819.9962", "5449193.1675", "2957535.9139", "10460713.4890", "5677526.5673", "18025623.8371", "9783364.1281", "22203808.1949", "13191832.8395", "22404771.3489", "21644861.4607", "6361587.0098", "22549156.4310", "22349398.2415", "21369909.8858", "7229366.2070", "22640281.8809", "22558907.9494", "22291306.3693", "21317378.4148", "8525197.7286", "22647679.4510", "22618095.6401", "22544359.6204", "22293771.4813", "21434032.1725", "10316180.4522", "22689198.4090", "22672211.7033", "22661344.6308", "22662484.4175", "22657601.9982", "22661696.5853", "22641551.6215", "22563084.8984", "22357569.3416", "21751063.4664", "15521901.3686"], "r": ["3/536870912", "7/1073741824"], "tail_max": "0.000000000001", "zfloor": ["6.044155", "18.521531", "13.599349", "41.673446", "24.176621", "74.086127", "37.775971", "115.759574", "54.397398", "157.982814", "63.841392", "127.520309", "418.629976", "74.040905", "103.774910", "187.362871", "517.352705", "84.995938", "100.771599", "135.854906", "229.042890", "562.596769", "90.756774", "98.857005", "114.934700", "149.946754", "239.005393", "534.378054", "93.708022", "94.143826", "94.800954", "95.905348", "97.922480", "101.602957", "108.592243", "122.214139", "150.443799", "216.525664", "407.002159"]}, + {"bound": ["4077070.7121", "2212820.2163", "5449193.3145", "2957536.1751", "10460713.7236", "5677527.1249", "18025624.1904", "9783365.2087", "22203808.5767", "13191834.3681", "22404771.6532", "21644864.0667", "6361587.8616", "22549156.6794", "22349399.6747", "21369912.6163", "7229367.2462", "22640282.1034", "22558908.7774", "22291307.9069", "21317381.2040", "8525198.9740", "22647679.6614", "22618096.1570", "22544360.4940", "22293772.9977", "21434034.8328", "10316181.9475", "22689198.6109", "22672211.9201", "22661344.8628", "22662484.6770", "22657602.3067", "22661696.9826", "22641552.1778", "22563085.7373", "22357570.6859", "21751065.7100", "15521903.5527"], "r": ["7/1073741824", "1/134217728"], "tail_max": "0.000000000001", "zfloor": ["6.044155", "18.521531", "13.599349", "41.673446", "24.176621", "74.086126", "37.775970", "115.759573", "54.397398", "157.982813", "63.841392", "127.520308", "418.629974", "74.040905", "103.774909", "187.362869", "517.352703", "84.995937", "100.771599", "135.854905", "229.042889", "562.596767", "90.756773", "98.857005", "114.934699", "149.946753", "239.005391", "534.378052", "93.708021", "94.143825", "94.800953", "95.905348", "97.922479", "101.602957", "108.592243", "122.214139", "150.443798", "216.525663", "407.002157"]}, + {"bound": ["4077070.9874", "2212820.6878", "5449193.6970", "2957536.7526", "10460714.4047", "5677528.3722", "18025625.3339", "9783367.6430", "22203809.9208", "13191837.8252", "22404772.8717", "21644869.9750", "6361589.7638", "22549157.8140", "22349403.2270", "21369918.8112", "7229369.5656", "22640283.2006", "22558911.1107", "22291311.6897", "21317387.5304", "8525201.7594", "22647680.7407", "22618097.8620", "22544362.9296", "22293776.7462", "21434040.9056", "10316185.3025", "22689199.6801", "22672213.0193", "22661345.9928", "22662485.8637", "22657603.5936", "22661698.4522", "22641553.9731", "22563088.1106", "22357574.0913", "21751070.9445", "15521908.4872"], "r": ["1/134217728", "5/536870912"], "tail_max": "0.000000000001", "zfloor": ["6.044154", "18.521530", "13.599348", "41.673444", "24.176620", "74.086124", "37.775969", "115.759569", "54.397396", "157.982808", "63.841390", "127.520304", "418.629966", "74.040903", "103.774906", "187.362864", "517.352693", "84.995935", "100.771596", "135.854901", "229.042882", "562.596755", "90.756771", "98.857003", "114.934696", "149.946749", "239.005384", "534.378040", "93.708019", "94.143823", "94.800951", "95.905346", "97.922477", "101.602954", "108.592240", "122.214135", "150.443794", "216.525657", "407.002146"]}, + {"bound": ["4077071.2126", "2212821.1281", "5449193.9910", "2957537.2748", "10460714.8740", "5677529.4873", "18025626.0403", "9783369.8043", "22203810.6846", "13191840.8824", "22404773.4802", "21644875.1869", "6361591.4674", "22549158.3107", "22349406.0933", "21369924.2722", "7229371.6440", "22640283.6454", "22558912.7667", "22291314.7649", "21317393.1087", "8525204.2503", "22647681.1616", "22618098.8957", "22544364.6769", "22293779.7792", "21434046.2262", "10316188.2930", "22689200.0838", "22672213.4529", "22661346.4567", "22662486.3827", "22657604.2105", "22661699.2469", "22641555.0857", "22563089.7883", "22357576.7800", "21751075.4316", "15521912.8554"], "r": ["5/536870912", "3/268435456"], "tail_max": "0.000000000001", "zfloor": ["6.044154", "18.521530", "13.599348", "41.673444", "24.176619", "74.086123", "37.775968", "115.759568", "54.397395", "157.982805", "63.841389", "127.520301", "418.629963", "74.040902", "103.774905", "187.362861", "517.352689", "84.995934", "100.771595", "135.854900", "229.042879", "562.596752", "90.756770", "98.857002", "114.934695", "149.946747", "239.005381", "534.378036", "93.708018", "94.143822", "94.800950", "95.905345", "97.922476", "101.602954", "108.592239", "122.214135", "150.443793", "216.525654", "407.002142"]}, + {"bound": ["4077071.4379", "2212821.5684", "5449194.2850", "2957537.7971", "10460715.3433", "5677530.6024", "18025626.7468", "9783371.9655", "22203811.4483", "13191843.9397", "22404774.0887", "21644880.3988", "6361593.1709", "22549158.8074", "22349408.9596", "21369929.7332", "7229373.7224", "22640284.0903", "22558914.4227", "22291317.8400", "21317398.6871", "8525206.7413", "22647681.5825", "22618099.9294", "22544366.4243", "22293782.8121", "21434051.5468", "10316191.2836", "22689200.4876", "22672213.8864", "22661346.9205", "22662486.9017", "22657604.8273", "22661700.0416", "22641556.1982", "22563091.4661", "22357579.4687", "21751079.9188", "15521917.2237"], "r": ["3/268435456", "7/536870912"], "tail_max": "0.000000000001", "zfloor": ["6.044154", "18.521529", "13.599348", "41.673443", "24.176619", "74.086122", "37.775967", "115.759566", "54.397394", "157.982803", "63.841388", "127.520299", "418.629960", "74.040902", "103.774904", "187.362858", "517.352686", "84.995934", "100.771594", "135.854898", "229.042876", "562.596748", "90.756770", "98.857001", "114.934694", "149.946746", "239.005378", "534.378032", "93.708018", "94.143822", "94.800950", "95.905344", "97.922475", "101.602953", "108.592239", "122.214134", "150.443792", "216.525652", "407.002138"]}, + {"bound": ["4077071.6632", "2212822.0087", "5449194.5790", "2957538.3193", "10460715.8126", "5677531.7175", "18025627.4532", "9783374.1268", "22203812.2121", "13191846.9969", "22404774.6973", "21644885.6108", "6361594.8745", "22549159.3041", "22349411.8260", "21369935.1942", "7229375.8008", "22640284.5351", "22558916.0788", "22291320.9151", "21317404.2655", "8525209.2322", "22647682.0034", "22618100.9632", "22544368.1717", "22293785.8451", "21434056.8674", "10316194.2742", "22689200.8913", "22672214.3199", "22661347.3844", "22662487.4207", "22657605.4442", "22661700.8363", "22641557.3108", "22563093.1439", "22357582.1574", "21751084.4060", "15521921.5919"], "r": ["7/536870912", "1/67108864"], "tail_max": "0.000000000001", "zfloor": ["6.044154", "18.521529", "13.599347", "41.673442", "24.176618", "74.086120", "37.775967", "115.759564", "54.397393", "157.982800", "63.841387", "127.520297", "418.629957", "74.040901", "103.774903", "187.362855", "517.352683", "84.995933", "100.771594", "135.854897", "229.042873", "562.596744", "90.756769", "98.857000", "114.934693", "149.946745", "239.005375", "534.378029", "93.708017", "94.143821", "94.800949", "95.905344", "97.922475", "101.602952", "108.592238", "122.214133", "150.443790", "216.525650", "407.002134"]}, + {"bound": ["4077072.2137", "2212822.9517", "5449195.3440", "2957539.4743", "10460717.1748", "5677534.2122", "18025629.7404", "9783378.9955", "22203814.9003", "13191853.9110", "22404777.1344", "21644897.4274", "6361598.6789", "22549161.5734", "22349418.9305", "21369947.5841", "7229380.4395", "22640286.7297", "22558920.7453", "22291328.4809", "21317416.9183", "8525214.8030", "22647684.1621", "22618104.3732", "22544373.0427", "22293793.3420", "21434069.0130", "10316200.9841", "22689203.0298", "22672216.5184", "22661349.6445", "22662489.7940", "22657608.0180", "22661703.7756", "22641560.9014", "22563097.8905", "22357588.9682", "21751094.8749", "15521931.4609"], "r": ["1/67108864", "5/268435456"], "tail_max": "0.000000000001", "zfloor": ["6.044153", "18.521528", "13.599346", "41.673440", "24.176617", "74.086116", "37.775964", "115.759557", "54.397389", "157.982791", "63.841383", "127.520288", "418.629940", "74.040897", "103.774897", "187.362843", "517.352662", "84.995929", "100.771588", "135.854889", "229.042859", "562.596720", "90.756764", "98.856995", "114.934687", "149.946736", "239.005362", "534.378004", "93.708012", "94.143816", "94.800944", "95.905339", "97.922470", "101.602947", "108.592232", "122.214126", "150.443782", "216.525638", "407.002113"]}, + {"bound": ["4077072.6643", "2212823.8323", "5449195.9320", "2957540.5188", "10460718.1134", "5677536.4424", "18025631.1532", "9783383.3180", "22203816.4278", "13191860.0255", "22404778.3514", "21644907.8512", "6361602.0860", "22549162.5668", "22349424.6632", "21369958.5061", "7229384.5963", "22640287.6193", "22558924.0573", "22291334.6311", "21317428.0750", "8525219.7849", "22647685.0039", "22618106.4407", "22544376.5375", "22293799.4080", "21434079.6542", "10316206.9652", "22689203.8372", "22672217.3854", "22661350.5722", "22662490.8320", "22657609.2517", "22661705.3649", "22641563.1265", "22563101.2460", "22357594.3456", "21751103.8492", "15521940.1973"], "r": ["5/268435456", "3/134217728"], "tail_max": "0.000000000001", "zfloor": ["6.044153", "18.521527", "13.599346", "41.673438", "24.176616", "74.086114", "37.775962", "115.759554", "54.397387", "157.982786", "63.841382", "127.520283", "418.629935", "74.040896", "103.774894", "187.362838", "517.352655", "84.995927", "100.771586", "135.854887", "229.042853", "562.596713", "90.756763", "98.856994", "114.934685", "149.946734", "239.005356", "534.377997", "93.708011", "94.143815", "94.800943", "95.905338", "97.922468", "101.602946", "108.592231", "122.214124", "150.443780", "216.525633", "407.002104"]}, + {"bound": ["4077073.1149", "2212824.7129", "5449196.5200", "2957541.5633", "10460719.0520", "5677538.6726", "18025632.5661", "9783387.6405", "22203817.9553", "13191866.1400", "22404779.5685", "21644918.2751", "6361605.4930", "22549163.5602", "22349430.3958", "21369969.4280", "7229388.7531", "22640288.5089", "22558927.3693", "22291340.7814", "21317439.2318", "8525224.7667", "22647685.8456", "22618108.5082", "22544380.0322", "22293805.4739", "21434090.2954", "10316212.9463", "22689204.6446", "22672218.2525", "22661351.4999", "22662491.8701", "22657610.4854", "22661706.9543", "22641565.3516", "22563104.6016", "22357599.7230", "21751112.8236", "15521948.9338"], "r": ["3/134217728", "7/268435456"], "tail_max": "0.000000000001", "zfloor": ["6.044153", "18.521526", "13.599345", "41.673437", "24.176615", "74.086111", "37.775961", "115.759550", "54.397385", "157.982781", "63.841380", "127.520279", "418.629929", "74.040894", "103.774892", "187.362832", "517.352648", "84.995926", "100.771585", "135.854884", "229.042847", "562.596705", "90.756762", "98.856992", "114.934683", "149.946731", "239.005350", "534.377989", "93.708010", "94.143814", "94.800942", "95.905336", "97.922467", "101.602944", "108.592229", "122.214122", "150.443777", "216.525628", "407.002096"]}, + {"bound": ["4077073.5655", "2212825.5935", "5449197.1080", "2957542.6078", "10460719.9907", "5677540.9028", "18025633.9789", "9783391.9630", "22203819.4828", "13191872.2545", "22404780.7856", "21644928.6990", "6361608.9001", "22549164.5536", "22349436.1285", "21369980.3500", "7229392.9099", "22640289.3986", "22558930.6813", "22291346.9317", "21317450.3885", "8525229.7486", "22647686.6874", "22618110.5757", "22544383.5270", "22293811.5399", "21434100.9367", "10316218.9275", "22689205.4521", "22672219.1196", "22661352.4277", "22662492.9081", "22657611.7191", "22661708.5437", "22641567.5767", "22563107.9571", "22357605.1004", "21751121.7979", "15521957.6703"], "r": ["7/268435456", "1/33554432"], "tail_max": "0.000000000001", "zfloor": ["6.044152", "18.521526", "13.599345", "41.673435", "24.176614", "74.086109", "37.775959", "115.759546", "54.397383", "157.982776", "63.841379", "127.520274", "418.629923", "74.040893", "103.774890", "187.362826", "517.352642", "84.995925", "100.771583", "135.854881", "229.042841", "562.596698", "90.756760", "98.856991", "114.934681", "149.946728", "239.005344", "534.377981", "93.708008", "94.143812", "94.800940", "95.905335", "97.922466", "101.602943", "108.592227", "122.214120", "150.443774", "216.525624", "407.002088"]}, + {"bound": ["4077074.6664", "2212827.4794", "5449198.6380", "2957544.9178", "10460722.7150", "5677545.8922", "18025638.5534", "9783401.7003", "22203824.8592", "13191886.0827", "22404785.6598", "21644952.3322", "6361616.5090", "22549169.0921", "22349450.3376", "21370005.1299", "7229402.1874", "22640293.7878", "22558940.0145", "22291362.0633", "21317475.6942", "8525240.8903", "22647691.0048", "22618117.3958", "22544393.2691", "22293826.5338", "21434125.2280", "10316232.3474", "22689209.7292", "22672223.5166", "22661356.9479", "22662497.6549", "22657616.8669", "22661714.4222", "22641574.7580", "22563117.4504", "22357618.7219", "21751142.7360", "15521977.4082"], "r": ["1/33554432", "5/134217728"], "tail_max": "0.000000000001", "zfloor": ["6.044152", "18.521523", "13.599343", "41.673431", "24.176610", "74.086101", "37.775954", "115.759533", "54.397376", "157.982757", "63.841371", "127.520257", "418.629889", "74.040885", "103.774878", "187.362803", "517.352599", "84.995916", "100.771572", "135.854866", "229.042814", "562.596650", "90.756751", "98.856980", "114.934669", "149.946711", "239.005316", "534.377933", "93.707999", "94.143803", "94.800931", "95.905325", "97.922456", "101.602932", "108.592216", "122.214108", "150.443758", "216.525600", "407.002046"]}, + {"bound": ["4077075.5676", "2212829.2405", "5449199.8140", "2957547.0068", "10460724.5922", "5677550.3525", "18025641.3790", "9783410.3454", "22203827.9142", "13191898.3117", "22404788.0939", "21644973.1800", "6361623.3231", "22549171.0789", "22349461.8029", "21370026.9738", "7229410.5010", "22640295.5671", "22558946.6385", "22291374.3638", "21317498.0076", "8525250.8540", "22647692.6883", "22618121.5307", "22544400.2586", "22293838.6657", "21434146.5104", "10316244.3096", "22689211.3441", "22672225.2507", "22661358.8033", "22662499.7309", "22657619.3343", "22661717.6009", "22641579.2082", "22563124.1614", "22357629.4767", "21751160.6846", "15521994.8811"], "r": ["5/134217728", "3/67108864"], "tail_max": "0.000000000001", "zfloor": ["6.044151", "18.521522", "13.599341", "41.673428", "24.176608", "74.086096", "37.775951", "115.759526", "54.397372", "157.982747", "63.841368", "127.520247", "418.629878", "74.040882", "103.774873", "187.362792", "517.352586", "84.995913", "100.771569", "135.854861", "229.042801", "562.596635", "90.756748", "98.856977", "114.934666", "149.946706", "239.005304", "534.377917", "93.707996", "94.143800", "94.800928", "95.905323", "97.922453", "101.602929", "108.592213", "122.214104", "150.443753", "216.525590", "407.002030"]}, + {"bound": ["4077076.4688", "2212831.0017", "5449200.9901", "2957549.0958", "10460726.4695", "5677554.8129", "18025644.2047", "9783418.9905", "22203830.9693", "13191910.5407", "22404790.5280", "21644994.0278", "6361630.1373", "22549173.0658", "22349473.2683", "21370048.8178", "7229418.8145", "22640297.3464", "22558953.2626", "22291386.6643", "21317520.3212", "8525260.8177", "22647694.3718", "22618125.6657", "22544407.2481", "22293850.7977", "21434167.7929", "10316256.2719", "22689212.9589", "22672226.9849", "22661360.6588", "22662501.8070", "22657621.8017", "22661720.7797", "22641583.6584", "22563130.8725", "22357640.2315", "21751178.6333", "15522012.3541"], "r": ["3/67108864", "7/134217728"], "tail_max": "0.000000000001", "zfloor": ["6.044150", "18.521520", "13.599340", "41.673425", "24.176606", "74.086091", "37.775948", "115.759519", "54.397368", "157.982737", "63.841364", "127.520238", "418.629866", "74.040879", "103.774869", "187.362780", "517.352573", "84.995910", "100.771565", "135.854855", "229.042789", "562.596620", "90.756746", "98.856974", "114.934662", "149.946700", "239.005293", "534.377901", "93.707994", "94.143798", "94.800926", "95.905320", "97.922450", "101.602927", "108.592210", "122.214100", "150.443748", "216.525581", "407.002013"]}, + {"bound": ["4077077.3700", "2212832.7630", "5449202.1661", "2957551.1848", "10460728.3468", "5677559.2734", "18025647.0305", "9783427.6356", "22203834.0244", "13191922.7698", "22404792.9622", "21645014.8756", "6361636.9515", "22549175.0526", "22349484.7337", "21370070.6618", "7229427.1282", "22640299.1257", "22558959.8867", "22291398.9649", "21317542.6348", "8525270.7814", "22647696.0554", "22618129.8007", "22544414.2377", "22293862.9297", "21434189.0753", "10316268.2341", "22689214.5738", "22672228.7191", "22661362.5144", "22662503.8831", "22657624.2692", "22661723.9585", "22641588.1086", "22563137.5836", "22357650.9864", "21751196.5821", "15522029.8272"], "r": ["7/134217728", "1/16777216"], "tail_max": "0.000000000001", "zfloor": ["6.044150", "18.521519", "13.599339", "41.673421", "24.176604", "74.086086", "37.775945", "115.759512", "54.397364", "157.982727", "63.841361", "127.520228", "418.629855", "74.040877", "103.774864", "187.362769", "517.352560", "84.995908", "100.771562", "135.854849", "229.042777", "562.596605", "90.756743", "98.856971", "114.934658", "149.946694", "239.005281", "534.377885", "93.707991", "94.143795", "94.800923", "95.905317", "97.922448", "101.602924", "108.592207", "122.214096", "150.443742", "216.525572", "407.001997"]}, + {"bound": ["4077079.5718", "2212836.5348", "5449205.2261", "2957555.8049", "10460733.7954", "5677569.2522", "18025656.1795", "9783447.1102", "22203844.7772", "13191950.4262", "22404802.7108", "21645062.1423", "6361652.1693", "22549184.1297", "22349513.1520", "21370120.2217", "7229445.6832", "22640307.9041", "22558978.5531", "22291429.2281", "21317593.2462", "8525293.0648", "22647704.6902", "22618143.4409", "22544433.7220", "22293892.9175", "21434237.6582", "10316295.0740", "22689223.1281", "22672237.5130", "22661371.5547", "22662513.3766", "22657634.5649", "22661735.7157", "22641602.4714", "22563156.5702", "22357678.2295", "21751238.4583", "15522069.3030"], "r": ["1/16777216", "5/67108864"], "tail_max": "0.000000000001", "zfloor": ["6.044148", "18.521514", "13.599335", "41.673412", "24.176598", "74.086070", "37.775935", "115.759485", "54.397349", "157.982690", "63.841346", "127.520194", "418.629787", "74.040861", "103.774841", "187.362722", "517.352475", "84.995890", "100.771540", "135.854819", "229.042722", "562.596509", "90.756724", "98.856951", "114.934634", "149.946661", "239.005226", "534.377789", "93.707972", "94.143776", "94.800904", "95.905298", "97.922428", "101.602903", "108.592184", "122.214071", "150.443710", "216.525524", "407.001912"]}, + {"bound": ["4077081.3742", "2212840.0572", "5449207.5781", "2957559.9829", "10460737.5499", "5677578.1730", "18025661.8308", "9783464.4003", "22203850.8873", "13191974.8843", "22404807.5790", "21645103.8378", "6361665.7976", "22549188.1033", "22349536.0827", "21370163.9096", "7229462.3104", "22640311.4626", "22558991.8011", "22291453.8291", "21317637.8732", "8525312.9923", "22647708.0573", "22618151.7108", "22544447.7010", "22293917.1814", "21434280.2231", "10316318.9986", "22689226.3578", "22672240.9813", "22661375.2657", "22662517.5287", "22657639.4997", "22661742.0732", "22641611.3718", "22563169.9923", "22357699.7392", "21751274.3557", "15522104.2490"], "r": ["5/67108864", "3/33554432"], "tail_max": "0.000000000001", "zfloor": ["6.044147", "18.521511", "13.599333", "41.673406", "24.176594", "74.086060", "37.775929", "115.759471", "54.397341", "157.982670", "63.841340", "127.520175", "418.629764", "74.040855", "103.774831", "187.362699", "517.352449", "84.995885", "100.771533", "135.854808", "229.042698", "562.596479", "90.756719", "98.856945", "114.934626", "149.946650", "239.005202", "534.377757", "93.707967", "94.143771", "94.800899", "95.905293", "97.922422", "101.602897", "108.592178", "122.214063", "150.443700", "216.525505", "407.001880"]}, + {"bound": ["4077083.1766", "2212843.5796", "5449209.9302", "2957564.1609", "10460741.3045", "5677587.0938", "18025667.4823", "9783481.6906", "22203856.9974", "13191999.3425", "22404812.4473", "21645145.5336", "6361679.4260", "22549192.0770", "22349559.0135", "21370207.5977", "7229478.9376", "22640315.0213", "22559005.0493", "22291478.4303", "21317682.5004", "8525332.9198", "22647711.4244", "22618159.9809", "22544461.6801", "22293941.4453", "21434322.7881", "10316342.9231", "22689229.5876", "22672244.4497", "22661378.9768", "22662521.6809", "22657644.4346", "22661748.4308", "22641620.2723", "22563183.4146", "22357721.2490", "21751310.2532", "15522139.1952"], "r": ["3/33554432", "7/67108864"], "tail_max": "0.000000000001", "zfloor": ["6.044145", "18.521508", "13.599330", "41.673400", "24.176589", "74.086050", "37.775923", "115.759456", "54.397333", "157.982650", "63.841333", "127.520156", "418.629741", "74.040850", "103.774822", "187.362677", "517.352422", "84.995879", "100.771526", "135.854797", "229.042673", "562.596450", "90.756714", "98.856939", "114.934618", "149.946638", "239.005178", "534.377725", "93.707962", "94.143766", "94.800894", "95.905287", "97.922417", "101.602891", "108.592172", "122.214055", "150.443689", "216.525486", "407.001847"]}, + {"bound": ["4077084.9790", "2212847.1020", "5449212.2823", "2957568.3389", "10460745.0592", "5677596.0147", "18025673.1338", "9783498.9809", "22203863.1078", "13192023.8007", "22404817.3157", "21645187.2295", "6361693.0545", "22549196.0508", "22349581.9444", "21370251.2860", "7229495.5649", "22640318.5800", "22559018.2976", "22291503.0315", "21317727.1278", "8525352.8473", "22647714.7916", "22618168.2510", "22544475.6593", "22293965.7094", "21434365.3532", "10316366.8478", "22689232.8174", "22672247.9182", "22661382.6879", "22662525.8332", "22657649.3695", "22661754.7885", "22641629.1728", "22563196.8369", "22357742.7589", "21751346.1508", "15522174.1413"], "r": ["7/67108864", "1/8388608"], "tail_max": "0.000000000001", "zfloor": ["6.044144", "18.521505", "13.599328", "41.673394", "24.176585", "74.086040", "37.775917", "115.759442", "54.397325", "157.982630", "63.841326", "127.520137", "418.629718", "74.040844", "103.774813", "187.362654", "517.352396", "84.995874", "100.771519", "135.854786", "229.042648", "562.596420", "90.756709", "98.856933", "114.934611", "149.946627", "239.005155", "534.377694", "93.707957", "94.143761", "94.800888", "95.905282", "97.922411", "101.602886", "108.592165", "122.214048", "150.443679", "216.525468", "407.001815"]}, + {"bound": ["4077089.3827", "2212854.6457", "5449218.4024", "2957577.5792", "10460755.9565", "5677615.9725", "18025691.4320", "9783537.9304", "22203884.6136", "13192079.1139", "22404836.8130", "21645281.7632", "6361723.4901", "22549214.2052", "22349638.7813", "21370350.4062", "7229532.6752", "22640336.1369", "22559055.6306", "22291563.5584", "21317828.3511", "8525397.4143", "22647732.0613", "22618195.5316", "22544514.6282", "22294025.6855", "21434462.5194", "10316420.5277", "22689249.9262", "22672265.5063", "22661400.7688", "22662544.8203", "22657669.9610", "22661778.3029", "22641657.8985", "22563234.8103", "22357797.2453", "21751429.9037", "15522253.0933"], "r": ["1/8388608", "5/33554432"], "tail_max": "0.000000000001", "zfloor": ["6.044140", "18.521496", "13.599320", "41.673376", "24.176572", "74.086008", "37.775896", "115.759389", "54.397296", "157.982556", "63.841296", "127.520068", "418.629583", "74.040812", "103.774766", "187.362561", "517.352227", "84.995839", "100.771477", "135.854726", "229.042539", "562.596228", "90.756671", "98.856892", "114.934562", "149.946562", "239.005044", "534.377501", "93.707919", "94.143723", "94.800850", "95.905243", "97.922371", "101.602844", "108.592120", "122.213997", "150.443614", "216.525371", "407.001646"]}, + {"bound": ["4077092.9875", "2212861.6905", "5449223.1065", "2957585.9352", "10460763.4657", "5677633.8142", "18025702.7348", "9783572.5109", "22203896.8339", "13192128.0303", "22404846.5496", "21645365.1548", "6361750.7469", "22549222.1526", "22349684.6430", "21370437.7825", "7229565.9297", "22640343.2541", "22559082.1270", "22291612.7607", "21317917.6057", "8525437.2693", "22647738.7956", "22618212.0717", "22544542.5864", "22294074.2135", "21434547.6496", "10316468.3770", "22689256.3857", "22672272.4431", "22661408.1909", "22662553.1248", "22657679.8308", "22661791.0181", "22641675.6995", "22563261.6548", "22357840.2650", "21751501.6988", "15522322.9857"], "r": ["5/33554432", "3/16777216"], "tail_max": "0.000000000001", "zfloor": ["6.044138", "18.521490", "13.599315", "41.673364", "24.176564", "74.085988", "37.775884", "115.759360", "54.397280", "157.982516", "63.841283", "127.520031", "418.629537", "74.040801", "103.774747", "187.362515", "517.352174", "84.995828", "100.771463", "135.854704", "229.042490", "562.596168", "90.756661", "98.856880", "114.934547", "149.946538", "239.004997", "534.377438", "93.707909", "94.143712", "94.800840", "95.905233", "97.922361", "101.602833", "108.592108", "122.213981", "150.443593", "216.525334", "407.001581"]}, + {"bound": ["4077096.5924", "2212868.7354", "5449227.8108", "2957594.2913", "10460770.9750", "5677651.6560", "18025714.0380", "9783607.0916", "22203909.0545", "13192176.9470", "22404856.2864", "21645448.5469", "6361778.0039", "22549230.1002", "22349730.5050", "21370525.1593", "7229599.1843", "22640350.3716", "22559108.6236", "22291661.9634", "21318006.8606", "8525477.1245", "22647745.5300", "22618228.6120", "22544570.5449", "22294122.7417", "21434632.7801", "10316516.2264", "22689262.8454", "22672279.3800", "22661415.6132", "22662561.4294", "22657689.7007", "22661803.7335", "22641693.5006", "22563288.4995", "22357883.2849", "21751573.4943", "15522392.8783"], "r": ["3/16777216", "7/33554432"], "tail_max": "0.000000000001", "zfloor": ["6.044135", "18.521483", "13.599310", "41.673351", "24.176556", "74.085968", "37.775872", "115.759331", "54.397264", "157.982476", "63.841270", "127.519993", "418.629491", "74.040791", "103.774729", "187.362470", "517.352121", "84.995817", "100.771449", "135.854682", "229.042441", "562.596109", "90.756650", "98.856868", "114.934532", "149.946515", "239.004950", "534.377375", "93.707899", "94.143702", "94.800829", "95.905222", "97.922350", "101.602821", "108.592095", "122.213966", "150.443572", "216.525297", "407.001515"]}, + {"bound": ["4077100.1974", "2212875.7804", "5449232.5151", "2957602.6475", "10460778.4845", "5677669.4980", "18025725.3413", "9783641.6726", "22203921.2754", "13192225.8639", "22404866.0235", "21645531.9394", "6361805.2610", "22549238.0479", "22349776.3672", "21370612.5364", "7229632.4390", "22640357.4893", "22559135.1205", "22291711.1663", "21318096.1158", "8525516.9798", "22647752.2646", "22618245.1524", "22544598.5035", "22294171.2702", "21434717.9109", "10316564.0759", "22689269.3053", "22672286.3171", "22661423.0357", "22662569.7341", "22657699.5708", "22661816.4491", "22641711.3020", "22563315.3444", "22357926.3049", "21751645.2899", "15522462.7711"], "r": ["7/33554432", "1/4194304"], "tail_max": "0.000000000001", "zfloor": ["6.044132", "18.521476", "13.599305", "41.673339", "24.176547", "74.085948", "37.775859", "115.759302", "54.397248", "157.982435", "63.841257", "127.519955", "418.629444", "74.040780", "103.774710", "187.362424", "517.352069", "84.995807", "100.771435", "135.854659", "229.042392", "562.596049", "90.756640", "98.856856", "114.934517", "149.946492", "239.004903", "534.377311", "93.707889", "94.143692", "94.800819", "95.905212", "97.922339", "101.602810", "108.592082", "122.213951", "150.443551", "216.525260", "407.001450"]}, + {"bound": ["4077109.0048", "2212890.8679", "5449244.7557", "2957621.1284", "10460800.2797", "5677709.4141", "18025761.9385", "9783719.5725", "22203964.2879", "13192336.4915", "22404905.0188", "21645721.0088", "6361866.1327", "22549274.3573", "22349890.0424", "21370810.7788", "7229706.6602", "22640392.6036", "22559209.7874", "22291832.2214", "21318298.5644", "8525606.1145", "22647786.8046", "22618299.7144", "22544676.4424", "22294291.2236", "21434912.2452", "10316671.4368", "22689303.5235", "22672321.4941", "22661459.1983", "22662607.7091", "22657740.7545", "22661863.4786", "22641768.7541", "22563391.2922", "22358035.2790", "21751812.7974", "15522620.6764"], "r": ["1/4194304", "5/16777216"], "tail_max": "0.000000000001", "zfloor": ["6.044125", "18.521460", "13.599290", "41.673303", "24.176522", "74.085883", "37.775818", "115.759197", "54.397190", "157.982287", "63.841197", "127.519817", "418.629174", "74.040716", "103.774617", "187.362237", "517.351730", "84.995736", "100.771349", "135.854540", "229.042174", "562.595665", "90.756565", "98.856774", "114.934420", "149.946362", "239.004681", "534.376926", "93.707812", "94.143615", "94.800742", "95.905133", "97.922259", "101.602726", "108.591993", "122.213849", "150.443422", "216.525067", "407.001112"]}, + {"bound": ["4077116.2146", "2212904.9577", "5449254.1642", "2957637.8408", "10460815.2985", "5677745.0980", "18025784.5449", "9783788.7345", "22203988.7293", "13192434.3255", "22404924.4927", "21645887.7941", "6361920.6469", "22549290.2528", "22349981.7669", "21370985.5334", "7229773.1698", "22640406.8388", "22559262.7810", "22291930.6273", "21318477.0753", "8525685.8253", "22647800.2737", "22618332.7953", "22544732.3597", "22294388.2808", "21435082.5073", "10316767.1360", "22689316.4431", "22672335.3683", "22661474.0431", "22662624.3186", "22657760.4947", "22661888.9098", "22641804.3568", "22563444.9820", "22358121.3193", "21751956.3891", "15522760.4624"], "r": ["5/16777216", "3/8388608"], "tail_max": "0.000000000001", "zfloor": ["6.044120", "18.521447", "13.599280", "41.673278", "24.176505", "74.085844", "37.775794", "115.759139", "54.397158", "157.982206", "63.841171", "127.519742", "418.629082", "74.040694", "103.774579", "187.362146", "517.351624", "84.995714", "100.771321", "135.854495", "229.042076", "562.595546", "90.756544", "98.856750", "114.934389", "149.946316", "239.004587", "534.376799", "93.707792", "94.143595", "94.800721", "95.905113", "97.922238", "101.602703", "108.591967", "122.213818", "150.443380", "216.524993", "407.000982"]}, + {"bound": ["4077123.4246", "2212919.0478", "5449263.5731", "2957654.5533", "10460830.3178", "5677780.7824", "18025807.1522", "9783857.8970", "22204013.1715", "13192532.1602", "22404943.9672", "21646054.5807", "6361975.1614", "22549306.1487", "22350073.4923", "21371160.2891", "7229839.6797", "22640421.0745", "22559315.7753", "22292029.0339", "21318655.5873", "8525765.5364", "22647813.7434", "22618365.8768", "22544788.2776", "22294485.3387", "21435252.7703", "10316862.8358", "22689329.3631", "22672349.2429", "22661488.8884", "22662640.9285", "22657780.2354", "22661914.3415", "22641839.9601", "22563498.6725", "22358207.3603", "21752099.9816", "15522900.2490"], "r": ["3/8388608", "7/16777216"], "tail_max": "0.000000000001", "zfloor": ["6.044114", "18.521433", "13.599270", "41.673253", "24.176489", "74.085804", "37.775769", "115.759081", "54.397126", "157.982126", "63.841144", "127.519667", "418.628990", "74.040672", "103.774542", "187.362055", "517.351519", "84.995693", "100.771293", "135.854451", "229.041977", "562.595427", "90.756523", "98.856726", "114.934359", "149.946269", "239.004493", "534.376673", "93.707772", "94.143575", "94.800701", "95.905092", "97.922216", "101.602681", "108.591942", "122.213787", "150.443337", "216.524919", "407.000852"]}, + {"bound": ["4077130.6349", "2212933.1380", "5449272.9822", "2957671.2661", "10460845.3375", "5677816.4671", "18025829.7600", "9783927.0601", "22204037.6145", "13192629.9957", "22404963.4423", "21646221.3683", "6362029.6762", "22549322.0452", "22350165.2183", "21371335.0458", "7229906.1900", "22640435.3106", "22559368.7701", "22292127.4412", "21318834.1001", "8525845.2479", "22647827.2134", "22618398.9587", "22544844.1961", "22294582.3972", "21435423.0342", "10316958.5359", "22689342.2836", "22672363.1179", "22661503.7341", "22662657.5389", "22657799.9766", "22661939.7736", "22641875.5638", "22563552.3635", "22358293.4019", "21752243.5749", "15523040.0363"], "r": ["7/16777216", "1/2097152"], "tail_max": "0.000000000001", "zfloor": ["6.044109", "18.521420", "13.599259", "41.673229", "24.176472", "74.085764", "37.775745", "115.759023", "54.397094", "157.982046", "63.841118", "127.519591", "418.628897", "74.040650", "103.774505", "187.361964", "517.351414", "84.995672", "100.771265", "135.854406", "229.041879", "562.595308", "90.756502", "98.856702", "114.934328", "149.946223", "239.004399", "534.376546", "93.707752", "94.143555", "94.800681", "95.905071", "97.922194", "101.602658", "108.591916", "122.213757", "150.443295", "216.524845", "407.000721"]}, + {"bound": ["4077148.2506", "2212963.3138", "5449297.4644", "2957708.2291", "10460888.9299", "5677896.3014", "18025902.9572", "9784082.8637", "22204123.6427", "13192851.2555", "22405041.4358", "21646599.5153", "6362151.4218", "22549394.6664", "22350392.5739", "21371731.5386", "7230054.6347", "22640505.5416", "22559518.1078", "22292369.5566", "21319239.0050", "8526023.5202", "22647896.2955", "22618508.0860", "22545000.0776", "22294822.3092", "21435811.7106", "10317173.2612", "22689410.7221", "22672433.4747", "22661576.0622", "22662733.4917", "22657882.3469", "22662033.8357", "22641990.4714", "22563704.2628", "22358511.3549", "21752578.5966", "15523355.8526"], "r": ["1/2097152", "5/8388608"], "tail_max": "0.000000000001", "zfloor": ["6.044095", "18.521387", "13.599231", "41.673157", "24.176421", "74.085635", "37.775662", "115.758814", "54.396977", "157.981748", "63.840998", "127.519316", "418.628357", "74.040523", "103.774318", "187.361591", "517.350735", "84.995530", "100.771094", "135.854167", "229.041443", "562.594540", "90.756353", "98.856538", "114.934134", "149.945962", "239.003956", "534.375775", "93.707599", "94.143401", "94.800526", "95.904914", "97.922034", "101.602491", "108.591737", "122.213553", "150.443038", "216.524458", "407.000045"]}, + {"bound": ["4077162.6709", "2212991.4943", "5449316.2829", "2957741.6551", "10460918.9696", "5677967.6716", "18025948.1734", "9784221.1913", "22204172.5289", "13193046.9283", "22405080.3865", "21646933.0940", "6362260.4523", "22549426.4598", "22350576.0277", "21372081.0554", "7230187.6563", "22640534.0144", "22559624.0987", "22292566.3732", "21319596.0340", "8526182.9444", "22647923.2362", "22618574.2508", "22545111.9158", "22295016.4281", "21436152.2416", "10317364.6630", "22689436.5636", "22672461.2255", "22661605.7544", "22662766.7133", "22657921.8299", "22662084.7008", "22642061.6798", "22563811.6459", "22358683.4397", "21752865.7858", "15523635.4295"], "r": ["5/8388608", "3/4194304"], "tail_max": "0.000000000001", "zfloor": ["6.044084", "18.521360", "13.599210", "41.673107", "24.176387", "74.085555", "37.775614", "115.758697", "54.396913", "157.981588", "63.840945", "127.519165", "418.628172", "74.040479", "103.774244", "187.361409", "517.350525", "84.995487", "100.771038", "135.854078", "229.041246", "562.594302", "90.756311", "98.856490", "114.934073", "149.945870", "239.003768", "534.375522", "93.707559", "94.143361", "94.800485", "95.904873", "97.921991", "101.602445", "108.591686", "122.213491", "150.442953", "216.524310", "406.999784"]}, + {"bound": ["4077177.0920", "2213019.6754", "5449335.1022", "2957775.0818", "10460949.0107", "5678039.0430", "18025993.3916", "9784359.5209", "22204221.4174", "13193242.6033", "22405119.3390", "21647266.6764", "6362369.4837", "22549458.2549", "22350759.4840", "21372430.5758", "7230320.6788", "22640562.4887", "22559730.0914", "22292763.1920", "21319953.0662", "8526342.3698", "22647950.1782", "22618640.4172", "22545223.7557", "22295210.5491", "21436492.7757", "10317556.0662", "22689462.4066", "22672488.9777", "22661635.4480", "22662799.9362", "22657961.3145", "22662135.5675", "22642132.8898", "22563919.0308", "22358855.5267", "21753152.9778", "15523915.0087"], "r": ["3/4194304", "7/8388608"], "tail_max": "0.000000000001", "zfloor": ["6.044074", "18.521334", "13.599189", "41.673058", "24.176354", "74.085476", "37.775565", "115.758581", "54.396849", "157.981428", "63.840893", "127.519014", "418.627988", "74.040435", "103.774169", "187.361227", "517.350314", "84.995445", "100.770983", "135.853989", "229.041050", "562.594063", "90.756269", "98.856441", "114.934012", "149.945777", "239.003580", "534.375269", "93.707519", "94.143320", "94.800444", "95.904831", "97.921948", "101.602400", "108.591635", "122.213430", "150.442869", "216.524162", "406.999524"]}, + {"bound": ["4077191.5136", "2213047.8570", "5449353.9223", "2957808.5091", "10460979.0530", "5678110.4155", "18026038.6117", "9784497.8520", "22204270.3078", "13193438.2806", "22405158.2931", "21647600.2623", "6362478.5159", "22549490.0513", "22350942.9423", "21372780.0993", "7230453.7023", "22640590.9642", "22559836.0857", "22292960.0129", "21320310.1014", "8526501.7963", "22647977.1215", "22618706.5849", "22545335.5972", "22295404.6721", "21436833.3124", "10317747.4707", "22689488.2507", "22672516.7311", "22661665.1428", "22662833.1604", "22658000.8002", "22662186.4354", "22642204.1012", "22564026.4173", "22359027.6154", "21753440.1721", "15524194.5900"], "r": ["7/8388608", "1/1048576"], "tail_max": "0.000000000001", "zfloor": ["6.044063", "18.521308", "13.599169", "41.673008", "24.176321", "74.085396", "37.775516", "115.758464", "54.396786", "157.981268", "63.840840", "127.518863", "418.627803", "74.040391", "103.774095", "187.361045", "517.350103", "84.995402", "100.770927", "135.853900", "229.040853", "562.593825", "90.756227", "98.856393", "114.933951", "149.945685", "239.003391", "534.375016", "93.707479", "94.143280", "94.800403", "95.904789", "97.921905", "101.602354", "108.591584", "122.213369", "150.442784", "216.524013", "406.999263"]}, + {"bound": ["4077226.7479", "2213108.2116", "5449402.8913", "2957882.4397", "10461066.2454", "5678270.0926", "18026185.0178", "9784809.4738", "22204442.3769", "13193880.8192", "22405314.2911", "21648356.5889", "6362722.0156", "22549635.3037", "22351397.6745", "21373573.1166", "7230750.6018", "22640731.4352", "22560134.7766", "22293444.2649", "21321119.9418", "8526858.3526", "22648115.2945", "22618924.8527", "22545647.3760", "22295884.5169", "21437610.6966", "10318176.9356", "22689625.1363", "22672657.4558", "22661809.8102", "22662985.0774", "22658165.5526", "22662374.5718", "22642433.9297", "22564330.2312", "22359463.5406", "21754110.2422", "15524826.2448"], "r": ["1/1048576", "5/4194304"], "tail_max": "0.000000000001", "zfloor": ["6.044035", "18.521241", "13.599111", "41.672865", "24.176218", "74.085138", "37.775351", "115.758046", "54.396552", "157.980672", "63.840600", "127.518312", "418.626722", "74.040137", "103.773720", "187.360298", "517.348747", "84.995119", "100.770584", "135.853420", "229.039980", "562.592290", "90.755928", "98.856065", "114.933564", "149.945163", "239.002505", "534.373474", "93.707173", "94.142973", "94.800094", "95.904476", "97.921585", "101.602020", "108.591226", "122.212961", "150.442270", "216.523241", "406.997910"]}, + {"bound": ["4077255.5919", "2213164.5760", "5449440.5335", "2957949.2968", "10461126.3333", "5678412.8421", "18026275.4630", "9785086.1441", "22204540.1629", "13194272.1838", "22405392.2041", "21649023.7783", "6362940.0846", "22549698.9012", "22351764.6014", "21374272.1807", "7231016.6542", "22640788.3907", "22560346.7723", "22293837.9170", "21321834.0285", "8527177.2117", "22648169.1853", "22619057.1941", "22545871.0663", "22296272.7730", "21438291.7861", "10318559.7521", "22689676.8287", "22672711.6867", "22661869.2048", "22663051.5309", "22658244.5294", "22662476.3132", "22642576.3587", "22564545.0113", "22359807.7272", "21754684.6443", "15525385.4190"], "r": ["5/4194304", "3/2097152"], "tail_max": "0.000000000001", "zfloor": ["6.044013", "18.521188", "13.599070", "41.672766", "24.176152", "74.084979", "37.775254", "115.757813", "54.396424", "157.980352", "63.840495", "127.518010", "418.626353", "74.040049", "103.773572", "187.359934", "517.348326", "84.995033", "100.770473", "135.853242", "229.039587", "562.591813", "90.755844", "98.855969", "114.933442", "149.944978", "239.002129", "534.372968", "93.707093", "94.142892", "94.800012", "95.904393", "97.921499", "101.601929", "108.591124", "122.212838", "150.442100", "216.522944", "406.997389"]}, + {"bound": ["4077284.4378", "2213220.9422", "5449478.1784", "2958016.1563", "10461186.4255", "5678555.5955", "18026365.9147", "9785362.8207", "22204637.9559", "13194663.5562", "22405470.1231", "21649690.9805", "6363158.1568", "22549762.5037", "22352131.5362", "21374971.2568", "7231282.7100", "22640845.3508", "22560558.7740", "22294231.5766", "21322548.1264", "8527496.0749", "22648223.0805", "22619189.5406", "22546094.7625", "22296661.0363", "21438972.8859", "10318942.5736", "22689728.5254", "22672763.4043", "22661928.6039", "22663117.9889", "22658323.5108", "22662578.0594", "22642718.7926", "22564759.7969", "22360151.9205", "21755259.0553", "15525944.6009"], "r": ["3/2097152", "7/4194304"], "tail_max": "0.000000000001", "zfloor": ["6.043992", "18.521136", "13.599028", "41.672667", "24.176085", "74.084820", "37.775156", "115.757580", "54.396296", "157.980031", "63.840389", "127.517709", "418.625984", "74.039961", "103.773423", "187.359570", "517.347904", "84.994948", "100.770361", "135.853064", "229.039194", "562.591336", "90.755760", "98.855873", "114.933320", "149.944793", "239.001752", "534.372462", "93.707012", "94.142811", "94.799931", "95.904310", "97.921413", "101.601837", "108.591022", "122.212716", "150.441931", "216.522648", "406.996868"]}, + {"bound": ["4077313.2855", "2213277.3099", "5449515.8257", "2958083.0180", "10461246.5217", "5678698.3527", "18026456.3722", "9785639.5033", "22204735.7551", "13195054.9361", "22405548.0474", "21650358.1950", "6363376.2321", "22549826.1110", "22352498.4781", "21375670.3443", "7231548.7693", "22640902.3153", "22560770.7810", "22294625.2433", "21323262.2349", "8527814.9420", "22648276.9799", "22619321.8917", "22546318.4640", "22297049.3064", "21439653.9956", "10319325.3997", "22689780.2263", "22672815.1260", "22661988.0071", "22663184.4511", "22658402.4965", "22662679.8100", "22642861.2313", "22564974.5878", "22360496.1202", "21755833.4747", "15526503.7902"], "r": ["7/4194304", "1/524288"], "tail_max": "0.000000000001", "zfloor": ["6.043970", "18.521083", "13.598987", "41.672568", "24.176019", "74.084660", "37.775059", "115.757347", "54.396169", "157.979711", "63.840284", "127.517407", "418.625614", "74.039874", "103.773275", "187.359206", "517.347483", "84.994862", "100.770249", "135.852887", "229.038801", "562.590859", "90.755676", "98.855777", "114.933198", "149.944608", "239.001376", "534.371956", "93.706932", "94.142730", "94.799849", "95.904226", "97.921326", "101.601746", "108.590921", "122.212593", "150.441762", "216.522351", "406.996347"]}, + {"bound": ["4077383.7656", "2213398.0311", "5449613.7825", "2958230.8977", "10461420.9369", "5679017.7409", "18026749.2315", "9786262.8049", "22205079.9440", "13195940.0894", "22405860.0870", "21651870.9787", "6363863.2655", "22550116.6549", "22353408.0263", "21377256.5061", "7232142.6082", "22641183.2937", "22561368.2248", "22295593.8321", "21324882.0384", "8528528.1017", "22648553.3611", "22619758.4796", "22546942.0842", "22298009.0788", "21441208.8889", "10320184.3866", "22690054.0321", "22673088.8947", "22662277.3866", "22663488.3306", "22658732.0478", "22663056.1319", "22643320.9420", "22565582.2773", "22361368.0475", "21757173.7228", "15527767.1888"], "r": ["1/524288", "5/2097152"], "tail_max": "0.000000000001", "zfloor": ["6.043915", "18.520949", "13.598872", "41.672281", "24.175813", "74.084144", "37.774728", "115.756511", "54.395701", "157.978519", "63.839804", "127.516304", "418.623452", "74.039365", "103.772525", "187.357713", "517.344771", "84.994296", "100.769565", "135.851928", "229.037055", "562.587790", "90.755079", "98.855121", "114.932422", "149.943564", "238.999603", "534.368871", "93.706321", "94.142116", "94.799230", "95.903600", "97.920686", "101.601079", "108.590203", "122.211776", "150.440734", "216.520805", "406.993640"]}, + {"bound": ["4077441.4667", "2213510.7736", "5449689.0880", "2958364.6328", "10461541.1467", "5679303.2763", "18026930.1736", "9786816.2058", "22205275.5707", "13196722.8948", "22406015.9605", "21653205.4857", "6364299.4360", "22550243.8923", "22354141.9570", "21378654.7562", "7232674.7499", "22641297.2440", "22561792.2727", "22296381.2121", "21326310.3267", "8529165.8628", "22648661.1805", "22620023.2101", "22547389.5211", "22298785.6643", "21442571.1778", "10320950.0714", "22690157.4542", "22673192.3585", "22662396.2169", "22663621.2792", "22658890.0442", "22663259.6595", "22643605.8480", "22566011.8922", "22362056.4884", "21758322.6209", "15528885.6183"], "r": ["5/2097152", "3/1048576"], "tail_max": "0.000000000001", "zfloor": ["6.043872", "18.520844", "13.598789", "41.672083", "24.175680", "74.083826", "37.774533", "115.756044", "54.395446", "157.977878", "63.839593", "127.515701", "418.622714", "74.039189", "103.772228", "187.356985", "517.343928", "84.994125", "100.769341", "135.851572", "229.036269", "562.586836", "90.754911", "98.854928", "114.932178", "149.943194", "238.998850", "534.367859", "93.706160", "94.141954", "94.799067", "95.903433", "97.920513", "101.600896", "108.590000", "122.211531", "150.440395", "216.520212", "406.992599"]}, + {"bound": ["4077499.1741", "2213623.5218", "5449764.4028", "2958498.3763", "10461661.3713", "5679588.8261", "18027111.1376", "9787369.6294", "22205471.2206", "13197505.7285", "22406171.8539", "21654540.0399", "6364735.6182", "22550371.1473", "22354875.9155", "21380053.0501", "7233206.9046", "22641411.2106", "22562216.3412", "22297168.6191", "21327738.6560", "8529803.6390", "22648769.0157", "22620287.9583", "22547836.9784", "22299562.2758", "21443933.5046", "10321715.7743", "22690260.8917", "22673295.8377", "22662515.0627", "22663754.2436", "22659048.0566", "22663463.2038", "22643890.7718", "22566441.5270", "22362744.9534", "21759471.5515", "15530004.0763"], "r": ["3/1048576", "7/2097152"], "tail_max": "0.000000000001", "zfloor": ["6.043828", "18.520739", "13.598707", "41.671884", "24.175547", "74.083507", "37.774339", "115.755578", "54.395190", "157.977238", "63.839383", "127.515098", "418.621976", "74.039014", "103.771931", "187.356257", "517.343085", "84.993954", "100.769118", "135.851216", "229.035483", "562.585882", "90.754743", "98.854736", "114.931934", "149.942824", "238.998098", "534.366847", "93.705999", "94.141793", "94.798903", "95.903267", "97.920341", "101.600713", "108.589796", "122.211286", "150.440056", "216.519620", "406.991557"]}, + {"bound": ["4077556.8873", "2213736.2755", "5449839.7263", "2958632.1278", "10461781.6097", "5679874.3896", "18027292.1224", "9787923.0752", "22205666.8925", "13198288.5899", "22406327.7662", "21655874.6398", "6365171.8117", "22550498.4190", "22355609.9009", "21381451.3867", "7233739.0721", "22641525.1927", "22562640.4295", "22297956.0523", "21329167.0252", "8530441.4297", "22648876.8657", "22620552.7234", "22548284.4555", "22300338.9125", "21445295.8684", "10322481.4949", "22690364.3437", "22673399.3314", "22662633.9234", "22663887.2229", "22659206.0843", "22663666.7640", "22644175.7127", "22566871.1809", "22363433.4415", "21760620.5137", "15531122.5620"], "r": ["7/2097152", "1/262144"], "tail_max": "0.000000000001", "zfloor": ["6.043784", "18.520634", "13.598624", "41.671686", "24.175414", "74.083189", "37.774144", "115.755112", "54.394935", "157.976597", "63.839172", "127.514494", "418.621237", "74.038839", "103.771634", "187.355529", "517.342242", "84.993783", "100.768895", "135.850860", "229.034697", "562.584928", "90.754575", "98.854544", "114.931690", "149.942454", "238.997345", "534.365835", "93.705839", "94.141631", "94.798740", "95.903100", "97.920169", "101.600530", "108.589593", "122.211042", "150.439717", "216.519027", "406.990515"]}, + {"bound": ["4077697.8937", "2213977.7662", "5450035.7144", "2958927.9616", "10462130.5621", "5680513.3013", "18027878.0297", "9789169.9116", "22206355.4729", "13200059.2013", "22406952.0210", "21658900.7293", "6366146.0146", "22551079.6641", "22357429.3330", "21384624.2201", "7234926.9097", "22642087.2956", "22563835.5654", "22299893.5695", "21332407.1236", "8531867.9372", "22649429.7691", "22621426.1089", "22549531.9466", "22302258.7893", "21448406.1557", "10324199.6974", "22690912.0939", "22673947.0074", "22663195.1078", "22664495.1640", "22659865.3743", "22664419.6046", "22645095.3483", "22568086.8064", "22365177.6041", "21763301.4414", "15533649.7156"], "r": ["1/262144", "5/1048576"], "tail_max": "0.000000000001", "zfloor": ["6.043675", "18.520365", "13.598394", "41.671112", "24.175003", "74.082157", "37.773483", "115.753440", "54.393999", "157.974214", "63.838213", "127.512290", "418.616913", "74.037820", "103.770135", "187.352542", "517.336818", "84.992650", "100.767525", "135.848943", "229.031205", "562.578789", "90.753380", "98.853231", "114.930140", "149.940367", "238.993799", "534.359666", "93.704616", "94.140403", "94.797502", "95.901847", "97.918887", "101.599196", "108.588158", "122.209408", "150.437661", "216.515935", "406.985101"]}, + {"bound": ["4077813.3486", "2214203.3052", "5450186.4104", "2959195.5150", "10462371.1182", "5681084.5183", "18028240.1206", "9790276.9541", "22206746.9446", "13201625.1168", "22407263.9573", "21661570.2570", "6367018.4854", "22551334.3087", "22358897.5015", "21387421.2075", "7235991.3413", "22642315.3538", "22564683.8861", "22301468.6329", "21335264.1602", "8533143.6310", "22649645.5599", "22621955.7603", "22550427.0451", "22303812.2538", "21451131.1737", "10325731.2744", "22691119.0876", "22674154.0844", "22663402.5438", "22664761.2279", "22660181.5379", "22664826.8385", "22645665.3534", "22568946.2555", "22366554.7567", "21765599.6137", "15535886.8994"], "r": ["5/1048576", "3/524288"], "tail_max": "0.000000000001", "zfloor": ["6.043588", "18.520155", "13.598228", "41.670716", "24.174737", "74.081520", "37.773093", "115.752508", "54.393489", "157.972932", "63.837791", "127.511083", "418.615436", "74.037470", "103.769541", "187.351086", "517.335132", "84.992308", "100.767079", "135.848231", "229.029633", "562.576881", "90.753044", "98.852847", "114.929651", "149.939627", "238.992294", "534.357641", "93.704295", "94.140079", "94.797176", "95.901514", "97.918543", "101.598830", "108.587751", "122.208918", "150.436983", "216.514749", "406.983018"]}, + {"bound": ["4077928.8253", "2214428.8653", "5450337.1401", "2959463.0998", "10462611.7276", "5681655.7891", "18028602.2913", "9791384.0830", "22207138.5009", "13203191.1403", "22407575.9662", "21664239.9643", "6367891.0008", "22551589.0182", "22360365.7748", "21390218.3625", "7237055.8228", "22642543.4720", "22565532.2841", "22303043.7985", "21338121.3534", "8534419.3822", "22649861.4087", "22622485.4776", "22551322.2202", "22305365.8164", "21453856.3363", "10327262.9206", "22691326.1380", "22674361.2182", "22663610.0366", "22665027.3501", "22660497.7610", "22665234.1343", "22646235.4248", "22569805.7792", "22367931.9999", "21767897.9096", "15538124.1920"], "r": ["3/524288", "7/1048576"], "tail_max": "0.000000000001", "zfloor": ["6.043501", "18.519945", "13.598063", "41.670320", "24.174472", "74.080883", "37.772704", "115.751575", "54.392978", "157.971650", "63.837369", "127.509876", "418.613959", "74.037119", "103.768947", "187.349630", "517.333446", "84.991966", "100.766632", "135.847519", "229.028061", "562.574973", "90.752708", "98.852462", "114.929163", "149.938887", "238.990788", "534.355617", "93.703973", "94.139756", "94.796849", "95.901181", "97.918199", "101.598464", "108.587345", "122.208428", "150.436305", "216.513563", "406.980934"]}, + {"bound": ["4078044.3230", "2214654.4457", "5450487.9023", "2959730.7155", "10462852.3889", "5682227.1128", "18028964.5397", "9792491.2972", "22207530.1392", "13204757.2702", "22407888.0461", "21666909.8486", "6368763.5603", "22551843.7909", "22361834.1512", "21393015.6828", "7238120.3537", "22642771.6489", "22566380.7578", "22304619.0643", "21340978.7010", "8535695.1900", "22650077.3139", "22623015.2593", "22552217.4704", "22306919.4756", "21456581.6417", "10328794.6351", "22691533.2439", "22674568.4074", "22663817.5848", "22665293.5291", "22660814.0422", "22665641.4907", "22646805.5611", "22570665.3759", "22369309.3319", "21770196.3273", "15540361.5922"], "r": ["7/1048576", "1/131072"], "tail_max": "0.000000000001", "zfloor": ["6.043413", "18.519736", "13.597898", "41.669924", "24.174206", "74.080246", "37.772315", "115.750643", "54.392467", "157.970368", "63.836947", "127.508669", "418.612482", "74.036768", "103.768352", "187.348174", "517.331761", "84.991625", "100.766185", "135.846808", "229.026490", "562.573065", "90.752372", "98.852077", "114.928675", "149.938147", "238.989283", "534.353593", "93.703652", "94.139432", "94.796522", "95.900848", "97.917854", "101.598099", "108.586938", "122.207938", "150.435627", "216.512378", "406.978850"]}, + {"bound": ["4078326.5205", "2215137.6202", "5450880.1766", "2960322.6804", "10463550.7818", "5683505.4783", "18030137.1091", "9794985.9033", "22208908.1104", "13208299.7121", "22409137.2575", "21672964.1169", "6370712.5106", "22553006.9100", "22365474.3590", "21399363.3897", "7240496.6685", "22643896.4394", "22568772.0231", "22308495.4577", "21347460.8644", "8538548.9585", "22651183.6848", "22624762.8692", "22554713.4565", "22310760.5577", "21462804.2201", "10332231.9557", "22692629.2988", "22675664.3137", "22664914.2441", "22666469.6569", "22662133.3712", "22667147.9595", "22648645.6896", "22573097.6127", "22372798.8894", "21775559.9097", "15545417.3254"], "r": ["1/131072", "5/524288"], "tail_max": "0.000000000001", "zfloor": ["6.043195", "18.519197", "13.597437", "41.668776", "24.173383", "74.078182", "37.770991", "115.747298", "54.390596", "157.965602", "63.835029", "127.504259", "418.603834", "74.034732", "103.765355", "187.342200", "517.320911", "84.989358", "100.763446", "135.842972", "229.019505", "562.560787", "90.749983", "98.849453", "114.925574", "149.933972", "238.982190", "534.341254", "93.701207", "94.136975", "94.794047", "95.898342", "97.915291", "101.595430", "108.584067", "122.204671", "150.431515", "216.506194", "406.968023"]}, + {"bound": ["4078557.6409", "2215588.9149", "5451181.9089", "2960858.1206", "10464032.4398", "5684648.4970", "18030862.1176", "9797200.9523", "22209691.9280", "13211432.7637", "22409761.8872", "21678305.2287", "6372457.9721", "22553516.8788", "22368411.9258", "21404959.3154", "7242626.1249", "22644353.1863", "22570469.5655", "22311646.7995", "21353176.7795", "8541101.0329", "22651615.8746", "22625822.9343", "22556504.5532", "22313868.6616", "21468256.0184", "10335295.9399", "22693043.8839", "22676079.0655", "22665329.7142", "22666886.9498", "22662766.3822", "22667963.1426", "22649786.4721", "22574817.3892", "22375554.2788", "21780157.7604", "15549892.9935"], "r": ["5/524288", "3/262144"], "tail_max": "0.000000000001", "zfloor": ["6.043020", "18.518778", "13.597106", "41.667983", "24.172852", "74.076908", "37.770213", "115.745433", "54.389575", "157.963039", "63.834186", "127.501846", "418.600880", "74.034030", "103.764166", "187.339287", "517.317540", "84.988675", "100.762553", "135.841549", "229.016361", "562.556970", "90.749311", "98.848683", "114.924598", "149.932492", "238.979180", "534.337205", "93.700564", "94.136328", "94.793393", "95.897675", "97.914602", "101.594698", "108.583254", "122.203691", "150.430159", "216.503822", "406.963855"]}, + {"bound": ["4078788.8425", "2216040.2898", "5451483.7687", "2961393.6822", "10464514.3007", "5685791.7249", "18031587.4306", "9799416.3384", "22210476.0667", "13214566.2362", "22410386.7947", "21683647.0421", "6374203.6081", "22554027.0963", "22371349.8994", "21410555.8967", "7244755.7770", "22644810.1636", "22572167.4064", "22314798.5379", "21358893.3069", "8543653.3319", "22652048.2866", "22626883.2532", "22558295.9458", "22316977.1468", "21473708.3820", "10338360.1949", "22693458.6873", "22676494.0356", "22665745.4027", "22667304.4615", "22663399.6222", "22668778.5641", "22650927.5104", "22576537.4538", "22378310.0193", "21784756.0931", "15554369.0877"], "r": ["3/262144", "7/524288"], "tail_max": "0.000000000001", "zfloor": ["6.042846", "18.518358", "13.596776", "41.667191", "24.172320", "74.075634", "37.769434", "115.743569", "54.388554", "157.960475", "63.833342", "127.499432", "418.597926", "74.033329", "103.762977", "187.336375", "517.314168", "84.987991", "100.761659", "135.840125", "229.013217", "562.553154", "90.748639", "98.847914", "114.923621", "149.931013", "238.976169", "534.333157", "93.699921", "94.135681", "94.792739", "95.897009", "97.913913", "101.593967", "108.582441", "122.202711", "150.428803", "216.501450", "406.959688"]}, + {"bound": ["4079020.1233", "2216491.7437", "5451785.7540", "2961929.3643", "10464996.3614", "5686935.1600", "18032313.0437", "9801632.0591", "22211260.5218", "13217700.1263", "22411011.9760", "21688989.5522", "6375949.4175", "22554537.5592", "22374288.2764", "21416153.1291", "7246885.6238", "22645267.3686", "22573865.5429", "22317950.6695", "21364610.4424", "8546205.8541", "22652480.9180", "22627943.8233", "22560087.6316", "22320086.0100", "21479161.3072", "10341424.7190", "22693873.7064", "22676909.2213", "22666161.3070", "22667722.1896", "22664033.0885", "22669594.2214", "22652068.8017", "22578257.8035", "22381066.1078", "21789354.9042", "15558845.6051"], "r": ["7/524288", "1/65536"], "tail_max": "0.000000000001", "zfloor": ["6.042671", "18.517939", "13.596446", "41.666398", "24.171788", "74.074359", "37.768655", "115.741704", "54.387532", "157.957911", "63.832498", "127.497019", "418.594972", "74.032627", "103.761788", "187.333462", "517.310797", "84.987308", "100.760766", "135.838702", "229.010073", "562.549338", "90.747967", "98.847144", "114.922644", "149.929533", "238.973158", "534.329108", "93.699278", "94.135034", "94.792085", "95.896343", "97.913224", "101.593236", "108.581628", "122.201731", "150.427447", "216.499079", "406.955520"]}, + {"bound": ["4079585.2580", "2217458.8659", "5452571.4966", "2963114.4856", "10466395.1011", "5689494.0624", "18034661.2044", "9806625.0094", "22214019.7086", "13224789.8939", "22413513.2082", "21701106.4574", "6379849.4998", "22556866.3148", "22381574.0726", "21428856.7147", "7251640.8156", "22647519.2897", "22578652.0512", "22325708.8982", "21377582.6463", "8551916.4093", "22654695.9183", "22631442.4019", "22565083.6230", "22327773.4944", "21491614.4893", "10348303.0278", "22696068.0358", "22679103.2533", "22668356.8465", "22669922.8437", "22666485.3081", "22672610.3120", "22655752.4914", "22583126.2243", "22388050.1575", "21800088.9857", "15568962.7839"], "r": ["1/65536", "5/262144"], "tail_max": "0.000000000001", "zfloor": ["6.042234", "18.516862", "13.595523", "41.664102", "24.170144", "74.070231", "37.766008", "115.735013", "54.383789", "157.948378", "63.828662", "127.488198", "418.577675", "74.028554", "103.755795", "187.321513", "517.289096", "84.982774", "100.755288", "135.831031", "228.996104", "562.524780", "90.743187", "98.841895", "114.916443", "149.921182", "238.958971", "534.304429", "93.694387", "94.130121", "94.787136", "95.891330", "97.908097", "101.587897", "108.575886", "122.195196", "150.419223", "216.486710", "406.933863"]}, + {"bound": ["4080048.3425", "2218362.3231", "5453176.3233", "2964186.7016", "10467360.6026", "5691782.4432", "18036114.5321", "9811058.9712", "22215590.8436", "13231060.8891", "22414765.5001", "21711796.9231", "6383342.5068", "22557888.9740", "22387454.1332", "21440056.3863", "7255902.1066", "22648435.3085", "22582050.7449", "22332016.4501", "21389021.8592", "8557023.3111", "22655562.7328", "22633535.5143", "22568669.4199", "22333994.4100", "21502525.1490", "10354434.3239", "22696899.6001", "22679935.1506", "22669190.1820", "22670759.8300", "22667328.4884", "22674243.5423", "22658037.1498", "22586569.2954", "22393565.2796", "21809290.7227", "15577919.3336"], "r": ["5/262144", "3/131072"], "tail_max": "0.000000000001", "zfloor": ["6.041885", "18.516023", "13.594863", "41.662517", "24.169080", "74.067683", "37.764451", "115.731284", "54.381747", "157.943250", "63.826975", "127.483371", "418.571766", "74.027151", "103.753416", "187.315688", "517.282352", "84.981407", "100.753501", "135.828184", "228.989815", "562.517147", "90.741843", "98.840356", "114.914489", "149.918222", "238.952950", "534.296331", "93.693101", "94.128826", "94.785828", "95.889998", "97.906719", "101.586434", "108.574259", "122.193236", "150.416511", "216.481966", "406.925527"]}, + {"bound": ["4080511.7392", "2219266.0939", "5453781.6470", "2965259.3964", "10468326.8953", "5694071.6497", "18037569.0488", "9815494.2667", "22217163.2312", "13237333.5491", "22416018.8772", "21722490.1675", "6386836.2054", "22558912.6072", "22393335.7997", "21451258.6558", "7260164.1746", "22649352.2306", "22585450.6139", "22338325.5678", "21400463.4985", "8562131.1040", "22656430.4185", "22634429.5740", "22572256.3826", "22340216.8310", "21513438.0489", "10360566.6944", "22697732.0210", "22680767.9043", "22670024.3743", "22671597.6751", "22668172.5305", "22675877.7097", "22660322.8140", "22590013.5007", "22399081.7875", "21818494.3673", "15586877.5723"], "r": ["3/131072", "7/262144"], "tail_max": "0.000000000001", "zfloor": ["6.041536", "18.515184", "13.594202", "41.660931", "24.168017", "74.065134", "37.762894", "115.727555", "54.379704", "157.938123", "63.825287", "127.478543", "418.565857", "74.025748", "103.751038", "187.309863", "517.275608", "84.980040", "100.751714", "135.825337", "228.983526", "562.509514", "90.740499", "98.838817", "114.912536", "149.915262", "238.946928", "534.288232", "93.691815", "94.127532", "94.784520", "95.888665", "97.905342", "101.584971", "108.572633", "122.191277", "150.413798", "216.477223", "406.917191"]}, + {"bound": ["4080975.4446", "2220170.1762", "5454387.4640", "2966332.5681", "10469293.9734", "5696361.6786", "18039024.7461", "9819930.8918", "22218736.8620", "13243607.8686", "22417273.3320", "21733186.1828", "6390330.5937", "22559937.2083", "22399219.0660", "21462463.5165", "7264427.0177", "22650270.0509", "22588851.6527", "22344636.2458", "21411907.5579", "8567239.7859", "22657298.9702", "22635324.5128", "22575844.5057", "22346440.7519", "21524353.1830", "10366700.1367", "22698565.2935", "22681601.5097", "22670859.4188", "22672436.3742", "22669017.4296", "22677512.8090", "22662609.4792", "22593458.8351", "22404599.6760", "21827699.9140", "15595837.4959"], "r": ["7/262144", "1/32768"], "tail_max": "0.000000000001", "zfloor": ["6.041186", "18.514344", "13.593541", "41.659346", "24.166953", "74.062585", "37.761336", "115.723825", "54.377661", "157.932995", "63.823600", "127.473715", "418.559949", "74.024345", "103.748660", "187.304037", "517.268864", "84.978673", "100.749926", "135.822489", "228.977237", "562.501880", "90.739155", "98.837278", "114.910583", "149.912302", "238.940906", "534.280134", "93.690529", "94.126238", "94.783212", "95.887332", "97.903964", "101.583509", "108.571006", "122.189317", "150.411086", "216.472479", "406.908856"]}, + {"bound": ["4082108.6792", "2222107.5225", "5455963.7333", "2968707.5905", "10472099.2820", "5701488.1951", "18043733.1757", "9829931.7885", "22224268.2359", "13257806.9944", "22422287.0538", "21757453.5625", "6398139.5111", "22564604.8069", "22413812.2309", "21487903.4679", "7273947.6796", "22654783.2700", "22598440.6129", "22360174.5219", "21437883.5634", "8578673.0041", "22661738.0208", "22639833.5674", "22585852.5979", "22361837.0510", "21549291.7318", "10380471.4662", "22702962.8469", "22685998.4674", "22675259.3981", "22676846.6040", "22673444.5036", "22682348.5600", "22669990.6144", "22603211.4981", "22418587.5586", "21849195.8127", "15616094.7680"], "r": ["1/32768", "5/131072"], "tail_max": "0.000000000001", "zfloor": ["6.040313", "18.512191", "13.591696", "41.654753", "24.163663", "74.054328", "37.756041", "115.710441", "54.370174", "157.913925", "63.815926", "127.456071", "418.525349", "74.016198", "103.736671", "187.280136", "517.225457", "84.969604", "100.738969", "135.807145", "228.949294", "562.452758", "90.729595", "98.826777", "114.898177", "149.895598", "238.912528", "534.230769", "93.680747", "94.116410", "94.773311", "95.877306", "97.893708", "101.572830", "108.559522", "122.176245", "150.394636", "216.447737", "406.865535"]}, + {"bound": ["4083038.2334", "2223917.9213", "5457178.8475", "2970857.3851", "10474039.0451", "5706074.3660", "18046653.1016", "9838815.2285", "22227424.5357", "13270368.6302", "22424803.7935", "21778867.5922", "6405133.8970", "22566661.0357", "22425592.1276", "21510334.2182", "7282479.8172", "22656625.4304", "22605252.4789", "22372809.1666", "21460791.6402", "8588897.8687", "22663481.4119", "22641629.8286", "22593038.6503", "22374297.7794", "21571141.4161", "10392747.4280", "22704635.5741", "22687671.8591", "22676935.6722", "22678530.2010", "22675140.5232", "22684068.7928", "22674572.3380", "22610111.7542", "22429635.2357", "21867623.5218", "15634028.8089"], "r": ["5/131072", "3/65536"], "tail_max": "0.000000000001", "zfloor": ["6.039614", "18.510512", "13.590374", "41.651582", "24.161536", "74.049230", "37.752926", "115.702981", "54.366088", "157.903668", "63.812551", "127.446414", "418.513529", "74.013391", "103.731913", "187.268483", "517.211967", "84.966870", "100.735394", "135.801450", "228.936715", "562.437488", "90.726906", "98.823698", "114.894270", "149.889678", "238.900482", "534.214570", "93.678174", "94.113821", "94.770695", "95.874640", "97.890952", "101.569904", "108.556268", "122.172324", "150.389210", "216.438248", "406.848860"]}, + {"bound": ["4083969.0161", "2225729.5663", "5458395.9286", "2973009.0889", "10475981.9399", "5710663.8316", "18049577.7359", "9847703.9971", "22230585.7923", "13282936.9170", "22427324.8323", "21800292.7304", "6412131.0499", "22568721.1278", "22437378.4300", "21532775.3603", "7291015.0658", "22658471.1760", "22607418.8628", "22385450.0599", "21483709.4239", "8599126.3012", "22665228.2609", "22643429.5990", "22600229.3450", "22386764.5148", "21593000.0613", "10405027.6912", "22706311.7021", "22689348.6513", "22678615.3488", "22680217.2077", "22676839.9646", "22685792.4722", "22679158.0631", "22617016.5275", "22440688.4407", "21886058.8566", "15651969.6101"], "r": ["3/65536", "7/131072"], "tail_max": "0.000000000001", "zfloor": ["6.038916", "18.508833", "13.589052", "41.648412", "24.159409", "74.044132", "37.749811", "115.695521", "54.362002", "157.893411", "63.809175", "127.436758", "418.501709", "74.010584", "103.727156", "187.256830", "517.198476", "84.964135", "100.731819", "135.795754", "228.924135", "562.422218", "90.724218", "98.820620", "114.890362", "149.883757", "238.888436", "534.198369", "93.675601", "94.111231", "94.768079", "95.871974", "97.888196", "101.566978", "108.553014", "122.168404", "150.383784", "216.428759", "406.832185"]}, + {"bound": ["4084901.0226", "2227542.4561", "5459614.9709", "2975162.7007", "10477927.9573", "5715256.5906", "18052507.0658", "9856598.0940", "22233751.9913", "13295511.8542", "22429850.1588", "21821728.9779", "6419130.9710", "22570785.0744", "22449171.1343", "21555226.8966", "7299553.4273", "22660320.4988", "22609381.0386", "22398097.1989", "21506636.9174", "8609358.3037", "22666978.5603", "22645232.8710", "22607424.6769", "22399237.2543", "21614867.6694", "10417312.2579", "22707991.2242", "22691028.8370", "22680298.4210", "22681907.6174", "22678542.8209", "22687519.5909", "22683239.8163", "22623925.8130", "22451747.1706", "21904501.8173", "15669917.1744"], "r": ["7/131072", "1/16384"], "tail_max": "0.000000000001", "zfloor": ["6.038217", "18.507154", "13.587730", "41.645241", "24.157282", "74.039034", "37.746696", "115.688061", "54.357915", "157.883154", "63.805799", "127.427101", "418.489889", "74.007776", "103.722398", "187.245177", "517.184985", "84.961401", "100.728244", "135.790059", "228.911554", "562.406948", "90.721529", "98.817541", "114.886455", "149.877835", "238.876390", "534.182169", "93.673028", "94.108642", "94.765462", "95.869308", "97.885440", "101.564051", "108.549759", "122.164483", "150.378358", "216.419270", "406.815509"]}, + {"bound": ["4087179.4250", "2231429.6456", "5462786.7215", "2979931.9828", "10483570.0035", "5725544.6771", "18061972.5292", "9876660.2274", "22244866.9258", "13323988.9211", "22439922.7924", "21870398.7804", "6434784.0242", "22580160.7679", "22478444.1607", "21606238.6691", "7318636.1078", "22669384.5839", "22618738.9812", "22429261.4386", "21558716.0329", "8632273.4539", "22675892.9970", "22654287.9197", "22627505.5663", "22430115.5730", "21664874.1800", "10444914.1039", "22716822.0431", "22699858.4607", "22689134.1141", "22690763.8974", "22687432.9313", "22696478.4011", "22692313.4582", "22643494.6841", "22479802.4291", "21947605.1185", "15710523.8981"], "r": ["1/16384", "5/65536"], "tail_max": "0.000000000001", "zfloor": ["6.036470", "18.502847", "13.584039", "41.636052", "24.150699", "74.022513", "37.736102", "115.661284", "54.342937", "157.845002", "63.790448", "127.391800", "418.420671", "73.991479", "103.698414", "187.197358", "517.098149", "84.943260", "100.706324", "135.759363", "228.855652", "562.308678", "90.702404", "98.796535", "114.861638", "149.844419", "238.819618", "534.083414", "93.653461", "94.088983", "94.745657", "95.849251", "97.864925", "101.542689", "108.526786", "122.138333", "150.345451", "216.369774", "406.728845"]}, + {"bound": ["4089052.1918", "2235064.5281", "5465238.9016", "2984253.1947", "10487484.7228", "5734754.9476", "18067865.6887", "9894489.6661", "22251235.8866", "13349191.3956", "22445005.1066", "21913360.2762", "6448806.5713", "22584317.0587", "22502083.5958", "21651226.8177", "7335738.9425", "22673109.5787", "22622690.5348", "22454609.4393", "21604651.7616", "8652767.8163", "22679419.0057", "22657920.2646", "22635217.9835", "22455113.1479", "21708687.9118", "10469519.9726", "22720206.0673", "22703243.8086", "22692525.2512", "22694169.7651", "22690863.7840", "22699957.9659", "22695876.9569", "22657351.9917", "22501967.9899", "21984558.2252", "15746476.4586"], "r": ["5/65536", "3/32768"], "tail_max": "0.000000000001", "zfloor": ["6.035072", "18.499489", "13.581395", "41.629708", "24.146444", "74.012314", "37.729870", "115.646359", "54.334762", "157.824481", "63.783695", "127.372480", "418.397021", "73.985863", "103.688895", "187.174045", "517.071157", "84.937788", "100.699171", "135.747967", "228.830483", "562.278125", "90.697024", "98.790375", "114.853820", "149.832573", "238.795517", "534.051001", "93.648313", "94.083802", "94.740422", "95.843917", "97.859410", "101.536835", "108.520275", "122.130489", "150.334595", "216.350788", "406.695482"]}, + {"bound": ["4090929.9077", "2238704.4688", "5467698.9561", "2988582.1061", "10491411.9636", "5743978.4986", "18073777.6747", "9912340.5994", "22257624.6612", "13374420.6989", "22450104.6142", "21956366.5940", "6462840.3005", "22588488.8110", "22509728.7270", "21696256.9250", "7352854.3584", "22676848.9262", "22626656.8859", "22479982.6128", "21650626.6936", "8673276.6085", "22682958.8599", "22661566.6586", "22639064.0669", "22480134.9230", "21752537.8314", "10494143.2340", "22723603.7119", "22706642.7747", "22695930.0148", "22697589.2883", "22694308.3399", "22703451.3316", "22699454.4211", "22671227.4568", "22524155.8130", "22021542.1096", "15782456.3414"], "r": ["3/32768", "7/65536"], "tail_max": "0.000000000001", "zfloor": ["6.033674", "18.496130", "13.578751", "41.623365", "24.142188", "74.002115", "37.723637", "115.631433", "54.326586", "157.803959", "63.776941", "127.353160", "418.373371", "73.980246", "103.679376", "187.150730", "517.044162", "84.932317", "100.692018", "135.736572", "228.805312", "562.247571", "90.691645", "98.784215", "114.846002", "149.820726", "238.771415", "534.018585", "93.643164", "94.078621", "94.735187", "95.838582", "97.853895", "101.530979", "108.513764", "122.122645", "150.323738", "216.331802", "406.662117"]}, + {"bound": ["4092812.6054", "2242349.5160", "5470166.8940", "2992918.7445", "10495351.7291", "5753215.3676", "18079708.4898", "9930213.0901", "22264033.2498", "13399676.9084", "22455221.3179", "21999417.8665", "6476885.2506", "22592676.0305", "22514448.8306", "21741329.1238", "7369982.4021", "22680602.6330", "22630638.0399", "22505381.0202", "21696640.9559", "8693799.8840", "22686512.5665", "22665227.1079", "22642924.5998", "22505180.9574", "21796424.0548", "10518783.9516", "22727014.9846", "22710055.3667", "22699348.4125", "22701022.4747", "22697766.6064", "22706958.5054", "22703045.8573", "22676241.5665", "22546365.9503", "22058556.8649", "15818463.6417"], "r": ["7/65536", "1/8192"], "tail_max": "0.000000000001", "zfloor": ["6.032276", "18.492771", "13.576106", "41.617021", "24.137932", "73.991915", "37.717405", "115.616507", "54.318411", "157.783435", "63.770187", "127.333838", "418.349719", "73.974629", "103.669857", "187.127414", "517.017166", "84.926845", "100.684864", "135.725175", "228.780141", "562.217014", "90.686265", "98.778055", "114.838183", "149.808878", "238.747312", "533.986168", "93.638015", "94.073440", "94.729951", "95.833248", "97.848380", "101.525124", "108.507252", "122.114800", "150.312881", "216.312814", "406.628750"]}, + {"bound": ["4094700.3372", "2245999.7390", "5472642.7331", "2997263.1447", "10499304.0325", "5762465.5989", "18085658.1495", "9948107.2097", "22270461.6669", "13424960.1116", "22460355.2317", "22042514.2412", "6490941.4641", "22596878.7318", "22519185.5334", "21786443.5602", "7387123.1238", "22684370.7139", "22634634.0109", "22530804.7330", "21742694.6881", "8714337.7005", "22690080.1405", "22668901.6271", "22646799.5960", "22530251.3201", "21840346.7097", "10543442.1942", "22730440.0213", "22713481.5998", "22702780.4595", "22704469.3392", "22701238.5985", "22710479.5020", "22706651.2803", "22679996.0225", "22568598.4629", "22095602.5950", "15854498.4631"], "r": ["1/8192", "9/65536"], "tail_max": "0.000000000001", "zfloor": ["6.030878", "18.489412", "13.573462", "41.610676", "24.133676", "73.981715", "37.711172", "115.601580", "54.310234", "157.762911", "63.763432", "127.314515", "418.326065", "73.969012", "103.660337", "187.104096", "516.990169", "84.921373", "100.677710", "135.713778", "228.754968", "562.186456", "90.680885", "98.771894", "114.830364", "149.797030", "238.723207", "533.953748", "93.632866", "94.068258", "94.724715", "95.827913", "97.842865", "101.519269", "108.500741", "122.106955", "150.302023", "216.293826", "406.595382"]}, + {"bound": ["4096593.1769", "2249655.2316", "5475126.4989", "3001615.3486", "10503268.8934", "5771729.2420", "18091626.6777", "9966023.0348", "22276909.9354", "13450270.4025", "22465506.3762", "22085655.8750", "6505008.9857", "22601096.9349", "22523938.8552", "21831600.3888", "7404276.5761", "22688153.1882", "22638644.8182", "22556253.8287", "21788788.0374", "8734890.1189", "22693661.6011", "22672590.2354", "22650689.0747", "22555346.0859", "21884305.9311", "10568118.0340", "22733878.9134", "22716921.4934", "22706226.1750", "22707929.9011", "22704724.3355", "22714014.3408", "22710270.7090", "22683764.7733", "22590853.4171", "22132679.4100", "15890560.9147"], "r": ["9/65536", "5/32768"], "tail_max": "0.000000000001", "zfloor": ["6.029480", "18.486053", "13.570817", "41.604332", "24.129419", "73.971514", "37.704938", "115.586651", "54.302058", "157.742386", "63.756677", "127.295192", "418.302411", "73.963395", "103.650817", "187.080777", "516.963170", "84.915900", "100.670556", "135.702381", "228.729793", "562.155896", "90.675505", "98.765733", "114.822545", "149.785182", "238.699102", "533.921327", "93.627715", "94.063076", "94.719479", "95.822577", "97.837350", "101.513413", "108.494229", "122.099110", "150.291165", "216.274837", "406.562011"]}, + {"bound": ["4098491.2229", "2253316.1170", "5477618.2237", "3005975.4058", "10507246.3368", "5781006.3506", "18097614.1037", "9983960.6464", "22283378.0839", "13475607.8792", "22470674.7764", "22128842.9312", "6519087.8618", "22605330.6633", "22528708.8201", "21876799.7695", "7421442.8135", "22691950.0786", "22642670.4845", "22579550.8020", "21834921.1562", "8755457.2014", "22697256.9705", "22676292.9552", "22654593.0581", "22580465.3336", "21928301.8588", "10592811.5454", "22737331.5507", "22720375.0696", "22709685.5814", "22711404.1827", "22708223.8397", "22717563.0441", "22713904.1660", "22687547.8411", "22613130.8832", "22169787.4248", "15926651.1088"], "r": ["5/32768", "11/65536"], "tail_max": "0.000000000001", "zfloor": ["6.028082", "18.482694", "13.568172", "41.597987", "24.125163", "73.961312", "37.698705", "115.571723", "54.293881", "157.721859", "63.749922", "127.275867", "418.278755", "73.957778", "103.641297", "187.057457", "516.936170", "84.910428", "100.663401", "135.690983", "228.704617", "562.125335", "90.670125", "98.759572", "114.814725", "149.773333", "238.674994", "533.888904", "93.622565", "94.057895", "94.714243", "95.817242", "97.831834", "101.507557", "108.487717", "122.091264", "150.280307", "216.255846", "406.528638"]}, + {"bound": ["4100394.6026", "2256982.5535", "5480117.9478", "3010343.3740", "10511236.3920", "5790296.9826", "18103620.4608", "10001920.1289", "22289866.1446", "13500972.6433", "22475860.4602", "22172075.5775", "6533178.1400", "22609579.9429", "22533495.4551", "21922041.8663", "7438621.8913", "22695761.4098", "22646711.0347", "22584032.5431", "21881094.2002", "8776039.0119", "22700866.2732", "22680009.8106", "22658511.5709", "22605609.1448", "21972334.6361", "10617522.8045", "22740797.9572", "22723842.3526", "22713158.7027", "22714892.2082", "22711737.1351", "22721125.6360", "22717551.6753", "22691345.2503", "22635430.9339", "22206926.7569", "15962769.1604"], "r": ["11/65536", "3/16384"], "tail_max": "0.000000000001", "zfloor": ["6.026684", "18.479334", "13.565528", "41.591641", "24.120906", "73.951110", "37.692471", "115.556793", "54.285704", "157.701331", "63.743167", "127.256541", "418.255097", "73.952160", "103.631776", "187.034136", "516.909167", "84.904955", "100.656247", "135.679585", "228.679440", "562.094771", "90.664745", "98.753411", "114.806905", "149.761483", "238.650886", "533.856479", "93.617413", "94.052713", "94.709006", "95.811907", "97.826318", "101.501701", "108.481204", "122.083418", "150.269448", "216.236855", "406.495264"]}, + {"bound": ["4102303.4774", "2260654.7415", "5482625.7193", "3014719.3208", "10515239.0925", "5799601.2001", "18109645.7861", "10019901.5696", "22296374.1530", "13526364.7988", "22481063.4579", "22215353.9852", "6547279.8685", "22613844.8010", "22538298.7891", "21967326.8464", "7455813.8659", "22699587.2080", "22650766.4956", "22588530.1024", "21927307.3281", "8796635.6152", "22704489.5345", "22683740.8276", "22662444.6393", "22623408.4303", "22016404.4084", "10642251.8882", "22744278.1583", "22727323.3678", "22716645.5643", "22718394.0029", "22715264.2473", "22724702.1420", "22721213.2628", "22695157.0270", "22654981.9432", "22244097.5261", "15998915.1862"], "r": ["3/16384", "13/65536"], "tail_max": "0.000000000001", "zfloor": ["6.025286", "18.475975", "13.562883", "41.585296", "24.116649", "73.940908", "37.686237", "115.541862", "54.277526", "157.680802", "63.736411", "127.237214", "418.231439", "73.946542", "103.622254", "187.010813", "516.882164", "84.899482", "100.649091", "135.668186", "228.654261", "562.064206", "90.659364", "98.747249", "114.799084", "149.749633", "238.626776", "533.824052", "93.612262", "94.047530", "94.703770", "95.806571", "97.820802", "101.495844", "108.474692", "122.075572", "150.258588", "216.217863", "406.461887"]}, + {"bound": ["4104218.0482", "2264332.9307", "5485141.5957", "3019103.3248", "10519254.4758", "5808919.0699", "18115690.1194", "10037905.0586", "22302902.1465", "13551784.4519", "22486283.8009", "22244974.0345", "6561393.0967", "22618125.2663", "22543118.8523", "22012654.8790", "7473018.7944", "22703427.5003", "22654836.8948", "22593043.5087", "21973560.7006", "8817247.0768", "22708126.7812", "22687486.0330", "22666392.2904", "22627738.1416", "22060511.3233", "10666998.8748", "22747772.1804", "22730818.1414", "22720146.1925", "22721909.5933", "22718805.2026", "22728292.5888", "22724888.9551", "22698983.1980", "22659088.6999", "22281299.8540", "16035089.3046"], "r": ["13/65536", "7/32768"], "tail_max": "0.000000000001", "zfloor": ["6.023888", "18.472615", "13.560238", "41.578950", "24.112392", "73.930704", "37.680002", "115.526931", "54.269348", "157.660272", "63.729655", "127.217886", "418.207779", "73.940924", "103.612732", "186.987489", "516.855158", "84.894009", "100.641936", "135.656786", "228.629081", "562.033639", "90.653983", "98.741087", "114.791264", "149.737782", "238.602665", "533.791623", "93.607110", "94.042348", "94.698533", "95.801235", "97.815286", "101.489988", "108.468179", "122.067725", "150.247728", "216.198869", "406.428509"]}, + {"bound": ["4106138.5624", "2268017.4291", "5487665.6451", "3023495.4773", "10523282.5841", "5818250.6638", "18121753.5034", "10055930.6891", "22309450.1647", "13577231.7110", "22491521.5224", "22251641.0002", "6575517.8742", "22622421.3685", "22547955.6762", "22058026.1357", "7490236.7345", "22707282.3148", "22658922.2608", "22597572.7922", "22019854.4800", "8837873.4629", "22711778.0406", "22691245.4542", "22670354.5524", "22632083.2434", "22104655.5301", "10691763.8432", "22751280.0506", "22734326.7005", "22723660.6142", "22725439.0061", "22722360.0281", "22731897.0034", "22728578.7795", "22702823.7912", "22663210.4404", "22318533.8634", "16071291.6349"], "r": ["7/32768", "15/65536"], "tail_max": "0.000000000001", "zfloor": ["6.022490", "18.469255", "13.557592", "41.572604", "24.108135", "73.920501", "37.673768", "115.511999", "54.261169", "157.639741", "63.722899", "127.198557", "418.184117", "73.935306", "103.603210", "186.964164", "516.828152", "84.888536", "100.634780", "135.645386", "228.603900", "562.003070", "90.648602", "98.734925", "114.783443", "149.725930", "238.578552", "533.759192", "93.601957", "94.037165", "94.693296", "95.795899", "97.809769", "101.484131", "108.461665", "122.059878", "150.236867", "216.179875", "406.395128"]}, + {"bound": ["4108065.3207", "2271708.6117", "5490197.9471", "3027895.8842", "10527323.4641", "5827596.0589", "18127835.9835", "10073978.5573", "22316018.2486", "13602706.6862", "22496776.6563", "22258328.7810", "6589654.2516", "22626733.1377", "22552809.2934", "22103440.7899", "7507467.7446", "22711151.6800", "22663022.6230", "22602117.9835", "22066188.8304", "8858514.8403", "22715443.3404", "22695019.1195", "22674331.4540", "22636443.7654", "22148837.1790", "10716546.8727", "22754801.7964", "22737849.0726", "22727188.8572", "22728982.2692", "22725928.7514", "22735515.4136", "22732282.7642", "22706678.8349", "22667347.1941", "22355799.6784", "16107522.2976"], "r": ["15/65536", "1/4096"], "tail_max": "0.000000000001", "zfloor": ["6.021091", "18.465895", "13.554947", "41.566257", "24.103877", "73.910297", "37.667533", "115.497066", "54.252991", "157.619208", "63.716142", "127.179227", "418.160454", "73.929687", "103.593687", "186.940837", "516.801143", "84.883062", "100.627624", "135.633985", "228.578717", "561.972499", "90.643221", "98.728763", "114.775621", "149.714079", "238.554438", "533.726760", "93.596804", "94.031982", "94.688059", "95.790562", "97.804253", "101.478273", "108.455152", "122.052030", "150.226006", "216.160880", "406.361746"]}, + {"bound": ["4112769.0496", "2279639.8983", "5496757.3374", "3037652.9877", "10538954.3185", "5848561.4249", "18147298.6006", "10114765.0549", "22338815.8903", "13660519.1100", "22517412.8563", "22282438.5301", "6621340.8263", "22645924.0294", "22573382.0038", "22206886.9998", "7546077.5011", "22729687.9245", "22682160.4642", "22622425.4049", "22171712.4840", "8904866.6060", "22733665.8469", "22713529.2374", "22693386.9325", "22656529.0424", "22250223.1624", "10772383.2228", "22772851.5019", "22755895.0715", "22745247.2670", "22747082.7612", "22744098.4042", "22753825.5175", "22750827.6893", "22725631.1606", "22687062.3235", "22443185.7487", "16189721.3818"], "r": ["1/4096", "9/32768"], "tail_max": "0.000000000001", "zfloor": ["6.017592", "18.457267", "13.547552", "41.547848", "24.090691", "73.877198", "37.646309", "115.443421", "54.222983", "157.542775", "63.685393", "127.108504", "418.021820", "73.897047", "103.545647", "186.845043", "516.627235", "84.846733", "100.583726", "135.572505", "228.466734", "561.775695", "90.604922", "98.686698", "114.725923", "149.647152", "238.440719", "533.528979", "93.557619", "93.992616", "94.648401", "95.750400", "97.763171", "101.435497", "108.409146", "121.999663", "150.160102", "216.061743", "406.188160"]}, + {"bound": ["4116674.4172", "2287079.4061", "5501883.5908", "3046516.6660", "10547130.8422", "5867357.5705", "18159606.2690", "10151034.6284", "22352102.9930", "13711690.0735", "22528053.6916", "22295971.0490", "6649709.2114", "22654664.6269", "22583215.1349", "22298073.5148", "7580649.5367", "22737535.3080", "22690473.3646", "22631635.1469", "22264720.1750", "8946277.2026", "22741101.2495", "22721182.9854", "22701450.2832", "22665365.7968", "22338915.3972", "10822103.8925", "22779998.4179", "22763042.8304", "22752406.8345", "22754272.5988", "22751339.5408", "22761166.8010", "22758341.4257", "22733449.3180", "22695448.3518", "22517998.4634", "16262424.1410"], "r": ["9/32768", "5/16384"], "tail_max": "0.000000000001", "zfloor": ["6.014795", "18.450545", "13.542259", "41.535150", "24.082172", "73.856780", "37.633832", "115.413538", "54.206617", "157.501687", "63.671871", "127.069822", "417.974460", "73.885801", "103.526589", "186.798361", "516.573177", "84.835778", "100.569403", "135.549688", "228.416337", "561.714506", "90.594151", "98.674363", "114.710268", "149.623432", "238.392460", "533.464065", "93.547303", "93.982241", "94.637918", "95.739718", "97.752129", "101.423773", "108.396109", "121.983956", "150.138364", "216.023726", "406.121349"]}, + {"bound": ["4120615.3059", "2294558.8844", "5507045.4674", "3055416.7350", "10555359.8144", "5886210.9692", "18171991.5147", "10187395.3901", "22365471.3811", "13762974.3492", "22538764.9941", "22309587.9203", "6678125.0868", "22663468.6035", "22593116.2150", "22389437.3771", "7615275.1014", "22745441.5570", "22698846.9341", "22640909.2536", "22357893.6866", "8987749.1921", "22748593.4568", "22728894.3616", "22709572.8631", "22674264.9432", "22427760.6595", "10871898.5087", "22787201.4697", "22770246.4734", "22759622.3191", "22761518.4710", "22758636.9048", "22768564.7075", "22765912.4509", "22741325.9392", "22703895.1218", "22592941.0891", "16335242.8164"], "r": ["5/16384", "11/32768"], "tail_max": "0.000000000001", "zfloor": ["6.011997", "18.443822", "13.536966", "41.522450", "24.073652", "73.836359", "37.621355", "115.383652", "54.190249", "157.460594", "63.658349", "127.031136", "417.927094", "73.874555", "103.507529", "186.751674", "516.519111", "84.824821", "100.555079", "135.526869", "228.365933", "561.653310", "90.583379", "98.662028", "114.694613", "149.599709", "238.344196", "533.399143", "93.536986", "93.971866", "94.627434", "95.729036", "97.741086", "101.412048", "108.383071", "121.968248", "150.116625", "215.985706", "406.054531"]}, + {"bound": ["4124598.6901", "2302087.1560", "5512244.5920", "3064355.2852", "10563641.9689", "5905122.6900", "18184454.8769", "10223848.3297", "22378921.4607", "13814372.9342", "22549547.0728", "22323289.5848", "6706588.8890", "22672336.2213", "22603085.5338", "22451271.6224", "7649954.6891", "22753406.9135", "22707281.4230", "22650247.9943", "22451234.3929", "9029283.1345", "22756142.7032", "22736663.6037", "22717754.9168", "22683226.7412", "22516760.2048", "10921767.7357", "22794460.8882", "22777506.2312", "22766893.9515", "22768820.6089", "22765990.7280", "22776019.4704", "22773541.0008", "22749261.2650", "22712402.8843", "22634998.4237", "16408178.4138"], "r": ["11/32768", "3/8192"], "tail_max": "0.000000000001", "zfloor": ["6.009199", "18.437098", "13.531673", "41.509749", "24.065131", "73.815936", "37.608876", "115.353763", "54.173879", "157.419497", "63.644825", "126.992445", "417.879722", "73.863308", "103.488467", "186.704982", "516.465040", "84.813864", "100.540754", "135.504048", "228.315524", "561.592107", "90.572606", "98.649692", "114.678955", "149.575984", "238.295926", "533.334214", "93.526667", "93.961491", "94.616949", "95.718353", "97.730042", "101.400323", "108.370032", "121.952538", "150.094883", "215.947682", "405.987704"]}, + {"bound": ["4128633.7041", "2309675.8212", "5517483.0551", "3073334.9966", "10571978.2093", "5924094.0144", "18196996.9773", "10260394.5396", "22392453.6750", "13865886.8786", "22560400.2544", "22337076.5296", "6735101.0692", "22681267.7522", "22613123.3957", "22463512.2490", "7684688.8058", "22761431.6264", "22715777.0899", "22659651.6500", "22534789.1054", "9070879.6003", "22763749.2290", "22744490.9558", "22725996.6962", "22692251.4601", "22596904.5282", "10971712.2500", "22801776.9094", "22784822.3394", "22774221.9675", "22776179.2489", "22773401.2477", "22783531.3287", "22781227.3174", "22757255.5431", "22720971.8989", "22644659.0090", "16481231.9570"], "r": ["3/8192", "13/32768"], "tail_max": "0.000000000001", "zfloor": ["6.006401", "18.430374", "13.526379", "41.497046", "24.056610", "73.795511", "37.596396", "115.323871", "54.157508", "157.378395", "63.631300", "126.953750", "417.832345", "73.852060", "103.469404", "186.658285", "516.410962", "84.802906", "100.526428", "135.481225", "228.265110", "561.530897", "90.561832", "98.637355", "114.663297", "149.552257", "238.247652", "533.269277", "93.516346", "93.951114", "94.606464", "95.707669", "97.718997", "101.388596", "108.356991", "121.936828", "150.073139", "215.909653", "405.920869"]}, + {"bound": ["4132732.0785", "2317339.8384", "5522763.5048", "3082359.2597", "10580369.6416", "5943126.4787", "18209618.5353", "10297035.2340", "22406068.5089", "13917517.2930", "22571324.8849", "22350949.2946", "6763662.0954", "22690263.4781", "22623230.1205", "22475832.3122", "7719477.9707", "22769515.9513", "22724334.2012", "22669120.5133", "22546041.8524", "9112539.1723", "22771413.2795", "22752376.6677", "22734298.4602", "22701339.3794", "22607508.1679", "11021732.7410", "22809149.7745", "22792195.0387", "22781606.6080", "22783594.6322", "22780868.7061", "22791100.5265", "22788971.6484", "22765309.0274", "22729602.4334", "22654385.8167", "16554404.4886"], "r": ["13/32768", "7/16384"], "tail_max": "0.000000000001", "zfloor": ["6.003602", "18.423649", "13.521084", "41.484343", "24.048088", "73.775084", "37.583915", "115.293975", "54.141135", "157.337288", "63.617773", "126.915051", "417.784963", "73.840811", "103.450338", "186.611582", "516.356878", "84.791947", "100.512101", "135.458399", "228.214689", "561.469679", "90.551058", "98.625016", "114.647637", "149.528528", "238.199371", "533.204332", "93.506024", "93.940737", "94.595978", "95.696984", "97.707951", "101.376869", "108.343950", "121.921116", "150.051393", "215.871621", "405.854027"]}, + {"bound": ["4136908.6245", "2325098.1762", "5528089.2510", "3091432.3103", "10588817.6106", "5962221.9214", "18222320.3840", "10333771.7708", "22419766.4948", "13969265.3588", "22582321.3319", "22364908.4802", "6792272.4545", "22699323.6914", "22633406.0459", "22488232.2948", "7754322.7181", "22777660.1504", "22732953.0321", "22678654.8898", "22557368.4028", "9154262.4459", "22779135.1060", "22760320.9956", "22742660.4754", "22710490.7891", "22618182.1415", "11071829.9116", "22816579.7292", "22799625.2972", "22789048.1187", "22791067.0055", "22788393.3507", "22798727.3137", "22796774.2475", "22773421.9791", "22738294.7647", "22664179.1630", "16627697.0718"], "r": ["7/16384", "15/32768"], "tail_max": "0.000000000001", "zfloor": ["6.000803", "18.416924", "13.515789", "41.471638", "24.039565", "73.754655", "37.571433", "115.264076", "54.124761", "157.296177", "63.604246", "126.876348", "417.737575", "73.829562", "103.431271", "186.564874", "516.302788", "84.780987", "100.497772", "135.435572", "228.164263", "561.408455", "90.540282", "98.612677", "114.631976", "149.504796", "238.151086", "533.139380", "93.495700", "93.930356", "94.585490", "95.686298", "97.696904", "101.365140", "108.330907", "121.905402", "150.029645", "215.833585", "405.787177"]}, + {"bound": ["4141181.7674", "2332974.5431", "5533464.3796", "3100559.3810", "10597323.7409", "5981382.5361", "18235103.4892", "10370605.6753", "22433548.2201", "14021132.3387", "22593389.9871", "22378954.7569", "6820932.6555", "22708448.6964", "22643651.5283", "22500712.7273", "7789223.5993", "22785864.4932", "22741633.8667", "22688255.0990", "22568769.1822", "9196050.0314", "22786914.9655", "22768324.2022", "22751083.0163", "22719705.9909", "22628926.8268", "11122004.4806", "22824067.0244", "22807113.8986", "22796546.7506", "22798596.6202", "22795975.4345", "22806411.9455", "22804635.3742", "22781594.6662", "22747049.1791", "22674039.3798", "16701110.7930"], "r": ["15/32768", "1/2048"], "tail_max": "0.000000000001", "zfloor": ["5.998005", "18.410198", "13.510494", "41.458932", "24.031041", "73.734223", "37.558949", "115.234174", "54.108385", "157.255061", "63.590717", "126.837640", "417.690182", "73.818311", "103.412202", "186.518161", "516.248691", "84.770027", "100.483442", "135.412742", "228.113832", "561.347223", "90.529506", "98.600337", "114.616314", "149.481062", "238.102795", "533.074421", "93.485374", "93.919970", "94.575002", "95.675612", "97.685856", "101.353411", "108.317864", "121.889687", "150.007895", "215.795545", "405.720319"]}, + {"bound": ["4151801.5724", "2350295.2819", "5547367.2605", "3120919.6385", "10621629.8422", "6024514.9552", "18275565.2119", "10454132.2350", "22480767.4611", "14130778.2859", "22636061.6185", "22428872.1822", "6885416.6892", "22748081.3863", "22686147.8654", "22548929.7919", "7867740.5913", "22824098.6990", "22781111.2878", "22730153.1558", "22615413.7545", "9290275.2064", "22824480.8609", "22806483.6985", "22790368.8025", "22761121.3504", "22674441.9668", "11235522.3457", "22861271.4612", "22844310.8439", "22833765.6721", "22835902.3156", "22833423.7626", "22844149.9430", "22842857.8482", "22820658.1759", "22787688.9501", "22717675.4744", "16868380.5805"], "r": ["1/2048", "9/16384"], "tail_max": "0.000000000001", "zfloor": ["5.990991", "18.392903", "13.495670", "41.422027", "24.004606", "73.667868", "37.516401", "115.126631", "54.048230", "157.101834", "63.529089", "126.695857", "417.412371", "73.752907", "103.315928", "186.326137", "515.900230", "84.697241", "100.395486", "135.289541", "227.889378", "560.952889", "90.452779", "98.516061", "114.516739", "149.346954", "237.874876", "532.678116", "93.406863", "93.841095", "94.495557", "95.595156", "97.603559", "101.267715", "108.225697", "121.784770", "149.875845", "215.596876", "405.372445"]}, + {"bound": ["4161464.7796", "2367447.9340", "5558568.1782", "3139686.8084", "10639105.3258", "6063372.0309", "18301756.0626", "10528581.2852", "22508970.3072", "14148556.7056", "22658746.2135", "22457632.8048", "6943150.7706", "22766819.6888", "22707165.5545", "22574505.6962", "7938016.6969", "22840960.0235", "22798940.6090", "22749852.1058", "22638781.7143", "9374400.0969", "22840477.0534", "22822933.4149", "22807670.4683", "22780034.6751", "22696470.1310", "11336535.3481", "22876676.6458", "22859718.5700", "22849192.1483", "22851391.7252", "22849019.7057", "22859954.2391", "22859020.6411", "22837453.8464", "22805667.0303", "22737903.8292", "17016242.8749"], "r": ["9/16384", "5/8192"], "tail_max": "0.000000000001", "zfloor": ["5.985390", "18.379442", "13.485070", "41.396592", "23.987543", "73.626964", "37.491408", "115.066761", "54.015443", "157.019509", "63.501998", "126.618354", "417.317444", "73.730374", "103.277740", "186.232597", "515.791868", "84.675286", "100.366784", "135.243819", "227.788387", "560.830236", "90.431192", "98.491343", "114.485367", "149.299420", "237.778168", "532.548001", "93.386172", "93.820283", "94.474547", "95.573748", "97.581428", "101.244219", "108.199569", "121.753292", "149.832282", "215.520692", "405.238545"]}, + {"bound": ["4172197.9307", "2385970.6608", "5570116.2106", "3158863.1430", "10656870.6283", "6102565.2827", "18328303.2354", "10583648.6478", "22537525.0336", "14166580.6188", "22681729.9285", "22486761.7765", "7001096.5279", "22785824.5577", "22728470.6356", "22600418.5760", "8008530.1063", "22858068.2133", "22817024.7152", "22769822.3285", "22662458.1565", "9458796.0172", "22856711.2813", "22839624.7326", "22825220.7068", "22799210.5295", "22718791.0644", "11437874.0536", "22892316.9090", "22875361.3344", "22864852.8283", "22867115.8424", "22864851.1858", "22875995.7715", "22875423.5431", "22854494.7294", "22823900.3094", "22758408.0603", "17164614.0949"], "r": ["5/8192", "11/16384"], "tail_max": "0.000000000001", "zfloor": ["5.979787", "18.365978", "13.474469", "41.371153", "23.970476", "73.586052", "37.466411", "115.006877", "53.982650", "156.937165", "63.474903", "126.540835", "417.222496", "73.707837", "103.239545", "186.139037", "515.683481", "84.653328", "100.338078", "135.198089", "227.687373", "560.707553", "90.409602", "98.466620", "114.453990", "149.251877", "237.681440", "532.417855", "93.365474", "93.799464", "94.453534", "95.552337", "97.559293", "101.220719", "108.173436", "121.721809", "149.788711", "215.444492", "405.104612"]}, + {"bound": ["4184473.4117", "2406499.3810", "5582113.9666", "3178582.7754", "10674963.9564", "6142144.8879", "18355226.3447", "10598774.0237", "22566441.1261", "14184862.1706", "22705017.9592", "22516270.6224", "7059259.9265", "22805099.3760", "22750067.5921", "22626676.8011", "8079286.6643", "22875425.9759", "22835366.5999", "22790067.5320", "22686449.0850", "9543469.0387", "22873186.0264", "22856560.2391", "22843022.3294", "22818652.2600", "22741409.7119", "11539545.4561", "22908194.6221", "22891241.5103", "22880750.0880", "22883077.0557", "22880920.6133", "22892276.9940", "22892069.0883", "22871783.5172", "22842391.8333", "22779192.1505", "17313504.7602"], "r": ["11/16384", "3/4096"], "tail_max": "0.000000000001", "zfloor": ["5.974184", "18.352512", "13.463866", "41.345709", "23.953407", "73.545131", "37.441409", "114.946981", "53.949851", "156.854803", "63.447803", "126.463298", "417.127526", "73.685296", "103.201343", "186.045455", "515.575069", "84.631366", "100.309366", "135.152350", "227.586338", "560.584842", "90.388009", "98.441893", "114.422608", "149.204325", "237.584690", "532.287679", "93.344770", "93.778638", "94.432517", "95.530922", "97.537155", "101.197215", "108.147299", "121.690321", "149.745132", "215.368277", "404.970649"]}, + {"bound": ["4198922.5594", "2429900.7589", "5594698.3494", "3199026.6096", "10693435.9204", "6176291.7863", "18382550.8683", "10614191.6106", "22595730.4259", "14203417.0651", "22728616.5139", "22546173.8997", "7117647.8594", "22824647.9904", "22771961.7071", "22653290.7722", "8150292.9095", "22893036.2859", "22853969.6064", "22810591.9874", "22710761.7802", "9628425.7994", "22889903.9754", "22873742.7566", "22861078.4460", "22838363.6682", "22764331.9617", "11641557.1370", "22924312.3303", "22907361.6459", "22896886.4799", "22899277.9335", "22897230.5848", "22908800.5578", "22908960.0302", "22889323.1668", "22861145.0153", "22800260.7321", "17462926.2516"], "r": ["3/4096", "13/16384"], "tail_max": "0.000000000001", "zfloor": ["5.968580", "18.339043", "13.453261", "41.320259", "23.936335", "73.504202", "37.416403", "114.887071", "53.917046", "156.772422", "63.420698", "126.385745", "417.032534", "73.662752", "103.163134", "185.951852", "515.466632", "84.609401", "100.280650", "135.106602", "227.485279", "560.462103", "90.366413", "98.417163", "114.391221", "149.156764", "237.487920", "532.157473", "93.324059", "93.757806", "94.411497", "95.509504", "97.515014", "101.173708", "108.121158", "121.658827", "149.701545", "215.292046", "404.836654"]}, + {"bound": ["4216371.0600", "2452668.0563", "5608048.2464", "3220434.1285", "10712352.3430", "6187533.4431", "18410309.4849", "10629942.3853", "22625407.6635", "14222265.3698", "22752533.0412", "22576489.8841", "7176268.3622", "22844474.8141", "22794159.2434", "22680273.3800", "8221556.2312", "22910902.4424", "22872837.5044", "22831400.6540", "22735405.0852", "9713673.6280", "22906868.0633", "22891175.3917", "22879392.5291", "22858349.1105", "22787564.8568", "11743917.3918", "22940672.7892", "22923724.5006", "22913264.7701", "22915721.2619", "22913783.9216", "22925569.3535", "22926099.3886", "22907116.9567", "22880163.7162", "22821619.2302", "17611664.0124"], "r": ["13/16384", "7/8192"], "tail_max": "0.000000000001", "zfloor": ["5.962975", "18.325572", "13.442654", "41.294805", "23.919260", "73.463264", "37.391391", "114.827148", "53.884234", "156.690023", "63.393588", "126.308174", "416.937520", "73.640203", "103.124918", "185.858228", "515.358169", "84.587432", "100.251929", "135.060845", "227.384198", "560.339335", "90.344813", "98.392428", "114.359828", "149.109194", "237.391128", "532.027236", "93.303341", "93.736967", "94.390474", "95.488083", "97.492869", "101.150196", "108.095013", "121.627328", "149.657949", "215.215799", "404.702627"]}, + {"bound": ["4237879.1385", "2474747.7215", "5622393.2546", "3243117.4606", "10731797.4537", "6199313.1499", "18438543.6026", "10646078.6814", "22655491.0702", "14241432.4323", "22776776.4931", "22607241.3560", "7235130.8644", "22864584.9461", "22816667.6495", "22707640.5324", "8293085.0544", "22929028.1351", "22891974.5785", "22852499.3229", "22760389.7352", "9799220.6895", "22924081.5234", "22908861.5938", "22897968.4885", "22878613.6137", "22811116.8372", "11846635.3783", "22957279.0067", "22940333.0879", "22929887.9809", "22932410.0881", "22930583.7155", "22942586.5587", "22943490.5039", "22925168.5525", "22899452.3362", "22843274.0291", "17628737.1459"], "r": ["7/8192", "15/16384"], "tail_max": "0.000000000001", "zfloor": ["5.957369", "18.312099", "13.432046", "41.269345", "23.902182", "73.422317", "37.366375", "114.767211", "53.851417", "156.607605", "63.366473", "126.230587", "416.842484", "73.617651", "103.086694", "185.764582", "515.249681", "84.565459", "100.223203", "135.015080", "227.283094", "560.216538", "90.323209", "98.367689", "114.328429", "149.061615", "237.294314", "531.896969", "93.282617", "93.716121", "94.369447", "95.466658", "97.470720", "101.126681", "108.068863", "121.595823", "149.614346", "215.139536", "404.568569"]}, + {"bound": ["4264787.0109", "2503972.5400", "5638023.5166", "3265845.8663", "10751877.4993", "6211769.3476", "18467305.0909", "10662666.4149", "22686003.0726", "14260949.9175", "22801357.6243", "22638456.4905", "7294246.4825", "22884984.3073", "22839495.7970", "22735411.7523", "8364889.0536", "22947417.5223", "22911385.7295", "22873894.7823", "22785728.7327", "9885076.1537", "22941547.9455", "22926805.2215", "22916810.7573", "22899163.0078", "22834998.0161", "11949721.2885", "22974134.2920", "22957190.7241", "22946762.4919", "22949347.7713", "22947633.3810", "22959855.6947", "22961137.0991", "22943482.0832", "22919015.9223", "22865232.6621", "17646064.3333"], "r": ["15/16384", "1/1024"], "tail_max": "0.000000000001", "zfloor": ["5.951763", "18.298624", "13.421436", "41.243881", "23.885100", "73.381362", "37.341355", "114.707262", "53.818593", "156.525168", "63.339354", "126.152982", "416.747427", "73.595095", "103.048464", "185.670916", "515.141168", "84.543483", "100.194472", "134.969307", "227.181967", "560.093712", "90.301602", "98.342946", "114.297026", "149.014028", "237.197479", "531.766671", "93.261886", "93.695268", "94.348406", "95.445230", "97.448568", "101.103163", "108.042709", "121.564314", "149.570735", "215.063257", "404.434479"]}, + {"bound": ["4345517.1410", "2595562.3945", "5680867.5638", "3300283.3962", "10809128.2401", "6248099.0360", "18556698.6325", "10715290.6551", "22788086.6959", "14326963.0129", "22892939.8651", "22746478.9389", "7428368.4417", "22969679.1242", "22930452.0427", "22839167.7136", "8527811.7933", "23028876.9741", "22995527.3923", "22963291.8208", "22885597.8663", "10080342.3844", "23021479.8098", "23008011.2193", "23000439.8374", "22987397.7389", "22932211.2501", "12184981.4813", "23053266.5185", "23036307.5455", "23025926.1361", "23028683.3062", "23027274.2492", "23040116.5083", "23042436.4265", "23026588.4966", "23005521.8277", "22958255.1952", "17719599.8317"], "r": ["1/1024", "9/8192"], "tail_max": "0.000000000001", "zfloor": ["5.937676", "18.263880", "13.391650", "41.169721", "23.831977", "73.248015", "37.255853", "114.491157", "53.697720", "156.217269", "63.215574", "125.868059", "416.189631", "73.463797", "102.855135", "185.285122", "514.441659", "84.397401", "100.017917", "134.721941", "226.731096", "559.302137", "90.147629", "98.173814", "114.097162", "148.744787", "236.739710", "530.971081", "93.104301", "93.536953", "94.188947", "95.283791", "97.283431", "100.931201", "107.857752", "121.353746", "149.305666", "214.664330", "403.735916"]}, + {"bound": ["4469880.0636", "2747724.3164", "5728251.9580", "3344789.2003", "10856411.9891", "6281172.1574", "18619327.1996", "10753315.6359", "22852826.0824", "14369326.3209", "22944865.4100", "22813026.9208", "7548854.4032", "23012761.8742", "22978695.3778", "22898184.8266", "8673854.1829", "23067707.7018", "23036499.7940", "23008452.4737", "22939230.4943", "10254773.5792", "23058370.8154", "23045897.8739", "23040206.4983", "23030755.4685", "22982672.9877", "12394394.6722", "23088897.4354", "23071943.2276", "23061606.2630", "23064479.8474", "23063304.0092", "23076603.8118", "23079711.1605", "23065257.0865", "23046813.4822", "23004618.1494", "17756352.0837"], "r": ["9/8192", "5/4096"], "tail_max": "0.000000061151", "zfloor": ["5.926447", "18.236890", "13.370395", "41.118702", "23.797750", "73.165941", "37.205709", "114.370996", "53.631930", "156.052022", "63.161202", "125.712499", "415.998954", "73.418558", "102.778473", "185.097335", "514.223957", "84.353316", "99.960287", "134.630143", "226.528331", "559.055723", "90.104279", "98.124176", "114.034168", "148.649344", "236.545537", "530.709700", "93.062680", "93.495089", "94.146673", "95.240795", "97.238984", "100.884012", "107.805279", "121.290534", "149.218190", "214.511358", "403.466995"]}, + {"bound": ["4668346.0854", "2998372.8970", "5792125.6201", "3410674.5976", "10910386.2785", "6322355.8123", "18686073.8831", "10795716.0403", "22920120.9928", "14414309.5076", "22998527.6460", "22882496.8011", "7670740.2439", "23057199.4309", "23028530.7477", "22959548.0179", "8821313.6965", "23107722.5039", "23078726.6454", "23055031.8581", "22994754.6481", "10430720.9915", "23096381.0721", "23084932.0296", "23081178.4104", "23075446.9808", "23034812.6576", "12497585.1726", "23125621.2290", "23108672.0084", "23098380.8207", "23101370.4201", "23100433.9841", "23114203.6633", "23118120.4231", "23105101.7279", "23089368.9187", "23052457.1432", "17794439.9572"], "r": ["5/4096", "11/8192"], "tail_max": "0.000306433705", "zfloor": ["5.915215", "18.209890", "13.349133", "41.067664", "23.763512", "73.083832", "37.155546", "114.250780", "53.566115", "155.886700", "63.106811", "125.556871", "415.808189", "73.373304", "102.701782", "184.909464", "514.006153", "84.309216", "99.902639", "134.538310", "226.325475", "558.809193", "90.060915", "98.074521", "113.971152", "148.553866", "236.351278", "530.448198", "93.021032", "93.453197", "94.104371", "95.197786", "97.194522", "100.836809", "107.752789", "121.227300", "149.130681", "214.358321", "403.197948"]}, + {"bound": ["4978858.9556", "3397536.4886", "5880702.3311", "3508753.1564", "10974050.5185", "6375548.0510", "18758384.3704", "10844344.6356", "22990565.4439", "14462784.2981", "23054191.9770", "22955645.6237", "7794294.3504", "23103121.4242", "23080170.8750", "23023770.7497", "8970399.8701", "23149001.4050", "23122308.6948", "23103183.5365", "23052498.6054", "10608362.8827", "23135574.8621", "23125185.4101", "23123443.2118", "23121598.8211", "23088876.8715", "12523260.9528", "23163494.4154", "23146550.6273", "23136306.9759", "23139413.0089", "23138723.6769", "23152978.4831", "23157732.1971", "23146201.6515", "23133292.9101", "23101946.5233", "17834083.6286"], "r": ["11/8192", "3/2048"], "tail_max": "0.103341690345", "zfloor": ["5.903980", "18.182881", "13.327863", "41.016605", "23.729261", "73.001689", "37.105364", "114.130512", "53.500276", "155.721304", "63.052400", "125.401175", "415.617337", "73.328034", "102.625063", "184.721507", "513.788249", "84.265102", "99.844970", "134.446443", "226.122528", "558.562548", "90.017538", "98.024851", "113.908115", "148.458352", "236.156935", "530.186573", "92.979358", "93.411279", "94.062041", "95.154763", "97.150046", "100.789590", "107.700282", "121.164045", "149.043141", "214.205222", "402.928775"]}, + {"bound": ["5453229.0368", "4013352.3475", "6005287.2478", "3653833.7704", "11051530.6036", "6446102.7661", "18838247.7011", "10901747.3242", "23064972.6537", "14515946.4973", "23112219.2743", "23033510.6098", "7919888.7903", "23150701.5618", "23133904.0300", "23091555.2452", "9121398.2428", "23191649.5247", "23167379.6398", "23153113.9829", "23112909.3000", "10639390.9269", "23176035.5590", "23166751.6486", "23167116.4685", "23169380.1521", "23145200.0402", "12550229.1415", "23202589.6525", "23185652.0545", "23175458.2910", "23178682.3115", "23178249.8787", "23193009.0802", "23198634.9578", "23188660.8389", "23178724.6359", "23153321.2778", "17875582.4024"], "r": ["3/2048", "13/8192"], "tail_max": "10.815487385036", "zfloor": ["5.892741", "18.155862", "13.306586", "40.965527", "23.694997", "72.919511", "37.055163", "114.010190", "53.434412", "155.555834", "62.997971", "125.245410", "415.426397", "73.282750", "102.548314", "184.533466", "513.570243", "84.220975", "99.787282", "134.354541", "225.919490", "558.315788", "89.974146", "97.975164", "113.845056", "148.362802", "235.962506", "529.924825", "92.937657", "93.369333", "94.019685", "95.111727", "97.105556", "100.742356", "107.647758", "121.100768", "148.955568", "214.052058", "402.659476"]}, + {"bound": ["6161118.9011", "4937338.2651", "6181072.0678", "3865690.8019", "11148381.5958", "6541217.8742", "18928343.3021", "10971347.5238", "23144434.7493", "14575402.3894", "23173092.3262", "23117484.8763", "7963766.2304", "23200170.0629", "23190115.0367", "23163843.8176", "9167548.2358", "23235804.2032", "23214115.4178", "23205097.3215", "23176584.7211", "10663808.5275", "23217871.0659", "23209752.5070", "23212349.5526", "23219014.6476", "23204228.4435", "12578777.7549", "23243000.3547", "23226070.1303", "23215929.4088", "23219274.5129", "23219111.6026", "23234399.8930", "23240943.4977", "23232615.0238", "23225847.3331", "23206893.8058", "17919336.2865"], "r": ["13/8192", "7/4096"], "tail_max": "699.107274599396", "zfloor": ["5.881499", "18.128834", "13.285303", "40.914429", "23.660722", "72.837298", "37.004944", "113.889815", "53.368524", "155.390288", "62.943522", "125.089576", "415.235370", "73.237450", "102.471537", "184.345340", "513.352136", "84.176832", "99.729573", "134.262604", "225.716361", "558.068913", "89.930741", "97.925461", "113.781975", "148.267215", "235.767991", "529.662956", "92.895929", "93.327360", "93.977300", "95.068677", "97.061052", "100.695107", "107.595216", "121.037469", "148.867963", "213.898831", "402.390050"]}, + {"bound": ["7203163.2861", "6308195.4331", "6428027.0690", "4170230.2688", "11271948.8668", "6670391.5755", "19032215.7490", "11057664.9811", "23230393.7274", "14643270.9431", "23237447.4016", "23209407.2370", "7988759.3339", "23251828.5724", "23249310.3647", "23241879.8277", "9192407.6585", "23281643.5735", "23262745.3545", "23259492.9424", "23244312.4311", "10690086.6473", "23261220.3640", "23254345.3566", "23259339.0996", "23270794.7207", "23266548.8771", "12609285.8509", "23284846.2586", "23267925.1605", "23257841.7033", "23261313.0412", "23261436.0316", "23277285.3024", "23284805.9366", "23278240.1042", "23274899.8611", "23263073.9242", "17965871.6301"], "r": ["7/4096", "15/8192"], "tail_max": "21872.346650398392", "zfloor": ["5.870254", "18.101797", "13.264012", "40.863310", "23.626434", "72.755051", "36.954705", "113.769387", "53.302611", "155.224668", "62.889054", "124.933674", "415.044256", "73.192136", "102.394732", "184.157129", "513.133928", "84.132676", "99.671846", "134.170633", "225.513141", "557.821923", "89.887323", "97.875742", "113.718873", "148.171593", "235.573391", "529.400963", "92.854173", "93.285361", "93.934889", "95.025614", "97.016534", "100.647843", "107.542657", "120.974148", "148.780325", "213.745540", "402.120498"]}, + {"bound": ["8795032.4997", "8438201.3756", "6771951.3345", "4600871.1234", "11431794.1285", "6845939.2433", "19154481.2749", "11166574.1400", "23324725.1613", "14722303.9370", "23306111.6181", "23311667.9352", "8017206.6023", "23306067.9017", "23312147.8585", "23327279.5214", "9220025.8294", "23329396.7824", "23313565.4276", "23316766.3883", "23317114.9951", "10718715.4589", "23306261.3335", "23300732.0999", "23308338.2653", "23325098.4048", "23332922.4752", "12642245.2612", "23328280.0787", "23311370.6066", "23301350.0344", "23304983.9846", "23305385.6255", "23321837.1714", "23330412.0856", "23325762.1642", "23326190.4425", "23322392.5421", "18015871.3489"], "r": ["15/8192", "1/512"], "tail_max": "222751.102758725157", "zfloor": ["5.859005", "18.074751", "13.242713", "40.812172", "23.592134", "72.672769", "36.904448", "113.648905", "53.236674", "155.058973", "62.834566", "124.777703", "414.853054", "73.146806", "102.317897", "183.968834", "512.915618", "84.088505", "99.614098", "134.078626", "225.309830", "557.574817", "89.843890", "97.826007", "113.655749", "148.075935", "235.378705", "529.138848", "92.812391", "93.243334", "93.892450", "94.982434", "96.972002", "100.600564", "107.490081", "120.910806", "148.692656", "213.592186", "401.850819"]}, + {"bound": ["19556406.1838", "23232192.5276", "7910596.9152", "6037863.1054", "11946593.5347", "7425128.7123", "19544453.5745", "11523669.0693", "23632663.5502", "14983851.0361", "23547185.2007", "23653622.3055", "8118991.4316", "23513416.1146", "23544416.2767", "23627502.9731", "9323658.6610", "23522359.5205", "23515250.2470", "23537153.9863", "23583860.8096", "10829924.3275", "23493443.4671", "23491738.1162", "23506852.4043", "23539032.3495", "23582729.5308", "12771607.4814", "23512593.1024", "23495678.9460", "23485819.7137", "23489947.7574", "23491171.4352", "23509389.9618", "23521014.5190", "23521880.1658", "23533267.7997", "23553200.0796", "18209024.4079"], "r": ["1/512", "9/4096"], "tail_max": "8558918.674810918743", "zfloor": ["5.830589", "18.004645", "13.182588", "40.662442", "23.484873", "72.403516", "36.731812", "113.212605", "52.992660", "154.437361", "62.584898", "124.202402", "413.728727", "72.882230", "101.928104", "183.190217", "511.506205", "83.794288", "99.258404", "133.580016", "224.400190", "555.979991", "89.533861", "97.485404", "113.253154", "147.533334", "234.455400", "527.535689", "92.494960", "92.924431", "93.571241", "94.657230", "96.639550", "100.254349", "107.117660", "120.486730", "148.158619", "212.787942", "400.442364"]}, + {"bound": ["84123009.0237", "98436272.6574", "9939694.8948", "8635847.5669", "12769179.1089", "8417744.9812", "20039485.0109", "12053207.0259", "23929927.4202", "15292382.7826", "23737109.2738", "23994038.1880", "8221571.7054", "23650829.7087", "23713562.7736", "23893108.4043", "9414575.4632", "23637799.8217", "23640557.2632", "23684714.6692", "23792609.8152", "10916736.4626", "23600523.7554", "23602873.8165", "23626107.3665", "23675844.0667", "23764565.9373", "12867890.8497", "23615047.6949", "23598194.2435", "23588537.9508", "23593155.2648", "23595184.8828", "23615153.4815", "23629915.2528", "23636667.5790", "23660190.9114", "23708426.8277", "18351714.3757"], "r": ["9/4096", "5/2048"], "tail_max": "71967637.713002001644", "zfloor": ["5.808029", "17.950393", "13.139851", "40.559803", "23.416016", "72.238293", "36.630884", "112.970584", "52.860209", "154.104465", "62.475386", "123.889048", "413.344059", "72.791058", "101.773625", "182.811795", "511.066867", "83.705410", "99.142235", "133.394995", "223.991506", "555.482709", "89.446436", "97.385319", "113.126154", "147.340943", "234.063999", "527.008302", "92.410759", "92.839736", "93.485717", "94.570193", "96.549908", "100.159183", "107.011845", "120.359271", "147.982258", "212.479561", "399.900021"]}, + {"bound": ["359764274.2693", "364500708.3699", "13449043.4669", "13141405.6416", "14147340.0584", "10116449.3051", "20809358.8775", "12926195.7475", "24342336.7975", "15764453.8168", "23980407.7879", "24479586.4787", "8373268.9707", "23815643.0799", "23926019.5852", "24258454.9882", "9543278.6996", "23770811.3660", "23787476.0002", "23864048.1595", "24066084.5826", "11034203.5430", "23722100.7257", "23729882.3159", "23764349.5471", "23839160.4460", "23995666.0772", "12995293.8853", "23730381.2670", "23713631.7225", "23704262.7541", "23709537.4546", "23712657.5134", "23734956.2390", "23753955.3141", "23768803.0252", "23809426.6169", "23899273.2104", "18537882.0875"], "r": ["5/2048", "11/4096"], "tail_max": "321518939.381658620381", "zfloor": ["5.785456", "17.896103", "13.097086", "40.457084", "23.347109", "72.072931", "36.529879", "112.728348", "52.727660", "153.771269", "62.365797", "123.575419", "412.959040", "72.699824", "101.619030", "182.433031", "510.627120", "83.616474", "99.025986", "133.209833", "223.582455", "554.984964", "89.358651", "97.285168", "112.999067", "147.148406", "233.672254", "526.480422", "92.326448", "92.754932", "93.400083", "94.483043", "96.460209", "100.063956", "106.905960", "120.231724", "147.805766", "212.170923", "399.357169"]}, + {"bound": ["1210055145.4089", "936373442.5809", "19480197.7803", "20745083.6623", "16399801.4617", "12921953.5480", "22012431.2145", "14338976.7069", "24934448.1689", "16493109.8846", "24305759.4233", "25192010.9759", "8601812.2572", "24021447.6069", "24204592.6771", "24778970.2835", "9730830.6408", "23929259.7574", "23966199.1023", "24091198.0153", "24439298.4099", "11199047.1532", "23864143.1927", "23879645.7546", "23930245.9864", "24041962.0288", "24302081.1113", "13170580.7242", "23863748.5031", "23847172.5553", "23838224.6264", "23844420.6469", "23849087.6551", "23874626.6725", "23899591.9797", "23926009.8822", "23991546.4087", "24143952.2763", "18790835.2596"], "r": ["11/4096", "3/1024"], "tail_max": "1145773954.908037293973", "zfloor": ["5.762869", "17.841775", "13.054291", "40.354285", "23.278153", "71.907430", "36.428798", "112.485897", "52.595011", "153.437772", "62.256130", "123.261514", "412.573668", "72.608529", "101.464320", "182.053926", "510.186966", "83.527480", "98.909658", "133.024531", "223.173037", "554.486754", "89.270754", "97.184951", "112.871892", "146.955725", "233.280164", "525.952049", "92.242030", "92.670019", "93.314339", "94.395781", "96.370453", "99.968668", "106.800005", "120.104089", "147.629143", "211.862028", "398.813808"]}, + {"bound": ["2216862479.4891", "1612403032.0701", "37855972.2516", "36980385.8027", "19993104.3960", "17410976.0799", "23877607.8118", "16573507.4526", "25800100.6317", "17612211.0690", "24755059.1735", "26249775.0954", "8947286.5141", "24288162.3199", "24582604.8642", "25535193.7335", "10007795.9032", "24124673.2922", "24191645.6991", "24389590.1110", "24963163.4541", "11435549.4557", "24035504.6336", "24062243.4380", "24136476.6050", "24303200.4637", "24721709.1909", "13418096.1112", "24022706.0015", "24006412.0119", "23998090.8834", "24005612.1089", "24012533.7609", "24042705.2859", "24076283.4218", "24119591.9499", "24221998.7431", "24469003.9649", "19144435.4944"], "r": ["3/1024", "13/4096"], "tail_max": "2110863506.512380323605", "zfloor": ["5.740268", "17.787411", "13.011468", "40.251405", "23.209147", "71.741790", "36.327642", "112.243232", "52.462262", "153.103974", "62.146384", "122.947333", "412.187943", "72.517173", "101.309493", "181.674479", "509.746403", "83.438428", "98.793250", "132.839089", "222.763253", "553.988079", "89.182743", "97.084669", "112.744630", "146.762897", "232.887730", "525.423182", "92.157503", "92.584997", "93.228484", "94.308407", "96.280639", "99.873318", "106.693980", "119.976367", "147.452391", "211.552876", "398.269937"]}, + {"bound": ["5501151015.2765", "3511310767.2067", "135610034.0062", "98609684.4213", "26139280.1414", "24661039.8205", "26745647.4898", "20034210.8176", "27072556.2311", "19309940.9193", "25388262.2680", "27820237.2744", "9466163.5120", "24644419.4315", "25107724.3121", "26641290.9519", "10417428.0721", "24373608.6237", "24485201.9499", "24792700.9231", "25710021.1646", "11778153.0841", "24248897.9772", "24292135.7442", "24401205.4999", "24649955.3814", "25308464.4470", "13772393.9672", "24218112.3060", "24202263.7584", "24194877.9583", "24204327.9702", "24214570.1676", "24251454.2713", "24297600.4991", "24365749.6723", "24522880.5398", "24912264.3068", "19646772.8581"], "r": ["13/4096", "7/2048"], "tail_max": "5330399946.180846697497", "zfloor": ["5.717654", "17.733009", "12.968616", "40.148445", "23.140092", "71.576010", "36.226409", "112.000352", "52.329415", "152.769875", "62.036561", "122.632876", "411.801866", "72.425755", "101.154550", "181.294690", "509.305432", "83.349319", "98.676761", "132.653506", "222.353100", "553.488940", "89.094620", "96.984321", "112.617280", "146.569925", "232.494951", "524.893820", "92.072867", "92.499866", "93.142519", "94.220920", "96.190769", "99.777907", "106.587886", "119.848557", "147.275508", "211.243466", "397.725556"]}, + {"bound": ["5943710911.3392", "3286304143.9366", "703806288.2761", "460597646.7685", "51384734.0740", "44201647.5605", "31789416.6197", "25626747.8652", "28951897.1128", "21853684.0770", "26295201.3486", "30139474.9765", "10237871.0455", "25133247.9412", "25848960.1874", "28257288.3157", "11020255.2474", "24700078.1351", "24877562.0838", "25347967.5021", "26780861.0949", "12274820.9965", "24522599.3407", "24590024.3860", "24750281.5261", "25120460.6920", "26137689.9704", "14281580.8872", "24465595.6773", "24450432.1191", "24444432.5517", "24456692.2165", "24471932.9315", "24518450.9763", "24582940.4481", "24687537.6366", "24925446.3045", "25526823.2601", "20364837.5609"], "r": ["7/2048", "15/4096"], "tail_max": "5675171888.244705732051", "zfloor": ["5.695025", "17.678569", "12.925734", "40.045405", "23.070987", "71.410090", "36.125100", "111.757257", "52.196467", "152.435475", "61.926661", "122.318142", "411.415435", "72.334276", "100.999491", "180.914558", "508.864051", "83.260152", "98.560193", "132.467782", "221.942580", "552.989335", "89.006384", "96.883908", "112.489841", "146.376806", "232.101827", "524.363964", "91.988123", "92.414626", "93.056444", "94.133322", "96.100442", "99.682434", "106.481721", "119.720659", "147.098494", "210.933799", "397.180664"]}, + {"bound": ["5486616622.1015", "3157799403.8140", "3082816727.9805", "1669074638.1048", "298659890.8376", "196296656.5332", "55537081.4148", "42639674.6958", "32184918.9660", "25855052.8294", "27786793.3472", "33673127.4660", "11417783.5776", "25898702.2553", "26972040.8173", "30658015.6089", "11920289.0156", "25158695.4702", "25430508.5928", "26137248.5990", "28326944.1828", "12996783.3894", "24893169.3285", "24995244.1595", "25229227.6744", "25775908.5222", "27319391.1801", "15014758.8485", "24796581.7357", "24782416.6051", "24778406.8453", "24794670.6787", "24817067.8455", "24877333.2616", "24968088.0225", "25125182.2453", "25480281.4502", "26391841.1322", "21394247.9490"], "r": ["15/4096", "1/256"], "tail_max": "5073878256.475586704321", "zfloor": ["5.672384", "17.624092", "12.882824", "39.942284", "23.001832", "71.244031", "36.023715", "111.513946", "52.063421", "152.100774", "61.816682", "122.003131", "411.028651", "72.242736", "100.844315", "180.534083", "508.422262", "83.170928", "98.443545", "132.281918", "221.531692", "552.489265", "88.918036", "96.783428", "112.362315", "146.183542", "231.708358", "523.833612", "91.903270", "92.329276", "92.970258", "94.045610", "96.009960", "99.586899", "106.375486", "119.592672", "146.921350", "210.623875", "396.635261"]}, + {"bound": ["5715179362.5943", "3658319460.3774", "3187193211.5398", "1806011730.1774", "2213411437.9777", "1205688453.9784", "1421657129.5691", "846778657.1734", "181753259.9221", "126113390.6009", "103214835.8766", "106662442.6580", "35763799.1422", "62877682.8778", "61298170.5927", "65703191.7761", "25339341.2002", "37037816.1338", "36958843.5396", "37564911.7615", "41466547.7396", "18984541.1447", "32053287.7021", "32070200.0999", "32241034.0375", "32952946.9793", "35852947.3913", "19890257.2373", "31102776.2126", "31079541.9003", "31065688.8077", "31070777.5858", "31072831.2855", "31105277.1509", "31155060.1787", "31278121.5530", "31721657.0764", "33321503.8802", "27842065.4191"], "r": ["1/256", "9/2048"], "tail_max": "4794208395.780027339202", "zfloor": ["5.614566", "17.481372", "12.760325", "39.637119", "22.783202", "70.695169", "35.671827", "110.624790", "51.566207", "150.834021", "61.308817", "120.830424", "408.744758", "71.705586", "100.052044", "178.948390", "505.561508", "82.574205", "97.721717", "131.269012", "219.680449", "549.252496", "88.288433", "96.092782", "111.545536", "145.081685", "229.830318", "520.578933", "91.259281", "91.682294", "92.318584", "93.385804", "95.335349", "98.885222", "105.620519", "118.732639", "145.837521", "208.989543", "393.772559"]}, + {"bound": ["5540451488.6323", "4307572399.2887", "2873821094.0360", "1807230957.0341", "1931167559.3639", "1120394772.9071", "1485035247.7707", "829071635.1625", "1066745114.4758", "631609089.1138", "850847877.3714", "788363463.9082", "260569935.1461", "703256104.3577", "666134027.7961", "624169163.2542", "239238067.8472", "381811083.4480", "372162626.9066", "361307520.9046", "361259468.7617", "164556310.7433", "262120299.7023", "258627534.6034", "253619575.7293", "247849884.0493", "247857506.5252", "134344723.5566", "237557591.3283", "237226593.5766", "236864547.7426", "236442150.6081", "235642637.0864", "234420822.6570", "232212923.4293", "228630992.1504", "224031361.6198", "221273393.4959", "173758608.7841"], "r": ["9/2048", "5/1024"], "tail_max": "3637139528.057880050042", "zfloor": ["5.569031", "17.371768", "12.673934", "39.429406", "22.643849", "70.360378", "35.467373", "110.133878", "51.297775", "150.158507", "61.086679", "120.194667", "407.962035", "71.520428", "99.738406", "178.180011", "504.666931", "82.393580", "97.485690", "130.893193", "218.850305", "548.239934", "88.109135", "95.889334", "111.287440", "144.690799", "229.035144", "519.505453", "91.086995", "91.509001", "92.143597", "93.207727", "95.151659", "98.691696", "105.405365", "118.473529", "145.479088", "208.362911", "392.669655"]}, + {"bound": ["6480508490.4233", "6141096291.6374", "2822896454.9260", "2081967401.4685", "1825490781.5940", "1179322988.1932", "1352509132.1686", "816562968.7292", "905986160.9498", "569187143.8359", "692116792.4001", "677402222.1410", "223507177.9295", "554611118.5659", "532494060.5212", "521802413.4428", "199348858.9439", "466734221.0249", "454494383.3925", "437924027.3120", "425005417.4361", "190097128.0296", "431179860.8709", "425042038.4187", "415490135.8348", "401728827.1270", "388215336.5132", "205375211.8995", "414259813.7926", "413671653.1036", "413021631.8977", "412248658.3751", "410778082.6137", "408468215.6004", "404195326.3548", "396841111.2809", "385758908.8392", "372150283.3287", "281267826.0354"], "r": ["5/1024", "11/2048"], "tail_max": "2773969029.384375777413", "zfloor": ["5.523439", "17.262013", "12.587425", "39.221368", "22.504295", "70.025022", "35.262609", "109.642096", "51.028939", "149.481773", "60.864223", "119.557790", "407.177881", "71.335019", "99.424296", "177.410243", "503.770697", "82.211692", "97.249337", "130.516802", "218.018670", "547.225485", "87.929380", "95.685617", "111.028984", "144.299319", "228.238568", "518.429967", "90.914268", "91.335264", "91.968162", "93.029194", "94.967498", "98.497918", "105.189925", "118.214059", "145.120123", "207.735233", "391.564681"]}, + {"bound": ["9012886723.2218", "9790052924.6244", "3168335892.5008", "2787534312.1938", "1876842231.2895", "1406575583.9170", "1344096604.7263", "912233766.5179", "855141282.3653", "590802489.5743", "623861384.1882", "669458956.3883", "220694942.2066", "481910160.7968", "474270248.7421", "501902374.9467", "191008649.9731", "394801715.8969", "387661504.8445", "381132394.4800", "392389745.6958", "176272842.5962", "360408418.8718", "356496577.6838", "350996496.5048", "345103119.2546", "349448755.9530", "187916943.9276", "344202277.9489", "343759276.8199", "343297149.0747", "342798274.2952", "341834400.7116", "340392634.6148", "337755408.6585", "333424506.9421", "328004777.3826", "326152028.8377", "257341963.0817"], "r": ["11/2048", "3/512"], "tail_max": "2144866874.994415977920", "zfloor": ["5.477792", "17.152107", "12.500799", "39.013006", "22.364539", "69.689102", "35.057536", "109.149442", "50.759698", "148.803818", "60.641450", "118.919791", "406.392295", "71.149358", "99.109712", "176.639085", "502.872802", "82.029127", "97.012656", "130.139836", "217.185542", "546.209147", "87.749167", "95.481630", "110.770169", "143.907245", "227.440591", "517.352472", "90.741101", "91.161085", "91.792280", "92.850205", "94.782867", "98.303887", "104.974198", "117.954229", "144.760625", "207.106507", "390.457635"]}, + {"bound": ["13887994410.3019", "16217323261.2718", "4106615134.4586", "4158028619.3459", "2161448398.1136", "1893528761.6689", "1460275193.5387", "1142979000.9124", "877445200.4609", "689322423.4711", "608216284.9936", "745487077.3775", "245720972.2026", "452803619.8626", "463977868.8749", "548740761.0923", "207931889.4477", "362143195.3523", "360635011.1084", "366481515.7325", "412140169.9685", "186390477.7782", "326832471.4295", "325181755.0347", "324077361.8630", "327580289.5554", "356418547.8734", "196304007.4129", "310152597.1507", "309824249.2214", "309528477.5565", "309300647.0805", "308831597.3056", "308274854.3544", "307316807.7166", "306194658.2332", "307276396.0894", "320633820.2929", "269496320.6837"], "r": ["3/512", "13/2048"], "tail_max": "1686307379.696001880708", "zfloor": ["5.432090", "17.042049", "12.414056", "38.804317", "22.224581", "69.352616", "34.852153", "108.655917", "50.490052", "148.124641", "60.418358", "118.280668", "405.605274", "70.963446", "98.794653", "175.866535", "501.973245", "81.846096", "96.775647", "129.762296", "216.350920", "545.190918", "87.568496", "95.277374", "110.510995", "143.514576", "226.641209", "516.272967", "90.567493", "90.986461", "91.615949", "92.670759", "94.597764", "98.109544", "104.758183", "117.694039", "144.400593", "206.476731", "389.348513"]}, + {"bound": ["22258894948.6394", "26858059400.8498", "5917703085.8352", "6532735965.2208", "2803313604.2010", "2781066653.8310", "1760514594.9534", "1579252078.5237", "980293830.9488", "889245272.6989", "636093558.8527", "919240175.3652", "303008835.8813", "452226328.9086", "491743805.6124", "667096637.3463", "251645545.8310", "352892748.7703", "359239491.6277", "383307883.8453", "482635517.2297", "220013727.8654", "315084861.3336", "316429724.8368", "321381668.6090", "338494271.6626", "404985674.4761", "229510142.6307", "297113408.3202", "296908564.5828", "296811869.0898", "296936398.9536", "297105025.4456", "297728872.8227", "298999513.6523", "302235721.0768", "312540384.0407", "348721100.0567", "316681588.3302"], "r": ["13/2048", "7/1024"], "tail_max": "1348324483.559239004071", "zfloor": ["5.386332", "16.931840", "12.327195", "38.595303", "22.084420", "69.015564", "34.646460", "108.161518", "50.220000", "147.444241", "60.194948", "117.640420", "404.816818", "70.777281", "98.479120", "175.092593", "501.072025", "81.662599", "96.538310", "129.384180", "215.514800", "544.170796", "87.387366", "95.072848", "110.251459", "143.121311", "225.840421", "515.191449", "90.393443", "90.811394", "91.439170", "92.490857", "94.412190", "97.913278", "104.541881", "117.433488", "144.040027", "205.845905", "388.237315"]}, + {"bound": ["35832580365.8471", "43794610399.9157", "9010907467.3967", "10402831656.2789", "3977432545.2793", "4270692984.3755", "2342635471.4314", "2329418731.9324", "1201366114.4212", "1241507619.5892", "721079804.6265", "1234975010.6000", "406917429.3914", "482236371.6864", "565795982.9433", "884663979.8456", "332286983.3231", "363889063.8934", "382124791.8888", "434381258.7252", "618424766.0502", "284031364.9927", "320434777.4459", "326228010.3802", "340327423.5317", "378401601.8357", "504094261.6342", "293849062.6844", "299710323.3035", "299669987.6978", "299855187.6297", "300499849.0992", "301605720.5060", "303987116.1289", "308581306.1464", "318370319.1376", "342783094.8124", "414585555.9157", "407712726.1026"], "r": ["7/1024", "15/2048"], "tail_max": "1096666788.302687129780", "zfloor": ["5.340518", "16.821479", "12.240217", "38.385964", "21.944058", "68.677946", "34.440457", "107.666246", "49.949543", "146.762616", "59.971218", "116.999048", "404.026926", "70.590864", "98.163112", "174.317257", "500.169140", "81.478636", "96.300645", "129.005489", "214.677184", "543.148780", "87.205777", "94.868051", "109.991563", "142.727450", "225.038226", "514.107917", "90.218953", "90.635883", "91.261943", "92.310499", "94.226144", "97.716512", "104.325290", "117.172577", "143.678926", "205.214027", "387.124038"]}, + {"bound": ["57056569961.4478", "69971360017.7629", "13979168928.0455", "16469333646.9720", "5932542176.2148", "6648615623.7213", "3345811339.1759", "3547980073.0484", "1601132736.6751", "1822780020.1152", "891800599.2559", "1764725442.5014", "580725634.4156", "556394539.7852", "708028043.5402", "1250605067.2292", "467928491.3327", "401623137.6632", "438049523.5187", "533876635.4091", "849909208.5586", "392519490.4339", "346931622.9599", "359482947.5694", "387596185.1644", "458052661.0309", "675910214.3171", "403213676.7403", "320875639.3362", "321071092.7670", "321674941.8652", "323109427.3098", "325635101.5350", "330695955.1299", "340357911.7550", "360176591.7265", "406341569.7168", "533489670.4642", "562009380.5927"], "r": ["15/2048", "1/128"], "tail_max": "903995437.455455907581", "zfloor": ["5.294648", "16.710967", "12.153121", "38.176299", "21.803493", "68.339761", "34.234144", "107.170100", "49.678679", "146.079767", "59.747170", "116.356549", "403.235596", "70.404194", "97.846628", "173.540525", "499.264589", "81.294206", "96.062652", "128.626221", "213.838068", "542.124868", "87.023730", "94.662984", "109.731307", "142.332992", "224.234624", "513.022369", "90.044020", "90.459927", "91.084266", "92.129683", "94.039626", "97.519245", "104.108410", "116.911303", "143.317289", "204.581097", "386.008680"]}, + {"bound": ["139260482967.8848", "169927353177.7088", "33824097032.8545", "40106848072.1779", "14065076833.7528", "16154615641.3055", "7705805152.6889", "8551783663.2083", "3442525691.6223", "4270699083.0095", "1757890513.3076", "4056017850.6068", "1325250551.5126", "992750106.6221", "1412432182.6233", "2846127451.6773", "1056287678.0210", "661112224.8406", "768181650.3513", "1035618268.1715", "1877365569.0647", "868824888.6967", "549037912.8595", "587577497.1041", "670246282.6369", "868210421.0361", "1452917052.0502", "885702298.2804", "496096405.6266", "497120836.4893", "499282668.5187", "503755169.3166", "511722672.7153", "527147137.1595", "556417624.4638", "615254640.5938", "746889084.7870", "1093807234.8639", "1242160505.1715"], "r": ["1/128", "9/1024"], "tail_max": "768452348.458096607320", "zfloor": ["5.174956", "16.415227", "11.898880", "37.542599", "21.349358", "67.199641", "33.503200", "105.324009", "48.646539", "143.449895", "58.696511", "113.920440", "398.524402", "69.297222", "96.210172", "170.252486", "493.372493", "80.062393", "94.576367", "126.536261", "210.004638", "535.459503", "85.726760", "93.243183", "108.050436", "140.061196", "220.349853", "506.315895", "88.718818", "89.128539", "89.743169", "90.771737", "92.651011", "96.074033", "102.557195", "115.142754", "141.085262", "201.206695", "380.096117"]}, + {"bound": ["313452420200.9877", "379226292735.2249", "76289911519.9982", "89999774546.9598", "31676592940.5002", "36413586003.5560", "17254167244.2939", "19327441567.1240", "7482899043.3689", "9562856918.5404", "3668584300.2241", "9046262948.1271", "2936424591.0279", "1957244709.6371", "2962737553.9558", "6323558994.0690", "2333297185.4190", "1228934266.0590", "1491517646.7247", "2134492574.9952", "4114922394.4485", "1902121856.9491", "987530083.1132", "1083589127.8111", "1286511062.1578", "1763905241.8610", "3144738268.9090", "1931942944.9274", "874558651.2454", "877437031.9742", "883070638.5904", "894298066.8396", "914360718.0279", "952785036.4766", "1025409252.4255", "1170450892.6777", "1489901810.0475", "2315778120.8844", "2718540304.0439"], "r": ["9/1024", "5/512"], "tail_max": "553082883.605427201615", "zfloor": ["5.082170", "16.191518", "11.722323", "37.117206", "21.063916", "66.512269", "33.083612", "104.314054", "48.095150", "142.059031", "58.239428", "112.611784", "396.904278", "68.915350", "95.563678", "168.668406", "491.518402", "79.683071", "94.089166", "125.760907", "208.291951", "533.360836", "85.352008", "92.820037", "107.517424", "139.254365", "218.708749", "504.092448", "88.358384", "88.766003", "89.377101", "90.399230", "92.266807", "95.667786", "102.112433", "114.607330", "140.344966", "199.912938", "377.815704"]}, + {"bound": ["664742470063.7071", "796242518724.2115", "162963422624.9908", "190387435695.7134", "68154243666.0557", "77673454874.9846", "37335362521.3021", "41547021046.8292", "16091702261.3314", "20559151546.5928", "7820822874.0249", "19552257278.8125", "6299211488.8235", "4109459746.4218", "6331276777.4867", "13672460027.6590", "5016992486.0023", "2523459999.7413", "3110402625.3383", "4533432623.2482", "8867567027.5780", "4083250675.0852", "1999125488.9905", "2215234003.1506", "2669107153.8400", "3728207845.1535", "6756314096.0373", "4145061842.2883", "1755882391.6407", "1762559478.8240", "1775398785.2339", "1800744417.6384", "1846057939.2388", "1932562296.2390", "2095532442.2027", "2420653992.1338", "3132413786.7249", "4951532627.7993", "5846731637.1177"], "r": ["5/512", "11/1024"], "tail_max": "413336363.229865231582", "zfloor": ["4.989155", "15.967187", "11.545282", "36.690478", "20.777639", "65.822575", "32.662741", "103.300515", "47.542082", "140.663138", "57.781019", "111.298496", "395.278243", "68.530739", "94.915209", "167.078585", "489.657455", "79.301832", "93.600593", "124.983161", "206.573089", "531.254363", "84.975369", "92.392677", "106.982904", "138.445056", "217.061838", "501.860699", "87.996132", "88.401639", "89.009187", "90.024843", "91.880662", "95.259482", "101.666463", "114.070396", "139.602441", "198.614829", "375.526727"]}, + {"bound": ["1339889061792.5117", "1588430407773.6607", "331194419118.1452", "382735145585.8548", "139817455364.7540", "157566738930.9759", "77283555075.4533", "85045353731.3745", "33338018443.4945", "42219562012.9042", "16230305035.2411", "40458521895.8238", "12933295265.9008", "8530292229.4297", "13159580265.7578", "28333778523.4870", "10339337751.4970", "5209924924.1384", "6437685390.8716", "9406315129.3578", "18376105128.5537", "8421494241.6864", "4112637897.0079", "4566985661.2975", "5517013259.6909", "7726621826.7111", "14002699336.2453", "8553755957.9395", "3606541238.5038", "3620707237.8755", "3647853492.5946", "3701334291.0175", "3796918877.4773", "3979153041.7649", "4321334641.4548", "5003504489.8874", "6489768970.9381", "10272281629.6016", "12090960895.4646"], "r": ["11/1024", "3/256"], "tail_max": "318473372.839832855536", "zfloor": ["4.895909", "15.742235", "11.367755", "36.262414", "20.490527", "65.130557", "32.240587", "102.283385", "46.987331", "139.262210", "57.321282", "109.980568", "393.646285", "68.141130", "94.264762", "165.483011", "487.789637", "78.918672", "93.110645", "124.203016", "204.848041", "529.140067", "84.596840", "91.963161", "106.446874", "137.633261", "215.409107", "499.620633", "87.632060", "88.035444", "88.639424", "89.648573", "91.492573", "94.849118", "101.218181", "113.531948", "138.857682", "197.312357", "373.229170"]}, + {"bound": ["2586436720997.7072", "3034406559538.3779", "644521885194.7625", "736582282606.2671", "274732422025.3466", "305966860834.5198", "153324822821.1774", "166652517210.4207", "66348888481.7555", "83070565398.2887", "32461486162.8208", "80270537566.8075", "25454438384.2280", "17156319854.0797", "26355045169.7522", "56313961568.5148", "20434241303.2625", "10484589716.9048", "12934161385.0721", "18838985821.4894", "36564448697.2007", "16671604946.2916", "8275100584.5408", "9184799552.3358", "11081384743.1954", "15479858378.2953", "27896816485.6576", "16950395994.9935", "7262400897.8428", "7290813491.8480", "7345303183.5328", "7452683434.8125", "7644509514.0369", "8010019793.3800", "8695438237.3093", "10058342370.7095", "13021848481.4260", "20525329160.7364", "24009321699.6394"], "r": ["3/256", "13/1024"], "tail_max": "251665563.639994911749", "zfloor": ["4.802434", "15.516661", "11.189744", "35.833013", "20.202577", "64.436213", "31.817148", "101.262660", "46.430895", "137.856237", "56.860214", "108.657992", "392.008397", "67.749549", "93.612333", "163.881677", "485.914937", "78.533590", "92.619319", "123.420469", "203.116796", "527.017937", "84.216419", "91.531488", "105.909330", "136.818977", "213.750547", "497.372235", "87.266167", "87.667416", "88.267808", "89.270417", "91.102537", "94.436692", "100.762725", "112.991984", "138.110686", "196.005514", "370.923016"]}, + {"bound": ["4810824717442.3931", "5585478143358.1587", "1208030964162.4334", "1365362452220.1119", "519781390459.7784", "572057438765.6431", "292845076537.2499", "314345863387.6677", "127199495796.5871", "157358240232.3856", "62585637250.7015", "153335601622.9609", "48225304445.0301", "33311230462.4529", "50872338221.3018", "107754079821.5002", "38875915310.3128", "20412785684.6353", "25103999338.6319", "36387201053.4932", "70065048578.3271", "31778751166.3886", "16130920360.3845", "17878696323.6938", "21512875202.7747", "29923130441.5481", "53538519379.7343", "32347221327.8013", "14180007997.6552", "14234548434.9060", "14339389505.0596", "14546225546.9833", "14915522697.3567", "15618971125.0379", "16936460139.3991", "19549567535.8242", "25224138303.8470", "39527855968.4045", "45912301238.0053"], "r": ["13/1024", "7/512"], "tail_max": "203156216.544042191663", "zfloor": ["4.708729", "15.290464", "11.011246", "35.402274", "19.913790", "63.739539", "31.392421", "100.238336", "45.872771", "136.445213", "56.397813", "107.330761", "390.364568", "67.355993", "92.957919", "162.274571", "484.033345", "78.146582", "92.126613", "122.635516", "201.379343", "524.887959", "83.834104", "91.097655", "105.370268", "136.002198", "212.086147", "495.115491", "86.898449", "87.297552", "87.894340", "88.890375", "90.710552", "94.022200", "100.304979", "112.450499", "137.361448", "194.694293", "368.608253"]}, + {"bound": ["8665137068393.1518", "9956019454279.8119", "2191371516008.7021", "2449753272085.5618", "951336463998.4963", "1034848412477.0997", "540879232497.8232", "573470648590.7270", "235823333311.7894", "288280513026.0400", "116674561868.1804", "283242329700.6185", "88335645844.6949", "62551397819.6754", "94936655705.1922", "199340068680.9127", "71497644630.9826", "38459729418.3000", "47132932677.2517", "67959296947.7603", "129804930941.9260", "58560640216.3836", "30443142904.3316", "33684447707.9762", "40406762750.6002", "55938974468.6970", "99343133556.3185", "59678966758.8825", "26811416987.6454", "26912366466.5422", "27106981044.4760", "27491475014.8567", "28177598400.6187", "29484295263.9806", "31928726932.7159", "36764501939.2241", "47257613493.3256", "73601349136.8585", "84880582065.7067"], "r": ["7/512", "15/1024"], "tail_max": "167014041.672379346462", "zfloor": ["4.614793", "15.063644", "10.832262", "34.970195", "19.624164", "63.040533", "30.966404", "99.210408", "45.312956", "135.029132", "55.934077", "105.998869", "388.714792", "66.960462", "92.301516", "160.661687", "482.144852", "77.757647", "91.632524", "121.848151", "199.635673", "522.750121", "83.449892", "90.661659", "104.829687", "135.182920", "210.415897", "492.850389", "86.528905", "86.925851", "87.519015", "88.508442", "90.316616", "93.605641", "99.844941", "111.907492", "136.609963", "193.378685", "366.284867"]}, + {"bound": ["15174797427265.5022", "17254355056897.0472", "3862733277574.1783", "4271623345254.2016", "1691123367404.9855", "1818572004394.0915", "969831263734.9964", "1015917103460.9613", "424374873249.9529", "512776099953.9125", "211039720200.5779", "507901064449.7291", "157045094001.9905", "113936980702.0093", "171875790846.9824", "357898787286.4434", "127600200070.4190", "70296070608.1778", "85844141641.3811", "123136037326.5608", "233369855330.7983", "104715238863.2923", "55741998830.1991", "61570244463.0367", "73626531501.0033", "101452141041.3803", "178872391108.5589", "106841875214.1672", "49184656220.5629", "49365727240.1784", "49715894810.8599", "50408780433.3970", "51644562252.3530", "53997766756.0053", "58395007342.3763", "67070667835.8411", "85889949258.7039", "132965416794.4147", "152275033950.0566"], "r": ["15/1024", "1/64"], "tail_max": "139486768.697320494657", "zfloor": ["4.520628", "14.836201", "10.652791", "34.536776", "19.333699", "62.339195", "30.539097", "98.178873", "44.751449", "133.607988", "55.469004", "104.662309", "387.059061", "66.562952", "91.643120", "159.043016", "480.249447", "77.366782", "91.137049", "121.058371", "197.885776", "520.604413", "83.063781", "90.223497", "104.287583", "134.361138", "208.739790", "490.576917", "86.157532", "86.552310", "87.141832", "88.124618", "89.920727", "93.187013", "99.382608", "111.362959", "135.856227", "192.058685", "363.952845"]} + ] +} diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json new file mode 100644 index 00000000..e966d1a0 --- /dev/null +++ b/frontiers/c8_theorem_a_constants_d3_20261001/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-D3-20261001-v1", + "files": [ + { + "path": "NOTE.md", + "bytes": 35268, + "sha256": "873e466b84d6b6e5a2f0ce71a0f58b3b6ebf1298a1ba9d588cbc91c86242ed6d", + "git_blob": "e22b13df4e4fb9c0ec99c3a0e92b548a388a182a" + }, + { + "path": "README.md", + "bytes": 3624, + "sha256": "b096e42b1f31b30f025c813b64eda44b03a725496ea1a298de0f51edc3249b94", + "git_blob": "bfd92f786151b154b86fdde34f94675995045df9" + }, + { + "path": "RESULTS.json", + "bytes": 159177, + "sha256": "9d9e889018b197ef4d997744d05bb1e7b84881abd29ae14874d452343d9b67c0", + "git_blob": "e227c1aca350afed080923fa0bb6b3e976f967ee" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 5906, + "sha256": "2f23f4a57cf4f64da2d95069e874dae417ed5407d186008c0b4f48bc17e6ca58", + "git_blob": "b5de31814760baf99b37ff242684cf1ff71c6eb3" + }, + { + "path": "theorem_a3.py", + "bytes": 75753, + "sha256": "b0e1b3b4f43e140b51609332fe2e54f4f6b50d10f9f6af48d40ff548bbe742c0", + "git_blob": "ac809dbd36981d1b214fb2f8626417b50afb41f3" + } + ], + "nonauthor_reads": [] +} diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_MAP.json b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_MAP.json new file mode 100644 index 00000000..b5de3181 --- /dev/null +++ b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_MAP.json @@ -0,0 +1,85 @@ +{ + "schema": 1, + "object": "CL-C8-THEOREM-A-CONSTANTS-D3-20261001-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 E3: for the d = 3 eight-pin law of [LP] and the good event G_r of [LP] section 7 / [CAP] (1) (partial-block operator norms on D = [-2r, 2r] x ball(0, 2r)), 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) <= C3(r_*) r^3 and Z_r / r^2 >= z3(r_*) for 0 < r <= r_*, with C3(1/4096) = 22754801.7964 (1.0148 c_G^(3)(0, 2)), C3(1/1024) = 22974134.2920, C3(1/512) = 23332922.4752 (C3 r_*^3 <= 0.174), z3(1/512) = 5.859005 and three further certified (uninformative) pairs. 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) in d = 3. Every C3 here is a cap-route constant (a constant for [LP] (7.8)), hence >= c_G^(3)(0, 2) = 2.2424e7 (Math-#208). C8 stays OPEN: no catalog edit; c_{B,K}, c_{d,L} and d >= 4 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 in every dimension (torus kernel K_L, pins, Q, W_r with index(H_S) = d - 1, Z_r, Q^W) and Theorem A (1.1); section 3: the preconditioned pins (3.1) with m = d - 1 transverse rows 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 = [-2r, 2r] x ball(0, 2r), the partial-block operator norms M_3, M_4 (suprema over independently chosen transverse unit vectors) and condition (1) defining G_r; the deterministic cap theorem behind [LP] section 8 (consumed as a statement)", + "current_required": true, + "on_main": true + }, + { + "path": "frontiers/c8_cap_failure_coefficient_dims_20261001/NOTE.md", + "bytes": 21719, + "sha256": "d6b4992c41b781101152e888bf601b5371e7d018b9a556563094acd700aeeec6", + "git_blob": "17e6866b8dd5b2d14845032b3aac3de68dec03b0", + "id": "G3", + "commit": "da483732664d128728950dcad6d4fdbe5181f7cd", + "pull_request": "Math-#208", + "role": "Theorem G_d, the d = 3 contact law (Lemma 1: B ~ b I + GOE_2, v ~ N(0, I/2), Omega' ~ GOE_2, Y with variances 6, 2, 2, 6) and m_(3,0) = (7 - 4 sqrt2)/2, reproduced independently here; the certified lower end c_G^(3)(0, 2) >= 22424320.655069 (its RESULTS.json, below) is used only for the --check sanity rule C3 > c_G^(3)(0, 2) and for the comparisons in NOTE section 0; not consumed by the proof", + "current_required": false, + "on_main": false + }, + { + "path": "frontiers/c8_cap_failure_coefficient_dims_20261001/RESULTS.json", + "bytes": 6837, + "sha256": "1406d5138ac3d33bcb0358f6a3005a67e3a4a2dbfc2c43bc3ac2593667550608", + "git_blob": "e9fd6f377d1fd9dca9d09cc884d2bad2422e8b17", + "id": "G3-RESULTS", + "commit": "da483732664d128728950dcad6d4fdbe5181f7cd", + "pull_request": "Math-#208", + "role": "the certified enclosure c_G^(3)(0, 2) in [22424320.655069, 22424320.655072]; comparison and sanity check only", + "current_required": false, + "on_main": false + }, + { + "path": "frontiers/c8_theorem_a_constants_planar_20260930/NOTE.md", + "bytes": 31497, + "sha256": "d943f39d0cce065397a3ecc0d698a42e4a97c6fe0d8d1491f91a5daa910dbe94", + "git_blob": "0b0f54e247d68c45e9560a362738f7ce614110e0", + "id": "E", + "commit": "0cb8ad3ca1fe1733e737570ab682f469b66d76e4", + "pull_request": "Math-#206", + "role": "the planar Theorem E: the proof structure (sections 1-9) followed here and the planar constants quoted for comparison; every step used is restated or generalized in this NOTE", + "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 (C3, r_*) and z3 on (0, r_*] for d = 3 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-#206 (the planar Theorem E: explicit cap-route constants in d = 2)", + "Math-#208 (sharp cap coefficient c_G^(d); lower bound for every d = 3 cap-route constant)", + "Math-#203 (planar sharp cap coefficient c_G)", + "Math-#205 (c_{B,K} in d = 3)" + ], + "nonauthor_reads": [], + "nonauthor_acceptance": false, + "governing_status_changed": false, + "main_at_update": "3e0a91b69892b9717564c592e7a966492a81566a" +} diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/theorem_a3.py b/frontiers/c8_theorem_a_constants_d3_20261001/theorem_a3.py new file mode 100644 index 00000000..ac809dbd --- /dev/null +++ b/frontiers/c8_theorem_a_constants_d3_20261001/theorem_a3.py @@ -0,0 +1,1709 @@ +#!/usr/bin/env python3 +"""Explicit cap-route constants for Theorem A of [LP] in dimension d = 3, 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) <= C3(r_*) r^3, Z_r / r^2 >= z3(r_*), + +with G_r the good event of [LP] section 7 / [CAP] (1) (partial-block operator norms on the cylinder +D = [-2r, 2r] x ball(0, 2r)) and C3(r_*), z3(r_*) certified here (NOTE.md Theorem E3). 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 eight preconditioned pins and the 31 targets 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 in C^3; + * the failure event is reduced to {lambda_1 <= (4/(3k)) r M_3^2} u {r M_4 > 3k/10}; M_3 is bounded blockwise through exact + averaging identities of the pinned jets and M_4 through the Taylor series at the midpoint (Frobenius norms); + * the main term is integrated over the transverse Hessian B = -D_y^2 f(M) in eigenvalue coordinates after an exact + regression on its three entries, against an angle-free Gaussian majorant of its density; the remaining expectations are + closed-form incomplete Gaussian and chi moments plus Hoelder-controlled perturbations; + * the normalizer Z_r is bounded below through a Loewner-order coupling with the contact law, whose moments + E[det(B)^a tr(B)^c 1{B > 0}] are in closed form; the rare branches are Gaussian and chi 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', 'no-lambda2') +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 +R0_COUPLING = 12 # radius of the Loewner coupling of the transverse Hessian with the contact law (floor, section 6) +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 / #206) +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).""" + x = Fr(x) + if abs(x) <= 12: + p = phi_point(x) + return IV(1 - p.hi, 1 - p.lo) + if x > 0: + return IV(0, (phi_pt(x) / x).hi) # Mills: Phibar(x) <= phi(x)/x + return IV(1 - (phi_pt(-x) / (-x)).hi, 1) + + +def dfact(n): + """(n)!! for n >= -1.""" + return math.prod(range(n, 0, -2)) if n > 0 else 1 + + +def gauss_moment(j): + """E[Z^j] for Z ~ N(0, 1).""" + return 0 if j % 2 else dfact(j - 1) + + +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 (intervals). For x < 0, + M_j(x) = E[Z^j] - (-1)^j M_j(-x).""" + x = Fr(x) + if x < 0: + M = upper_moments(-x, J) + return [IV(gauss_moment(j)) - M[j] * (-1) ** j for j in range(J + 1)] + 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[:J + 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 rdown_rel(x, bits=200): + """Round a rational x >= 0 down to a dyadic with `bits` significant bits.""" + 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 error below 2^-200 (no absolute rounding floor).""" + 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 sqrt_down(x): + """Rational lower bound of sqrt(x), x >= 0 rational.""" + 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 rdown_rel(Fr(math.isqrt(nd << (2 * m)), 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 znorm1(p): + """max(1, ||N(0,1)||_p): the factor in ||(|mu| + ||Sigma^(1/2) z||)||_p <= |mu| + sqrt(tr Sigma) znorm1(p).""" + return Fr(1) if p <= 2 else znorm(p) + + +def frob_norm(mu_abs, tr_hi, p): + """Upper bound of || ||X|| ||_p for a Gaussian vector X with ||E X|| <= mu_abs and tr Cov X <= tr_hi (Minkowski in + L^(p/2) on the eigen-decomposition for p >= 2; Lyapunov for p <= 2).""" + return rup_rel(mu_abs + sqrt_up(tr_hi) * znorm1(pow2(p))) + + +def gamma_half(n2): + """Gamma(n2 / 2) for an integer n2 >= 1, as an interval (sqrt(pi) for odd n2).""" + if n2 % 2 == 0: + return IV(math.factorial(n2 // 2 - 1)) + n = (n2 - 1) // 2 # Gamma(n + 1/2) = (2n - 1)!! sqrt(pi) / 2^n + return isqrt_iv(PI) * Fr(dfact(2 * n - 1), 2 ** n) + + +def chi_moment(nu, j): + """E[chi_nu^j] = 2^(j/2) Gamma((nu + j)/2) / Gamma(nu/2) (interval), integer j >= 0.""" + if j % 2 == 0: + return IV(math.prod(nu + 2 * i for i in range(j // 2))) + out = gamma_half(nu + j) / gamma_half(nu) + for _ in range(j): + out = out * SQRT2 + return out + + +CN = {} + + +def chi_norm(nu, p): + """Upper bound of ||chi_nu||_p for p a power of two.""" + if p == 1: + return sqrt_up(Fr(nu)) + key = (nu, p) + if key not in CN: + CN[key] = iroot(Fr(math.prod(nu + 2 * i for i in range(p // 2))), p) + return CN[key] + + +CC = {} + + +def chi_const(nu): + """C_nu sqrt(2 pi) with C_nu = 1 / (2^(nu/2 - 1) Gamma(nu/2)): E[chi_nu^j 1{chi > x}] = C_nu sqrt(2 pi) M_(j+nu-1)(x).""" + if nu not in CC: + p2 = IV(Fr(2) ** ((nu - 2) // 2)) if nu % 2 == 0 else IV(Fr(2) ** ((nu - 3) // 2)) * SQRT2 + CC[nu] = SQRT2PI / (p2 * gamma_half(nu)) + return CC[nu] + + +def chi_upper_moments(nu, x, J): + """[E[chi_nu^j 1{chi_nu > x}] for j = 0..J] (intervals), rational x >= 0.""" + M = upper_moments(x, J + nu - 1) + c = chi_const(nu) + return [M[j + nu - 1] * c for j in range(J + 1)] + + +def chi_tail(nu, x): + """Rational upper bound of P(chi_nu > x) for rational x >= 0 (Mills-type bound beyond the series range).""" + x = Fr(x) + if x <= 0: + return Fr(1) + if x <= 12: + return min(Fr(1), chi_upper_moments(nu, x, 0)[0].hi) + # x > 12: P(chi_nu > x) = c_nu sqrt(2pi) M_(nu-1)(x), M_j(x) <= phi(x) x^(j-1) (1 + 2 (j-1)/x^2) for x^2 >= 2 j, and + # phi(x) <= m!/(x^2/2)^m / sqrt(2 pi) (m = 40) + y = x * x / 2 + ph = Fr(math.factorial(40)) / y ** 40 * Fr(2, 5) # 1/sqrt(2 pi) < 2/5 + j = nu - 1 + Mj = ph * (x ** (j - 1) if j >= 1 else 1 / x) * (1 + Fr(2 * max(j - 1, 1)) / (x * x)) + return min(Fr(1), Mj * Fr(51, 20)) # c_nu sqrt(2 pi) <= sqrt(2 pi) < 51/20 + + +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)) + + +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 absup(x): + return max(abs(x.lo), abs(x.hi)) + + +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) + + +# ----------------------------------------------------------------------------- functionals and exact covariance series (d = 3) +HALF = Fr(1, 2) +XM, XS, X0PT = -HALF, HALF, Fr(0) +JET4_IDX = {'X%d%d%d' % (a, b1, 4 - a - b1): (a, b1, 4 - a - b1) for a in range(5) for b1 in range(5 - a)} +JET4 = tuple(sorted(JET4_IDX, key=lambda n: (-JET4_IDX[n][0], -JET4_IDX[n][1]))) +BLOCKS = ((4, 0), (3, 1), (2, 2), (1, 3), (0, 4)) # partial blocks (a, c) of the fourth derivatives, a + c = 4 + + +def block_members(a, c): + """[(name, Frobenius multiplicity c!/beta!)] of the 4-jet block d_x^a D_y^c f(0).""" + out = [] + for b1 in range(c, -1, -1): + b2 = c - b1 + out.append(('X%d%d%d' % (a, b1, b2), math.factorial(c) // (math.factorial(b1) * math.factorial(b2)))) + return out + + +def term(c, p, a, b1, b2, x0): + """c r^p d_x^a d_y1^b1 d_y2^b2 f(x0 r, 0, 0).""" + return (Fr(c), p, a, b1, b2, Fr(x0)) + + +def functionals(): + pins = { + 'p1': [term(HALF, 0, 0, 0, 0, XM), term(HALF, 0, 0, 0, 0, XS)], + 'p2': [term(-1, -1, 0, 0, 0, XM), term(1, -1, 0, 0, 0, XS)], + 'p3p': [term(6, -2, 1, 0, 0, XM), term(6, -2, 1, 0, 0, XS), term(12, -3, 0, 0, 0, XM), term(-12, -3, 0, 0, 0, XS)], + 'p4': [term(-1, -1, 1, 0, 0, XM), term(1, -1, 1, 0, 0, XS)], + } + for j, (e1, e2) in ((1, (1, 0)), (2, (0, 1))): + pins['q1%d' % j] = [term(HALF, 0, 0, e1, e2, XM), term(HALF, 0, 0, e1, e2, XS)] + pins['q2%d' % j] = [term(-1, -1, 0, e1, e2, XM), term(1, -1, 0, e1, e2, XS)] + targets = { + 'a11': [term(1, 0, 0, 2, 0, XM)], 'a22': [term(1, 0, 0, 0, 2, XM)], 'a12': [term(1, 0, 0, 1, 1, XM)], + 'o11': [term(1, -1, 0, 2, 0, XS), term(-1, -1, 0, 2, 0, XM)], + 'o22': [term(1, -1, 0, 0, 2, XS), term(-1, -1, 0, 0, 2, XM)], + 'o12': [term(1, -1, 0, 1, 1, XS), term(-1, -1, 0, 1, 1, XM)], + 'T': [term(1, -2, 2, 0, 0, XM), term(4, -3, 1, 0, 0, XM), term(2, -3, 1, 0, 0, XS), term(6, -4, 0, 0, 0, XM), + term(-6, -4, 0, 0, 0, XS)], + 'tau': [term(1, -3, 2, 0, 0, XS), term(-1, -3, 2, 0, 0, XM), term(-6, -4, 1, 0, 0, XM), term(-6, -4, 1, 0, 0, XS), + term(-12, -5, 0, 0, 0, XM), term(12, -5, 0, 0, 0, XS)], + } + for j, (e1, e2) in ((1, (1, 0)), (2, (0, 1))): + targets['v%d' % j] = [term(1, -1, 1, e1, e2, XM), term(1, -2, 0, e1, e2, XM), term(-1, -2, 0, e1, e2, XS)] + targets['nu%d' % j] = [term(1, -2, 1, e1, e2, XM), term(1, -2, 1, e1, e2, XS), term(2, -3, 0, e1, e2, XM), + term(-2, -3, 0, e1, e2, XS)] + for b1 in range(3, -1, -1): + targets['y%s' % ('1' * b1 + '2' * (3 - b1))] = [term(1, 0, 0, b1, 3 - b1, X0PT)] + for n, (a, b1, b2) in JET4_IDX.items(): + targets[n] = [term(1, 0, a, b1, b2, X0PT)] + return pins, targets + + +PIN_NAMES = ('p1', 'p2', 'p3p', 'p4', 'q11', 'q21', 'q12', 'q22') +BNAMES = ('a11', 'a22', 'a12') # the transverse Hessian A = D_y^2 f(M) = -B +VNAMES = ('v1', 'v2') +ONAMES = ('o11', 'o22', 'o12') +YNAMES = ('y111', 'y112', 'y122', 'y222') +FREE = VNAMES + ONAMES + YNAMES # the free third-derivative blocks, in Cholesky order +FREE_W = (1, 1, 1, 1, 2, 1, 3, 3, 1) # Frobenius multiplicities (Euclidean norms in these weights) +TARGET_NAMES = BNAMES + FREE + ('T', 'tau', 'nu1', 'nu2') + JET4 +NP = len(PIN_NAMES) + + +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), gamma = (gx, gy1, gy2): + returns (reference series {power: rational}, weight w, list of (|c c'|, a+a', gy1, gy2) 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, bf1, bf2, xf) in F: + for (cg, pg, ag, bg1, bg2, xg) in G: + g1, g2 = bf1 + bg1, bf2 + bg2 + sgn = (-1) ** (ag + bg1 + bg2) + d = xf - xg + absterms.append((abs(cf * cg), af + ag, g1, g2)) + 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, g1, g2)] = pi.get((gx, g1, g2), Fr(0)) + val + for (gx, g1, g2), v in pi.items(): + require(v == 0 or gx - w >= 0, 'negative power of r in a covariance (regularity fails)') + ser = {} + for (gx, g1, g2), v in pi.items(): + kap = hcoef(gx) * hcoef(g1) * hcoef(g2) + 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 + + +E_UP = Fr(27183, 10000) # > e +SQRT3_UP = Fr(7, 4) # > sqrt(3) + + +def torus_M1(L): + """Bound of |sum_{n != 0} G(z + p_n)| on the polydisc |z_1|, |z_2|, |z_3| <= 1 (every frame, |p_n| = |n| L): + exp(3/2) sum_{j >= 1} (24 j^2 + 2) exp(-(j L - sqrt 3)^2 / 2); 24 j^2 + 2 lattice points have sup-norm j.""" + L = Fr(L) + e32 = exp_neg_point(Fr(3, 2)).inv().hi + tot = Fr(0) + for j in range(1, 6): + tot += (24 * j * j + 2) * exp_neg_point((j * L - SQRT3_UP) ** 2 / 2).hi + # j >= 6: (24 j^2 + 2) exp(-(jL - 7/4)^2/2) decreases by more than 1/2 per step for L >= 10 + tail = 2 * (24 * 36 + 2) * exp_neg_point((6 * L - SQRT3_UP) ** 2 / 2).hi + return e32 * (tot + tail) + + +def theta_minus_one(L): + L = Fr(L) + tot = Fr(0) + for j in range(1, 6): + tot += (24 * j * j + 2) * exp_neg_point((j * L) ** 2 / 2).hi + return tot + 2 * (24 * 36 + 2) * exp_neg_point((6 * L) ** 2 / 2).hi + + +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, g1, g2) in absterms: + tail += acc * abs(hcoef(g1) * hcoef(g2)) + tail *= 2 * Fr(NX + 1) ** A * r1 ** (NX + 1 - w) + # torus remainder: Cauchy estimates |rho_gamma| <= gx! gy1! gy2! M1 on the unit polydisc + tor = Fr(0) + for (acc, aa, g1, g2) in absterms: + tor += acc * math.factorial(g1) * math.factorial(g2) * Fr(max(w, 1)) ** aa + tor = tor * M1 / (1 - E_UP * 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 cholesky(C): + """Interval Cholesky of an n x n SPD interval matrix (pivots must be positive).""" + n = len(C) + L = [[IV(0)] * n for _ in range(n)] + for i in range(n): + 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 opnorm_lower_tri(L, rows, cols): + """Upper bound of the operator norm of the block L[rows][cols] of an interval lower-triangular matrix: + max |diagonal| + Frobenius norm of the rest (square diagonal blocks), Frobenius norm otherwise.""" + if rows == cols: + dg = max(absup(L[i][i]) for i in rows) + off = sum(absup(L[i][j]) ** 2 for i in rows for j in cols if j < i) + return rup_rel(dg + sqrt_up(off)) + return sqrt_up(sum(absup(L[i][j]) ** 2 for i in rows for j in cols)) + + +def sym3_eig_bounds(C): + """(lower bound of lambda_min, upper bound of lambda_max) of a symmetric 3 x 3 interval matrix (Gershgorin).""" + lo = min(C[i][i].lo - sum(absup(C[i][j]) for j in range(3) if j != i) for i in range(3)) + hi = max(C[i][i].hi + sum(absup(C[i][j]) for j in range(3) if j != i) for i in range(3)) + return lo, hi + + +def det3(C): + a, b, c = C[0] + d, e, f = C[1] + g, h, i = C[2] + return a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g) + + +# ----------------------------------------------------------------------------- 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; then the + regression on the transverse Hessian (three entries) and the g-law of the remaining targets.""" + 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 = [[None] * NP for _ in range(NP)] + for i in range(NP): + for j in range(i, NP): + Spp[i][j] = Spp[j][i] = cov_band(P[i], P[j], ('p', i, j), r0, r1, M1) + Stp = [[cov_band(T[i], P[j], ('tp', i, j), r0, r1, M1) for j in range(NP)] for i in range(nt)] + Stt = [[None] * nt for _ in range(nt)] + for i in range(nt): + for j in range(i, nt): + Stt[i][j] = Stt[j][i] = cov_band(T[i], T[j], ('tt', i, j), r0, r1, M1) + r = IV(r0, r1) + kvec = [-(r * r * r) * HALF, -(r * r), IV(12)] + [IV(0)] * (NP - 3) + e1 = [IV(1)] + [IV(0)] * (NP - 1) + 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(NP)), 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 in range(i, nt): + c = TARGET_NAMES[j] + v = Stt[i][j] - sum((W[i][l] * Stp[j][l] for l in range(NP)), IV(0)) + 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(NP)), IV(0)) * escale + law.e_kk = sum((kvec[j] * xs[1][j] for j in range(NP)), IV(0)) * escale + regress_on_B(law) + law.S = {blk: taylor_tail_coefficient(blk, r1, M1) for blk in BLOCKS} + law.net_var = {blk: net_max_variance(law.C, blk) for blk in BLOCKS if blk[1] >= 2} + return law + + +NET_M = 128 # rational unit vectors ((1 - t^2), 2 t)/(1 + t^2), t = j/NET_M, and their rotations + + +def circle_net(): + """Rational unit vectors u_j covering angles [0, pi) with consecutive angular gaps <= 2/NET_M (theta = 2 arctan t has + d theta/dt <= 2), together with the rotated copies (-u2, u1).""" + pts = [] + for j in range(NET_M + 1): + t = Fr(j, NET_M) + pts.append(((1 - t * t) / (1 + t * t), 2 * t / (1 + t * t))) + return pts + [(-u2, u1) for (u1, u2) in pts] + + +NET = circle_net() + + +def block_form_weights(blk, u): + """w_beta = (c!/beta!) u1^beta1 u2^beta2: d_x^a d_u^c f(0) = sum_beta w_beta X_(a,beta).""" + a, c = blk + return [(n, m * u[0] ** int(n[2]) * u[1] ** int(n[3])) for n, m in block_members(a, c)] + + +def net_max_variance(C, blk): + """Upper bound of max_j Var_Q(d_x^a d_(u_j)^c f(0)) over the net.""" + best = Fr(0) + for u in NET: + w = block_form_weights(blk, u) + v = sum(abs(wi) * abs(wj) * absup(C[(ni, nj)]) if ni != nj else wi * wi * C[(ni, ni)].hi + for ni, wi in w for nj, wj in w) + best = max(best, v) + return best + + +FROB_B = (IV(1), IV(1), SQRT2) # (B11, B22, B12) -> Frobenius-isometric coordinates (B11, B22, sqrt2 B12) + + +def regress_on_B(law): + """Regression of every target on the three entries of the transverse Hessian, in the Frobenius-isometric coordinates + b~ = (B11, B22, sqrt2 B12) of B = -A: F = F_g + beta~_F . (b~ - mu~), with F_g independent of B.""" + C = law.C + # covariance of b~ (B = -A: signs cancel in the covariance) + Cb = [[C[(BNAMES[i], BNAMES[j])] * FROB_B[i] * FROB_B[j] for j in range(3)] for i in range(3)] + law.Cb = Cb + law.detCb = det3(Cb) + require(law.detCb.lo > 0, 'transverse Hessian covariance not positive') + lo, hi = sym3_eig_bounds(Cb) + require(lo > 0, 'transverse Hessian covariance eigenvalue bound') + law.sB_lo2, law.sB_hi2 = lo, hi + law.sB_lo = sqrt_down(lo) + # regression coefficients of F on b~: beta~_F = Cov(F, b~) Cb^-1, Cov(F, b~_i) = -Cov(F, A_i) FROB_B[i] + others = [n for n in TARGET_NAMES if n not in BNAMES] + rhs = [[-C[(n, BNAMES[i])] * FROB_B[i] for i in range(3)] for n in others] + sol = solve_iv(Cb, rhs) + law.bt = {n: sol[i] for i, n in enumerate(others)} + law.bnorm = {n: sqrt_up(sum(absup(x) ** 2 for x in law.bt[n])) for n in others} + Cg = {} + for a in others: + for c in others: + Cg[(a, c)] = C[(a, c)] - sum((law.bt[a][i] * (-C[(c, BNAMES[i])] * FROB_B[i]) for i in range(3)), IV(0)) + law.Cg = Cg + # the free blocks in Frobenius coordinates: v, omega = (o11, o22, sqrt2 o12), Y~ = (y111, sqrt3 y112, sqrt3 y122, y222) + fw = [isqrt_iv(IV(w)) if w != 1 else IV(1) for w in FREE_W] + law.Lfree = cholesky([[Cg[(FREE[i], FREE[j])] * fw[i] * fw[j] for j in range(9)] for i in range(9)]) + law.fw = fw + law.sdg = {n: sqrt_up(max(Cg[(n, n)].hi, Fr(0))) for n in others} + law.sdQ = {n: sqrt_up(C[(n, n)].hi) for n in TARGET_NAMES} + + +def sd0_sq(g, M1): + """Upper bound of Var d^g f(0) = |d^(2g) K_L(0)| (normalized kernel, every frame, L >= L_MIN), g = (gx, gy1, gy2): + the reference value prod (2 g_i - 1)!! plus the Cauchy bound (2g)! M1 of the torus remainder.""" + return math.prod(dfact(2 * x - 1) for x in g) + math.prod(math.factorial(2 * x) for x in g) * M1 + + +def taylor_tail_coefficient(blk, r1, M1): + """S_(a,c)(r1) = sum_{gamma != 0} sigma_(a,c),gamma (2 r1)^|gamma| / gamma!, sigma^2 = sum_beta (c!/beta!) s^2_(a+gx, beta+gy): + the Frobenius norm of the Taylor tail of the block d_x^a D_y^c f at the midpoint over D.""" + a, c = blk + tot = Fr(0) + for n in range(1, NB + 1): + for gx in range(n + 1): + for g1 in range(n - gx + 1): + g2 = n - gx - g1 + s2 = Fr(0) + for b1 in range(c + 1): + b2 = c - b1 + mult = math.factorial(c) // (math.factorial(b1) * math.factorial(b2)) + s2 += mult * sd0_sq((a + gx, b1 + g1, b2 + g2), M1) + tot += sqrt_up(s2) * (2 * r1) ** n / (math.factorial(gx) * math.factorial(g1) * math.factorial(g2)) + # tail |gamma| = n > NB: s_delta <= 2^|delta| delta! sqrt(1 + M1) and (alpha + gamma)!/gamma! <= (n + 4)^4, so + # sigma (2 r1)^n / gamma! <= 2^(c/2) 2^(4 + n) (n + 4)^4 (2 r1)^n sqrt(1 + M1); (n+1)(n+2)/2 multi-indices of order n; + # the ratio of consecutive bounds is below 2 q for these n (q = 4 r1 <= 1/16) + q = 4 * r1 + require(q <= Fr(1, 16), 'Taylor tail ratio too large') + n = NB + 1 + base = 2 * 2 ** 4 * sqrt_up(Fr(2) ** c * (1 + M1)) + tail = base * Fr((n + 1) * (n + 2), 2) * Fr(n + 4) ** 4 * q ** n / (1 - 2 * q) + return rup_rel(tot + tail) + + +# ----------------------------------------------------------------------------- closed forms for the contact transverse Hessian +# B = m I + GOE_2 (diagonal N(0, 2), off-diagonal N(0, 1)): its eigenvalues are s -+ rho with s = m + (G11 + G22)/2 ~ N(m, 1) +# and rho = sqrt(((G11 - G22)/2)^2 + G12^2) Rayleigh, independent; det B = s^2 - rho^2, tr B = 2 s, B > 0 iff s > rho. +def upper_moments_iv(x, J): + """[M_0(x), ..., M_J(x)] over an interval x whose interior does not contain 0 (each M_j is monotone there).""" + if x.lo == x.hi: + return upper_moments(x.lo, J) + require(not (x.lo < 0 < x.hi), 'incomplete moment over an interval containing 0') + A, B = upper_moments(x.lo, J), upper_moments(x.hi, J) + return [IV(min(a.lo, b.lo), max(a.hi, b.hi)) for a, b in zip(A, B)] + + +def es_pos(m, n): + """[E[s^j 1{s > 0}] for j = 0..n], s ~ N(m, 1), rational m (intervals).""" + M = upper_moments(-Fr(m), n) + return [sum((M[i] * (math.comb(j, i) * Fr(m) ** (j - i)) for i in range(j + 1)), IV(0)) for j in range(n + 1)] + + +def isqrt2_pow(i): + """2^(-i/2) (interval).""" + return IV(Fr(1, 2 ** (i // 2))) if i % 2 == 0 else IV(Fr(1, 2 ** (i // 2))) / SQRT2 + + +def es_pos_exp(m, n): + """[E[s^j exp(-s^2/2) 1{s > 0}] for j = 0..n], s ~ N(m, 1), rational m: + = exp(-m^2/4)/sqrt2 . E[(m/2 + U/sqrt2)^j 1{U > -m/sqrt2}], U ~ N(0, 1).""" + m = Fr(m) + M = upper_moments_iv(-(IV(m) / SQRT2), n) + pre = exp_neg_point(m * m / 4) / SQRT2 + out = [] + for j in range(n + 1): + tot = IV(0) + for i in range(j + 1): + tot = tot + M[i] * (math.comb(j, i) * (m / 2) ** (j - i)) * isqrt2_pow(i) + out.append(pre * tot) + return out + + +def inner_rho_polys(a): + """integral_0^s (s^2 - rho^2)^a rho exp(-rho^2/2) d rho = P_a(s) - exp(-s^2/2) Q_a(s) (exact polynomial coefficient + dicts {power: Fraction}); with u = rho^2/2 it is integral_0^(s^2/2) (s^2 - 2u)^a e^(-u) du.""" + P, Q = {}, {} + for i in range(a + 1): + c = Fr(math.comb(a, i) * (-2) ** i * math.factorial(i)) + P[2 * (a - i)] = P.get(2 * (a - i), Fr(0)) + c + for l in range(i + 1): + pw = 2 * (a - i) + 2 * l + Q[pw] = Q.get(pw, Fr(0)) + c / (2 ** l * math.factorial(l)) + return P, Q + + +def contact_moment(a, c, m): + """E[det(B)^a tr(B)^c 1{B > 0}] for B = m I + GOE_2, rational m (interval).""" + P, Q = inner_rho_polys(a) + n = 2 * a + c + E1 = es_pos(m, n) + E2 = es_pos_exp(m, n) + tot = IV(0) + for pw, cf in P.items(): + tot = tot + E1[pw + c] * (cf * 2 ** c) + for pw, cf in Q.items(): + tot = tot - E2[pw + c] * (cf * 2 ** c) + return tot + + +def m3(m): + """m_(3,m) = E[det(B)^2 1{B > 0}] = E[(s^4 - 4 s^2 + 8) 1{s > 0}] - 4 sqrt2 exp(-m^2/4) Phi(m/sqrt2).""" + return contact_moment(2, 0, m) + + +def gauss_half_moment(j, m, sig): + """J_j(m, sig) = integral_0^inf lambda^j exp(-(lambda - m)^2/(2 sig^2)) d lambda for rational m, sig > 0 (interval): + sig sqrt(2 pi) E[(m + sig Z)^j 1{m + sig Z > 0}].""" + m, sig = Fr(m), Fr(sig) + M = upper_moments(-m / sig, j) + tot = sum((M[i] * (math.comb(j, i) * m ** (j - i) * sig ** i) for i in range(j + 1)), IV(0)) + return tot * SQRT2PI * sig + + +# ----------------------------------------------------------------------------- moment calculus (normalized by K = 12 k) +def binom(n, k): + return math.comb(n, k) + + +def pos_part_moments_chi(s, c, nu, nmax, extra_max): + """P[(n, e)] = upper bound of E[u^e (u^n - c^n)_+], u = s chi_nu, for 1 <= n <= nmax, 0 <= e <= extra_max.""" + x = c / s + M = chi_upper_moments(nu, 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).hi) + return out + + +NU = {2: 2, 3: 3, 4: 4} # chi degrees of freedom of the free blocks v (2), omega (3), Y~ (4) + + +def normalized_moments(q, nmax, theta): + """Component moments, normalized by K = 12 k (K >= Klo), for n <= nmax, under the product of the g-law and nu: + E1[n], E1o[n], E1v[n] : upper bounds of E[y1^n], E[o0 y1^n], E[v0^2 y1^n], y1 = 1 + cmt1 + (r1/Klo) D1; + 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 chi_nu_i independent), threshold c = q['c']. + o0 = Klo u_3 and v0^2 = Klo^2 u_2^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_chi(q['s'][i], cp, NU[i], nmax, 2) for i in (2, 3, 4)} + Eo0 = (chi_moment(3, 1) * q['s3']).hi + Ev0sq = (chi_moment(2, 2) * q['s2'] * q['s2']).hi / 4 + n_o0_2 = q['s3'] * chi_norm(3, 2) + n_v0sq_2 = q['s2'] * q['s2'] * chi_norm(2, 4) ** 2 / 4 + Klo = q['Klo'] + E1, E1o, E1v, Tn, To, Tv = {}, {}, {}, {}, {}, {} + base = rup_rel(1 + q['cmt1']) + bp = [Fr(1)] + for _ in range(nmax): + bp.append(rup_rel(bp[-1] * base)) + # (r/K) D1 terms: ||(rK D1)^j||_1 <= (rK ||D1||_pow2(j))^j and ||(rK D1)^j||_2 <= (rK ||D1||_pow2(2j))^j + d1 = [Fr(1)] + [rup_rel((q['rK'] * q['nD1'](pow2(j))) ** j) for j in range(1, nmax + 1)] + d2 = [Fr(1)] + [rup_rel((q['rK'] * q['nD1'](pow2(2 * j))) ** j) for j in range(1, nmax + 1)] + for n in range(0, nmax + 1): + ey = bp[n] + eo = bp[n] * Eo0 + ev = bp[n] * Ev0sq + for j in range(1, n + 1): + coef = binom(n, j) * bp[n - j] + ey += coef * d1[j] + eo += coef * n_o0_2 * d2[j] + ev += coef * n_v0sq_2 * d2[j] + E1[n], E1o[n], E1v[n] = rup_rel(ey), rup_rel(eo), rup_rel(ev) + 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 = rup_rel(q['nd'](i, pow2(n)) ** n) + dn2 = rup_rel(q['nd'](i, pow2(2 * n)) ** n) + tn += f1 * P[(n, 0)] + f2 * dn + to += (f1 * Klo * P[(n, 1)] if i == 3 else f1 * Eo0 * P[(n, 0)]) + f2 * n_o0_2 * dn2 + tv += (f1 * Klo * Klo / 4 * P[(n, 2)] if i == 2 else f1 * Ev0sq * P[(n, 0)]) + f2 * n_v0sq_2 * dn2 + Tn[n], To[n], Tv[n] = rup_rel(tn), rup_rel(to), rup_rel(tv) + return E1, E1o, E1v, Tn, To, Tv + + +def half_gauss_moments(m, sig, J): + """[J_j(m, sig) for j = 0..J], J_j = integral_0^inf l^j exp(-(l - m)^2/(2 sig^2)) dl, rational m >= 0, sig > 0 (intervals): + J_0 = sig sqrt(2 pi) Phi(m/sig), J_1 = m J_0 + sig^2 exp(-m^2/(2 sig^2)), J_(j+1) = m J_j + j sig^2 J_(j-1) + (integration by parts; every term is positive for m >= 0).""" + m, sig = Fr(m), Fr(sig) + require(m >= 0 and sig > 0, 'half-line Gaussian moments') + s2 = sig * sig + out = [SQRT2PI * sig * (1 - Phibar_pt(m / sig))] + out.append(out[0] * m + exp_neg_point(m * m / (2 * s2)) * s2) + for j in range(1, J): + nxt = out[j] * m + out[j - 1] * (j * s2) + out.append(IV(rdown_rel(nxt.lo), rup_rel(nxt.hi))) + return out + + +def lam2_moments(b_lo, b_hi, eps, sig): + """Bounds on the lambda_2-integrals of the density majorant g(l) = exp(-(l - b)^2/(2 sig^2) + eps |l - b|/sig^2), + uniformly over b in [b_lo, b_hi] (b >= 0): I_hi[j] >= integral_0^inf l^j g(l) dl (j = 0..JM), I3_lo <= integral l^3 g. + For l >= 0, eps |l - b| <= eps (l + b), so g(l) <= exp((4 b eps + eps^2)/(2 sig^2)) exp(-(l - b - eps)^2/(2 sig^2)); + each J_j(m, sig) increases with m; and g(l) >= exp(-(l - b)^2/(2 sig^2)).""" + JM = 3 + 64 + shift = (4 * b_hi * eps + eps * eps) / (2 * sig * sig) + fac = exp_neg_point(shift).inv().hi + Jh = half_gauss_moments(b_hi + eps, sig, JM) + I_hi = [rup_rel(x.hi * fac) for x in Jh] + I3_lo = rdown_rel(half_gauss_moments(b_lo, sig, 3)[3].lo) + return I_hi, I3_lo + + +DETN = {} + + +def det_norm(p, bpp, muB, sig): + """Upper bound of ||det(B) 1{B > 0}||_p (p a power of two) for B = mu_B + Gaussian with Loewner coupling + B <= (b'' + eta ||z||) I + GOE (b'' rounded up to a 1/1024 grid): the contact moment E[det^p 1{B > 0}] at b'' on + {||z|| <= R0}, plus E[(||B||_F^2/2)^p 1{||z|| > R0}] <= 2^-p E[(||mu_B|| + sig chi_3)^(2p) 1{chi_3 > R0}].""" + bg = Fr(math.ceil(bpp * 1024), 1024) + key = (p, bg) + if key not in DETN: + DETN[key] = contact_moment(p, 0, bg).hi + cm = DETN[key] + R0 = Fr(R0_COUPLING) + U = chi_upper_moments(3, R0, 2 * p) + out = sum((U[i] * (binom(2 * p, i) * muB ** (2 * p - i) * sig ** i) for i in range(2 * p + 1)), IV(0)).hi / 2 ** p + return iroot(rup_rel(cm + out), p) + + +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); every choice gives a valid bound.""" + 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]) + blo, bhi = bb + klo, khi = kb[0], kb[1] + require(blo >= 0, 'b >= 0 assumed by the density majorant') + 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 = sqrt_up(E.hi) + nl2 = MUT != 'no-lambda2' + # ---- the transverse Hessian B = -A: mean in Frobenius coordinates, its distance to b I, the density majorant + dmu = [b * (-law.alpha['a11'] - 1) + k * (-law.beta['a11']), b * (-law.alpha['a22'] - 1) + k * (-law.beta['a22']), + (b * law.alpha['a12'] + k * law.beta['a12']) * SQRT2] + eps = sqrt_up(sum(absup(x) ** 2 for x in dmu)) # sup over the box of ||mu_B - b I||_F + muB = rup_rel(bhi * sqrt_up(Fr(2)) + eps) # sup ||mu_B||_F + sig = sqrt_up(law.sB_hi2) # rational, >= sqrt(lambda_max(Cov b~)) + sB_lo = law.sB_lo # <= sqrt(lambda_min(Cov b~)) + KB = rup_rel((PI * SQRT2 / (2 * PI * SQRT2PI) / isqrt_iv(law.detCb)).hi) # pi sqrt2 (2 pi)^(-3/2) det^(-1/2) + s2g = sig * sig + ex0 = blo * blo / (2 * s2g) - eps * bhi / s2g # g(0; b) <= exp(-ex0) over the box + g0 = exp_neg_point(ex0).hi if ex0 >= 0 else exp_neg_point(-ex0).inv().hi + gbar = exp_neg_point(eps * eps / (2 * s2g)).inv().hi + # slope of the linear density bound g(l) <= g0 + l Lg on l >= 0: the global |g'| <= exp(-1/2) gbar / sig, or the chord + # of min(gbar, g0 exp(c l)) with c = (b_hi + eps)/sig^2 (g(l; b) <= g(0; b) exp((b + eps) l / sig^2) for l >= 0): + # g0 c (x - 1)/log x with log x = log(gbar/g0) = y (rational), (x - 1)/log x increasing in x + Lg = rup_rel(exp_neg_point(Fr(1, 2)).hi * gbar / sig) + y = (eps * eps + blo * blo - 2 * eps * bhi) / (2 * s2g) + if y > 0: + cc = (bhi + eps) / s2g + Lg = min(Lg, rup_rel(g0 * cc * (exp_neg_point(y).inv().hi - 1) / y)) + else: + Lg = Fr(0) # gbar <= g0: the bound g <= gbar alone is the smaller one + I_hi, I3_lo = lam2_moments(blo, bhi, eps, sig) + require(I3_lo > 0, 'lambda_2 moment') + + def l2norm(p): # ||lambda_2||_p under nu (and under nu'), p a power of two + if not nl2: + return Fr(0) + return iroot(rup_rel(I_hi[3 + p] / I3_lo), p) + # ---- regression on B and the coefficients bar-beta_i (NOTE section 4) + bn = law.bnorm + bv = sqrt_up(bn['v1'] ** 2 + bn['v2'] ** 2) + bo = sqrt_up(bn['o11'] ** 2 + bn['o22'] ** 2 + 2 * bn['o12'] ** 2) + by = sqrt_up(bn['y111'] ** 2 + 3 * bn['y112'] ** 2 + 3 * bn['y122'] ** 2 + bn['y222'] ** 2) + bnu = sqrt_up(bn['nu1'] ** 2 + bn['nu2'] ** 2) + a_fac = Fr(1, 2) if MUT == 'cap-half' else Fr(1) # the cap constant 4/(3k) (mutant: halved) + + def Bblk(blk): + return rup_rel(sqrt_up(sum(m * bn[n] ** 2 for n, m in block_members(*blk))) + law.S[blk] / sB_lo) + Bb = {blk: Bblk(blk) for blk in BLOCKS} + bb1 = rup_rel(Fr(5, 2) * Bb[(4, 0)] + 2 * Bb[(3, 1)]) # bar-beta_1 / r + bbars = {1: rup_rel(r1 * bb1), + 2: rup_rel(2 * bv + r1 * (Fr(5, 2) * Bb[(3, 1)] + 2 * Bb[(2, 2)])), + 3: rup_rel(bo + r1 * (Fr(5, 2) * Bb[(2, 2)] + 2 * Bb[(1, 3)])), + 4: rup_rel(by + r1 * (2 * Bb[(1, 3)] + 2 * Bb[(0, 4)]))} + bbar = max(bbars.values()) + # ---- free blocks: Cholesky factors in Frobenius coordinates (v | omega | Y~) + Lf = law.Lfree + Iv, Io, Iy = (0, 1), (2, 3, 4), (5, 6, 7, 8) + Lvv, Low, Loo = opnorm_lower_tri(Lf, Iv, Iv), opnorm_lower_tri(Lf, Io, Iv), opnorm_lower_tri(Lf, Io, Io) + Lyv, Lyo, Lyy = opnorm_lower_tri(Lf, Iy, Iv), opnorm_lower_tri(Lf, Iy, Io), opnorm_lower_tri(Lf, Iy, Iy) + mu_v = sqrt_up(mabs['v1'] ** 2 + mabs['v2'] ** 2) + mu_o = sqrt_up(mabs['o11'] ** 2 + mabs['o22'] ** 2 + 2 * mabs['o12'] ** 2) + mu_y = sqrt_up(mabs['y111'] ** 2 + 3 * mabs['y112'] ** 2 + 3 * mabs['y122'] ** 2 + mabs['y222'] ** 2) + mu_nu = sqrt_up(mabs['nu1'] ** 2 + mabs['nu2'] ** 2) + s2, s3, s4 = 2 * Lvv, Loo, Lyy + + memo = {} + + def blk_g_norm(blk, p): # || ||X_blk,g||_F ||_p + mem = block_members(*blk) + m_ = sqrt_up(sum(m * mabs[n] ** 2 for n, m in mem)) + tr = sum(m * max(law.Cg[(n, n)].hi, Fr(0)) for n, m in mem) + return frob_norm(m_, tr, p) + + def nA(blk, p): # ||A^g_blk||_p, A^g = ||X_blk,g||_F + T^g_blk + key = ('A', blk, p) + if key not in memo: + memo[key] = rup_rel(blk_g_norm(blk, p) + law.S[blk] * (sqE + znorm1(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((4, 0), p) + 2 * nA((3, 1), p) + if i == 2: + return Fr(5, 2) * nA((3, 1), p) + 2 * nA((2, 2), p) + if i == 3: + return Fr(5, 2) * nA((2, 2), p) + 2 * nA((1, 3), p) + return 2 * nA((1, 3), p) + 2 * nA((0, 4), p) + + def nd(i, p, lam=True): + key = ('d', i, p, lam) + if key not in memo: + memo[key] = rup_rel(nd0(i, p, lam)) + return memo[key] + + def nd0(i, p, lam): # ||delta_i||_p / Klo, delta_i including bar-beta_i (||mu_B|| + lambda_2) + cm = bbars[i] * (muB + (l2norm(p) if lam else 0)) + if i == 2: + v = 2 * mu_v + cm + r1 * nDelta(2, p) + elif i == 3: + v = mu_o + Low * chi_norm(2, pow2(p)) + cm + r1 * nDelta(3, p) + else: + v = mu_y + Lyv * chi_norm(2, pow2(p)) + Lyo * chi_norm(3, pow2(p)) + 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] * muB / Klo, 'rK': r1 / Klo, + 'nD1': lambda p: rup_rel(nDelta(1, p) + bb1 * l2norm(pow2(p))), + 's': {2: s2 / Klo, 3: s3 / Klo, 4: s4 / Klo}, 'nd': nd, 's3': s3, 's2': s2, 'c': cth, 'Klo': Klo} + 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 + + def EUt(p): # upper bound of E[Ut^p], Ut = U/(a K^2) <= max(Z1, Fk y_i^2) + 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 EoUt(p): + return sum(binom(p, l) * et1 ** l * E1o[2 * p + l] for l in range(p + 1)) + Fk ** p * To[2 * p] + + def EvUt(p): + return sum(binom(p, l) * et1 ** l * E1v[2 * p + l] for l in range(p + 1)) + Fk ** p * Tv[2 * p] + + def sq(x): + return sqrt_up(x) + + def nUt(m, p): # ||Ut^m||_p <= Fk^m ||max_i y_i||_2mp^2m (on the event x_i <= X0) + require(2 * m * p <= NMAX and pow2(p) == p, 'norm order') + key = ('nUt', m, p) + if key not in memo: + memo[key] = rup_rel(Fk ** m * iroot(E1[2 * m * p] + Tn[2 * m * p], p)) + return memo[key] + + def nU(p): + return rup_rel(aK2_hi * nUt(1, p)) + + def ndel(p): # || ||B - mu_B||_F ||_p <= ||mu_B|| + lambda_1 + lambda_2 <= ||mu_B|| + 2 lambda_2 + return rup_rel(muB + 2 * l2norm(p)) + + def nbar(n, p): # ||F_bar||_p, F_bar = |F_g| + ||beta_F|| ||B - mu_B||_F + return rup_rel(gauss_norm(mabs[n], law.sdg[n], p) + bn[n] * ndel(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 + U2_2, U3_2, U4_2 = sq(EUt(4)), sq(EUt(6)), sq(EUt(8)) + U2_4, U3_4 = nUt(2, 4), nUt(3, 4) + # the Omega majorant: Omega_bar = o0 + d_o, o0 = s3 chi_3 (shares u_3), d_o = rest + ndo = lambda p: rup_rel(mu_o + Low * chi_norm(2, pow2(p)) + bo * ndel(p)) + no4 = rup_rel(s3 * chi_norm(3, 4) + ndo(4)) + # the ||r nu - v||^2 majorant (Term C) + th = THETA_E + dv = lambda p: rup_rel(mu_v + bv * ndel(p)) + nnu = lambda p: rup_rel(frob_norm(mu_nu, law.Cg[('nu1', 'nu1')].hi + law.Cg[('nu2', 'nu2')].hi, p) + + bnu * ndel(p)) + ebar4 = rup_rel((r1 * nnu(8) + Lvv * chi_norm(2, 8) + dv(8)) ** 2) # ||e_bar||_4 + ebar8 = rup_rel((r1 * nnu(16) + Lvv * chi_norm(2, 16) + dv(16)) ** 2) # ||e_bar||_8 + cC = (1 + th) * (1 + 1 / th) * dv(4) ** 2 + (1 + 1 / th) * r1 * r1 * nnu(4) ** 2 + # ---- Term A, B, C (one power of U per lambda_1 integration), normalized by 36 k^2 r^5 and by the lambda_2 weight + termA = aK2_hi ** 3 / 3 * (EUt(3) + epsc2 * U3_2) + termB = aK2_hi ** 2 / 2 * (EoUt(2) + (ndo(2) + epsc4 * no4) * U2_2) + termC = aK2_hi ** 2 / (12 * klo) * ((1 + th) ** 2 * EvUt(2) + cC * U2_2 + r1 * nT4 / six_klo * ebar4 * U2_2) + termAp = aK2_hi ** 4 / 4 * (EUt(4) + epsc2 * U4_2) + termBp = aK2_hi ** 3 / 3 * (EoUt(3) + (ndo(2) + epsc4 * no4) * U3_2) + termCp = aK2_hi ** 3 / (18 * klo) * ((1 + th) ** 2 * EvUt(3) + cC * U3_2 + r1 * nT4 / six_klo * ebar4 * U3_2) + if MUT == 'no-om-term': + termB = termBp = Fr(0) + # ---- the Jacobian-correction terms: the part r Omega_bar of (lambda_2 + r Omega_bar), integrated against nu' + # D = E[Omega_bar (A + B + C integrands)], D' = E[Omega_bar (A' + B' + C' integrands)] + nT16 = nbar('T', 16) + termD = (aK2_hi ** 3 / 3 * (EoUt(3) + (ndo(2) + epsc4 * no4) * U3_2) + + aK2_hi ** 2 / 2 * no4 * no4 * (U2_2 + epsc4 * U2_4) + + aK2_hi ** 2 / (12 * klo) * no4 * (1 + r1 * nT16 / six_klo) * ebar8 * U2_4) + termDp = (aK2_hi ** 4 / 4 * (EoUt(4) + (ndo(2) + epsc4 * no4) * U4_2) + + aK2_hi ** 3 / 3 * no4 * no4 * (U3_2 + epsc4 * U3_4) + + aK2_hi ** 3 / (18 * klo) * no4 * (1 + r1 * nT16 / six_klo) * ebar8 * U3_4) + if MUT == 'no-om-term': + termD = termDp = Fr(0) + I2, I3 = I_hi[2], I_hi[3] + lead = I3 * (termA + termB + termC) + r1 * I2 * termD + leadp = I3 * (termAp + termBp + termCp) + r1 * I2 * termDp + # ---- normalizer floor Z_r / (36 k^2 r^2) >= m3(b'_lo) - corrections (NOTE section 6) + Lb = cholesky([[IV(x.lo, x.hi) for x in row] for row in law.Cb]) + eta = sqrt_up(sum(absup(Lb[i][j] - (SQRT2 if i == j else 0)) ** 2 for i in range(3) for j in range(i + 1))) + R0 = Fr(R0_COUPLING) + bp_lo = blo - eps - eta * R0 + bp_hi = bhi + eps + eta * R0 + bp_lo = Fr(math.floor(bp_lo * 2 ** 40), 2 ** 40) + bp_hi = Fr(math.ceil(bp_hi * 2 ** 40), 2 ** 40) + pR0 = chi_tail(3, R0) + m3lo = m3(bp_lo).lo + tail_c = sqrt_up(contact_moment(4, 0, bp_lo).hi) * sqrt_up(pR0) + # upper bounds of E[h(B)] for Loewner-monotone h through b'' = bp_hi, plus the outside-ball part + nBF16 = rup_rel(muB + sig * chi_norm(3, 16)) # || ||B||_F ||_16 + out_ball = sqrt_up(pR0) + + def up_moment(a, c): # E[det^a tr^c 1{B > 0}] <= contact value at b'' + outside-ball part + crude = rup_rel(nBF16 ** (2 * a + c)) # det <= ||B||^2, tr <= sqrt2 ||B|| <= 2 ||B||: crude, times P^(1/2) + return rup_rel(contact_moment(a, c, bp_hi).hi + 2 ** c * crude * out_ball) + F2 = up_moment(4, 0) # E[(det B)^4 1{B > 0}] + DT, TDT, TTDT = up_moment(1, 1), up_moment(1, 2), up_moment(1, 3) + sdT, sdtau = law.sdQ['T'], law.sdQ['tau'] + q_bad = gauss_tail2(mabs['T'], sdT, 3 * klo / (2 * r1)) + gauss_tail2(mabs['tau'], sdtau, 3 * klo / (2 * r1 * r1)) + nF = sqrt_up(F2) + corr_G0 = nF * sqrt_up(q_bad) if q_bad > 0 else Fr(0) + corr_eps = (2 * r1 * gauss_norm(mabs['T'], sdT, 2) + r1 * r1 * gauss_norm(mabs['tau'], sdtau, 2)) / six_klo * nF + trO = sum(m * max(law.Cg[(n, n)].hi, Fr(0)) for n, m in zip(ONAMES, (1, 1, 2))) + trV = law.Cg[('v1', 'v1')].hi + law.Cg[('v2', 'v2')].hi + Eog = rup_rel(mu_o + sqrt_up(trO)) + corr_om = Eog * DT + bo * (TDT + muB * DT) + Evg2 = mu_v ** 2 + trV + corr_v = (Fr(17, 16) * Evg2 * DT + 17 * bv ** 2 * (TTDT + 2 * muB * TDT + muB * muB * DT)) / (4 * klo) + corr = tail_c + corr_G0 + corr_eps + r1 * (corr_om + corr_v) + if MUT == 'no-zfloor-correction': + corr = Fr(0) + zt = m3lo - corr + require(zt > 0, 'normalizer floor not positive') + main = KB * min(gbar * lead, g0 * lead + r1 * Lg * leadp) / zt + # ---- rare branches at the band top: E[W 1_E] <= ||W 1_typed||_q P(E)^(1 - 1/q), ||W 1_typed||_q / r^2 <= g1 g2 + six_khi = 6 * khi + trB = sum(x.hi for x in (law.Cb[0][0], law.Cb[1][1], law.Cb[2][2])) + trOQ = sum(m * law.C[(n, n)].hi for n, m in zip(ONAMES, (1, 1, 2))) + trVQ = law.C[('v1', 'v1')].hi + law.C[('v2', 'v2')].hi + trNQ = law.C[('nu1', 'nu1')].hi + law.C[('nu2', 'nu2')].hi + + # W_r / r^2 <= |c1| D [|c2| (D + r Om tr + r^2 Om^2) + r ||e||^2 (tr + r Om)] on the typed support, D = det B 1{B > 0}, + # tr = tr B, Om = ||Omega'||_F (NOTE section 7) + sd_tr = sqrt_up(law.C[('a11', 'a11')].hi + law.C[('a22', 'a22')].hi + 2 * absup(law.C[('a11', 'a22')])) + m_tr = absup(mu['a11'] + mu['a22']) + + def wnorm(qq): + p4, p8 = 4 * qq, 8 * qq + nD = lambda p: det_norm(p, bp_hi, muB, sig) + ntr = lambda p: gauss_norm(m_tr, sd_tr, p) + no = lambda p: frob_norm(mu_o, trOQ, p) + nT = lambda p: gauss_norm(mabs['T'], sdT, p) + nc2 = lambda p: six_khi + r1 * nT(p) + r1 * r1 * gauss_norm(mabs['tau'], sdtau, p) + ne = lambda p: r1 * frob_norm(mu_nu, trNQ, p) + frob_norm(mu_v, trVQ, p) + g1 = (six_khi + r1 * nT(p4)) * nD(p4) + g2 = (nc2(p4) * (nD(p4) + r1 * no(p8) * ntr(p8) + r1 * r1 * no(p8) ** 2) + + r1 * ne(p8) ** 2 * (ntr(p4) + r1 * no(p4))) + return g1 * g2 + thr = 3 * klo / (10 * r1) + qA2 = Fr(0) + args = [] + for blk in BLOCKS: + a_, c_ = blk + mem = block_members(*blk) + m_ = sqrt_up(sum(m * mabs[n] ** 2 for n, m in mem)) # |mean of d_x^a d_u^c f(0)| <= ||mean||_F for unit u + best = None + for frac in (Fr(7, 8), Fr(15, 16)): # split t = frac t + (1 - frac) t between jet and Taylor tail + if c_ == 0: # scalar block + x_ = (thr * frac - m_) / law.sdQ[mem[0][0]] + pj = gauss_tail2(m_, law.sdQ[mem[0][0]], thr * frac) + elif c_ == 1: # vector block: ||X - mean|| <= sqrt(lambda_max) chi_2 + lmax = max(sum(absup(law.C[(ni, nj)]) for nj, mj in mem) for ni, mi in mem) + x_ = (thr * frac - m_) / sqrt_up(lmax) + pj = chi_tail(2, x_) if x_ > 0 else Fr(1) + else: # ||X||_op = max_theta |Q(theta)|, Q a trigonometric + rho = 1 - Fr(c_, NET_M) # polynomial of degree c: Bernstein |Q'| <= c max|Q| and + sdn = sqrt_up(law.net_var[blk]) # net gaps <= 2/NET_M give max|Q| <= max_j |Q_j| / rho + x_ = (thr * frac * rho - m_) / sdn + pj = min(Fr(1), len(NET) * gauss_tail2(m_, sdn, thr * frac * rho)) + pj += (law.S[blk] * (sqE + znorm(32)) / (thr * (1 - frac))) ** 32 + if best is None or pj < best[0]: + best = (pj, x_) + args.append(best[1]) + qA2 += best[0] + a_hi = Fr(4, 3) / klo * a_fac + qfar = Fr(0) + qx = Fr(0) + sdB11 = sqrt_up(law.C[('a11', 'a11')].hi) + if bbar > 0: + lam_far = 1 / (4 * a_hi * r1 * bbar * bbar) + args.append((lam_far - absup(mu['a11'])) / sdB11) + qfar = gauss_tail1(absup(mu['a11']), sdB11, lam_far) + + def lam2_tail(s): # P(lambda_2 > s) <= P(sig chi_3 > s - ||mu_B||) + x_ = (s - muB) / sig + args.append(x_) + return chi_tail(3, x_) if x_ > 0 else Fr(1) + for i in (1, 2, 3, 4): # x_i > X0 <=> y_i' + bar-beta_i lambda_2 > X0 / (a r1 bar-beta_i) + if bbars[i] == 0: + continue + tx = x0 / (a_hi * r1 * bbars[i]) + if i == 1: + cb = 12 * khi + bbars[1] * muB + if tx <= cb: + qx += Fr(1) + else: + qx += (r1 * nDelta(1, 32) / ((tx - cb) / 2)) ** 32 + qx += lam2_tail((tx - cb) / (2 * bbars[1])) + else: + s_i = {2: s2, 3: s3, 4: s4}[i] + x_ = tx / (3 * s_i) + args.append(x_) + qx += chi_tail(NU[i], x_) + (nd(i, 32, lam=False) * Klo / (tx / 3)) ** 32 + lam2_tail(tx / (3 * bbars[i])) + qs = [min(Fr(1), x) for x in (qA2, qfar, qx)] + tail_num = min(wnorm(qq) * sum(pow_tail(x, qq) for x in qs) for qq in QS) + if last_band: + # (0, R] is the union of [R 2^-(j+1), R 2^-j]; every Gaussian or chi tail argument scales at least like 1/r and is + # >= 3 at R, so each such 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') + 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, 'tail_num': tail_num, 'KB': KB, 'g0': g0, 'gbar': gbar, 'I3': I3, + 'termA': termA, 'termB': termB, 'termC': termC, 'termD': termD, 'qA2': qA2, 'qfar': qfar, 'qx': qx, + 'm3lo': m3lo, 'corr': corr, 'eps': eps, 'eta': eta, 'min_arg': min(args)} +# ----------------------------------------------------------------------------- the (k, b) boxes of the sweep +F_ = Fr +GRID = ( + ((F_(1, 2), F_(3, 4)), (F_(0), F_(1, 2), F_(1))), + ((F_(3, 4), F_(1)), (F_(0), F_(1, 2), F_(1))), + ((F_(1), F_(5, 4)), (F_(0), F_(1, 2), F_(1))), + ((F_(5, 4), F_(3, 2)), (F_(0), F_(1, 2), F_(1))), + ((F_(3, 2), F_(13, 8)), (F_(0), F_(243, 512), F_(1))), + ((F_(13, 8), F_(7, 4)), (F_(0), F_(309, 1024), F_(899, 1024), F_(1))), + ((F_(7, 4), F_(15, 8)), (F_(0), F_(37, 256), F_(105, 256), F_(933, 1024), F_(1))), + ((F_(15, 8), F_(31, 16)), (F_(0), F_(37, 512), F_(207, 1024), F_(225, 512), F_(113, 128), F_(1))), + ((F_(31, 16), F_(63, 32)), (F_(0), F_(37, 1024), F_(103, 1024), F_(111, 512), F_(439, 1024), F_(421, 512), F_(1))), + ((F_(63, 32), F_(2)), (F_(0), F_(1, 512), F_(5, 1024), F_(5, 512), F_(19, 1024), F_(35, 1024), F_(1, 16), F_(29, 256), + F_(209, 1024), F_(377, 1024), F_(685, 1024), F_(1))), +) + + +# ----------------------------------------------------------------------------- bands, boxes, runs +TOP_OCTAVES = 7 # octaves [2^-(j+1), 2^-j], j = 6..12 (r up to 1/64), split into 8 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] +COMBO = (Fr(1, 64), Fr(1, 32)) # (X_0, theta) of NOTE sections 4-5 + + +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, 6 + TOP_OCTAVES + LOW_OCTAVES): + hi = Fr(1, 2 ** j) + lo = hi / 2 + m = 8 if j < 6 + 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') + out = sorted(out) + require(all(out[i][1] == out[i + 1][0] for i in range(len(out) - 1)), 'bands contiguous') + return out + + +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:] + + +def grid_boxes(): + out = [] + for kb, bg in GRID: + require(bg[0] == 0 and bg[-1] == 1 and all(bg[i] < bg[i + 1] for i in range(len(bg) - 1)), 'b grid') + for i in range(len(bg) - 1): + out.append(((Fr(bg[i]), Fr(bg[i + 1])), (Fr(kb[0]), Fr(kb[1])))) + ks = [kb for kb, _ in GRID] + require(ks[0][0] == BAND_K[0] and ks[-1][1] == BAND_K[1] and all(ks[i][1] == ks[i + 1][0] for i in range(len(ks) - 1)), + 'k boxes cover K') + return tuple(out) + + +CG3_02_LO = Fr('22424320.655069') # certified lower end of c_G^(3)(0, 2) (Math-#208) + + +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 box in BOXES order, and the largest tail part (rounded up, 12 places).""" + r0, r1 = args + law = band_law(r0, r1) + last = (r0 == 0) + bound, zfloor, tails = [], [], [] + for bb, kb in BOXES: + res = box_bound(law, bb, kb, r0, r1, last_band=last, x0=COMBO[0], theta=COMBO[1]) + bound.append(dec_up(res['total'])) + zfloor.append(dec_down(36 * kb[0] * kb[0] * res['zt'], 6)) + tails.append(res['tail']) + return {'r': [str(r0), str(r1)], 'bound': bound, 'zfloor': zfloor, 'tail_max': dec_up(max(tails), 12)} + + +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_cG3_02': dec_up(mx / CG3_02_LO, 6), + 'C_rstar3': dec_up(mx * rs ** 3, 10), 'z_star': str(zmin)} + return {'schema': 1, 'object': 'CL-C8-THEOREM-A-CONSTANTS-D3-20261001-v1', 'scientific_effect': 'NONE', + 'certified': True, 'mutant': MUT, 'L_min': L_MIN, 'dimension': 3, + 'band': {'b': [str(BAND_B[0]), str(BAND_B[1])], 'k': [str(BAND_K[0]), str(BAND_K[1])]}, + 'parameters': params(), 'C_table': table, 'bands': recs} + + +def params(): + return {'PBITS': PBITS, 'NX': NX, 'NB': NB, 'COMBO_X0_THETA': [str(COMBO[0]), str(COMBO[1])], 'THETA_E': str(THETA_E), + 'QS': list(QS), 'R0_COUPLING': R0_COUPLING, 'NET_M': NET_M, 'R_STARS': [str(x) for x in R_STARS], + 'TOP_OCTAVES': TOP_OCTAVES, 'LOW_OCTAVES': LOW_OCTAVES, 'R_LAST': str(R_LAST), + 'GRID': [[[str(kb[0]), str(kb[1])], [str(x) for x in bg]] for kb, bg in GRID]} + + +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') + require(abs(m3(0).mid() - (Fr(7, 2) - 2 * SQRT2.mid())) < Fr(1, 10 ** 40), 'm_(3,0) closed form') + 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: # in order; the first differing band exits (and stops the pool) + for i, rec in zip(idx, pool.imap(band_record, [bl[i] for i in idx])): + 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'], 'C table is not the maximum of the stored bounds') + # sanity: every C exceeds the sharp reference-kernel cap coefficient c_G^(3)(0, 2) of Math-#208 (a lower bound for every + # d = 3 cap-route constant valid at (0, 2) for the reference kernel, which this certificate covers) + for rs, row in ref['C_table'].items(): + require(Fr(row['C']) > CG3_02_LO, '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()}, + 'z_star': {rs: row['z_star'] for rs, row in ref['C_table'].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({'C': {rs: row['C'] for rs, row in res['C_table'].items()}, + 'z': {rs: row['z_star'] for rs, row in res['C_table'].items()}})) +BOXES = grid_boxes() + + +# ----------------------------------------------------------------------------- floating control (not part of the certificate) +def mc_event(r, b, k, n, seed, deg=7, nang=24): + """End-to-end Monte Carlo of Q^W(G_r^c) / r^3 and Z_r / r^2 for the reference kernel in d = 3 (floating point): the + Taylor jet of order deg at the midpoint is sampled under Q (exact pin series evaluated in floating point), W_r is + evaluated from the Hessians at M and S, and M_3, M_4 are the partial-block operator norms ([CAP] (1)) maximized over a + grid of the cylinder D (binary forms maximized over nang angles; floating, so slightly below the true suprema).""" + import random + pins, _ = functionals() + P = [pins[nm] for nm in PIN_NAMES] + jets = [(a, b1, m - a - b1) for m in range(deg + 1) for a in range(m, -1, -1) for b1 in range(m - a, -1, -1)] + J = [[term(1, 0, a, b1, b2, X0PT)] for (a, b1, b2) in jets] + nj = len(J) + + 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(NP)] for i in range(NP)] + Sjp = [[ev(J[i], P[j], ('jp3', deg, i, j)) for j in range(NP)] for i in range(nj)] + Sjj = [[ev(J[i], J[j], ('jj3', deg, i, j)) for j in range(nj)] for i in range(nj)] + + 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] * (NP - 3) + Wt = [solve(Spp, Sjp[i]) for i in range(nj)] + mu = [sum(Wt[i][j] * vr[j] for j in range(NP)) for i in range(nj)] + C = [[Sjj[i][j] - sum(Wt[i][l] * Sjp[j][l] for l in range(NP)) for j in range(nj)] for i in range(nj)] + # Cholesky with clamped pivots (the conditional covariance is positive semidefinite up to rounding) + L = [[0.0] * nj for _ in range(nj)] + for i in range(nj): + for j in range(i + 1): + s = C[i][j] - sum(L[i][l] * L[j][l] for l in range(j)) + if i == j: + L[i][i] = math.sqrt(s) if s > 1e-300 else 0.0 + else: + L[i][j] = s / L[j][j] if L[j][j] > 0 else 0.0 + index = {al: i for i, al in enumerate(jets)} + fact = [math.factorial(i) for i in range(deg + 2)] + + def deriv(cf, be, p): + """d^be f(p) from the jet (Taylor at 0).""" + tot = 0.0 + for al, i in index.items(): + if al[0] >= be[0] and al[1] >= be[1] and al[2] >= be[2]: + e = (al[0] - be[0], al[1] - be[1], al[2] - be[2]) + tot += cf[i] * (p[0] ** e[0] * p[1] ** e[1] * p[2] ** e[2]) / (fact[e[0]] * fact[e[1]] * fact[e[2]]) + return tot + angs = [(math.cos(math.pi * t / nang), math.sin(math.pi * t / nang)) for t in range(nang)] + pts = [(x, 0.0, 0.0) for x in (-2 * r, -r, 0.0, r, 2 * r)] + pts += [(x, 2 * r * math.cos(2 * math.pi * t / 6), 2 * r * math.sin(2 * math.pi * t / 6)) for x in (-2 * r, 0.0, 2 * r) + for t in range(6)] + + def block_norm(vals, c): + """Operator norm of the symmetric c-form with components vals[(b1, b2)] (b1 + b2 = c) over unit vectors.""" + if c == 0: + return abs(vals[(0, 0)]) + best = 0.0 + for (u1, u2) in angs: + q = sum(math.comb(c, b1) * vals[(b1, c - b1)] * u1 ** b1 * u2 ** (c - b1) for b1 in range(c + 1)) + best = max(best, abs(q)) + return best + + def Mj(cf, j): + best = 0.0 + for p in pts: + for a in range(j + 1): + c = j - a + vals = {(b1, c - b1): deriv(cf, (a, b1, c - b1), p) for b1 in range(c + 1)} + best = max(best, block_norm(vals, c)) + return best + + def hess(cf, p): + return [[deriv(cf, tuple(int(x == i) + int(x == j) for x in range(3)), p) for j in range(3)] for i in range(3)] + + def det3f(H): + return (H[0][0] * (H[1][1] * H[2][2] - H[1][2] * H[2][1]) - H[0][1] * (H[1][0] * H[2][2] - H[1][2] * H[2][0]) + + H[0][2] * (H[1][0] * H[2][1] - H[1][1] * H[2][0])) + + def neg_def(H): + return H[0][0] < 0 and H[0][0] * H[1][1] - H[0][1] ** 2 > 0 and det3f(H) < 0 + + def index2(H): + """Number of negative eigenvalues of a symmetric 3 x 3 matrix is 2: det > 0 and not positive definite.""" + d = det3f(H) + pd = H[0][0] > 0 and H[0][0] * H[1][1] - H[0][1] ** 2 > 0 and d > 0 + return d > 0 and not pd + rng = random.Random(seed) + num = den = 0.0 + acap = 4 / (3 * k) + for _ in range(n): + z = [rng.gauss(0, 1) for _ in range(nj)] + cf = [mu[i] + sum(L[i][j] * z[j] for j in range(i + 1)) for i in range(nj)] + HM, HS = hess(cf, (-r / 2, 0.0, 0.0)), hess(cf, (r / 2, 0.0, 0.0)) + if not (neg_def(HM) and index2(HS)): + continue + Wv = abs(det3f(HM) * det3f(HS)) + den += Wv + a11, a22, a12 = -HM[1][1], -HM[2][2], -HM[1][2] + lam1 = (a11 + a22) / 2 - math.sqrt(((a11 - a22) / 2) ** 2 + a12 * a12) + M3 = Mj(cf, 3) + if lam1 <= acap * r * M3 * M3: + num += Wv + continue + if r * Mj(cf, 4) > 3 * k / 10: + num += Wv + return {'r': r, 'b': b, 'k': k, 'n': n, 'seed': seed, 'QW_Gc_over_r3': num / den / r ** 3 if den else None, + 'Z_over_r2': den / n / r ** 2} + + +if __name__ == '__main__': + main() From c4b8ec3e0232a6dcfc29c8d938268d51693b46b0 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Thu, 1 Oct 2026 03:22:07 +0000 Subject: [PATCH 2/4] C8 d = 3 constants: scope the "no constant on record" remark to [LP], [CAP] and the open packets NOTE section 0 now says that no explicit constant for (1.1) or (7.8) in d >= 3 is recorded in [LP], [CAP] or the open packets of this repository, instead of "on record" without qualification. Manifest updated; no numerical change. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md | 4 ++-- .../c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md b/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md index e22b13df..d1cf4b21 100644 --- a/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md +++ b/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md @@ -75,8 +75,8 @@ The same holds for the reference kernel `exp(-|z|^2/2)` on `R^3`. Every enclosur - `(C, r_*) = (23332922.4752, 1/512)`, where the bound at `r = r_*` is below `0.174`; - `(22974134.2920, 1/1024)`, where it is below `0.0214`. - **What was missing.** [LP] §16 lists "a numerical `r_*` or `C` on a prescribed band" among the items it does not supply. - [CAP]'s probabilistic corollary is planar only ("No 3D eight-pin matrix-boundary estimate ... is proved here"). Before - this packet no explicit constant was on record in any dimension `d >= 3`. + [CAP]'s probabilistic corollary is planar only ("No 3D eight-pin matrix-boundary estimate ... is proved here"). No + explicit constant for (1.1) or (7.8) in `d >= 3` is recorded in [LP], [CAP] or the open packets of this repository. - **Near-optimal for the cap route.** - Every `d = 3` cap-route constant valid for the reference kernel at `(b, k) = (0, 2)` is at least `c_G^(3)(0, 2) > 22424320.65` ([G3] Corollary 1). diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json index e966d1a0..9691e7ad 100644 --- a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json +++ b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json @@ -7,9 +7,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 35268, - "sha256": "873e466b84d6b6e5a2f0ce71a0f58b3b6ebf1298a1ba9d588cbc91c86242ed6d", - "git_blob": "e22b13df4e4fb9c0ec99c3a0e92b548a388a182a" + "bytes": 35306, + "sha256": "3809e3506f2b19f194224163d9c73584a1227fc866a4770c549b33116080e899", + "git_blob": "d1cf4b21de9c7e19f3c6063149846a6520d1778d" }, { "path": "README.md", From 250b90722e8c47adf8f7e7c41a61e8a8085d9741 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Fri, 2 Oct 2026 00:12:37 +0000 Subject: [PATCH 3/4] Theorem A constants (d = 3) v1.1: two docstrings only (C59-DOC-01, C61) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit sqrt_up: the stated relative excess becomes 2^-198 (2^-200 fails at 49/100). box_bound: 'every choice gives a valid bound' becomes the proved domain 0 < x0 < 2/9, 0 < theta < 1, which contains COMBO = (1/64, 1/32). AST with docstrings removed is unchanged; RESULTS.json and every constant unchanged; --check passes in both interpreter modes. NOTE gains §12 Revisions. Byte-identical copies follow in #215 and #227. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md | 10 ++++++++++ .../SOURCE_FILES.json | 12 ++++++------ .../c8_theorem_a_constants_d3_20261001/theorem_a3.py | 9 +++++++-- 3 files changed, 23 insertions(+), 8 deletions(-) diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md b/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md index d1cf4b21..718dd17e 100644 --- a/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md +++ b/frontiers/c8_theorem_a_constants_d3_20261001/NOTE.md @@ -531,3 +531,13 @@ Pooled over 16 seeds: since `c_G^(3) (1/256)^3 > 1`. - **Status.** C8 stays OPEN. - **Independence.** Same GitHub account as every lane; zero organizational-independence credit. The author will not merge. + +## 12. Revisions + +- **v1 (`c4b8ec3`):** Theorem E3 on the band. +- **v1.1:** documentation only. It changes two docstrings in `theorem_a3.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). `COMBO = (1/64, 1/32)` lies inside it. diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json index 9691e7ad..1026b2c3 100644 --- a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json +++ b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json @@ -7,9 +7,9 @@ "files": [ { "path": "NOTE.md", - "bytes": 35306, - "sha256": "3809e3506f2b19f194224163d9c73584a1227fc866a4770c549b33116080e899", - "git_blob": "d1cf4b21de9c7e19f3c6063149846a6520d1778d" + "bytes": 36029, + "sha256": "a93366be08211820492613b611c8c0e205158e520617716485707afb7ea0fc19", + "git_blob": "718dd17eb6f1e94391ea8f3ad4d7c1bfd9d48d2d" }, { "path": "README.md", @@ -31,9 +31,9 @@ }, { "path": "theorem_a3.py", - "bytes": 75753, - "sha256": "b0e1b3b4f43e140b51609332fe2e54f4f6b50d10f9f6af48d40ff548bbe742c0", - "git_blob": "ac809dbd36981d1b214fb2f8626417b50afb41f3" + "bytes": 76209, + "sha256": "310d4ab3d3a38a377d753753f3b814591a9090a947f87d6843ab7389389572d3", + "git_blob": "267890232119b35206be7a8cc74d730de9a68644" } ], "nonauthor_reads": [] diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/theorem_a3.py b/frontiers/c8_theorem_a_constants_d3_20261001/theorem_a3.py index ac809dbd..26789023 100644 --- a/frontiers/c8_theorem_a_constants_d3_20261001/theorem_a3.py +++ b/frontiers/c8_theorem_a_constants_d3_20261001/theorem_a3.py @@ -319,7 +319,9 @@ def rdown_rel(x, bits=200): def sqrt_up(x): - """Rational upper bound of sqrt(x), x >= 0 rational, relative error below 2^-200 (no absolute rounding floor).""" + """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) @@ -1053,7 +1055,10 @@ def det_norm(p, bpp, muB, sig): 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); every choice gives a valid bound.""" + 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. COMBO = (1/64, 1/32), also used by Math-#215's caller, + lies 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]) From 558912468604c668fc77411fe3a29181cb0436b2 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Sat, 3 Oct 2026 20:26:27 +0000 Subject: [PATCH 4/4] Theorem A (d = 3): #208 merged at b55b8f3; promote [G3-RESULTS] to current_required (provenance only) Math-#208 (cap-failure coefficient in every dimension) landed on main at b55b8f3. Its RESULTS.json (blob e9fd6f37) is byte-identical to the pinned da48373 version, so the [G3-RESULTS] pin is now current_required and on_main, and the workflow checks it on the tree. The path filter gains the file. The [G3] NOTE pin (17e6866b) stays historical: main's NOTE differs only by the C208-C-01 wording fix (b42be5b8). theorem_a3.py hardcodes CG3_02_LO and does not read either file. No executable, RESULTS.json, NOTE.md or constant changes. Classification as provenance-only is an author proposal pending nonauthor assessment. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .github/workflows/c8-theorem-a-constants-d3.yml | 1 + .../c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json | 6 +++--- .../c8_theorem_a_constants_d3_20261001/SOURCE_MAP.json | 8 ++++---- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/.github/workflows/c8-theorem-a-constants-d3.yml b/.github/workflows/c8-theorem-a-constants-d3.yml index d96347b7..559e2a39 100644 --- a/.github/workflows/c8-theorem-a-constants-d3.yml +++ b/.github/workflows/c8-theorem-a-constants-d3.yml @@ -7,6 +7,7 @@ name: C8 Theorem A constants in d = 3 (certified replay) - '.github/workflows/c8-theorem-a-constants-d3.yml' - 'imports/lifetime_parent_20260925/UNIFORM_MATRIX_CAP_AND_LIFETIME.md' - 'imports/lifetime_parent_20260925/MARKED_CYLINDER_CAP_PROOF.md' + - 'frontiers/c8_cap_failure_coefficient_dims_20261001/RESULTS.json' workflow_dispatch: permissions: diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json index 1026b2c3..764ab989 100644 --- a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json +++ b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_FILES.json @@ -25,9 +25,9 @@ }, { "path": "SOURCE_MAP.json", - "bytes": 5906, - "sha256": "2f23f4a57cf4f64da2d95069e874dae417ed5407d186008c0b4f48bc17e6ca58", - "git_blob": "b5de31814760baf99b37ff242684cf1ff71c6eb3" + "bytes": 6153, + "sha256": "d2dfd680219ea576231725dfb48b55aae97067bc74a73cf1729131bf1fe84e14", + "git_blob": "9c08564351fbeadb2edff27a953999e47346414b" }, { "path": "theorem_a3.py", diff --git a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_MAP.json b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_MAP.json index b5de3181..9c085643 100644 --- a/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_MAP.json +++ b/frontiers/c8_theorem_a_constants_d3_20261001/SOURCE_MAP.json @@ -38,7 +38,7 @@ "id": "G3", "commit": "da483732664d128728950dcad6d4fdbe5181f7cd", "pull_request": "Math-#208", - "role": "Theorem G_d, the d = 3 contact law (Lemma 1: B ~ b I + GOE_2, v ~ N(0, I/2), Omega' ~ GOE_2, Y with variances 6, 2, 2, 6) and m_(3,0) = (7 - 4 sqrt2)/2, reproduced independently here; the certified lower end c_G^(3)(0, 2) >= 22424320.655069 (its RESULTS.json, below) is used only for the --check sanity rule C3 > c_G^(3)(0, 2) and for the comparisons in NOTE section 0; not consumed by the proof", + "role": "Theorem G_d, the d = 3 contact law (Lemma 1: B ~ b I + GOE_2, v ~ N(0, I/2), Omega' ~ GOE_2, Y with variances 6, 2, 2, 6) and m_(3,0) = (7 - 4 sqrt2)/2, reproduced independently here; the certified lower end c_G^(3)(0, 2) >= 22424320.655069 (its RESULTS.json, below) is used only for the --check sanity rule C3 > c_G^(3)(0, 2) and for the comparisons in NOTE section 0; not consumed by the proof; Math-#208 merged at b55b8f3, where NOTE.md has since changed by the C208-C-01 wording fix only (blob b42be5b8), so this NOTE pin stays historical", "current_required": false, "on_main": false }, @@ -50,9 +50,9 @@ "id": "G3-RESULTS", "commit": "da483732664d128728950dcad6d4fdbe5181f7cd", "pull_request": "Math-#208", - "role": "the certified enclosure c_G^(3)(0, 2) in [22424320.655069, 22424320.655072]; comparison and sanity check only", - "current_required": false, - "on_main": false + "role": "the certified enclosure c_G^(3)(0, 2) in [22424320.655069, 22424320.655072]; comparison and sanity check only; Math-#208 merged at b55b8f3 with this RESULTS.json byte-identical, so the pin is checked on the tree", + "current_required": true, + "on_main": true }, { "path": "frontiers/c8_theorem_a_constants_planar_20260930/NOTE.md",