diff --git a/.github/workflows/sard-g-a2-fixed-frame.yml b/.github/workflows/sard-g-a2-fixed-frame.yml new file mode 100644 index 000000000..3f207ebf5 --- /dev/null +++ b/.github/workflows/sard-g-a2-fixed-frame.yml @@ -0,0 +1,30 @@ +name: SARD-G fixed-frame and closure finite controls +'on': + pull_request: + paths: + - 'frontiers/sard_g_a2_parameter_20260929/**' + - '.github/workflows/sard-g-a2-fixed-frame.yml' + push: + branches: [main] + paths: + - 'frontiers/sard_g_a2_parameter_20260929/**' + - '.github/workflows/sard-g-a2-fixed-frame.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + finite-fixed-frame: + 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 successor sources and intended semantic failures in both modes + run: | + set -euo pipefail + python -B -S frontiers/sard_g_a2_parameter_20260929/v2/verify.py --output "${RUNNER_TEMP}/sard-fixed-frame-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}" + git diff --exit-code diff --git a/.github/workflows/sard-g-a2-parameter.yml b/.github/workflows/sard-g-a2-parameter.yml new file mode 100644 index 000000000..05d079a86 --- /dev/null +++ b/.github/workflows/sard-g-a2-parameter.yml @@ -0,0 +1,25 @@ +name: SARD-G A2 finite interface controls +'on': + pull_request: + paths: + - 'frontiers/sard_g_a2_parameter_20260929/**' + - '.github/workflows/sard-g-a2-parameter.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + finite-a2: + 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' + - run: | + set -euo pipefail + python -B -S frontiers/sard_g_a2_parameter_20260929/check.py + python -B -O -S frontiers/sard_g_a2_parameter_20260929/check.py + git diff --exit-code diff --git a/frontiers/sard_g_a2_parameter_20260929/PROOF.md b/frontiers/sard_g_a2_parameter_20260929/PROOF.md new file mode 100644 index 000000000..36bbc0c30 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/PROOF.md @@ -0,0 +1,119 @@ +# SARD-G A2 parameter-regularity interface + +Object: OA-SARD-A2-PARAMETER-20260929-v1. +Author: OpenAI / ChatGPT. +Disposition: AUTHOR-SIDE DOWNSTREAM CANDIDATE; nonauthor analytic review required. +Scientific effect: NONE. + +## 1. Exact interface + +Let X=C^2(T_L^2) and V_f=grad f, viewed as a C^1 vector field. Fix f0 and a +nondegenerate index-one critical point p0. After shrinking an X-neighborhood U +of f0 and a coordinate ball B about p0, the following are the A2-T/A2-D claims +consumed by Math-#135. + +**A2.1 tracked saddle.** There is a unique map p:U->B with V_f(p(f))=0. It is +C^1 as a map from the Banach space X to R^2. Its derivative is +Dp(f)[h]=-H_f(p(f))^{-1} grad h(p(f)). + +**A2.2 local branch germs.** After choosing one stable/unstable eigendirection +and its sign at f0, there are fixed compact graph-parameter intervals and maps +Gamma_f^sigma on them whose images are the four labelled local invariant +half-branches. The map f -> Gamma_f^sigma is continuous U->C^1, and C^1 after +possibly shrinking U. The graph parameter, not physical flow time at p(f), is +used at the stationary endpoint. + +**A2.3 local-section launch.** If a fixed finite section is transverse to the +chosen germ at an interior point, its first robust closed-section hit, under the +R1 hypotheses of #135, depends continuously on f; under A2.2 C^1 dependence it +is C^1 by the scalar implicit-function theorem. + +**A2.4 regular finite flow.** Let z(f) be such a C^1 launch point and suppose a +compact finite trajectory segment stays in a coordinate region on which +|V_f|>=eta>0. For every fixed finite time horizon before leaving that region, +Phi_f^t(z(f)) is C^1 jointly in (f,t). Its field derivative u=D_f Phi_f^t(z)[h] +satisfies the variational equation + u'=H_f(Phi_f^t)u + grad h(Phi_f^t), +with the corresponding initial derivative. Consequently any transverse robust +first hit along this finite segment is C^1 in f. + +These statements are local. They do not prove A3-A4, Gaussian genericity, +global connection absence, or any C103 estimate. + +## 2. Why C2 is the right field topology + +The linear map f -> V_f=grad f is bounded C^2->C^1. Evaluation +(f,x)->V_f(x) is C^1 from X x T^2 to R^2: its field derivative is grad h(x) +and its spatial derivative is H_f(x), continuous because f is C^2. Therefore +the Banach implicit-function theorem proves A2.1 directly. + +For finite regular flow, write the integral equation + x(t)=z + integral_0^t V_f(x(s)) ds. +On a compact coordinate region, V_f and D_x V_f are uniformly bounded and +continuous in f in the C^1 norm. Standard contraction on short time slabs gives +existence and continuous dependence. Differentiate the fixed-point equation in +the Banach parameter f. The derivative is the unique solution of the displayed +linear variational equation. Concatenating finitely many slabs proves A2.4 on a +fixed finite horizon. No derivative of H_f is used; C^2 field regularity is +therefore sufficient for this finite-flow part. + +## 3. Local invariant graph by a parameter-dependent contraction + +Translate p(f) to zero and use a continuously chosen orthonormal eigenframe of +the symmetric Hessian H_f(p(f)); the simple positive/negative eigenvalues remain +separated after shrinking U. In coordinates (x,y), write + V_f(x,y)=(lambda_f x, -mu_f y)+N_f(x,y), +where lambda_f,mu_f>=lambda_*>0 and N_f(0)=DN_f(0)=0. The map +f -> (lambda_f,mu_f,N_f) is C^1 into the natural C^1 coefficient space: the +eigenvalues/eigenprojections of a simple symmetric 2x2 matrix are C^1, and the +coordinate change and p(f) are C^1. + +Choose a small radius so sup ||DN_f|| is uniformly below a fixed fraction of +lambda_*. The usual graph transform on C^1 graphs y=g(x), g(0)=g'(0)=0, is then +a uniform contraction on a closed C^1 ball. Importantly, its contraction +constant is <1 uniformly in f. The transform is C^1 in (f,g): it is assembled +from V_f, finite local flow, coordinate projections and inverses whose +derivatives stay uniformly nonzero on this small ball. + +The fixed point g_f therefore depends C^1 on f. A direct proof avoids importing +a differentiable fixed-point theorem: from g_f=T(f,g_f), + [g_{f+h}-g_f]/||h|| +is Cauchy because the difference quotient equals the parameter difference +quotient of T plus a contraction applied to the graph difference quotient. +Taking the limit gives + Dg_f[h]=(I-D_g T(f,g_f))^{-1} D_f T(f,g_f)[h], +where the inverse is the convergent Neumann series since ||D_gT||<1. +Continuity of these derivatives follows from continuity of DT and the same +uniform contraction bound. The unstable graph is obtained by applying the same +argument to reversed time. Restricting x to positive or negative compact +subintervals gives the labelled half-branches and proves A2.2. + +This argument uses C^1 graph transforms, not a claim that an arbitrary C^1 +vector field has C^2 invariant manifolds. The output required downstream is +only a C^1 arc with C^1 dependence on the C^2 field parameter. + +## 4. Hitting maps + +Let Gamma(f,s) be any local germ or regular-flow arc already proved C^1 in +(f,s), and let a finite section be rho=0 with d rho(Gamma_s) nonzero at the +first robust hit. The R1 geometry in #135 supplies an open neighborhood on +which that zero remains the first closed contact. The Banach scalar IFT gives +a C^1 hit parameter tau(f), with + D tau(f)[h]= -D_f(rho o Gamma)(f,tau)[h] + / partial_s(rho o Gamma)(f,tau). +Composition gives the C^1 hit point. This proves exactly the differential part +of A2-D once R1 supplies the robust first-contact predicate. + +## 5. Scope and review target + +The only non-elementary local ingredient above is the uniform C^1 graph +transform. A reviewer should check that its chosen graph space and transform +really are C^1 in the Banach parameter when f is only C^2, and that no hidden +third derivative of f is used. The finite-flow argument needs only H_f +continuous; the local invariant graph uses the C^1 vector field V_f and its +C^1 parameter dependence. + +No literature priority claim is made. Consensus search was attempted on +2026-09-29 and returned the monthly quota error; no result is fabricated from +that call. This note is intended to discharge the precise imported A2-T/A2-D +interface after independent review, not to promote SARD-G by itself. diff --git a/frontiers/sard_g_a2_parameter_20260929/README.md b/frontiers/sard_g_a2_parameter_20260929/README.md new file mode 100644 index 000000000..c53bde904 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/README.md @@ -0,0 +1,21 @@ +# SARD-G A2: corrected successor and explicit predecessor withdrawal + +**The original PROOF.md is a noncontrolling, invalid predecessor at its Section 3 +and C1-into-C1 claim. Do not consume it as A2 discharge.** Its exact original bytes +are preserved for audit, as are its four illustrative finite tests. + +The replacement is [v2/README.md](v2/README.md). It proves the necessary joint C1 +evaluation/continuous-C1-arc interface using a fixed-frame C0 trajectory contraction, +not a differentiable moving eigenframe. The explicit counterexample and author +correction are in [v2/AUTHOR_CORRECTION.md](v2/AUTHOR_CORRECTION.md). + +The new companion supplies localized scalar-potential nonvanishing, a full-support +Fourier argument, mesh genericity, and a qualitative unconditioned planar no-saddle- +connection composition. All are new author-side claims requiring nonauthor review. +No C103 regional estimate, conditioned-field theorem, RN/JETMOD, 3D or registry +advancement is implied by publication or finite checking. + + python -B -S v2/verify.py --output /path/to/new-output + +The new manifest and finite tests are confined to v2 and cannot launder the old +invalid argument into a passing mathematical verdict. Scientific effect NONE. diff --git a/frontiers/sard_g_a2_parameter_20260929/check.py b/frontiers/sard_g_a2_parameter_20260929/check.py new file mode 100644 index 000000000..4fa5db865 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/check.py @@ -0,0 +1,43 @@ +"""Finite illustrations of the A2 parameter formulas; not a stable-manifold proof.""" +import unittest +from fractions import Fraction as F + +def tracked(a,b,c): # grad f=(a*x+b, -c*y), a,c>0 + return (-F(b,a), F(0)) + +def tracked_derivative(a, db): + return (-F(db,a), F(0)) + +def flow_derivative(a,t,x0,h): # x'=a x + eps*h*x? derivative at eps=0 + # for integer t=1 only in exact checker: u(1)=h*x0*e^a is not rational; + # use constant forcing x'=a x + eps*h, t symbolically via coefficients. + return F(h,a) # equilibrium derivative of -eps*h/a, sign handled by equation + +class A2(unittest.TestCase): + def test_implicit_saddle_derivative(self): + a,c=F(3),F(5) + for b in (F(-2),F(0),F(7,4)): + p=tracked(a,b,c) + eps=F(1,1000); db=F(7,3) + dq=((tracked(a,b+eps*db,c)[0]-p[0])/eps,F(0)) + self.assertEqual(dq,tracked_derivative(a,db)) + def test_graph_parameter_at_stationary_point(self): + # unstable branch y=0 is parameterized by x=s, including s=0; + # its derivative in s is nonzero although physical vector field vanishes at s=0. + for s in (F(0),F(1,10),F(-1,10)): + gamma=(s,F(0)); dgamma=(F(1),F(0)) + self.assertEqual(dgamma,(1,0)) + if s==0:self.assertEqual((3*s,-5*gamma[1]),(0,0)) + def test_transverse_hit_formula(self): + # Gamma(eps,s)=(s+eps, s); section rho=x-1. + eps=F(1,1000) + tau0=F(1); tau1=1-eps + self.assertEqual((tau1-tau0)/eps,-1) + def test_variational_forcing_sign(self): + # x'=-a x + eps*h has equilibrium x=eps*h/a. + a,h=F(7),F(3) + eps=F(1,1000) + xeq=eps*h/a + self.assertEqual(xeq/eps,h/a) + +if __name__=="__main__": unittest.main() diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/A2_FIXED_FRAME.md b/frontiers/sard_g_a2_parameter_20260929/v2/A2_FIXED_FRAME.md new file mode 100644 index 000000000..09c45efbd --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/A2_FIXED_FRAME.md @@ -0,0 +1,261 @@ +# A2 at C2: fixed-frame bounded trajectories, not a differentiable C1 graph transform + +Object: OA-SARD-A2-FIXED-FRAME-20260929-v2. +Author: OpenAI / ChatGPT. Status: AUTHOR-SIDE SUCCESSOR; nonauthor analytic review required. +Scientific effect NONE. The original #137 manuscript remains a historical, +noncontrolling predecessor; its moving-eigenframe/C1-into-C1 claim is withdrawn. + +## 1. The exact target and the false stronger claim + +Put X=C^2(T_L^2) with its usual Banach norm, and V_f=grad f. Fix a reference field +f_* in X and a nondegenerate saddle p_*. All assertions are LOCAL on a sufficiently +small X-neighborhood U of f_*. There are four labelled local branch germs, with +fixed compact graph-parameter intervals, for which: + +(T) f -> Gamma_f is continuous into C^1 arcs; +(D) (f,s) -> Gamma_f(s) is jointly Frechet C^1 into the surface; +(B) for fixed s, |D_f Gamma_f(s)[h]| <= C ||h||_{C^1}. + +Finite regular flow, robust local-section launches, and robust central hits have +the same joint differentiability and local derivative bounds. In particular the +scalar mismatch D_chi is Frechet C^1 on every robust chart from [RC-S], with +|D D_chi(f)[h]| <= C_chi,f ||h||_{C^1}; its derivative is continuous in operator +norm on X*. It therefore also supplies Claude's weaker line form A2-G in [CL]. + +(D) DOES NOT assert that f -> Gamma_f is differentiable into the C^1 arc norm. +That extra derivative is not needed by the hitting IFT or the Gaussian slicing. +[RC-S] A2-D is read literally as joint C^1 evaluation; graph axes are fixed with +the atlas neighborhood, not recomputed from a moving Hessian. This specifies the +previously ambiguous graph-coordinate sentence without changing the geometry. + +The original #137 Section 3 incorrectly claimed that H_f(p(f)), its eigenframe, +and its recentered nonlinearity are C^1 in the necessary strong norms for f in C^2. +They need not be. Here is a concrete counterexample in a coordinate ball, with a +fixed smooth cutoff equal to one near zero: + + f_t(x,y)=(x^2-y^2)/2 +(2/3)xy(x^2+y^2)^(1/4) + -t x -(2/3)t|t|^(1/2)y. (F1) + +The homogeneous nonpolynomial term has degree 5/2, is C^2, and its second +derivatives tend to zero at zero. The map t -> f_t is C^1 into C^2. The saddle +p_t=(t,0) has Hessian + + H_{f_t}(p_t)=[[1,sqrt(|t|)],[sqrt(|t|),-1]]. (F2) + +Its positive eigenline has slope + + m(t)=sqrt(|t|)/(1+sqrt(1+|t|)). (F3) + +For 0=1/(3 sqrt(t)), so it is not differentiable at zero. A fixed-x +graph of the local unstable manifold, anchored at p_t, has derivative m(t) at its +anchor. Differentiability into C^1 arcs would imply differentiability of that +slope, which is false. Periodization is harmless because all calculations are +inside the cutoff-one ball. This example refutes the old proof's strong regularity, +not the joint C^1 evaluation target (D). No C^3 assumption will be inserted to +hide the issue. + +## 2. Tracked saddle and fixed coordinates + +The map (f,x) -> grad f(x) is jointly C^1, with + + D[grad f(x)][h,z]=grad h(x)+H_f(x)z. (F4) + +For example its remainder is bounded by +omega_{H_f}(|z|)|z|+||h||_{C^2}|z|. Continuity of the derivative in operator norm +uses uniform continuity of H_f and +sup_{||h||C2<=1}|grad h(x)-grad h(y)|<=C|x-y|. This agrees with [CL] Lemma J. +The Banach IFT therefore gives the unique nearby saddle p(f), with + + Dp(f)[h]=-H_f(p(f))^{-1} grad h(p(f)). (F5) + +We USE the derivative of p, but we do NOT differentiate H_f(p(f)). Its continuity +suffices for the local inverse bound. Choose the origin p_* and an orthonormal +eigenframe of H_{f_*}(p_*) ONCE. In these fixed coordinates + + A=diag(lambda,-mu), lambda,mu>0, + V_f(x)=A x+R_f(x), (F6) + +where R_f=V_f-Ax. The saddle p(f) is not translated out of the vector field. +In particular R_f(0) is usually nonzero and must be retained. + +## 3. A fixed compact cutoff with a uniformly small Lipschitz constant + +Let chi be a fixed smooth cutoff equal to one on the ball B_a and zero outside +B_{2a}, in a coordinate ball contained in the declared endpoint neighborhood. +Set + + N_f(x)=chi(x)(V_f(x)-Ax), (F7) + +and extend by zero to R^2. This need not be a gradient vector field outside B_a; +all local trajectories used below remain in B_a, where it is the original field. +The map f -> N_f is affine and bounded C^2->C^1 on this fixed coordinate region. +The functions N_f and DN_f are globally bounded; DN_f is uniformly continuous +for each fixed f. There is no moving cutoff or moving-coordinate derivative. + +Given epsilon>0, first choose a small a so ||DV_{f_*}-A||<=epsilon on B_{2a}. +Then ||R_{f_*}(x)||<=epsilon|x| there. If ||f-f_*||C2<=delta, + + ||DN_f||_infinity <= C_chi(epsilon+delta/a+delta), (F8) + +by the product rule. Thus by choosing a and THEN delta sufficiently small, +we may arrange ||DN_f||<=ell with ell as small as desired, uniformly on U. +Also ||N_f(0)||<=C delta. All constants below use an adapted max norm on the +fixed stable/unstable factors; projections have norm one. + +Choose beta with 0N_f(x(.)) really IS C^1 into E_0. Its +variation is + + (h,z(.)) -> chi(x(.)) grad h(x(.))+DN_f(x(.))z(.). (F12) + +For the x part, the uniform remainder is at most +omega_{DN_f}(||z||infinity)||z||infinity. The mixed f/x remainder is at most +C||h||C2 ||z||infinity. The parameter derivative is continuous in operator norm +because, uniformly on ||h||C2<=1, chi grad h is Lipschitz; DN_f changes uniformly +under C^2 field changes. A compact fixed cutoff ensures these estimates also +hold for trajectories outside the local ball. Hence T is genuinely C^1 on +U x R x E_0; no spatial derivative of DN_f is differentiated. + +Banach IFT applied to x-T(f,a_0,x), or the differentiable-contraction argument, +now proves (f,a_0)->x_{f,a_0} is jointly Frechet C^1 into E_0. Its derivative z +in direction (h,da_0) is the unique bounded solution + + z=(exp(lambda t)da_0,0) + +K[chi(x(.))grad h(x(.))+DN_f(x(.))z(.)]. (F13) + +In particular + + ||z||infinity <= (|da_0|+C_0 C_chi||h||C1)/(1-theta_0). (F14) + +The inverse I-K DN_f is its norm-convergent Neumann series. This is the correct +fixed-point differentiability argument, in a C^0 trajectory norm, replacing the +unproved C^1-graph-transform assertion. The time interval is infinite but the +paths are bounded and DN_f is uniformly continuous, so no exponentially growing +Nemytskii domain is being differentiated. + +## 5. Localization, convergence to the moved saddle, and full-germ coverage + +The fixed point estimate gives + + ||x_{f,a_0}||infinity + <= (|a_0|+C_0||N_f(0)||)/(1-theta_0). (F15) + +Choose |a_0| and U small enough that this is strictly below a/2. The entire +backward trajectory then stays where chi=1 and is a trajectory of V_f. It is +not an artefact of the cutoff. + +Let p=p(f) and a_p=P_u p. The constant path p is the fixed point of (F11) for +a_0=a_p, since Ap+N_f(p)=0. Subtracting this constant path gives the equation + + y=(exp(lambda t)(a_0-a_p),0)+K[N_f(p+y)-N_f(p)]. (F16) + +For THIS existence comparison only, use E_beta with norm +sup_{t<=0} exp(-beta t)|y(t)|. The elementary two integral estimates give the +bound C_beta in (F9), so (F16) has a unique fixed point in E_beta, satisfying + + ||y||beta <= |a_0-a_p|/(1-theta_beta). (F17) + +This fixed point also belongs to E_0 and solves (F16) there; E_0 uniqueness +identifies it with x_{f,a_0}-p. Thus x(t)->p exponentially as t->-infinity. No +differentiability in E_beta is invoked. In particular we never differentiate +the moving p inside DN_f or an exponentially weighted composition operator. + +Conversely, any backward trajectory of the original V_f that stays in the small +ball is bounded. Variation of constants gives (F10)-(F11): the stable homogeneous +term from a time -T disappears as T->infinity because the trajectory is bounded. +The unstable part uses its value at zero. By uniqueness it is one of our graphs. +This proves that the construction gives the full local unstable germ, not a +selected orbit or an arbitrary continuously chosen curve. Reversing time proves +the stable germ, with the roles of lambda and mu interchanged. + +Define the anchored graph parameterization by + + Gamma_f(s)=x_{f,a_p(f)+s}(0), |s|<=s_*, (F18) + +on a compact interval with strict smallness slack. Its unstable projection is +a_p(f)+s, so partial_s Gamma is nonzero and it is embedded. Gamma_f(0)=p(f). +Formulae (F5),(F13) prove joint C^1 evaluation (D) and the C^1 perturbation bound +(B). Joint continuity of partial_s Gamma, uniform on compact s-intervals, proves +f->Gamma_f is CONTINUOUS into C^1 arcs. We do not differentiate partial_s Gamma +in f. Restrict s to either sign for the two half-branches. Fixed frame plus +fixed sign labels produce the four branches needed by [RC-S]. + +The construction is localized: if h vanishes on the endpoint neighborhood that +contains the cutoff and subsequent local arc, then N_{f+th}=N_f there and all +local branch launches are identical. A germ may be propagated to any declared +nearby local section by a finite flow inside that neighborhood; the same locality +holds. This is the endpoint-support fact needed by the companion proof. + +## 6. Finite flows, robust sections, and mismatch derivatives + +On each compact finite-time region, the integral equation +Phi_f(t,z)=z+integral_0^t V_f(Phi_f(s,z)) ds is a contraction on sufficiently short +time slabs. Its Nemytskii map in the C^0 path norm is C^1 by (F4). The same IFT +argument and concatenation of finitely many slabs give jointly C^1 dependence +in (f,z,t), with continuous derivatives. The field variation satisfies + + w'=H_f(Phi_f)w+grad h(Phi_f), (F19) + +with initial derivative if z=z(f). Gronwall bounds it by C||h||C1. There is no +need for positive speed merely to solve or differentiate this ODE; positive speed +is required on the finite regular arcs used for transverse hits and chart margins. +Physical flow starting exactly at the saddle is stationary; (F18), not that flow, +parameterizes the local germ across its anchor. + +For a fixed section rho=0 and a robust transverse hit at parameter tau, [RC-S] R1 +ensures the nearby zero stays the FIRST contact with the CLOSED section. Joint +C^1 evaluation and the scalar IFT give + + Dtau(f)[h]=-D_f[rho(Gamma(f,tau))][h]/partial_s[rho(Gamma(f,tau))]. (F20) + +The transverse denominator is bounded away from zero on a smaller neighborhood. +This gives the required derivative bounds for launches, central hits, and +D_chi=s(z_u)-s(z_s). Applying it to EVERY local and central section supplies the +literal A2-T and joint A2-D hypotheses of [RC-S], with graph coordinates fixed +once per atlas chart. The same reasoning yields A2-G and its bound for [CL]. + +A2-G alone supports the reduced slicing application, but does not by logical +implication prove an arbitrary stronger Frechet statement. Here joint Frechet +C^1 was proved separately by (F11)-(F14); no Gâteaux/Frechet identification is +being made from the line theorem alone. + +## 7. Interface disposition and remaining use + +This is an author-side full argument for the precise A2 interface. [CL]'s Lemma J, +regularity diagnosis and weaker-use observation are credited. Its center-manifold +citations are not imported as unverified substitutes: the hyperbolic construction +above is displayed in full, including cutoff smallness, forcing, differentiability, +decay and complete local-germ identification. + +No false C^1-into-C^1 conclusion remains in this successor. The companion manuscript +supplies a new A3/A4 route, the generic full-measure argument, and a qualitative +planar no-connection composition. The robust first-contact geometry still has the +exact [RC-S] source/review lineage. A nonauthor review must evaluate these actual +arguments, not infer them from the finite scalar checks or the previously merged +R3/R4 conditional review. No C103 bound, RN/JETMOD, 3D theorem, numerical constant, +scientific-status transition, or claimed historical novelty is included. diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/AUTHOR_CORRECTION.md b/frontiers/sard_g_a2_parameter_20260929/v2/AUTHOR_CORRECTION.md new file mode 100644 index 000000000..1f72865b3 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/AUTHOR_CORRECTION.md @@ -0,0 +1,24 @@ +# Author correction to Math-#137 v1 + +The original PROOF.md at e944ba0b595d790d27d1466cc4f576467890bc3a is NOT an accepted +proof of A2.2 or Section 3. Its claim that a moving Hessian/eigenframe and a +recentered C1 graph transform are C1 in a C2 field parameter is invalid without +additional arguments/regularity. Claude's #138 correctly identified this issue. +The preceding assistant explanation repeated that unsupported claim; it is +withdrawn here, not merely relabelled as needing a routine check. + +The explicit C2 gradient counterexample (F1)-(F3) in A2_FIXED_FRAME.md disproves +the C1-into-C1 strengthening. The tracked-saddle and finite-flow formulas remain +valid. The old four finite illustrations never verified the invalid analytic step. + +This additive v2 preserves all original files in Git history and as predecessor +files in the branch. Its claims are different and narrower: joint C1 evaluation, +not C1 dependence into C1 arcs; continuous C1 arc dependence is proved separately. +The actual fixed-point map on bounded C0 trajectories is displayed and its +Nemytskii differentiability justified. Only a decay comparison uses weighted +spaces; no weighted differentiability is assumed. + +The extension to A3/A4 and genericity is new author-side work. It must receive +its own source-bound analytic review; the merged R3/R4 review cannot discharge +its newly supplied premises retroactively. No original proof or review verdict, +scientific register, lemma flag, prize, RN/JETMOD or C103 status is altered here. diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/NONVANISHING_AND_CLOSURE.md b/frontiers/sard_g_a2_parameter_20260929/v2/NONVANISHING_AND_CLOSURE.md new file mode 100644 index 000000000..7da6a393c --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/NONVANISHING_AND_CLOSURE.md @@ -0,0 +1,291 @@ +# Localized forcing, full Fourier support, and the qualitative planar SARD-G conclusion + +Object: OA-SARD-NONVANISHING-CLOSURE-20260929-v1. +Author: OpenAI / ChatGPT. Status: AUTHOR-SIDE PROOF; nonauthor review required. +Scientific effect NONE. This is not a quantitative or regional C103 certificate. + +## 1. Exact scope and conclusion + +On the fixed flat torus T_L^2, consider the centered variance-one Gaussian field +with covariance + + K_L(x-y)= [sum_{m in Z^2} exp(-|x-y+Lm|^2/2)] + / [sum_{m in Z^2} exp(-|Lm|^2/2)]. (N1) + +All constants and neighborhoods in this manuscript are local/existential for +fixed L. Use ascending gradient flow x'=grad f; reversing its sign exchanges +stable and unstable conventions without changing the no-connection event. + +**Theorem S (qualitative planar no-connection candidate).** Almost surely the +field has finitely many nondegenerate critical points, with distinct critical +values, and no gradient trajectory connects two different index-one saddles. +Precisely, the connection event has outer Gaussian measure zero and is null in +the completed Gaussian probability space. This does not assert in advance that +the uncompleted connection event itself is Borel. + +The proof assembles: the ACTUAL first-closed-contact charts of [RC-S] (not the +old endpoint-admitting predicate); the corrected joint C^1 regularity proved in +A2_FIXED_FRAME.md; the explicit interior perturbation in Sections 2-4 below; +full Fourier support; and the mesh/genericity and countable Gaussian slicing +arguments in Sections 5-7. No A2, A3/A4 or genericity black-box assumption remains +inside this new composition. The source-level R1/R2 geometry is consumed at its +pinned proof, with its separate review status retained. This is an author-side +composition pending review, not a canonical advancement of the old SG source. + +The theorem is unconditioned. It does not apply a full-support proof to a +coalescing pair-conditioned field, and gives no bound uniform under conditioning. +There is no 3D Morse-Smale conclusion, no regional intensity, no RN/JETMOD claim, +no numerical probability of a near-connection, and no new quantitative C103 gate. + +## 2. An interior perturbation cannot be canceled by endpoint variation + +Fix a zero of a robust chart: a genuine saddle connection from p to q, with its +unstable and stable launches in disjoint endpoint neighborhoods. Along its compact +regular arc write gamma(t), 0<=t<=T, with central first section hit at t=c in (0,T). +By uniqueness and strict increase of f, the arc is embedded. Pick t_0 in (0,c), +strictly after the unstable launch. A small coordinate neighborhood O of gamma(t_0) +can be chosen disjoint from both endpoint neighborhoods and from the entire +stable travel half gamma([c,T]); it meets the remaining trajectory only inside +a small time interval J compactly contained in (0,c). + +Why O exists matters. An embedded compact arc is a homeomorphism onto its image. +Remove a small open parameter interval around t_0; its remaining compact image +is disjoint from a smaller compact subarc. Their distance is positive. Choose +O inside that separation, small enough for a local coordinate graph. This rules +out hidden returns through the support of the perturbation. + +Let h in C^2 be supported in O. The original vector field and every endpoint local +germ are unchanged near their entire defining endpoint neighborhoods. The fixed +cutoff construction in A2_FIXED_FRAME.md, followed by local finite flow, makes +both launch points EXACTLY unchanged for f+epsilon h. The stable travel half and +its central hit are also unchanged, since the field is unchanged on a neighborhood +of that half. The unstable variation w therefore satisfies + + w'=H_f(gamma(t))w+grad h(gamma(t)), w(0)=0, 0<=t<=c. (N2) + +Let Sigma have unit normal n and unit tangent tau, and V_c=grad f(gamma(c)). +Transversality means n.V_c!=0. Correction for the moving hit time projects the +fixed-time variation by + + Pi=I-V_c n^T/(n.V_c). (N3) + +The mismatch coordinate is the signed tangent coordinate, so its derivative is + + L_f(h)=tau^T Pi w(c). (N4) + +In particular endpoint-supported derivative terms have not been ignored; they +vanish for THIS specially supported perturbation by exact localization. +For general h the joint C^1 regularity gives a bounded linear derivative L_f on +X with |L_f(h)|<=C||h||C1. Only the supported perturbation is needed to prove it +is nonzero. No formula claiming endpoint variation is a finite list of two-jets +is asserted. + +## 3. The covector calculation and a concrete potential perturbation + +Let Phi(t,s) be the fundamental matrix of w'=H_f(gamma(t))w. Define + + b_c=Pi^T tau, b(t)=Phi(c,t)^T b_c. (N5) + +Pi fixes the tangent tau, so b_c.tau=1 and b_c!=0. Also b_c.V_c=0 because Pi V_c=0. +Invertibility of Phi gives b(t)!=0. The adjoint identity is + + b'=-H_f(gamma(t))^T b, b(t).grad f(gamma(t))=0. (N6) + +The last equality follows by differentiating the pairing; the vector grad f +along the orbit solves V'=H_f V. Duhamel now gives + + L_f(h)=integral_0^c b(t).grad h(gamma(t)) dt. (N7) + +It remains to choose h as a SCALAR POTENTIAL, not an arbitrary vector forcing. +In a fixed local Euclidean coordinate rotation, the regular C^2 trajectory is +a C^2 graph y=g(x) on O, with x(t) strictly monotone. Since b is perpendicular +to its tangent, on a smaller interval it has the form + + b(t)=a(t)(-g'(x(t)),1), + +where a is continuous, nonzero, and of constant sign. Choose a nonnegative C^2 +function phi supported strictly inside that x interval, not identically zero, +and a smooth transverse cutoff zeta equal to one near zero. Set + + h(x,y)=sign(a) phi(x)(y-g(x)) zeta(y-g(x)). (N8) + +The rectangle and cutoffs are small enough that h is supported in O; extend it +by zero globally. It is C^2. Along the orbit its gradient is +sign(a) phi(x)(-g'(x),1), so + + b(t).grad h(gamma(t))=|a(t)| phi(x(t))(1+g'(x(t))^2)>=0, + +with a strictly positive integral. Thus L_f(h)>0. This explicitly proves +nonvanishing at every robust connection using only C^2 regularity. If a smooth +h is desired, approximate this compactly supported C^2 function in C^2 inside +O by smooth functions; continuity of L_f preserves strict positivity. + +The construction is field-dependent only as an EXISTENCE witness for L_f!=0. +It is not selected measurably and is not itself used as a random Gaussian shift +direction. Countably many deterministic Fourier directions are chosen next. + +## 4. From a local bump to a deterministic Cameron-Martin direction + +Poisson summation gives Fourier weights + + a_n=[2pi/(L^2 Z_L)] exp(-2pi^2 |n|^2/L^2)>0, + Z_L=sum_m exp(-|Lm|^2/2), sum_n a_n=1. (N9) + +Every real trigonometric polynomial therefore belongs to the Cameron-Martin +space H: its RKHS norm is a FINITE sum of squared Fourier coefficients divided +by positive a_n (with the corresponding real-mode convention). Such polynomials +are dense in C^2. One direct proof uses periodic smoothing followed by Fourier +truncation of the smoothed function, or product Fejer means applied also to each +of the continuous derivatives of orders <=2. + +Since L_f is continuous on C^2 and is nonzero on (N8), it cannot vanish on all +trigonometric polynomials. By linearity it is nonzero on at least one individual +real Fourier mode. These modes all lie in H. This proves the A3/A4 nonvanishing +interface WITHOUT differentiating an RKHS kernel or representing every endpoint +variation by distributions. Positivity of EVERY Fourier weight is essential; +a band-limited or otherwise restricted spectrum is not covered by this argument. + +It also verifies compatibility with [RC-S] R3: a nonzero continuous L_f|H is +nonzero on its countable evaluation-image family. Thus one may use its already +written Gaussian decomposition. Section 7 instead gives a simpler equivalent +Fourier-coordinate decomposition for this particular periodic model. + +## 5. Smooth sample paths and finite-jet covariance floors + +Choose one representative n in each pair {n,-n}, n!=0. An exact real realization is + + f(x)=sqrt(a_0)Z_0+sum_{n+}sqrt(2a_n) + [Z_n^c cos(2pi n.x/L)+Z_n^s sin(2pi n.x/L)], (N10) + +with independent standard real Gaussians. For every integer k, + + sum_n sqrt(a_n)(1+|n|)^k E|Z_n| < infinity. + +Tonelli gives almost-sure absolute uniform convergence of all derivative series +through order k; a countable intersection in k gives smooth paths. Their C^k +norms also have finite fixed moments by the corresponding sum/Minkowski bound. +This realization has covariance (N1); its C^2-valued law is the Gaussian law used +in [RC-S]. No finite Fourier truncation is substituted for the exact field. + +Any finite set of distinct derivative functionals at one point is linearly +independent as distributions when symmetric duplicates are removed. The same +holds for gradients at two distinct points together with their value difference: +use test functions supported separately near the two points to isolate each +coefficient. If a linear combination had zero variance, positivity of all a_n +would force it to vanish on every Fourier mode. It would then vanish as a +finite-order distribution, by Fourier approximation of smooth tests, contrary +to independence. Hence its covariance is positive definite. + +In particular (grad f,H_f) at one point is a nondegenerate five-dimensional +Gaussian vector. Also + + (grad f(x),grad f(y),f(x)-f(y)) (N11) + +is nondegenerate for x!=y. Covariance varies continuously with the points, so +on dist(x,y)>=epsilon its smallest eigenvalue has a positive minimum. Gaussian +densities are therefore uniformly bounded on that compact separated set. These +floors are qualitative for each fixed separation; no uniform lower floor as +x->y is claimed or needed here. + +## 6. Two elementary mesh arguments establish the full-measure generic set + +This supplies the genericity input explicitly, not through an unverified claim +that every field along a Gaussian shift line is generic. + +### 6.1 Morse critical points + +Localize to ||f||C3<=M. If grad f(x)=0 and det H_f(x)=0, at a mesh point x_delta +within C delta one has |grad f(x_delta)|<=C_M delta, +||H_f(x_delta)||<=C_M, and |det H_f(x_delta)|<=C_M delta. There are O(delta^-2) +mesh points. For a symmetric matrix [[a,b],[b,c]] in a bounded box, the volume of + + |ac-b^2|<=epsilon (N12) + +is O_M(sqrt(epsilon)). Indeed split |a|<=sqrt(epsilon), which has volume +O_M(sqrt(epsilon)), from |a|>sqrt(epsilon), where at each fixed a,b the permitted +c interval has length at most 2epsilon/|a|<=2sqrt(epsilon). This rough bound is +sufficient even near the double-zero matrix. + +The joint five-variable density bound from Section 5 gives probability +O_M(delta^2 sqrt(delta)) per mesh point. The union bound gives O_M(sqrt(delta)), +which tends to zero along any sequence of refining meshes. The bad event is +contained in every such mesh union, so it has probability zero on ||f||C3<=M. +Take a countable union over M. Nondegenerate zeros of grad f are isolated; +compactness then makes their number finite. + +### 6.2 Distinct critical values + +Fix separation epsilon>0 and localize to ||f||C2<=M. If two separated critical +points have equal values, (N11) at a nearby mesh pair has norm <=C_M delta. +For small delta the pair remains separated by epsilon/2. There are O(delta^-4) +mesh pairs. The five-dimensional Gaussian density bound gives probability +O_{M,epsilon}(delta^5) for each, and hence O_{M,epsilon}(delta) for the union. +Let delta->0, then take the countable union over M and separations epsilon=1/n. +Every distinct pair has some positive separation, so almost surely all critical +values are distinct. + +The relevant events can be formulated by minima of continuous functions on compact +sets at fixed norm/separation bounds; alternatively the mesh unions supply Borel +null supersets directly. This is enough for the completed-measure conclusion. +There is no reliance on a sampled gradient minimum as a certified continuum bound. + +## 7. Countable Fourier slicing closes the qualitative connection event + +Use the robust charts of [RC-S] with fixed-frame branch parameterizations from +A2_FIXED_FRAME.md. The chart domains are open in C^2, form a countable family, +and cover every nondegenerate connection. Their mismatches D_chi are jointly +constructed and Frechet C^1. At every connection zero their derivative is +nonzero on some deterministic real Fourier mode by Sections 2-4. + +For a mode let h_j be its function in the expansion (N10), INCLUDING its standard- +Gaussian scale sqrt(a_0) or sqrt(2a_n). Its Fourier coefficient xi_j is standard +normal, and the residual g_j=f-xi_j h_j is independent of xi_j. One can check +this from the independent series, or by vanishing cross-covariances and the +Gaussian characteristic functional. Subtracting one smooth mode leaves a +C^2-valued residual. All modes are countably indexed. The constant mode has +zero mismatch derivative, but at least one nonconstant mode is nonzero. + +For fixed chi,j let + + B_chi,j={f in U_chi: D_chi(f)=0, D D_chi(f)[h_j]!=0}. (N13) + +This is Borel because U_chi is open and both scalar maps are continuous. For +EVERY fixed residual g, the validity set I_g={t:g+t h_j in U_chi} is open. The +function t->D_chi(g+t h_j) is C^1 there. Each zero counted in (N13) has nonzero +derivative, hence is isolated among all zeros on its validity interval. The +regular zeros are countable: each has a rational-endpoint interval containing +no other zero. Accumulation at singular zeros or interval boundaries is allowed. + +Independence and Tonelli therefore give mu(B_chi,j)=0, since the scalar Gaussian +charges no countable set. The union over chi,j is a Borel null set containing all +nondegenerate connections. Section 6 supplies a full-measure set of Morse fields +with distinct critical values. The connection event is thus outer-null and null +in the completion. A self-connection is excluded separately by strict increase +of f along every nonconstant gradient trajectory. This proves Theorem S as a +qualitative source-level composition. + +An equivalent ending applies [RC-S] R3/R4 after supplying A2-D and A3/A4 from this +packet and genericity from Section 6. We wrote the mode argument to show that the +concrete periodic theorem does not need any norm-separable Banach dual, abstract +measurable chart selector, or assertion about all shifted fields being Morse. + +## 8. What this resolves mathematically, and what it does not authorize + +The packet supplies explicit source arguments for local parameter regularity, +nonzero Cameron-Martin variation, the full-measure generic set, and their actual +composition with the robust first-contact predicate. It avoids proving the false +strong C1-into-C1 statement and does not attempt to repair it by enlarging the +field norm to C3, changing the Gaussian law, or allowing an endpoint hit. + +The original SG/BR/RI and conditional [RC-S] reviews remain historical evidence. +A nonauthor review of A2, of the localized-forcing/Fourier argument, and of this +assembly is still needed before any canonical downstream status fold. In particular +Theorem S is not a new regional Kac-Rice estimate, does not prove a deterministic +normalizer floor on a numerical interval, and does not settle conditioned SARD-G, +RN/JETMOD, P0.1 or any 3D claim. Such consumers must expose the exact measure and +object they use rather than treating an unconditioned null set as universally null. + +The methods are classical contraction, variation of constants, Fourier support, +mesh bounds and Gaussian slicing. No historical-priority or exhaustive novelty +claim is made. Finite tests check selected exact identities and logical exclusions; +they are not proofs of the infinite-dimensional or measure-theoretic statements. diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/README.md b/frontiers/sard_g_a2_parameter_20260929/v2/README.md new file mode 100644 index 000000000..82404a159 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/README.md @@ -0,0 +1,33 @@ +# Targeted SARD-G completion candidate + +**Author-side successor; nonauthor analytic review required. Scientific effect NONE.** + +[A2_FIXED_FRAME.md](A2_FIXED_FRAME.md) replaces the invalid moving-eigenframe and +C1-into-C1 assertions of #137 v1. It proves only what the downstream proof uses: +joint Frechet C1 evaluation, continuous C1 arc dependence and local derivative +bounds. It uses fixed-origin/splitting bounded trajectories; a separate weighted +argument proves decay but is not differentiated. + +[NONVANISHING_AND_CLOSURE.md](NONVANISHING_AND_CLOSURE.md) supplies an explicit +interior scalar-potential perturbation, a Fourier-density route to a nonzero +Cameron-Martin derivative, elementary full-measure genericity, and an assembly +with #135's actual robust charts. Its qualitative planar no-saddle-connection +statement is not a conditional-field or regional C103 estimate. + +[AUTHOR_CORRECTION.md](AUTHOR_CORRECTION.md) records exactly what was wrong and +what is preserved. Original #137 proof bytes are not rewritten or accepted. + +Run from this directory: + + python -B -S verify.py --output /path/to/new-output + python -B -O -S verify.py --output /path/to/other-output + +Both entry modes check the full flat packet and execute 18 tests plus 9 intended +semantic negatives in each Python mode. Outputs and source identities must agree. +The tests are finite exact illustrations, not invariant-manifold, support, or +measure-theoretic proofs. All implementation uses the Python standard library. + +The only imported source-level geometry is the pinned robust-chart manuscript +in SOURCE_MAP.json. Claude's A2 note is credited and reviewed separately; its +classical references are not silently used to validate our corrected contraction. +Old AMEND, C103, RN/JETMOD, 3D and registry statuses remain unchanged by publication. diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/RECONNAISSANCE.md b/frontiers/sard_g_a2_parameter_20260929/v2/RECONNAISSANCE.md new file mode 100644 index 000000000..da64e07c2 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/RECONNAISSANCE.md @@ -0,0 +1,29 @@ +# Dependency-focused reconnaissance, 29 September 2026 + +Consensus was called for C1 parameter-dependent hyperbolic invariant manifolds, +Lyapunov-Perron bounded trajectories and Gaussian transversality. It returned +its 30-search monthly quota error, reset October 1. No paper result was returned. + +Direct primary-source record inspected: +A. Vanderbauwhede and S. A. van Gils, Center manifolds and contractions on a scale +of Banach spaces, Journal of Functional Analysis 72(2),209-224 (1987), +DOI 10.1016/0022-1236(87)90086-3. +https://www.sciencedirect.com/science/article/pii/0022123687900863 + +Read scope: publisher abstract and metadata. It explicitly discusses differentiability +only after embeddings on a scale of spaces for a center-manifold construction. +That abstract does NOT verify the precise C2 parameter claim in #137, and this +packet does not import a theorem from it. Our hyperbolic bounded-trajectory proof +is written out, rather than citing a center-manifold theorem by name. + +Further targeted searches for Gaussian Morse-Smale potentials and parameter +stable manifolds returned adjacent results, not a directly verified theorem for +this precise periodic field. This is not a complete novelty audit or evidence +of historical priority. Contraction, Lyapunov-Perron, variation of constants, +Fourier approximation, mesh arguments and Gaussian slicing are classical. + +The source-level mathematics actually read includes #135's full robust predicate, +#137's erroneous predecessor, and #138's full regularity note. The last supplies +an important diagnosis and a weaker line-slicing interface, but its citation-only +invariant-manifold statements are not substituted for the new proof. The author +and dependency exposure are recorded in SOURCE_MAP.json. diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/RESULTS.json b/frontiers/sard_g_a2_parameter_20260929/v2/RESULTS.json new file mode 100644 index 000000000..70ce5a3f3 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/RESULTS.json @@ -0,0 +1,8 @@ +{ + "tests_per_mode": 18, + "semantic_mutants_per_mode": 9, + "identical_output_pairs": 10, + "all_intended_failures": true, + "scientific_effect": "NONE", + "continuum_verified_by_code": false +} diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/SOURCE_FILES.json b/frontiers/sard_g_a2_parameter_20260929/v2/SOURCE_FILES.json new file mode 100644 index 000000000..9fbf77d30 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/SOURCE_FILES.json @@ -0,0 +1,66 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "files": [ + { + "path": "A2_FIXED_FRAME.md", + "bytes": 13253, + "sha256": "d14f0d18213de9031ecc336f6b5b4bd804ae954b84b58c3c2e1a18e94976633d", + "git_blob": "09c45efbde38f81bc152e30ba4b4a51a37c9272b" + }, + { + "path": "AUTHOR_CORRECTION.md", + "bytes": 1514, + "sha256": "1e4f0ca0bb11a44a41331bebedb703b9a4031223e2ee86852c97dd356bbfe921", + "git_blob": "1f72865b30d5366c969be533f7521f01157ae1b8" + }, + { + "path": "NONVANISHING_AND_CLOSURE.md", + "bytes": 15901, + "sha256": "fce5e5ee33cbe49d59077de03a21ed8e6bb2cd77d800e33e67a05f830e43315e", + "git_blob": "7da6a393cabc08063e68587b6e4007c39baba38f" + }, + { + "path": "README.md", + "bytes": 1826, + "sha256": "1c86fcd42ec572fc1a391dc6c8bec106f19b18409cd04877c1847a7335f8759e", + "git_blob": "82404a159b4ed2690963cff7e84c47e2b2d434d0" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 1760, + "sha256": "5f4d4cba2606369fb2e39f579c4a424283bd029ae32a39e67ebeb064838dbff2", + "git_blob": "da64e07c2701aa2e8251c989b11afb09149d4b3c" + }, + { + "path": "RESULTS.json", + "bytes": 196, + "sha256": "e4502640063f3278dbd287d1ba2b1f83a4300cc2d2fd97f267570a7ec0ad880c", + "git_blob": "70ce5a3f3892304051912347e0c85136f8f6ccdf" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 1625, + "sha256": "b9f8194065a6a69395b9003db95ba8f655e7ee16a6d146157b848274175537fb", + "git_blob": "87bb332962a0db8ce46af33f40af4b8d7b8c15d9" + }, + { + "path": "a2.py", + "bytes": 4152, + "sha256": "119294e4d3ef9277bb6152bbbaafde498b998c39f917f48be4cd314ea6711f6a", + "git_blob": "c089a020cc1d56117e9626741a39a9da4b6731f2" + }, + { + "path": "test_a2.py", + "bytes": 5337, + "sha256": "a9272681bbb962888f02e7140fc8b75ddc765180f30a541e1e143aeea4e50dc8", + "git_blob": "f66c75b64c0eae940afd91f1492c5eaa60d17e4a" + }, + { + "path": "verify.py", + "bytes": 4773, + "sha256": "1fe9616dcd6f8d8787c03f592b5f8905ea6353d753c645373dbe9a4849306d08", + "git_blob": "d84a41f9f6c74090cfa2eb03a604e6da98b48cb9" + } + ] +} diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/SOURCE_MAP.json b/frontiers/sard_g_a2_parameter_20260929/v2/SOURCE_MAP.json new file mode 100644 index 000000000..87bb33296 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/SOURCE_MAP.json @@ -0,0 +1,40 @@ +{ + "scientific_effect": "NONE", + "upstream_replayed_by_packet": false, + "inputs": [ + { + "id": "RC-S", + "repository": "d6g8k5htny-coder/Math-", + "commit": "ee94b06368c29bceca80662698b4b4d6ee81ec91", + "path": "frontiers/sard_g_robust_charts_20260929/PROOF.md", + "git_blob": "7e2237063a8dd0120e9d5bd15a3caaa32e8495fa", + "bytes": 25022, + "sha256": "b91b9f792c6322204a0f2a573b2ca76d5c951e49ddd7caa6ffd1abed0aa79e79", + "use": "Actual first-closed-contact R1/R2 charts and optional R3/R4 slicing; geometric source not overwritten." + }, + { + "id": "CL", + "repository": "d6g8k5htny-coder/Math-", + "commit": "2726594c83ac35b0371362674a1e4e4f52fd3840", + "path": "frontiers/sard_g_a2_regularity_20260929/PROOF.md", + "git_blob": "b27a36e3d337fd0c2bcecdeae6bf013b56883b0f", + "use": "Attribution and cross-check of Lemma J, loss diagnosis and weaker A2-G; cited stable-manifold theorems not imported." + }, + { + "id": "PREDECESSOR", + "repository": "d6g8k5htny-coder/Math-", + "commit": "e944ba0b595d790d27d1466cc4f576467890bc3a", + "path": "frontiers/sard_g_a2_parameter_20260929/PROOF.md", + "use": "INVALID Section3/C1-into-C1 predecessor explicitly withdrawn; no proof dependency." + } + ], + "new_author_claims": [ + "fixed-frame joint Frechet C1 germs", + "localized scalar-potential nonvanishing", + "Fourier-support Cameron-Martin separation", + "Morse/distinct-values mesh proof", + "qualitative unconditioned planar no-connection composition" + ], + "nonauthor_review_required": true, + "no_status_fold": true +} diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/a2.py b/frontiers/sard_g_a2_parameter_20260929/v2/a2.py new file mode 100644 index 000000000..c089a020c --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/a2.py @@ -0,0 +1,115 @@ +"""Exact finite controls for a fixed-frame Lyapunov--Perron proof. + +No numerical trajectory sampling and no Gaussian continuum acceptance. +""" +from fractions import Fraction as F +from math import comb + +MUTANT=None + +def _positive(*values): + if any(F(x)<=0 for x in values): + raise ValueError('positive spectral/radius data required') + +def lp_constants(lam,mu,ell,beta): + lam,mu,ell,beta=map(F,(lam,mu,ell,beta)) + _positive(lam,mu,ell,beta) + if beta>=lam: + raise ValueError('unstable weight must be below lambda') + cu=1/(lam+beta) if MUTANT=='wrong-unstable-weight' else 1/(lam-beta) + cs=1/(mu-beta) if MUTANT=='wrong-stable-weight' else 1/(mu+beta) + return ell*(1/lam+1/mu),ell*(cu+cs) + +def anchor_equilibrium(lam,mu,bu,bs): + """Bounded constant path of x'=lambda*x+bu, y'=-mu*y+bs.""" + lam,mu,bu,bs=map(F,(lam,mu,bu,bs));_positive(lam,mu) + if MUTANT=='drop-constant-forcing': + return F(0),F(0) + px=bu/lam if MUTANT=='reverse-unstable-integral' else -bu/lam + return px,bs/mu + +def unstable_polynomial(lam,mu,rho,c): + """Triangular ILLUSTRATION x'=lambda*x+c, y'=-mu*y+rho*x^2. + +Returns px and coefficients of y(s)=y0+y1*s+y2*s^2, s=x-px. +This illustrative vector field need not be a gradient and is labelled as such. +""" + lam,mu,rho,c=map(F,(lam,mu,rho,c));_positive(lam,mu) + px=anchor_equilibrium(lam,mu,c,0)[0] + return px,rho*px*px/mu,2*rho*px/(mu+lam),rho/(mu+2*lam) + +def fixed_anchor_derivative(lam,mu,rho,c,a): + lam,mu,rho,c,a=map(F,(lam,mu,rho,c,a));_positive(lam,mu) + p=-c/lam;s=a-p + dp=-1/lam + return dp*(2*rho*p/mu+2*rho*(a-2*p)/(mu+lam)-2*rho*s/(mu+2*lam)) + +def matrix_inverse2(A): + a,b=A[0];c,d=A[1];det=a*d-b*c + if not det:raise ValueError('singular matrix') + return [[d/det,-b/det],[-c/det,a/det]] + +def mm(A,B): + return [[sum((x*y for x,y in zip(row,col)),F(0)) for col in zip(*B)] for row in A] + +def dot(a,b):return sum((x*y for x,y in zip(a,b)),F(0)) + +def projection(v,n): + v=list(map(F,v));n=list(map(F,n));den=dot(v,n) + if den==0:raise ValueError('transverse normal denominator required') + if MUTANT=='omit-hit-time-projection': + return [[F(1),F(0)],[F(0),F(1)]] + return [[F(int(i==j))-v[i]*n[j]/den for j in range(2)] for i in range(2)] + +def adjoint_hit(v,n,tau): + P=projection(v,n) + return [sum(F(tau[i])*P[i][j] for i in range(2)) for j in range(2)] + +def eigenline_quotient_bounds(n): + """At t=n^-4: k=sqrt(t)=n^-2, 1=2 required') + t=F(1,n**4);k=F(1,n**2) + if MUTANT=='pretend-Lipschitz-eigenline': + return F(0),F(1) + return k/(t*(2+t/2)),k/(2*t) + +def beta_polynomial_integral(n): + """Integral_0^1 x^n (1-x)^n dx by finite rational expansion.""" + if type(n) is not int or n<0:raise ValueError('integer n>=0 required') + return sum((F((-1)**j*comb(n,j),n+j+1) for j in range(n+1)),F(0)) + +def density_mesh_powers(): + """Probabilistic dimension ledger, not a continuum probability calculation.""" + morse=F(2)+F(1,2)-2 + distinct=F(5)-4 + if MUTANT=='omit-height-difference':distinct=F(4)-4 + if MUTANT=='ignore-singular-slab':morse=F(2)-2 + return morse,distinct + +def gaussian_residual_covariances(weights,ell): + weights=list(map(F,weights));ell=list(map(F,ell)) + v=sum(w*l*l for w,l in zip(weights,ell)) + if v<=0:raise ValueError('positive variance required') + q=[w*l for w,l in zip(weights,ell)] + scale=F(1) if MUTANT=='wrong-residual-scale' else 1/v + # xi=ell(f), g=f-(Qell/v)*xi: unnormalised exact equivalent. + return [a-a*scale*v for a in q] + +def matrix_rank(rows): + A=[list(map(F,row)) for row in rows] + if not A:return 0 + r=0 + for j in range(len(A[0])): + pivot=next((i for i in range(r,len(A)) if A[i][j]),None) + if pivot is None:continue + A[r],A[pivot]=A[pivot],A[r] + for i in range(r+1,len(A)): + if A[i][j]: + q=A[i][j]/A[r][j] + A[i]=[a-q*b for a,b in zip(A[i],A[r])] + r+=1 + if r==len(A):break + return r diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/test_a2.py b/frontiers/sard_g_a2_parameter_20260929/v2/test_a2.py new file mode 100644 index 000000000..f66c75b64 --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/test_a2.py @@ -0,0 +1,103 @@ +"""Exact finite falsification controls; not invariant-manifold or Gaussian proofs.""" +import unittest +from fractions import Fraction as F +import a2 as m + +class Checks(unittest.TestCase): + def test_contraction_denominators(self): + self.assertEqual(m.lp_constants(2,3,F(1,10),1),(F(1,12),F(1,8))) + def test_constant_forcing_retained(self): + self.assertEqual(m.anchor_equilibrium(2,3,1,2),(F(-1,2),F(2,3))) + self.assertEqual(m.unstable_polynomial(2,3,F(1,5),1),(F(-1,2),F(1,60),F(-1,25),F(1,35))) + def test_constant_path_solves_original_vector_field(self): + for bu in (F(-1,3),F(0),F(2,5)): + p=m.anchor_equilibrium(3,5,bu,F(7,11)) + self.assertEqual(3*p[0]+bu,0) + self.assertEqual(-5*p[1]+F(7,11),0) + def test_weight_validation(self): + with self.assertRaises(ValueError):m.lp_constants(2,3,F(1,10),2) + with self.assertRaises(ValueError):m.lp_constants(0,3,F(1,10),1) + def test_nonlinear_germ_exact_invariance(self): + # Triangular (not necessarily gradient) model; chain rule in s=x-p. + for lam,mu,rho,c in ((2,3,F(1,5),1),(3,2,F(1,7),F(-1,3))): + p,y0,y1,y2=m.unstable_polynomial(lam,mu,rho,c) + for s in (F(-1,9),F(0),F(1,11)): + y=y0+y1*s+y2*s*s + self.assertEqual(lam*s*(y1+2*y2*s),-mu*y+rho*(p+s)**2) + def test_fixed_anchor_parameter_derivative(self): + # Graph is a quadratic polynomial in c; centered difference is EXACT. + for c in (F(0),F(1,5),F(-2,7)): + lam,mu,rho,a=F(2),F(3),F(1,5),F(1,17) + def value(cc): + p,y0,y1,y2=m.unstable_polynomial(lam,mu,rho,cc);s=a-p + return y0+y1*s+y2*s*s + eps=F(1,1000) + self.assertEqual((value(c+eps)-value(c-eps))/(2*eps),m.fixed_anchor_derivative(lam,mu,rho,c,a)) + def test_neumann_inverse_equation(self): + B=[[F(1,8),F(1,16)],[F(1,24),F(1,12)]] + Iminus=[[F(int(i==j))-B[i][j] for j in range(2)] for i in range(2)] + inv=m.matrix_inverse2(Iminus) + self.assertEqual(m.mm(Iminus,inv),[[1,0],[0,1]]) + self.assertLess(max(sum(abs(x) for x in row) for row in B),F(1,4)) + def test_projection_annihilates_time_direction(self): + v=[F(2),F(3)];n=[F(1),F(0)];tau=[F(0),F(1)] + cov=m.adjoint_hit(v,n,tau) + self.assertEqual(m.dot(cov,v),0) + self.assertEqual(m.dot(cov,tau),1) + self.assertEqual(cov,[F(-3,2),F(1)]) + def test_projection_requires_transversality(self): + with self.assertRaises(ValueError):m.projection([0,1],[1,0]) + def test_scalar_potential_transverse_forcing(self): + # Straight regular segment: h(x,y)=x^3(1-x)^3*y near y=0. + self.assertEqual(m.beta_polynomial_integral(3),F(1,140)) + for a,gprime,phi in ((F(2),F(3,2),F(1,5)),(F(-3),F(-1,2),F(2,7))): + sign=1 if a>0 else -1 + cov=[-a*gprime,a];grad=[-sign*phi*gprime,sign*phi] + self.assertEqual(m.dot(cov,grad),abs(a)*phi*(1+gprime*gprime)) + self.assertGreater(m.dot(cov,grad),0) + def test_eigenline_derivative_loss_counterexample(self): + previous=F(0) + for n in (2,4,8,16,32): + lo,hi=m.eigenline_quotient_bounds(n) + self.assertGreater(lo,F(n*n,3)) + self.assertLess(lo,hi) + self.assertGreater(lo,previous) + previous=lo + def test_cusp_saddle_hessian(self): + for n in (2,4,8,16): + t=F(1,n**4);k=F(1,n**2) + self.assertEqual(k*k,t) + det=-1-k*k + self.assertEqual(det,-1-t) + self.assertLess(det,0) + # (1+t/2)^2>1+t gives the rational square-root enclosure. + self.assertGreater((1+t/2)**2,1+t) + def test_stationary_point_graph_parameter(self): + # Coordinate derivative stays nonzero at the saddle even though flow speed is zero. + for s in (F(0),F(1,10)): + dxds=1 + self.assertNotEqual(dxds,0) + if not s:self.assertEqual(3*s,0) + def test_morse_mesh_exponent(self): + self.assertEqual(m.density_mesh_powers()[0],F(1,2)) + self.assertGreater(m.density_mesh_powers()[0],0) + def test_distinct_value_mesh_exponent(self): + self.assertEqual(m.density_mesh_powers()[1],1) + self.assertGreater(m.density_mesh_powers()[1],0) + def test_two_point_derivative_functionals(self): + # Columns x,x^2,x^3,y,xy; rows grad at (0,0),(1,0), f(1,0)-f(0,0). + rows=[[1,0,0,0,0],[0,0,0,1,0],[1,2,3,0,0],[0,0,0,1,1],[1,1,1,0,0]] + self.assertEqual(m.matrix_rank(rows),5) + self.assertEqual(m.matrix_rank(rows[:-1]),4) + self.assertEqual(m.matrix_rank(rows[:-1]+[rows[0]]),4) + def test_gaussian_residual_independence_identity(self): + self.assertEqual(m.gaussian_residual_covariances([1,F(1,2),F(1,3)],[1,2,3]),[0,0,0]) + with self.assertRaises(ValueError):m.gaussian_residual_covariances([1,0],[0,1]) + def test_localization_second_derivative_vanishes_at_edge(self): + # x^3(1-x)^3 has value, first and second derivatives zero at both endpoints. + coeff=[0,0,0,1,-3,3,-1] + for order in (0,1,2): + for x in (0,1):self.assertEqual(sum(c*x**i for i,c in enumerate(coeff)),0) + coeff=[i*c for i,c in enumerate(coeff)][1:] + +if __name__=='__main__':unittest.main() diff --git a/frontiers/sard_g_a2_parameter_20260929/v2/verify.py b/frontiers/sard_g_a2_parameter_20260929/v2/verify.py new file mode 100644 index 000000000..d84a41f9f --- /dev/null +++ b/frontiers/sard_g_a2_parameter_20260929/v2/verify.py @@ -0,0 +1,96 @@ +"""Exact packet membership and finite controls; no continuum proof claim.""" +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-unstable-weight':'test_contraction_denominators', + 'wrong-stable-weight':'test_contraction_denominators', + 'drop-constant-forcing':'test_constant_forcing_retained', + 'reverse-unstable-integral':'test_constant_path_solves_original_vector_field', + 'omit-hit-time-projection':'test_projection_annihilates_time_direction', + 'pretend-Lipschitz-eigenline':'test_eigenline_derivative_loss_counterexample', + 'omit-height-difference':'test_distinct_value_mesh_exponent', + 'ignore-singular-slab':'test_morse_mesh_exponent', + 'wrong-residual-scale':'test_gaussian_residual_independence_identity', +} + +def need(ok,message): + if not ok:raise ValueError(message) + +def decode(text): + def unique(items): + out={} + for k,v in items: + need(k not in out,'duplicate JSON key: '+k);out[k]=v + return out + return json.loads(text,object_pairs_hook=unique) + +def identity(p): + need(p.is_file() and not p.is_symlink(),'regular source required: '+p.name) + b=p.read_bytes() + return {'bytes':len(b),'sha256':hashlib.sha256(b).hexdigest(), + 'git_blob':hashlib.sha1(f'blob {len(b)}\0'.encode()+b).hexdigest()} + +def sources(): + identity(ROOT/'SOURCE_FILES.json') + entries=decode((ROOT/'SOURCE_FILES.json').read_text())['files'] + names=[e['path'] for e in entries] + need(len(names)==len(set(names)) and all(Path(n).name==n and n!='SOURCE_FILES.json' for n in names), + 'unique flat paths required') + need(sorted(p.name for p in ROOT.iterdir())==sorted(names+['SOURCE_FILES.json']), + 'source membership differs') + for e in entries: + need(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 a2, test_a2 + a2.MUTANT=mutant + res=unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromModule(test_a2)) + data={'tests':res.testsRun,'passed':res.wasSuccessful(), + 'failures':sorted(t.id().rsplit('.',1)[-1] for t,_ in res.failures), + 'errors':sorted(t.id().rsplit('.',1)[-1] for t,_ in res.errors)} + print(json.dumps(data,sort_keys=True)) + return 0 if res.wasSuccessful() else 1 + +def replay(path): + path=path.resolve() + need(not path.exists() and not path.is_relative_to(ROOT),'new output outside packet required') + before=sources();path.mkdir(parents=True) + cases={} + for case in ['baseline',*MUTANTS]: + outputs=[] + 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) + (path/(case+'_'+mode+'.stdout')).write_bytes(run.stdout) + (path/(case+'_'+mode+'.stderr')).write_bytes(run.stderr) + record=decode(run.stdout.decode()) + need(not run.stderr and not record['errors'],'execution error, not intended failure: '+case) + need(record['tests']==18,'incorrect test count') + if case=='baseline':need(run.returncode==0 and record['passed'] and not record['failures'],'baseline failed') + else:need(run.returncode==1 and not record['passed'] and MUTANTS[case] in record['failures'],'semantic mutant escaped: '+case) + outputs.append(run.stdout) + need(outputs[0]==outputs[1],'normal/optimized mismatch: '+case) + cases[case]=decode(outputs[0].decode()) + summary={'tests_per_mode':18,'semantic_mutants_per_mode':9,'identical_output_pairs':10, + 'all_intended_failures':True,'scientific_effect':'NONE','continuum_verified_by_code':False} + need(summary==decode((ROOT/'RESULTS.json').read_text()),'stored summary differs') + need(before==sources(),'source changed during execution') + (path/'REPORT.json').write_text(json.dumps({**summary,'cases':cases,'sources':before,'sources_unchanged':True},indent=2,sort_keys=True)+'\n') + print(json.dumps(summary,sort_keys=True));return 0 + +if __name__=='__main__': + p=argparse.ArgumentParser(description=__doc__);g=p.add_mutually_exclusive_group(required=True) + g.add_argument('--child',action='store_true');g.add_argument('--output',type=Path) + p.add_argument('--mutant',choices=MUTANTS);o=p.parse_args() + need(o.child or o.mutant is None,'mutant requires child mode') + raise SystemExit(child(o.mutant) if o.child else replay(o.output))