diff --git a/reviews/lm006_normalizer_stability_20261005/NOTE.md b/reviews/lm006_normalizer_stability_20261005/NOTE.md new file mode 100644 index 000000000..5790aaa03 --- /dev/null +++ b/reviews/lm006_normalizer_stability_20261005/NOTE.md @@ -0,0 +1,226 @@ +# LM006: quantitative stability of the normalized typed endpoint weight + +Dylan Roy — delegated AI mathematical work. Author: OpenAI / GPT-6 Astra Pro, +session `round12-audit-completion-20261005`, 5 October 2026 (Central Time). +Scientific effect NONE. This is an additive analytic companion, not a Lean +formalization or a revision of any historical proof or acceptance record. + +## 1. Scope and prior work + +The historical P02-LM-006 body, 9,147 bytes, SHA256 +`239ed094f70aa4352021572ad8bdc0c6ac6404edab4e1d7e61addec0c6659150`, +fixes the exact side24 six-pin law at b=6/5 and gap r^3/6. Its §§2,4 define +six endpoint coordinates and the physical Hessians. Math-#301 supplies a +separate conditional endpoint convergence/moment argument; its unchanged +NOTE is blob `551aa563562bc88a19e33d146259c03aa2d318f6` at merge +`e31b6ad8356e0760c8a7fb6e816ff640c45176c9`. + +Filtered-determinant continuity and a common regression coupling already appear +in `frontiers/remote_window_20260924/PROOF.md`, §§3–4, particularly (5),(8), +blob `b383bfcc88ec4ad497dff01fb6640e429ba24a84`, at Math- commit +`f4c33a98a982d50aa490e49ce9327c755682527c`. This note does NOT claim a new +general filtered-determinant continuity theorem or a new qualitative O(r) rate +for that remote-window theorem. Its contribution is an explicit scalar formula +and constants for the particular six-coordinate normalizer, requiring only a +specified endpoint-vector coupling. All proofs below are self-contained. + +Notation: x_+=max(x,0), x_-=max(-x,0), and ||.|| is the Euclidean norm. +Use v=(a_-,a_+,b_-,b_+,c_-,c_+) in R^6 and 0<=r<=1. Set + + M_r(v) = [[r a_-, r b_-], [r b_-, c_-]], + S_r(v) = [[r a_+, r b_+], [r b_+, c_+]], + F_r(v) = [(a_-)_- (c_-)_- - r b_-^2]_+, + G_r(v) = [r b_+^2 - a_+ c_+]_+, + T_r(v) = F_r(v) G_r(v). (1) + +At r=0, (1) defines a continuous extension, not division by zero in a physical +normalizer. The concrete torus application stays on 00, + + T_r(v) = r^-2 |det M_r(v) det S_r(v)| + 1_{M_r(v) negative definite} 1_{det S_r(v)<0}. (2) + +Proof. Write D_-=a_-c_--r b_-^2 and D_+=a_+c_+-r b_+^2. Both physical +determinants are r D_i. Negative definiteness of M_r is equivalent to a_-<0 +and D_->0. These imply c_-<0. Conversely, if both a_-,c_- are negative and +D_->0, the maximum type holds. If either is nonnegative, the first factor of +(1) is zero; if either is zero, it is also zero. Thus the maximum-filtered +normalized determinant is exactly F_r. For the 2x2 saddle, index one is +exactly det S_r<0, so the filtered normalized absolute determinant is G_r. +All singular cases contribute zero. Multiplication proves (2). + +Consequently T is continuous jointly in (r,v), even where the index indicators +are discontinuous. It is nonnegative and satisfies, for 0<=r<=1, + + 0 <= T_r(v) <= ||v||^4. (3) + +Indeed F_r<=|a_-c_-| when positive, and G_r<=r b_+^2+|a_+c_+|. Each is +bounded by the squared norm of its respective three-coordinate block, hence +by ||v||^2. The coarse bound (3) is sufficient; no sharp constant is claimed. + +For every real a,q let + + v0(a,q)=(-1,1,-a/2,a/2,q,q). + +Then, including q=0, + + T_0(v0(a,q))=(q_-)^2. (4) + +Thus a null-probability type boundary is unnecessary for convergence of the +DETERMINANT-WEIGHTED variable using this representation. It can still be +necessary for a claim about the bare indicator, which is not made here. +If Q has an atom at zero, (4) remains true. This observation does not change +the old proof's hypotheses or automatically settle its concrete-field inputs. + +## 3. Deterministic quantitative bound + +For v,w in R^6 and r,s in [0,1], + + |T_r(v)-T_s(w)| + <= (||v||+||w||)^3 ||v-w|| + |r-s| ||w||^4. (5) + +Proof of the fixed-r part. Reorder v into blocks v_-=(a_-,b_-,c_-) and +v_+=(a_+,b_+,c_+), and similarly w. The projection +P(a,b,c)=(a_-,b,c_-) is norm-contracting and 1-Lipschitz. The quadratic form +ac-rb^2 has symmetric matrix with eigenvalues 1/2,-1/2,-r; its operator norm +is at most1. The form rb^2-ac has the same norm bound. For any symmetric H +with ||H||<=1, + + |x^T Hx-y^T Hy| <= (||x||+||y||)||x-y||. + +Composition with P and then positive part therefore gives + + |F_r(v)-F_r(w)| <= S ||v_--w_-||, + |G_r(v)-G_r(w)| <= S ||v_+-w_+||, + S=||v||+||w||. + +Using nonnegative factors, F_r(v)<=||v||^2, G_r(w)<=||w||^2, and the product +difference split, + + |T_r(v)-T_r(w)| + <= S (||v||^2 ||v_+-w_+|| + ||w||^2 ||v_--w_-||) + <= S sqrt(||v||^4+||w||^4) ||v-w|| + <= S^3 ||v-w||. + +For fixed w, positive part is 1-Lipschitz in r. The same product split yields + + |T_r(w)-T_s(w)| + <= |r-s| [F_r(w)b_+^2 + G_s(w)b_-^2] + <= |r-s| ||w||^2 (b_+^2+b_-^2) + <= |r-s| ||w||^4. + +The triangle inequality completes (5). In particular the proof divides by +neither a transverse eigenvalue nor a distance to a type boundary. + +## 4. Expectation and normalizer error under an explicitly given coupling + +Let X,Y be any coupled R^6-valued random vectors on ONE probability space. +Assume E(||X||+||Y||)^60 and B e_r+D r<=z0/2, it yields the explicit sufficiency condition + + (z0/2)r^2 <= Z_r <= (3z0/2)r^2. (10) + +If a proved bound e_r<=K r^alpha with fixed K and alpha>0 is supplied, one +sufficient radius is the minimum of the application's allowed radius,1, +z0/(4D), and (z0/(4BK))^(1/alpha), omitting any term whose denominator is zero. +Neither K,alpha nor a numerical radius is supplied here. For square-integrable +Q, z0>0 is equivalent to P(Q<0)>0; nondegeneracy of Q is sufficient but is not +necessary. Constant Q=-1 gives z0=1; constant Q=0 or+1 gives z0=0 and no +positive lower-normalizer conclusion. No field model is inferred from those +edge-case witnesses. + +## 6. Reproduction and negative controls + +Run `python -B -S test_stability.py` and again with `-O` from this directory. +The12 methods cover physical determinant/type identities at exactly +729 vectors times3 positive radii =2187 cases; r=0 boundary/limit values; +300 parameter comparisons;500 paired-vector comparisons; the quartic envelope; +Gaussian moment constants; an exact covariance-I finite coupling check; and +CLI/input rejection. These are finite checks, not the continuum proof. + +`stability_check.py` prints a deterministic JSON count. Its baseline has2187 +physical identities,15 limit values,200 parameter inequalities,200 squared +vector-envelope tests,3 radial moments and1 mean-shift witness (2606 total). +For the vector diagnostic, (||v||+||w||)^6 is bounded above by +8(||v||^2+||w||^2)^3; squaring avoids irrational arithmetic but tests a weaker +finite envelope than the sharp expression in (5). + +M1 replaces r by r^2 in (1); M2 selects minima rather than maxima; M3 omits the +saddle positive part; M4 substitutes a one-dimensional sixth moment; M5 drops +the mean error from (7). Each must exit1 with its named STABILITY_FAIL reason. +Unknown arguments/labels exit2. No floating simulation, Lean or dedicated +hosted execution is represented by these Fraction controls. + +## 7. Exclusions and audit boundary + +Not claimed: a new parent theorem, unconditional historical LM006 acceptance, +full-field event transfer, new numerical coefficient, covariance-error +certificate, sharp constants, uniformity over unbounded marks, or higher-d +analogue. No existing proof/review/status is edited. Historical #281 alignment +and source-admission issue#310 remain separate. A fresh nonauthor review must +inspect the whole argument including (5)–(10), not just the tests or a previous +review of filtered determinants. This note consumes the explicit definitions +above, not another agent's unreviewed proposed rate. diff --git a/reviews/lm006_normalizer_stability_20261005/SOURCES.json b/reviews/lm006_normalizer_stability_20261005/SOURCES.json new file mode 100644 index 000000000..20ca26bdd --- /dev/null +++ b/reviews/lm006_normalizer_stability_20261005/SOURCES.json @@ -0,0 +1,50 @@ +{ + "schema_version": 1, + "scientific_effect": "NONE", + "author": { + "provider": "OpenAI", + "model": "GPT-6 Astra Pro", + "session": "round12-audit-completion-20261005" + }, + "files": { + "NOTE.md": { + "bytes": 10900, + "sha256": "2e63518026cef54bb91757ccbdba986a0765f8a8b640240417ba30c59e2f5fd4", + "git_blob": "5790aaa0332bd8e79b276be1577e4c5f3502eed6" + }, + "stability_check.py": { + "bytes": 4418, + "sha256": "eba33b7edaf530e6dff3d644ad8691ddc2eebe44975ecbf69692fdba27f0fa09", + "git_blob": "c0b1d5e9040d9ed1bf346b4e49771d91afc25eea" + }, + "test_stability.py": { + "bytes": 5374, + "sha256": "544321fc04b997e8fd440d810e10eff79bd192018339ddc0c6d6219cdfc72a7a", + "git_blob": "07a23d35abfdf06087080071a1826e07b88f3ab0" + } + }, + "sources": [ + { + "id": "LM006", + "frozen_body_bytes": 9147, + "frozen_body_sha256": "239ed094f70aa4352021572ad8bdc0c6ac6404edab4e1d7e61addec0c6659150", + "scope": "definitions of six endpoint variables and exact typed Hessian weight; source not rewritten" + }, + { + "id": "endpoint-extension", + "repository": "d6g8k5htny-coder/Math-", + "commit": "e31b6ad8356e0760c8a7fb6e816ff640c45176c9", + "path": "reviews/lm006_endpoint_extension_20261005/NOTE.md", + "git_blob": "551aa563562bc88a19e33d146259c03aa2d318f6", + "scope": "related conditional Gaussian endpoint convergence, not a transferred verdict" + }, + { + "id": "prior-filtered-determinants", + "repository": "d6g8k5htny-coder/Math-", + "commit": "f4c33a98a982d50aa490e49ce9327c755682527c", + "path": "frontiers/remote_window_20260924/PROOF.md", + "git_blob": "b383bfcc88ec4ad497dff01fb6640e429ba24a84", + "scope": "prior coupling and filtered determinant continuity; no novelty claimed for those general facts" + } + ] +} diff --git a/reviews/lm006_normalizer_stability_20261005/stability_check.py b/reviews/lm006_normalizer_stability_20261005/stability_check.py new file mode 100644 index 000000000..c0b1d5e90 --- /dev/null +++ b/reviews/lm006_normalizer_stability_20261005/stability_check.py @@ -0,0 +1,123 @@ +#!/usr/bin/env python3 +"""Exact finite controls for LM006 endpoint-weight stability (stdlib only). + +These rational controls do not prove the continuum theorem or execute Lean. +""" +import argparse +from fractions import Fraction as F +import itertools +import json +import random +import sys + + +def rational(x): + if type(x) not in (int,F): + raise TypeError('expected an exact integer or Fraction, not bool/float') + return F(x) + + +def vector(v): + v=tuple(rational(x) for x in v) + if len(v)!=6: raise ValueError('endpoint vector must have six entries') + return v + + +def radius(r): + r=rational(r) + if not 0<=r<=1: raise ValueError('radius must lie in [0,1]') + return r + + +def norm_sq(v): + return sum((rational(x)**2 for x in v),F(0)) + + +def pos(x): return max(x,F(0)) + + +def weight(v,r,mutant=None): + am,ap,bm,bp,cm,cp=vector(v); r=radius(r) + rr=r*r if mutant=='M1' else r + if mutant=='M2': + fm=pos(pos(am)*pos(cm)-rr*bm*bm) + else: + fm=pos(pos(-am)*pos(-cm)-rr*bm*bm) + fs=rr*bp*bp-ap*cp + if mutant!='M3': fs=pos(fs) + return fm*fs + + +def physical_weight(v,r): + am,ap,bm,bp,cm,cp=vector(v); r=radius(r) + if r==0: raise ValueError('physical normalized ratio requires r>0') + dm=(r*am)*cm-(r*bm)**2 + ds=(r*ap)*cp-(r*bp)**2 + return abs(dm*ds)/(r*r) if r*am<0 and dm>0 and ds<0 else F(0) + + +def normal_norm_even(d,k,mutant=None): + if type(d) is not int or type(k) is not int or d<=0 or k<0: + raise ValueError('positive integer dimension and nonnegative integer order required') + if mutant=='M4' and k==3: return 15 + ans=1 + for j in range(k): ans*=d+2*j + return ans + + +def affine_gap_sq(m,A,n,B,mutant=None): + m,n=vector(m),vector(n) + A=tuple(tuple(rational(x) for x in row) for row in A) + B=tuple(tuple(rational(x) for x in row) for row in B) + if len(A)!=6 or len(B)!=6 or not A[0]: raise ValueError('six nonempty factor rows required') + width=len(A[0]) + if any(len(row)!=width for row in A+B): raise ValueError('factor shapes differ') + shift=F(0) if mutant=='M5' else norm_sq(tuple(x-y for x,y in zip(m,n))) + return shift+sum(((x-y)**2 for row,col in zip(A,B) for x,y in zip(row,col)),F(0)) + + +def check(condition,label): + if not condition: raise ValueError(label) + + +def controls(mutant=None): + counts={'physical_identity':0,'limit':0,'parameter':0,'vector_squared_envelope':0,'gaussian_moments':0,'mean_shift':0} + for values in itertools.product((-1,0,1),repeat=6): + v=tuple(map(F,values)) + for r in (F(1,4),F(1,2),F(1)): + check(weight(v,r,mutant)==physical_weight(v,r),'PHYSICAL_TYPED_IDENTITY') + counts['physical_identity']+=1 + for a,q in itertools.product((-3,0,4),(-2,-1,0,1,2)): + v=(F(-1),F(1),-F(a)/2,F(a)/2,F(q),F(q)) + check(weight(v,0,mutant)==pos(-F(q))**2,'LIMIT_NEGATIVE_PART') + counts['limit']+=1 + rng=random.Random(20261005) + for _ in range(200): + v=tuple(F(rng.randrange(-8,9),4) for _ in range(6)) + w=tuple(F(rng.randrange(-8,9),4) for _ in range(6)) + r,s=F(rng.randrange(9),8),F(rng.randrange(9),8) + check(abs(weight(v,r,mutant)-weight(v,s,mutant))<=abs(r-s)*norm_sq(v)**2,'PARAMETER_ENVELOPE') + counts['parameter']+=1 + excess=pos(abs(weight(v,r,mutant)-weight(w,s,mutant))-abs(r-s)*norm_sq(w)**2) + check(excess**2<=8*(norm_sq(v)+norm_sq(w))**3*norm_sq(tuple(x-y for x,y in zip(v,w))),'VECTOR_ENVELOPE') + counts['vector_squared_envelope']+=1 + for d,k,want in ((6,2,48),(6,3,480),(6,4,5760)): + check(normal_norm_even(d,k,mutant)==want,'GAUSSIAN_NORM_MOMENT') + counts['gaussian_moments']+=1 + a=tuple(map(F,(-1,1,0,0,-1,-1))); b=tuple(map(F,(-1,1,0,0,-2,-2))) + zero=((F(0),),)*6 + check(affine_gap_sq(a,zero,b,zero,mutant)==2,'MEAN_SHIFT_NOT_COVARIANCE_ONLY') + counts['mean_shift']+=1 + return {'scientific_effect':'NONE','exact_controls':counts,'total':sum(counts.values()),'meaning':'finite algebra diagnostics, not a continuum or Lean proof'} + + +def main(): + p=argparse.ArgumentParser(description=__doc__) + p.add_argument('--mutant',choices=['M1','M2','M3','M4','M5']) + a=p.parse_args() + try: result=controls(a.mutant) + except (ValueError,TypeError) as e: + print('STABILITY_FAIL: '+str(e),file=sys.stderr); return 1 + print(json.dumps(result,sort_keys=True)); return 0 + +if __name__=='__main__': sys.exit(main()) diff --git a/reviews/lm006_normalizer_stability_20261005/test_stability.py b/reviews/lm006_normalizer_stability_20261005/test_stability.py new file mode 100644 index 000000000..07a23d35a --- /dev/null +++ b/reviews/lm006_normalizer_stability_20261005/test_stability.py @@ -0,0 +1,109 @@ +"""Exact finite controls for the endpoint-weight stability note; not Lean.""" +import importlib.util +import itertools +import json +from fractions import Fraction as F +from pathlib import Path +import random +import subprocess +import sys +import unittest + +PATH=Path(__file__).with_name('stability_check.py') +class StabilityTests(unittest.TestCase): + def setUp(self): + self.assertTrue(PATH.is_file(), 'stability implementation has not been supplied') + spec=importlib.util.spec_from_file_location('stability_check', PATH) + self.m=importlib.util.module_from_spec(spec); spec.loader.exec_module(self.m) + + def test_physical_typed_weight(self): + for values in itertools.product((-1,0,1), repeat=6): + v=tuple(map(F,values)) + for r in (F(1,8),F(1,2),F(1)): + self.assertEqual(self.m.weight(v,r),self.m.physical_weight(v,r)) + + def test_singular_and_type_boundary(self): + for q in map(F,(-2,-1,0,1,2)): + for a in map(F,(-3,0,4)): + v=(F(-1),F(1),-a/2,a/2,q,q) + self.assertEqual(self.m.weight(v,0),max(-q,F(0))**2) + # Index decisions may alternate while the determinant-weighted value converges. + for n in (2,3,4,8,16): + q=F((-1)**n,n) + v=(F(-1),F(1),F(0),F(0),q,q) + self.assertLessEqual(self.m.weight(v,F(1,n)),F(1,n*n)) + + def test_parameter_error(self): + rng=random.Random(310301) + for _ in range(300): + v=tuple(F(rng.randrange(-8,9),4) for _ in range(6)) + r,s=F(rng.randrange(9),8),F(rng.randrange(9),8) + self.assertLessEqual(abs(self.m.weight(v,r)-self.m.weight(v,s)),abs(r-s)*self.m.norm_sq(v)**2) + + def test_vector_error_squared_envelope(self): + rng=random.Random(478) + for _ in range(500): + v=tuple(F(rng.randrange(-6,7),3) for _ in range(6)) + w=tuple(F(rng.randrange(-6,7),3) for _ in range(6)) + r,s=F(rng.randrange(5),4),F(rng.randrange(5),4) + excess=max(abs(self.m.weight(v,r)-self.m.weight(w,s))-abs(r-s)*self.m.norm_sq(w)**2,F(0)) + d2=self.m.norm_sq(tuple(a-b for a,b in zip(v,w))) + self.assertLessEqual(excess**2,8*(self.m.norm_sq(v)+self.m.norm_sq(w))**3*d2) + + def test_quartic_envelope(self): + for values in itertools.product((-1,0,1),repeat=6): + v=tuple(map(F,values)) + for r in (F(0),F(1,2),F(1)): + self.assertGreaterEqual(self.m.weight(v,r),0) + self.assertLessEqual(self.m.weight(v,r),self.m.norm_sq(v)**2) + + def test_gaussian_even_moments(self): + for d,want in ((1,15),(2,48),(3,105),(6,480)): + self.assertEqual(self.m.normal_norm_even(d,3),want) + self.assertEqual(self.m.normal_norm_even(6,2),48) + self.assertEqual(self.m.normal_norm_even(6,4),5760) + + def test_moving_mean_is_load_bearing(self): + # Zero covariances do not imply equal Gaussian laws when their means differ. + a=(F(-1),F(1),F(0),F(0),F(-1),F(-1)) + b=(F(-1),F(1),F(0),F(0),F(-2),F(-2)) + self.assertEqual(self.m.weight(a,0),1) + self.assertEqual(self.m.weight(b,0),4) + self.assertGreater(self.m.affine_gap_sq(a,((F(0),),)*6,b,((F(0),),)*6),0) + + def test_factor_coupling_identity(self): + # Average over all +/-1 vectors has covariance I: exact second-moment identity. + a=tuple(map(F,(-1,1,0,0,-1,-1))); b=tuple(x+F(1,5) for x in a) + A=tuple(tuple(F((i+2*j)%5-2,3) for j in range(2)) for i in range(6)) + B=tuple(tuple(F((2*i+j)%7-3,4) for j in range(2)) for i in range(6)) + actual=F(0) + for z in itertools.product((-1,1),repeat=2): + diff=tuple(a[i]-b[i]+sum((A[i][j]-B[i][j])*z[j] for j in range(2)) for i in range(6)) + actual+=self.m.norm_sq(diff)/4 + self.assertEqual(actual,self.m.affine_gap_sq(a,A,b,B)) + + def test_positive_limit_needed(self): + for q,expected in ((-1,1),(0,0),(1,0)): + self.assertEqual(self.m.weight(tuple(map(F,(-1,1,0,0,q,q))),0),expected) + + def test_input_validation(self): + for v,r in [((0,)*5,F(1)),((0,)*6,F(-1)),((0,)*6,F(2)),((True,)*6,F(1)),((0.0,)*6,F(1))]: + with self.assertRaises((TypeError,ValueError)): self.m.weight(v,r) + with self.assertRaises(ValueError): self.m.physical_weight((0,)*6,F(0)) + + def test_cli_baseline_and_mutants(self): + for flags in (['-B','-S'],['-B','-O','-S']): + out=subprocess.run([sys.executable,*flags,str(PATH)],capture_output=True,text=True,timeout=25) + self.assertEqual(out.returncode,0,out.stderr); self.assertEqual(out.stderr,'') + self.assertGreater(json.loads(out.stdout)['total'],0) + for mutant in ('M1','M2','M3','M4','M5'): + bad=subprocess.run([sys.executable,*flags,str(PATH),'--mutant',mutant],capture_output=True,text=True,timeout=25) + self.assertEqual(bad.returncode,1,(mutant,bad.stdout,bad.stderr)) + self.assertTrue(bad.stderr.startswith('STABILITY_FAIL:'),(mutant,bad.stderr)) + + def test_unknown_arguments(self): + for args in (['--mutant','M9'],['--bogus'],['--mutant']): + p=subprocess.run([sys.executable,'-B','-S',str(PATH),*args],capture_output=True,text=True) + self.assertEqual(p.returncode,2) + +if __name__=='__main__': unittest.main()