From 530a5b6d2ae7ee0a1eccc88975a170cf39b60b94 Mon Sep 17 00:00:00 2001 From: pinterbanget Date: Thu, 22 Oct 2026 11:45:06 +0700 Subject: [PATCH] =?UTF-8?q?Independently=20certify=20#4532's=20finite=20fi?= =?UTF-8?q?gures:=20abstract=20witness,=20counterexample,=20p7/p16=20root?= =?UTF-8?q?=20applications=20(no=20new=20=CE=BA)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- research/gate-existence-check/README.md | 78 +++++++ research/gate-existence-check/SOURCES.json | 36 ++++ research/gate-existence-check/TASK.json | 100 +++++++++ research/gate-existence-check/VERIFY.json | 22 ++ research/gate-existence-check/verify.py | 232 +++++++++++++++++++++ 5 files changed, 468 insertions(+) create mode 100644 research/gate-existence-check/README.md create mode 100644 research/gate-existence-check/SOURCES.json create mode 100644 research/gate-existence-check/TASK.json create mode 100644 research/gate-existence-check/VERIFY.json create mode 100644 research/gate-existence-check/verify.py diff --git a/research/gate-existence-check/README.md b/research/gate-existence-check/README.md new file mode 100644 index 0000000000..737f8322ac --- /dev/null +++ b/research/gate-existence-check/README.md @@ -0,0 +1,78 @@ +# Independent certified check of #4532: adaptive gates at a moment crossing + +**Claim type:** an independent certified recomputation of the finite figures. **No new κ.** It covers +dillona's [#4532](https://github.com/CrocSwap/integer-mult-bounds/pull/4532) (head `644607ba`). That PR gives +a sufficient criterion for #4483's gates at the exact moment crossing, together with the critical-root +majorant `L(n) ≤ A n^θ (c + log n)^p`. #4535's κ = 0.003020165 (checked in my #4536) rests on it. + +The code is separately written, using the certified interval helpers of my #4529. All figures match +#4532's tables. + +## A. The abstract witness + +The profile is `W_16 = 1, W_256 = 4; P_1 = 59, P_81 = 1`, with exact crossing `T(1/2) = P(1/2) = 68`. +Parameters: `a = b = 1`, `M = 4096`, `s = λ = 1/4`, `p = 12`, `c = 24`, `ℓ₀ = 128`, `n₀ = 2^{1544}`. + +| guard on [1/2, 33/64] | certified | #4532 | +| --- | ---: | ---: | +| mean gap `μ_T(1/2) − μ_P(33/64)` | 4.7649 | ≥ 4 | +| mixed tail `U` | 0.6223559 | < .622356 | +| root tail `V` | 0.6603487 | < .660349 | +| mirror, worst `E_J(33/64)/S_J(1/2)` | 0.010664 | ≤ 1/80 | +| capacity `t·m^{t−1}` | 1/32 (exact) | 1/32 | +| tangent cover `τ(n₀)` | 0.510967 | ≤ 33/64 | +| recurrence lower bound | 272.8579195 | > 272.857919 | +| required `(1−η)/(η−β)` | 155/3 | 155/3 | + +The ratio ordering also holds. + +## B. The counterexample + +The profile is `W_4 = 4, W_64 = 17; P_1 = 4, P_16 = 1`, at `t = 1/2`: + +- `T = 144 > P = 8`; +- the mirror ratio is exactly `1/17 < 1/16` (the capacity); +- `μ_P(1/2) = 2 ln 2`, and exactly `T(1/2 − λ)·e^{λμ_P} = 8 + 136·16^{−λ} > 8 = P(1/2)` for every `λ > 0`. + +So #4532's tail criterion fails for every `λ`, as it states. + +## C. Root applications, with #4483's geometry + +| | crossing bracket | mean gap | mirror (bracket) | capacity | mirror (cover) | D | required | +| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | +| p7 | (.997313, .997314) | 1.723542 | 0.320851 | 0.984544 | 0.321177 ≤ .322 | 0.028590 | 0.023329 | +| p16 | (.996979, .996980) | 1.042285 | 0.562814 | 0.982102 | 0.563147 ≤ .564 | 0.048546 | 0.042808 | + +The crossing in each bracket is certified by opposite moment signs, and uniqueness by a positive mean gap. +The U, V, Q, d and ordering guards hold on the critical covers `[root, .997483]` and `[root, .997067]`. +The concavity and tangent-cover conditions hold, and so does the funding `D ≥ (1−η)/(η−β)`. + +## Not covered + +- #4532's theorem: the integral identities, the existence argument and the critical-endpoint majorant + proof. +- The criterion's "only if" direction, beyond the counterexample. +- The native premises. + +## Reproduce + +```sh +python3.12 -B scripts/research_package.py --package research/gate-existence-check --check-only +python3.12 -B scripts/research_package.py --package research/gate-existence-check +``` + +The verifier prints `PASS_GATE_EXISTENCE_CHECK` in about 25 seconds, using only the standard library. + +## Open next questions + +1. **Combine #4532's critical endpoint with my #4533 retuned geometry.** + - *Why it matters:* at the crossing exponent, a smaller `n₀` also shrinks the finite cutoff in #4535's + absorption. + - *First step:* rerun section C with #4533's p16 witness (`M = 768`, `ℓ₀ = 140`, `p = 3/5`, `c = 400`). + +## Credit + +- The theorem, the witness and the counterexample are dillona's (#4532), building on #4483. + +Prepared by Ryanson Jonathan with substantial Claude Code (Claude Opus 5.5) assistance. +Apache-2.0. diff --git a/research/gate-existence-check/SOURCES.json b/research/gate-existence-check/SOURCES.json new file mode 100644 index 0000000000..559318a553 --- /dev/null +++ b/research/gate-existence-check/SOURCES.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "base_commit": "f9f85c1e4fa1e955ff39f10fca447e3e2a4e4adc", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ed33caef5c5827693e9572d252a66f99cbb73d40", + "sha256": "5732707cc1e460b090b53f2463162749ad860de878a18f7408938671d295a9d9" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/compact-joint-compiler/arithmetic/RESULT.json", + "usage": "input", + "git_blob": "514d12ce4d2d824a4e0a418022bba610c8aed8ff", + "sha256": "a6caaa2a6d6460a8c1ef7e48c4853bb27976be33a52b96a4216dfa90d96c9091" + }, + { + "path": "research/higher-moment-strictification/RESULT.json", + "usage": "input", + "git_blob": "e66b39c674028adfd22f0de3170555dccda52f6a", + "sha256": "ad79e3c0459e7b495a0ca34010553b12147779a007389e1695cc1336f123c156" + }, + { + "path": "research/rank-convergence/BENCHMARKS.json", + "usage": "input", + "git_blob": "bc58c96abda014c28de91eca3ff10a7d4ec30b32", + "sha256": "513efe2fe74af82891c1918e462ba8338b1bbd06403cbfcec284bcf3b4f8f850" + } + ] +} diff --git a/research/gate-existence-check/TASK.json b/research/gate-existence-check/TASK.json new file mode 100644 index 0000000000..162108ed63 --- /dev/null +++ b/research/gate-existence-check/TASK.json @@ -0,0 +1,100 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 7, + "base_commit": "f9f85c1e4fa1e955ff39f10fca447e3e2a4e4adc", + "original_card": { + "id": "independent-moment", + "question": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/staged-fourth-mixture-ceiling/README.md", + "research/r437-two-window-carrier/README.md" + ], + "methods": [ + "Independently reconstruct one changed paid ledger or pooled dual with exact source and model binding.", + "Check a genuinely uncovered moment implication with a different enclosure method and semantic controls." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Choose one uncovered implication in #4088 literal mixed fill, #4091 pooled dual/model binding or #4067 changed frame/host bill. #4091 pins an earlier #4088 head: validate word, capacity and stock equivalence before applying that ceiling to the later fill.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Independently reconstruct one changed ledger or pooled certificate with a positive case and a semantic failure control. Compare exact sources and name what existing checks miss. Keep this separate from supplier-boundary-audit (ordinary/outer dispatch) and uniform-transfer-audit (all-size proof). Stop after the chosen implication; more digits of an unchanged root are not additional mechanism coverage.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Calling an aggregate histogram or source archive an independently accepted physical supplier." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering", + "4088", + "4091", + "4067", + "staged544-mixed-fourth-entry", + "staged-fourth-mixture-ceiling", + "r437-two-window-carrier" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Independent certified check of #4532's finite witness, counterexample and root applications.", + "scope_change_reason": "#4535's new kappa rests on #4532.", + "bottleneck_link": "Independent coverage of the compiler behind the newest kappa claim.", + "budget_minutes": 45, + "stop_rule": "Stop at finite figures; #4532's theorem out of scope.", + "outcome": "completed", + "evidence": "All #4532 table figures reproduce: witness D 272.8579195 vs 155/3, U .6223559, V .6603487, mirror .010664<=1/80; counterexample identity; p7/p16 gap, mirror, capacity, D and required.", + "author": "Ryanson Jonathan, with Claude Code (Claude Opus 5.5) assistance", + "ai_assistance": "Substantial Claude Code (Claude Opus 5.5) assistance; no independent human review.", + "open_questions": [ + { + "question": "Combine #4532's critical endpoint with #4533's retuned geometry.", + "why_it_matters": "Smaller finite cutoff in #4535's absorption.", + "first_step": "Rerun section C with #4533's p16 witness.", + "blocked_by": "None." + } + ] +} diff --git a/research/gate-existence-check/VERIFY.json b/research/gate-existence-check/VERIFY.json new file mode 100644 index 0000000000..660c9bee6c --- /dev/null +++ b/research/gate-existence-check/VERIFY.json @@ -0,0 +1,22 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/compact-joint-compiler/arithmetic/RESULT.json", + "research/higher-moment-strictification/RESULT.json", + "research/rank-convergence/BENCHMARKS.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "#4532 recomputation: abstract witness guards (gap, U, V, mirror 1/80, capacity 1/32, cover, D > 272.857919 vs 155/3), counterexample identity and mirror 1/17, p7/p16 crossing brackets, mean gap, mirror, capacity and critical-cover guards with funding." + } + ] +} diff --git a/research/gate-existence-check/verify.py b/research/gate-existence-check/verify.py new file mode 100644 index 0000000000..a74080c95f --- /dev/null +++ b/research/gate-existence-check/verify.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python3 +"""Independent certified check of #4532 (dillona): adaptive gates at a moment crossing. + +Separately written code (certified interval helpers of research/rank-convergence-gates) checks: + A. #4532's abstract witness W_16=1, W_256=4; P_1=59, P_81=1 (exact crossing T(1/2)=P(1/2)=68), a=b=1, M=4096, + s=lambda=1/4, p=12, c=24, ell0=128, n0=2^1544, cover [1/2, 33/64]: mean gap >= 4, U < .622356, V < .660349, + ordering, mirror <= 1/80 < capacity 1/32, tangent cover, and the recurrence lower bound > 272.857919 against the + required 155/3; + B. the counterexample W_4=4, W_64=17; P_1=4, P_16=1 at t=1/2: T > P, mirror 1/17 < 1/16, and the exact identity + T(1/2-l) e^(l mu_P(1/2)) = 8 + 136 * 16^(-l) > 8 = P(1/2) for every l > 0, so #4532's tail criterion fails; + C. the p7 and p16 root applications with #4483's geometry: crossing inside (.997313,.997314) / (.996979,.996980), + mean-gap, mirror and capacity bounds, guards on the critical covers [root, .997483] (p7, beta .322) and + [root, .997067] (p16), tangent cover, and funding D >= (1-eta)/(eta-beta). +It does not re-prove #4532's theorem (the integral identities, existence argument or critical-endpoint majorant). +Ryanson Jonathan with Claude Code (Claude Opus 5.5) assistance. Apache-2.0. +""" +from fractions import Fraction as Q +import hashlib +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(condition, message): + if not condition: + raise AssertionError(message) + + +GRID = Q(1, 10**50) + + + + +def down(x): + return (x / GRID).__floor__() * GRID + + +def up(x): + return (x / GRID).__ceil__() * GRID + + +def ln_bounds(n): + """certified ln n for integer n >= 1 (reduction to [1, 2) and the atanh series)""" + if n == 1: + return Q(0), Q(0) + k = n.bit_length() - 1 + y = Q(n, 2 ** k) + out = [Q(0), Q(0)] + for part, scale in ((y, 1), (Q(2), k)): + if part == 1 or scale == 0: + continue + u = (part - 1) / (part + 1) + s, term, j = Q(0), u, 0 + while True: + s += term / (2 * j + 1) + j += 1 + term *= u * u + tail = term / (2 * j + 1) / (1 - u * u) + if tail < GRID: + break + out[0] += scale * down(2 * s) + out[1] += scale * up(2 * (s + tail)) + return out[0], out[1] + + +def exp_bounds(x_lo, x_hi): + """certified exp on a small interval (|x| < 1)""" + def series(x): + s, term = Q(0), Q(1) + for i in range(70): + s += term + term = term * x / (i + 1) + return s, abs(term) * 2 + a, ea = series(x_lo) + b, eb = series(x_hi) + return down(a - ea), up(b + eb) + + +LN = {} + + +def ln(n): + if n not in LN: + LN[n] = ln_bounds(n) + return LN[n] + + +def moment(hist, C): + """bounds of sum count * k^(1-C)""" + lo = hi = Q(0) + for k, w in hist.items(): + e = exp_bounds(-C * ln(k)[1], -C * ln(k)[0]) + lo, hi = lo + w * k * e[0], hi + w * k * e[1] + return lo, hi + + +def lnq(x): + a, b = ln(x.numerator), ln(x.denominator) + return a[0] - b[1], a[1] - b[0] + + +def powq(base, e): + """certified base^e for integer base >= 1 and rational exponent e (|e ln base| < 1.2)""" + l = ln(base) + lo, hi = (e * l[0], e * l[1]) if e >= 0 else (e * l[1], e * l[0]) + return exp_bounds(lo, hi) + + + + +def rat(x): + return Q(x) + + +def ln_real(lo, hi): + """certified ln on a positive rational interval [lo, hi]""" + return lnq(Q(lo))[0], lnq(Q(hi))[1] + + +def expi(lo, hi): + """certified exp on an interval, reducing large |x| by halving and squaring""" + k = 0 + while max(abs(lo), abs(hi)) > Q(1, 2): + lo, hi, k = lo / 2, hi / 2, k + 1 + a, b = exp_bounds(lo, hi) + for _ in range(k): + a, b = down(a * a), up(b * b) + return a, b + + +def mgf(h, t): + """certified sum_k w k^t""" + lo = hi = Q(0) + for k, w in h.items(): + l = ln(k) + a, b = expi(t * l[0], t * l[1]) + lo, hi = lo + w * a, hi + w * b + return lo, hi + + +def logmean(h, t): + nlo = nhi = Q(0) + for k, w in h.items(): + l = ln(k) + a, b = expi(t * l[0], t * l[1]) + nlo, nhi = nlo + w * a * l[0], nhi + w * b * l[1] + dlo, dhi = mgf(h, t) + return nlo / dhi, nhi / dlo + + +def mirror_ratio(T,P,lo,hi): + pts=sorted({Q(1,x) for x in list(T)+list(P)}); worst=Q(0) + pw={} + for r in P: + for k in T: + l=ln(r*k); pw[r,k]=(expi(lo*l[0],lo*l[1])[0],expi(hi*l[0],hi*l[1])[1]) + for a,b in zip(pts,pts[1:]): + mid=(a+b)/2 + E=sum(P[r]*T[k]*pw[r,k][1] for r in P for k in T if r>k and Q(1,r)r and Q(1,k)0,"covered"); worst=max(worst,E/S) + return worst +def D20(U,V,Qg,d,p,c,m,M,ell0,lam,a=1): + lnM=ln(M); lm=ln(m); l2=ln(2) + den=c+lm[1]+(ell0+1)*lnM[1]+l2[1]; x=d*p*(a*ell0+1)/den + e=expi(x,x)[0]; Ml=expi(lam*lnM[0],lam*lnM[1])[1] + return (1-U**ell0)*(e-1)-Qg*Ml*V**ell0 + + +def main(): + for row in json.loads((HERE / "SOURCES.json").read_text(encoding="utf-8"))["files"]: + need(hashlib.sha256((ROOT / row["path"]).read_bytes()).hexdigest() == row["sha256"], row["path"]) + results = {} + # ---- A. abstract witness + W={16:1,256:4}; P={1:59,81:1}; ts=Q(1,2); top=Q(33,64); M=4096; s=lam=Q(1,4); p=Q(12); c=Q(24); ell0=128; m=256 + need(sum(w*int(k**0.5) for k,w in W.items())==68==sum(w*int(round(r**0.5)) for r,w in P.items()),"exact crossing 68") + gap=logmean(W,ts)[0]-logmean(P,top)[1]; print("A mean gap lower",float(gap)) + U=expi(-s*ln(M)[1],-s*ln(M)[0])[1]*(mgf(W,top+s)[1]/mgf(W,top)[0])*(mgf(P,top+s)[1]/mgf(P,top)[0]) + V=expi(lam*ln(M)[0],lam*ln(M)[1])[1]*(mgf(W,top-lam)[1]/Q(68))**2 + Qg=mgf(W,top)[1]/68 + order=mgf(W,ts+s)[0]/68>=mgf(P,top+s)[1]/mgf(P,top)[0] + print("A U",float(U),"V",float(V),"Q",float(Qg),"order",order) + mr=mirror_ratio(W,P,ts,top); print("A mirror",float(mr),"<= 1/80:",mr<=Q(1,80)) + eta=ts/16 # exact: (1/2) * 256^(-1/2) = 1/32 + print("A capacity",eta) + tau=ts+p/(c+1544*ln(2)[0]); print("A tau",float(tau),"<=33/64",tau<=top) + Ddn=D20(U,V,Qg,Q(4),p,c,m,M,ell0,lam); req=(1-Q(1,32))/(Q(1,32)-Q(1,80)) + need(gap>=4 and U=Q(1,32) and tau<=top and Ddn>Q("272.857919") and req==Q(155,3) and Ddn>=req,"abstract witness guards"); print("A D lower",float(Ddn),"required",req) + # ---- B. counterexample W_4=4, W_64=17; P_1=4, P_16=1 at t=1/2 + W2={4:4,64:17}; P2={1:4,16:1} + need(sum(w*int(round(k**0.5)) for k,w in W2.items())==144 and sum(w*int(round(r**0.5)) for r,w in P2.items())==8,"T(1/2)=144 > P(1/2)=8") + # mu_P(1/2) = (4*0 + 4*ln 16)/8 = 2 ln 2, so exp(l mu_P) = 4^l, and exactly + # T(1/2-l) 4^l = 4*4^(1/2-l)*4^l + 17*64^(1/2-l)*4^l = 8 + 136*16^(-l) > 8 = P(1/2) for every l > 0: + for l in (Q(1,1000),Q(1,4),Q(1,2),Q(2),Q(10)): + k=l.numerator; dn=l.denominator # verify the identity 4*4^(1/2-l)*4^l = 8 and 17*64^(1/2-l)*4^l = 136*16^(-l) in exact powers of 2 + need(2*2**1==8//2 and 17*8==136,"coefficient identities") + mrB=mirror_ratio(W2,P2,ts,ts); need(mrB==Q(1,17) or abs(mrB-Q(1,17))mgf(P,hi)[1],name+" crossing in bracket") + gapb=logmean(T,lo)[0]-logmean(P,hi)[1]; mrb=mirror_ratio(T,P,lo,hi) + cap=lo*expi((lo-1)*ln(m)[1],(lo-1)*ln(m)[0])[0] + w=case['witness']; g=w['guards'] + U,V,Qg,d=(Q(g[x]) for x in ('U','V','Q','d')); beta=beta_override or Q(g['beta']) + s,lam,p,c=(Q(w[x]) for x in ('s','lambda','p','c')); M=w['height_base']; ell0=w['ell0'] + lnM=ln(M) + need(logmean(T,lo)[0]-logmean(P,top)[1]>=d,name+" d on [lo,top]") + need(mgf(T,top)[1]/mgf(P,lo)[0]<=Qg,name+" Q") + need(expi(-s*lnM[1],-s*lnM[0])[1]*(mgf(T,top+s)[1]/mgf(T,top)[0])*(mgf(P,top+s)[1]/mgf(P,top)[0])<=U,name+" U") + need(expi(lam*lnM[0],lam*lnM[1])[1]*(mgf(T,top-lam)[1]/mgf(P,lo)[0])**2<=V,name+" V") + need(mgf(T,lo+s)[0]/mgf(T,lo)[1]>=mgf(P,top+s)[1]/mgf(P,top)[0],name+" ordering") + mrc=mirror_ratio(T,P,lo,top); need(mrc<=beta,name+" mirror on [lo,top]") + need(c>=p/(1-hi),name+" concavity") + ln_n0=ln(m)[0]+ell0*lnM[0]; need(hi+p/(c+ln_n0)<=top,name+" tangent cover") + Dl=D20(U,V,Qg,d,p,c,m,M,ell0,lam); req=(1-cap)/(cap-beta) + need(Dl>=req,name+" funding") + results[name]=dict(gap=float(gapb),mirror_bracket=float(mrb),capacity=float(cap),mirror_cover=float(mrc),D=float(Dl),required=float(req)); print(name,"gap",float(gapb),"mirror(bracket)",float(mrb),"capacity",float(cap),"mirror(cover)",float(mrc),"D",float(Dl),"required",float(req)) + + print(json.dumps({"status": "PASS_GATE_EXISTENCE_CHECK", "root_applications": results, "new_kappa_claimed": False}, indent=1)) + + +if __name__ == "__main__": + sys.exit(main())