diff --git a/.github/workflows/c6-count-cap-boundary.yml b/.github/workflows/c6-count-cap-boundary.yml new file mode 100644 index 000000000..c5a297d62 --- /dev/null +++ b/.github/workflows/c6-count-cap-boundary.yml @@ -0,0 +1,33 @@ +name: C6 count-cap method-boundary controls + +'on': + pull_request: + paths: + - 'frontiers/c6_count_cap_boundary_20260929/**' + - '.github/workflows/c6-count-cap-boundary.yml' + push: + branches: [main] + paths: + - 'frontiers/c6_count_cap_boundary_20260929/**' + - '.github/workflows/c6-count-cap-boundary.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + exact-boundary: + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.11.16' + - name: Exact sources and both-mode semantic controls + run: | + set -euo pipefail + python -B -S frontiers/c6_count_cap_boundary_20260929/verify.py --output "${RUNNER_TEMP}/count-cap-boundary-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}" + git diff --exit-code diff --git a/frontiers/c6_count_cap_boundary_20260929/PROOF.md b/frontiers/c6_count_cap_boundary_20260929/PROOF.md new file mode 100644 index 000000000..3d4c28a4c --- /dev/null +++ b/frontiers/c6_count_cap_boundary_20260929/PROOF.md @@ -0,0 +1,223 @@ +# What a rare first moment and a global count cap can—and cannot—prove + +Object: OA-C6-COUNT-CAP-BOUNDARY-20260929-v1. +Author: OpenAI / ChatGPT, 29 September 2026. +Disposition: AUTHOR-SIDE MATHEMATICAL CANDIDATE; nonauthor review required. +Scientific effect NONE. No existing source, review, status, graph, lemma flag or +prize is modified. No novelty or Gaussian optimality claim is made. + +## 1. Purpose and independence from the Gaussian candidates + +The new C6 route bounds a rare window count N by a total critical-point cap Psi. +Claude's Math-#142 separately develops a Gaussian cap tail using a growing +complex Cauchy radius. This note does NOT duplicate that theorem. It proves an +abstract inference bound, an explicit example saturating it, and an exact +size-bias identity isolating the extra information needed for a log-free result. + +No Gaussian covariance, Rouché theorem, invariant manifold or unreviewed +higher-dimensional first-moment statement is an input to the proofs below. +The existing project arguments motivate the hypotheses but are not proved or +accepted by this note. In particular, the example is NOT a Gaussian random +field and says nothing about the actual optimal order of C6. + +Fix an integer d>=2. For each sufficiently small r>0, let Q_r be a probability +law, P_r a law with density R_r=dP_r/dQ_r, N_r a nonnegative integer-valued +random variable, and Psi_r a nonnegative measurable cap with N_r<=Psi_r. +Assume constants independent of r satisfy + + E_{P_r} N_r <= C_0 r^3, ||R_r||_{L2(Q_r)} <= K, + Q_r(Psi_r>x) <= C_1 exp(-c phi_d(x)), + phi_d(x)=x^(1/d) log(2+x), x>=0. (B1) + +The laws and variables may otherwise depend on r. Constants may depend on d. +No independence between the cap, count and density is assumed. The cap-tail +hypothesis implies Psi_r=1, (N)_q=N(N-1)...(N-q+1), with value zero when N=2, writing +L=log(1/r), (B1) implies + + E_{P_r}(N_r)_q <= C_q r^3 [L/log L]^{d(q-1)} (B2) + +for all sufficiently small r. It also implies a uniformly bounded small positive +exponential moment of phi_d(Psi_r), under Q_r and P_r. + +**Theorem B (limit of these hypotheses).** There is an explicit family satisfying +(B1), even with P_r=Q_r and E N_r=r^3 on a sequence r_n decreasing to zero, such +that for every fixed q>=2 + + E (N_{r_n})_q ~ r_n^3 [L_n/log L_n]^{d(q-1)}. (B3) + +Thus (B1) alone cannot imply an o of the right-hand side in (B2), or an O(r^3) +second factorial moment. This is an optimality statement for this ABSTRACT +class of inference, not for Gaussian critical points. + +**Proposition C (the missing correlation).** Let m_r=E_{P_r}N_r>0 and define the +count-size-biased configuration law + + dP_r^sb = (N_r/m_r) dP_r. + +Then the exact identity + + E_{P_r}(N_r)_q + = m_r E_{P_r^sb}[(N_r-1)_{q-1}] + <= m_r E_{P_r^sb}[Psi_r^{q-1}] (B4) + +holds as an identity/inequality of nonnegative extended expectations. Therefore +uniform size-biased cap moments, not merely unconditional cap moments, suffice +for a log-free O(r^3) result. Count-size bias is NOT conditioning on N_r>=1. + +## 2. Proof of the upper inference bound + +The tail in (B1) gives every fixed polynomial cap moment uniformly: + + E_{Q_r}Psi_r^p + = p integral_0^infinity t^(p-1) Q_r(Psi_r>t)dt <= C_p. + +This formula follows first for truncations and then by monotone convergence. +Since phi_d grows faster than log t, the integral is finite. In particular all +moments used below exist, independently of r. + +For any cutoff lambda>0 and integer q>=2, pathwise + + (N)_q <= N Psi^{q-1} + <= lambda^{q-1}N + Psi^q 1{Psi>lambda}. (B5) + +Take expectations under P_r. Cauchy–Schwarz with the actual density R_r, followed +by another Cauchy–Schwarz under Q_r, gives + + E_{P_r}[Psi^q 1_A] + <= ||R_r||_2 (E_{Q_r}[Psi^{2q}1_A])^(1/2) + <= K (E_{Q_r}Psi^{4q})^(1/4) Q_r(A)^(1/4) + <= C_q exp(-c phi_d(lambda)/4), A={Psi>lambda}. (B6) + +Both square roots matter. Neither (B5) nor (B6) factors an expectation of N and +Psi or assumes independence of R_r from the cap. In the application R_r=W_r/Z_r; +a uniform W_r/r^2 moment and a positive Z_r/r^2 floor are what bound its norm. +Those Gaussian facts are external premises, not consequences of this note. + +Take lambda=(A L/log L)^d, A>=1, with L sufficiently large. For example, +log L>=2 implies 2loglog L<=log L; hence + + log lambda = d(log A+log L-loglog L) >= log L, + phi_d(lambda) >= lambda^(1/d) log lambda >= A L. (B7) + +Choose A so cA/4>=4. The tail term in (B6) is at most C_q r^4. The first term in +(B5) is at most C_0 r^3 lambda^{q-1}. Since lambda>=1 for small r, the r^4 term is +absorbed, proving (B2). Each q is fixed; no uniform-in-q constant is asserted. + +For the exponential-moment assertion, use that phi_d is continuous, strictly +increasing on [0,infinity), and unbounded. From (B1), +Q_r(phi_d(Psi_r)>t)<=C_1 e^{-ct}. Layer-cake integration gives + + E_{Q_r} exp(a phi_d(Psi_r)) + =1+ a integral_0^infinity e^{at}Q_r(phi_d(Psi_r)>t)dt + <=1+C_1 a/(c-a), 0=3 define + + r_n=n^{-n}, K_n=n^d, p_n=r_n^3/K_n. + +Under P_n=Q_n, set N_n=K_n with probability p_n and N_n=0 otherwise. Put +Psi_n=N_n+2. This +2 models the harmless presence of two excluded prescribed +objects in a total cap; no pinning or Gaussian law is asserted. The density +R_n is identically one, so its L2 norm is one. Direct computation gives + + E N_n = p_n K_n = r_n^3, + E(N_n)_2 = r_n^3(K_n-1), + E(N_n)_q = r_n^3 product_{j=1}^{q-1}(K_n-j). (B8) + +For fixed q and n large, the last expression is asymptotic to +r_n^3 n^{d(q-1)}. These identities use falling factorials, not ordinary powers. + +### A uniform cap-tail bound, not merely bounded moments + +For x<2, Q_n(Psi_n>x)=1. For 2<=x=K_n+2 it is zero. +For n>=3 and d>=2, + + (n^d+2)^(1/d)<=2n, n^d+4<=n^{d+1}, + phi_d(K_n+2)<=2(d+1)n log n. + +Let c_d=1/[2(d+1)]. Monotonicity gives, whenever 2<=x0 the formula in Proposition C defines a probability law because +E N_r/m_r=1. It assigns zero mass to N_r=0. At N_r>=1, + + (N_r)_q=N_r (N_r-1)_{q-1}. + +Integrating proves the identity in (B4), including when the result is infinite. +Since (N-1)_{q-1}<=Psi^{q-1}, its upper bound follows. Thus + + sup_r E_{P_r^sb}Psi_r^{q-1}=1), their probabilities +are 3/4 and 1/4. They yield different expectations, even in a finite space. + +In the family of Section 3, P_n^sb is concentrated entirely on the rare outcome +N_n=K_n. Consequently E_{P_n^sb}Psi_n=K_n+2 diverges, even though the original +cap has a uniform stretched-super-exponential tail. This isolates precisely the +correlation not controlled by (B1). + +For an actual point process, disintegrating the N-weighted configuration law by +a tagged point is the appropriate entry to a Palm/marked-intensity argument. +The current Gaussian research route called M'/H aims to supply such conditional +marked control. This note neither proves that route nor assumes it to close C6. +It explains why a new marked estimate is genuinely additional information. + +## 5. Verification and boundaries + +The public finite checker uses exact rational probabilities and integer falling +factorials. It tests (B8), finite size-bias identities, the probability-tail +steps, algebra behind (B9), the pathwise cap split and the W/Z exponent ledger. +Its negative variants deliberately replace count-size bias by conditioning on +nonemptiness, use the wrong rare probability, replace falling factorials with +ordinary powers, lose the dimension, remove the +2 pin offset, or drop Z. + +Those checks are NOT a proof of all real-parameter tail integrals or asymptotic +limits. The analytic arguments are the displayed derivations above. No numerical +Gaussian constant, actual Gaussian lower saturation, all-d D5 acceptance, or +independent formal alignment follows from the tests. No scientific register or +source proof is altered. Classical truncation, Hölder, size-bias and power-law +calculations are credited as such; there is no worldwide novelty claim. + +Context only, not mathematical inputs: Math-#140, the separate Claude successor +#142, and the marked M'/H lane discussed in #140. Their exact context references +are recorded in SOURCE_MAP.json. This note does not depend on those drafts being +accepted or merged, and must not be used as their Gaussian verification. diff --git a/frontiers/c6_count_cap_boundary_20260929/README.md b/frontiers/c6_count_cap_boundary_20260929/README.md new file mode 100644 index 000000000..a783de284 --- /dev/null +++ b/frontiers/c6_count_cap_boundary_20260929/README.md @@ -0,0 +1,22 @@ +# Count-cap method boundary + +Author-side mathematical candidate; nonauthor review required. Scientific effect NONE. + +PROOF.md proves an abstract factorial-moment implication from a rare first moment, +an L2 likelihood bound and a global count-cap tail. An explicit finite probability +family attains its logarithmic factor, so those hypotheses alone cannot prove the +Gaussian program's hoped-for log-free result. This is NOT a Gaussian counterexample. + +The distinct practical conclusion is the exact count-size-biased identity: uniform +marked cap moments would supply the extra input needed to remove the loss. Count +size bias is not conditioning on a nonempty configuration. + +Run from this directory: + + python -B -S verify.py --output /path/to/new-output + python -B -O -S verify.py --output /path/to/another-new-output + +Each runner verifies the flat packet, executes fifteen finite tests and six semantic +negatives in both Python modes, and requires matching output pairs. It writes only +outside the source directory. Finite checks do not certify the continuum arguments. +No upstream Gaussian proof is consumed or locally replayed by this packet. diff --git a/frontiers/c6_count_cap_boundary_20260929/RESULTS.json b/frontiers/c6_count_cap_boundary_20260929/RESULTS.json new file mode 100644 index 000000000..d9700273c --- /dev/null +++ b/frontiers/c6_count_cap_boundary_20260929/RESULTS.json @@ -0,0 +1,7 @@ +{ + "tests_per_mode": 15, + "semantic_mutants_per_mode": 6, + "identical_output_pairs": 7, + "scientific_effect": "NONE", + "gaussian_analysis_verified": false +} diff --git a/frontiers/c6_count_cap_boundary_20260929/SOURCE_FILES.json b/frontiers/c6_count_cap_boundary_20260929/SOURCE_FILES.json new file mode 100644 index 000000000..936472a36 --- /dev/null +++ b/frontiers/c6_count_cap_boundary_20260929/SOURCE_FILES.json @@ -0,0 +1,48 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "files": [ + { + "path": "PROOF.md", + "bytes": 10406, + "sha256": "264a5e762f598145e9230aa0947acb2e0354efdb2e3adf65d331e7ee0ba52011", + "git_blob": "3d4c28a4ca8784b6c71c13ca804a817a6cb52e6f" + }, + { + "path": "README.md", + "bytes": 1152, + "sha256": "5a9e0e57b29bb3956392e209683fb5c0310a25961b0cff993620bb9ad6c335ba", + "git_blob": "a783de28438824b4a91f01c97805396fe1ca755a" + }, + { + "path": "RESULTS.json", + "bytes": 162, + "sha256": "3dd4a09160c4ebbae034e8ce3d7c2b878caab616eff1273473082fd3099dfc00", + "git_blob": "d9700273c9ce5d4998630d29b47560b4838d7b6a" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 971, + "sha256": "426417104bd9360c9e99536bbcf7a41adea622b3deed690144939ef6ca2927dd", + "git_blob": "49ce9a638320ea783f90d55fa085c3d8e23854e7" + }, + { + "path": "barrier.py", + "bytes": 1767, + "sha256": "f4850d0dc5ed968fae6ddce7a8dfaff725795ca289e0625fd0af77668d61dfee", + "git_blob": "2dacdc83661e2b64d0dc5748fcc9d7d7258bf1c1" + }, + { + "path": "test_barrier.py", + "bytes": 3953, + "sha256": "da754c80301d5d8ddfa60ef8092e13f0098286ecbf06b35619d0f4ba8ffc14fc", + "git_blob": "b2a3264b94c69d0b421bfafbac34c2e8ec87009b" + }, + { + "path": "verify.py", + "bytes": 4721, + "sha256": "429e1d67961fff713ec6d11c63f564ac5b4f6b2161595f3776a772187ba5b3db", + "git_blob": "9428ba292a4c387d51a10c5a35ec9e40eb144b1d" + } + ] +} diff --git a/frontiers/c6_count_cap_boundary_20260929/SOURCE_MAP.json b/frontiers/c6_count_cap_boundary_20260929/SOURCE_MAP.json new file mode 100644 index 000000000..49ce9a638 --- /dev/null +++ b/frontiers/c6_count_cap_boundary_20260929/SOURCE_MAP.json @@ -0,0 +1,23 @@ +{ + "scientific_effect": "NONE", + "mathematical_inputs": [], + "context_only": [ + { + "repository": "d6g8k5htny-coder/Math-", + "pull_request": 140, + "commit": "09763caf5849c96ab291b4c51b2192c64529565f", + "path": "frontiers/c6_factorial_moment_20260929/PROOF.md", + "use": "Motivates rare-count/cap-tail inference; not an input to the abstract proof." + }, + { + "repository": "d6g8k5htny-coder/Math-", + "pull_request": 142, + "commit": "aee04cd1eca597cfd45ca88df4b2fdc1728717f9", + "path": "frontiers/c6_sharpened_20260929/PROOF.md", + "use": "Separate growing-Cauchy-radius candidate. This packet neither duplicates nor accepts its Gaussian argument." + } + ], + "independence": "The author proposed the growing-radius route and reviewed inputs in the same account. This separate abstract result requires its own nonauthor review.", + "gaussian_optimality_claimed": false, + "global_factorial_order_closed": false +} diff --git a/frontiers/c6_count_cap_boundary_20260929/barrier.py b/frontiers/c6_count_cap_boundary_20260929/barrier.py new file mode 100644 index 000000000..2dacdc836 --- /dev/null +++ b/frontiers/c6_count_cap_boundary_20260929/barrier.py @@ -0,0 +1,57 @@ +"""Exact finite rare-count and size-bias controls. No Gaussian model is implemented.""" +from fractions import Fraction as F + +MUTANT=None + +def integer(n, minimum=0): + if type(n) is not int or n1:prod*=k-q+1 + self.assertEqual(b.rare_factorial(n,d,q),r**3*prod) + def test_orders_above_count_are_zero(self): + self.assertEqual(b.rare_factorial(3,2,10),0) + self.assertEqual(b.falling(0,0),1) + def test_probability_normalization(self): + for n in (3,5,9): + for d in (2,3): + r,k,p=b.rare_law(n,d) + self.assertGreater(p,0);self.assertLess(p,1) + self.assertEqual((1-p)+p,1) + def test_prescribed_pin_offset(self): + for n in (3,7): + for d in (2,3,4): + _,k,_=b.rare_law(n,d) + self.assertEqual(b.count_cap(n,d),k+2) + def test_tail_steps(self): + n,d=3,2;_,k,p=b.rare_law(n,d) + self.assertEqual(b.exact_tail(n,d,1),1) + self.assertEqual(b.exact_tail(n,d,2),p) + self.assertEqual(b.exact_tail(n,d,k+1),p) + self.assertEqual(b.exact_tail(n,d,k+2),0) + def test_tail_comparison_algebra(self): + # Ingredients of the analytic phi_d(k+2)<=2(d+1)n log n comparison. + for d in range(2,8): + for n in range(3,12): + self.assertLessEqual(n**d+2,(2*n)**d) + self.assertLessEqual(n**d+4,n**(d+1)) + self.assertGreaterEqual(3*n+d,n) + def test_exact_size_bias_identity(self): + law={0:F(1,3),1:F(1,2),3:F(1,6)} + mean=sum(n*p for n,p in law.items()) + biased=b.size_biased(law) + for q in (2,3,4): + lhs=sum(b.falling(n,q)*p for n,p in law.items()) + rhs=mean*sum(b.falling(n-1,q-1)*p for n,p in biased.items()) + self.assertEqual(lhs,rhs) + def test_rare_size_bias_concentrates_on_large_count(self): + r,k,p=b.rare_law(5,3) + biased=b.size_biased({0:1-p,k:p}) + self.assertEqual(biased,{k:F(1)}) + self.assertEqual(sum((n+2)*v for n,v in biased.items()),k+2) + def test_cap_truncation_pathwise(self): + for N in range(12): + for cap in (N,N+2,N+7): + for cutoff in (F(1,2),F(3),F(11)): + for q in (2,3,4): + rhs=cutoff**(q-1)*N+(cap**q if cap>cutoff else 0) + self.assertLessEqual(b.falling(N,q),rhs) + def test_full_normalizer_once(self): + self.assertEqual(b.tilt_cost(2,2),0) + self.assertEqual(b.tilt_cost(3,2),1) + def test_domains(self): + with self.assertRaises(ValueError):b.rare_law(2,2) + with self.assertRaises(ValueError):b.rare_law(3,1) + with self.assertRaises(ValueError):b.rare_law(True,2) + with self.assertRaises(ValueError):b.size_biased({0:1}) + with self.assertRaises(ValueError):b.size_biased({0:F(1,3)}) + with self.assertRaises(ValueError):b.falling(2,-1) + +if __name__=='__main__': unittest.main() diff --git a/frontiers/c6_count_cap_boundary_20260929/verify.py b/frontiers/c6_count_cap_boundary_20260929/verify.py new file mode 100644 index 000000000..9428ba292 --- /dev/null +++ b/frontiers/c6_count_cap_boundary_20260929/verify.py @@ -0,0 +1,98 @@ +"""Exact packet and finite semantic verification; not a Gaussian-proof verifier.""" +import argparse +import hashlib +import io +import json +from pathlib import Path +import subprocess +import sys +import unittest + +ROOT=Path(__file__).resolve().parent +MUTANTS={ + 'wrong-rarity':'test_rare_first_moment', + 'planar-only-cap':'test_arbitrary_fixed_dimension', + 'ordinary-not-factorial':'test_second_factorial_exact', + 'nonempty-not-size-biased':'test_size_bias_differs_from_nonempty_conditioning', + 'drop-normalizer':'test_full_normalizer_once', + 'omit-prescribed-pins':'test_prescribed_pin_offset', +} + +def require(ok,message): + if not ok:raise ValueError(message) + +def decode(data): + def unique(items): + result={} + for k,v in items: + require(k not in result,'duplicate JSON key: '+k) + result[k]=v + return result + return json.loads(data,object_pairs_hook=unique) + +def identity(path): + require(path.is_file() and not path.is_symlink(),'regular source required') + data=path.read_bytes() + return {'bytes':len(data),'sha256':hashlib.sha256(data).hexdigest(), + 'git_blob':hashlib.sha1(f'blob {len(data)}\0'.encode()+data).hexdigest()} + +def sources(): + identity(ROOT/'SOURCE_FILES.json') + entries=decode((ROOT/'SOURCE_FILES.json').read_text())['files'] + names=[e['path'] for e in entries] + require(len(names)==len(set(names)) and all(Path(n).name==n and n!='SOURCE_FILES.json' for n in names),'unique flat paths required') + require(sorted(p.name for p in ROOT.iterdir())==sorted(names+['SOURCE_FILES.json']),'packet membership differs') + for e in entries: + require(identity(ROOT/e['path'])=={k:e[k] for k in ('bytes','sha256','git_blob')},'source identity differs: '+e['path']) + return {p.name:identity(p) for p in sorted(ROOT.iterdir())} + +def child(mutant): + import barrier + import test_barrier + barrier.MUTANT=mutant + suite=unittest.defaultTestLoader.loadTestsFromModule(test_barrier) + result=unittest.TextTestRunner(stream=io.StringIO()).run(suite) + print(json.dumps({'tests':result.testsRun,'passed':result.wasSuccessful(), + 'failures':sorted(t.id().rsplit('.',1)[-1] for t,_ in result.failures), + 'errors':sorted(t.id().rsplit('.',1)[-1] for t,_ in result.errors)},sort_keys=True)) + return 0 if result.wasSuccessful() else 1 + +def replay(output): + output=output.resolve() + require(not output.exists() and not output.is_relative_to(ROOT),'new output outside packet required') + before=sources();output.mkdir(parents=True) + cases={} + for case in ['baseline',*MUTANTS]: + pair=[] + for mode,flags in [('normal',[]),('optimized',['-O'])]: + cmd=[sys.executable,'-B',*flags,'-S',str(ROOT/'verify.py'),'--child'] + if case!='baseline':cmd+=['--mutant',case] + run=subprocess.run(cmd,capture_output=True,timeout=30) + (output/(case+'_'+mode+'.stdout')).write_bytes(run.stdout) + (output/(case+'_'+mode+'.stderr')).write_bytes(run.stderr) + value=decode(run.stdout.decode()) + require(not run.stderr and not value['errors'],'execution error: '+case) + require(value['tests']==15,'unexpected test count') + if case=='baseline': + require(run.returncode==0 and value['passed'] and not value['failures'],'baseline failed') + else: + require(run.returncode==1 and not value['passed'] and MUTANTS[case] in value['failures'],'intended semantic failure missing: '+case) + pair.append(run.stdout) + require(pair[0]==pair[1],'Python modes disagree: '+case) + cases[case]=decode(pair[0].decode()) + result={'tests_per_mode':15,'semantic_mutants_per_mode':6,'identical_output_pairs':7, + 'scientific_effect':'NONE','gaussian_analysis_verified':False} + require(result==decode((ROOT/'RESULTS.json').read_text()),'stored summary differs') + require(sources()==before,'source changed during execution') + (output/'REPORT.json').write_text(json.dumps({**result,'cases':cases,'source_identities':before,'sources_unchanged':True},indent=2,sort_keys=True)+'\n') + print(json.dumps(result,indent=2,sort_keys=True)) + return 0 + +if __name__=='__main__': + parser=argparse.ArgumentParser(description=__doc__) + group=parser.add_mutually_exclusive_group(required=True) + group.add_argument('--child',action='store_true');group.add_argument('--output',type=Path) + parser.add_argument('--mutant',choices=MUTANTS) + args=parser.parse_args() + require(args.child or args.mutant is None,'mutant requires child mode') + raise SystemExit(child(args.mutant) if args.child else replay(args.output))