From ee94b06368c29bceca80662698b4b4d6ee81ec91 Mon Sep 17 00:00:00 2001 From: Dylan Roy Date: Tue, 29 Sep 2026 07:52:32 -0500 Subject: [PATCH] Add SARD robust chart/direction/slicing source successor with explicit remaining premises Every local and central first closed contact has interior/time/tube clearance; prove prefix separation and countable coverage. Replace norm-dual density by countable evaluation covariance images. A2 regularity/A3-A4/generic inputs remain explicit; no C103 or scientific-status promotion. --- .github/workflows/sard-robust-charts.yml | 31 ++ .../sard_g_robust_charts_20260929/PROOF.md | 422 ++++++++++++++++++ .../sard_g_robust_charts_20260929/README.md | 30 ++ .../RECONNAISSANCE.md | 25 ++ .../RESULTS.json | 8 + .../SOURCE_FILES.json | 53 +++ .../SOURCE_MAP.json | 39 ++ .../sard_g_robust_charts_20260929/charts.py | 112 +++++ .../test_charts.py | 104 +++++ .../sard_g_robust_charts_20260929/verify.py | 95 ++++ 10 files changed, 919 insertions(+) create mode 100644 .github/workflows/sard-robust-charts.yml create mode 100644 frontiers/sard_g_robust_charts_20260929/PROOF.md create mode 100644 frontiers/sard_g_robust_charts_20260929/README.md create mode 100644 frontiers/sard_g_robust_charts_20260929/RECONNAISSANCE.md create mode 100644 frontiers/sard_g_robust_charts_20260929/RESULTS.json create mode 100644 frontiers/sard_g_robust_charts_20260929/SOURCE_FILES.json create mode 100644 frontiers/sard_g_robust_charts_20260929/SOURCE_MAP.json create mode 100644 frontiers/sard_g_robust_charts_20260929/charts.py create mode 100644 frontiers/sard_g_robust_charts_20260929/test_charts.py create mode 100644 frontiers/sard_g_robust_charts_20260929/verify.py diff --git a/.github/workflows/sard-robust-charts.yml b/.github/workflows/sard-robust-charts.yml new file mode 100644 index 000000000..2ec278e32 --- /dev/null +++ b/.github/workflows/sard-robust-charts.yml @@ -0,0 +1,31 @@ +name: SARD robust-chart exact interface controls + +'on': + pull_request: + paths: + - 'frontiers/sard_g_robust_charts_20260929/**' + - '.github/workflows/sard-robust-charts.yml' + push: + branches: [main] + paths: + - 'frontiers/sard_g_robust_charts_20260929/**' + - '.github/workflows/sard-robust-charts.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + robust-chart-controls: + 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 packet and both-mode geometric negatives + run: | + set -euo pipefail + python -B -S frontiers/sard_g_robust_charts_20260929/verify.py --output "${RUNNER_TEMP}/sard-robust-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}" + git diff --exit-code diff --git a/frontiers/sard_g_robust_charts_20260929/PROOF.md b/frontiers/sard_g_robust_charts_20260929/PROOF.md new file mode 100644 index 000000000..7e2237063 --- /dev/null +++ b/frontiers/sard_g_robust_charts_20260929/PROOF.md @@ -0,0 +1,422 @@ +# SARD-G robust charts: a source-level A1/A5/A6 successor + +Object: OA-SARD-ROBUST-CHARTS-20260929-v1. +Author: OpenAI / ChatGPT, 29 September 2026. +Disposition: AUTHOR-SIDE INTERFACE REPAIR; source-bound nonauthor review required. +Scientific effect NONE. The original manuscript, AMEND reviews, STATUS, graph, +lemma flags and prizes are unchanged. This note is not a C103 regional certificate. + +## 1. The downstream defect and the precise replacement contract + +The strict-gradient successor SG, at main commit a1fc9581, correctly excludes +hidden critical points and equality at the gradient margin. Its Conditions 2–3 +still allow an endpoint hit of a finite closed section. The boundary review BR +shows that such a field can belong to a purported chart while arbitrarily close +fields do not. Thus A1's openness assertion fails for that written predicate and +A6 cannot apply its open-interval slicing to it. Harper's standalone RI note +identifies the missing geometric conditions but explicitly does not amend SG. + +This is an explicit alternative chart definition and its associated slicing +proof, not another suggestion to amend the predicate later. It replaces SG +Section 3's chart/first-hit definition, Section 6's countable-direction choice, +and Sections 7–8's application to those charts. It does not rewrite SG Sections +4–5 or claim a new verification of their endpoint-support and RKHS-injectivity +arguments. All source identities are in SOURCE_MAP.json. + +The repaired claims are: + +**R1 (robust first contact).** A finite arc whose FIRST CONTACT with the CLOSED +section is transverse, in its relative interior, after launch and before its +terminal parameter, with positive compact open-tube clearance, has a continuous +first-hit map under C1 arc perturbations. If the parameter-to-arc map is C1, +its hit parameter and hit point are C1 as well. + +**R2 (chart contract, A1).** Under the local-branch continuity premise A2-T below, +the actual chart sets U_chi^rob defined in Section 4 are open in C2, have a +countable index set, and cover every nondegenerate saddle connection by a zero +of their mismatch. If the branch maps satisfy A2-D, that mismatch is C1. + +**R3 (Gaussian directions, A5).** For the C2-valued centered Gaussian field, +rational finite combinations of point evaluations at a fixed countable dense +set supply covariance images dense in its Cameron–Martin space. Normalizing +these gives a countable separating family of Gaussian slicing directions with +an independent residual. Norm separability of the Banach dual is neither used +nor asserted. + +**R4 (conditional application, A6).** If A2-D and the original A3–A4 directional +nonvanishing implication hold on the new charts, the charted connection event +is contained in a Borel Gaussian null set. With a separately justified full- +measure generic set this yields the completed-measure almost-sure conclusion. +No statement that every point of a Gaussian shift line is Morse is required. + +R1 and R3 are proved here. R2 explicitly uses A2-T; the C1 part and R4 explicitly +use A2-D. The statement is not an independent proof of invariant-manifold +parameter regularity, A3–A4, finite-jet nondegeneracy or any regional Kac–Rice +estimate. In particular an accepted R1 does not, by itself, promote C103. + +## 2. Functional setting and the unaltered premises + +Let X=C2(T_L^2) with its separable Banach norm. Let mu be the centered Gaussian +law of the same smooth periodized field, Q:X* -> X its covariance operator, +and H its Cameron–Martin Hilbert space, continuously embedded in X. The smooth +sample-path and Gaussian moment assumptions of SG ensure that Q is defined by +Bochner integration and the reproducing identity below applies. This note uses +no special isotropic rotation of a conditioned field. + +For each pair of rational nested endpoint boxes and continuation neighborhoods, +retain SG's exact critical-point predicate: the CLOSED outer box contains exactly +one critical point, it lies in the interior continuation neighborhood, its index +is one and its spectral gap is greater than a specified positive rational margin. +The gradient minimum on the compact continuation complement is STRICTLY greater +than its specified positive rational threshold eta. The two outer boxes are +compactly disjoint. Equality is not accepted. + +**A2-T, explicit imported topological premise.** Around every field with these +hyperbolic tracked saddles there are open field neighborhoods on which the four +local stable/unstable branch germs have fixed-label embedded C1 parameterizations +on compact intervals, continuously depending on the field in the C1 arc topology. +They represent the full germs near the saddle, not arbitrary selected orbit +pieces. They stay inside their declared endpoint neighborhoods. The regular flow +arcs launched from them depend continuously in C1 on the field on their declared +finite time intervals. Ordinary gradient time may be used; an equivalent +normalized flow is used only on regions with a positive gradient lower bound. + +**A2-D, additional differential premise.** On those neighborhoods the local +parameterizations and finite regular flow maps are C1 in the field parameter and +the arc parameter, so the implicit-function derivative for transverse hitting +is defined on X. A2-T alone is not a differentiability theorem. Any regularity +loss at the C2-field/C1-vector-field interface must be resolved in A2's own +review, not hidden inside the first-hit argument. + +**A3–A4, imported nonvanishing premise.** At a chart zero corresponding to a +connection, the derivative of the mismatch is a continuous linear functional +on X whose restriction to H is nonzero. The original route uses a curve +contribution plus endpoint-supported terms and positivity of Fourier weights. +The endpoint neighborhoods remain disjoint from the compact interior test arc +in the new charts, so the SUPPORT hypothesis is unchanged. This note records +that compatibility but does not independently discharge that route. + +The generic full-measure set of nondegenerate critical points and distinct +critical values is another named input. R4 will state precisely where it is +needed, instead of assuming it for an entire one-dimensional shift line. + +## 3. The finite-section first-contact lemma with the missing early-prefix proof + +Work in a local Euclidean chart near a nondegenerate closed segment +Sigma=[a,b]. Its boundary relative to the supporting line is the two-point set +{a,b}, not its ambient topological boundary, which would be the whole segment. +Write n for a unit normal, and s for a signed coordinate along the supporting +line. Let T be an open tube in the surface. Suppose a C1 embedded arc gamma on +[0,H] is defined on a slightly larger parameter neighborhood when required by +local differentiation, and satisfies: + +(F1) gamma(0) is not in Sigma and the FIRST time tau of contact with the CLOSED + Sigma exists, with 00 so [tau-epsilon,tau+epsilon] lies in (0,H), +gamma on that interval stays in one supporting-line chart and in T, its tangential +coordinate lies a positive distance from both endpoints, and its normal derivative +has constant sign with absolute value bounded below. Its signed normal values at +tau-epsilon and tau+epsilon therefore have opposite signs with positive slack. + +The EARLY PREFIX gamma([0,tau-epsilon]) is compact and disjoint from the CLOSED +segment Sigma. Its distance from Sigma is consequently strictly positive. This +is the step that a phrase such as 'all conditions are strict' does not supply: +the whole travelled arc has zero distance to the section at the hit, so it cannot +be used as a separated prefix. Nor may the closed segment be replaced by relint +in this compact-set argument. + +Small C1 perturbations preserve early-prefix separation, endpoint and tube margins, +the normal derivative's sign and lower bound on the terminal interval, and the +opposite signs at its ends. The intermediate-value theorem gives one zero of the +normal coordinate in this interval; strict monotonicity makes it unique. Its +point lies in the relative interior of Sigma. No earlier contact is possible in +the prefix or in the terminal interval before that zero. Thus the continued zero +is still the first CLOSED contact. Later contacts beyond this interval are +irrelevant to this definition. The positive terminal-time slack ensures that the +continued hit is still inside the declared arc domain. + +The zero and hit point are continuous under C1 arc perturbations. If gamma is +Gamma(f,t) with C1 parameter dependence, the scalar implicit-function theorem +applies to n.(Gamma(f,t)-a), and + + d tau_f[h] = - n.(D_f Gamma(f,tau_f)[h]) + / (n.partial_t Gamma(f,tau_f)). (R1a) + +The hit-point derivative follows by the chain rule. This proves R1 and all its +strict-margin variants. The local terminal argument also persists under small +changes of the finite segment endpoints, a fact used for rational approximation +in the coverage proof. Earlier crossings of the SUPPORTING LINE outside Sigma +are allowed; only actual contacts with Sigma are excluded. QED. + +## 4. The actual successor predicate, including every local branch label + +Fix a countable atlas of local-branch field neighborhoods supplied by A2-T. +Here is why it may be fixed countably without assuming a countable norm-dense +subset of X*: for each choice of rational isolating data, its hyperbolic field +locus is an open subspace of the second-countable space X. The local field +neighborhoods of A2-T form an open cover. A countable subcover exists by Lindelof. +Choose one local-branch chart on each selected neighborhood once and for all, +with a fixed compact parameter interval after shrinking if needed. Products of +the two endpoint atlases and the finite branch labels remain countable. + +This is a countable topological atlas, not a computable enumeration of arbitrary +real fields. It is chosen ONCE, not as a measurable 'first chart' depending on a +random realization. Every field is allowed to belong to multiple charts. + +A label chi consists of one such atlas index; SG's rational isolating boxes, +continuation neighborhoods, strict spectral/gradient margins; branch signs; all +local closed rational sections; a central closed rational segment Sigma; a +finite rational polygonal open tube covering the compact regular travel arcs; +finite rational positive parameter/time horizons; and positive rational lower +clearances and speed/normal-angle margins. Keep the endpoint-support neighborhoods +disjoint from the compact interior test subarc as required by A3. + +Define U_chi^rob to be EXACTLY the set of fields satisfying all of the following: + +(P1) The field belongs to the specified local-branch atlas domain and satisfies + the CLOSED-outer-box uniqueness and STRICT spectral/gradient predicate of + Section 2 for each tracked saddle. +(P2) EVERY local branch-label section is met by its specified compact local + germ arc according to (F1)–(F4), with the declared strict margins. The local + arc parameter is a graph coordinate, not physical time from a stationary + saddle. It may start at the saddle, which lies OFF the local section. + There is no positive-flow-speed requirement at that stationary launch. + Its positive-parameter first section hit defines the regular launch point. +(P3) From these regular launch points, the forward unstable and backward stable + flow arcs are defined through their declared finite horizons. EACH meets + the same central CLOSED Sigma by (F1)–(F4), with strict launch/terminal, + endpoint, open-tube, regular-speed and transverse-normal margins. +(P4) Any other section hit used to specify a branch or mismatch is governed by + the SAME conditions. It is not enough to repair only the central section. + Separation of endpoint neighborhoods from the interior test arc is strict. + +Later returns after a first hit are immaterial. No predicate based on 'the first +relative-interior hit while ignoring earlier closed-boundary contacts' is used. +No degenerate field is admitted by overriding an invalid local predicate after +slicing has begun. A degeneracy elsewhere on the torus need not invalidate this +local chart, and the new definition does not say otherwise. + +On U_chi^rob define the mismatch by the ACTUAL robust first-contact points, + + D_chi(f)=s(z_u(f))-s(z_s(f)), (R2a) + +where s is the fixed signed coordinate on central Sigma. This definition is not +a post hoc restriction of the old possibly discontinuous hit map. + +## 5. Openness and C1 regularity of the defined charts + +For P1 the unique saddle continues in a small ball by the nondegenerate-zero +implicit-function theorem. The gradient has a positive minimum on the rest of +the compact outer box outside that ball; small C1 perturbations cannot create a +new zero there. The saddle stays inside its continuation neighborhood and its +index/spectral gap persist under C2 perturbations. On each fixed compact exclusion +set K, |min_K|grad f|-min_K|grad g||<=||grad f-grad g||_infinity, so a STRICT +margin remains strict. No sampled minimum is being substituted for this argument. + +A2-T supplies the local arcs continuously in C1. R1 first continues every local +section hit and hence both regular launch points. Continuous finite-time flow +dependence then supplies both travel arcs. Apply R1 again to the central hits. +Compact travel speed and tube-clearance minima are continuous under uniform arc +and C1 vector-field convergence; their strict bounds persist. There are finitely +many conditions per chart, so a sufficiently small C2 ball preserves all of them. +Therefore U_chi^rob is open. + +Under A2-D the same applications of (R1a), composition, and the chain rule give +C1 launch points, central hit times/points, and D_chi on U_chi^rob. This C1 conclusion +uses A2-D explicitly; the geometric lemma has not proved invariant-manifold +parameter differentiability. Different overlapping charts need not have identical +mismatch functions away from their connection zeros. The slicing argument only +uses each on its own open domain. + +## 6. Countable coverage still includes every genuine connection + +Fix a nondegenerate saddle-to-saddle gradient connection. Choose compactly +separated rational isolating boxes with each saddle the only zero in its outer +box. Choose rational continuation neighborhoods and smaller rational spectral and +gradient thresholds. The required strict minima exist by compactness. + +Choose atlas neighborhoods containing the field for the corresponding local +germs. On each selected branch, choose a small local section through an interior +point of its regular part, transverse to that branch, lying inside the endpoint +neighborhood. Shrink the segment so the earlier compact local germ prefix avoids +its closure; local monotonicity in a graph coordinate then gives first closed +contact in its relative interior. Extend the local parameter interval a little +past the hit. The same construction applies to every label section required. + +The connection's compact regular arc between these launches is embedded: a +repeated point of a nonstationary orbit would be periodic, while f strictly +increases along ascending gradient time. Choose a small central transverse +segment near an interior point. By shrinking it, the two compact earlier travel +prefixes avoid its closure. Their local transverse crossings are of the same +geometric connection, so they hit the central segment at the same point. +Extend both travel arcs a small positive time past that point, away from the +endpoint neighborhoods. An open tubular neighborhood of the compact travelled +arcs has positive clearance, positive regular speed and a central transverse +normal bound. A finite rational polygonal tube may be chosen within it and +around the arcs; a finite coordinate cover handles torus winding. + +All these properties have strict slack. The proof of R1, with segment endpoints +as additional finite-dimensional parameters, shows that close rational segment +endpoints preserve them. Hence the initially chosen local and central sections +can be replaced by rational ones. Rational horizons and smaller positive rational +margins complete a label chi. The field lies in U_chi^rob, and its mismatch is zero. +Thus + + Connection intersect Omega_gen + subset union_chi {f in U_chi^rob:D_chi(f)=0}. (R2b) + +The index set is countable. No realization is asked to select a first chart, +and no measurable-selection or analytic-projection theorem is needed. + +## 7. Countable Gaussian directions without a norm-dense Banach dual + +Let S={x_n} be a fixed countable dense subset of the torus (rational coordinates +after rescaling by L). Let ell_n be point evaluation at x_n, a continuous linear +functional on X, and k_n=Q ell_n in H. For h in H the covariance/RKHS identity is + + _H=ell_n(h)=h(x_n). (R3a) + +If h is orthogonal to every k_n, it vanishes on S. The embedding H -> C2 implies +continuity, so h vanishes everywhere and is the zero vector. Therefore the real +linear span of {k_n} is dense in H. Rational finite linear combinations are also +dense: approximate finitely many real coefficients by rationals in a fixed finite +sum before approximating h by such sums. + +Enumerate all rational finite combinations ell of the ell_n, remove those with +variance v_ell=ell(Qell)=0, and set + + h_ell=Qell/sqrt(v_ell), + xi_ell=ell(f)/sqrt(v_ell), + g_ell=f-xi_ell h_ell. (R3b) + +The h_ell are dense in the unit sphere of H (or merely a countable separating +family would suffice). This construction needs neither X* norm separability nor +a countable dense family in X*. The old dual-density sentence in SG is replaced, +not treated as an extra unproved assumption. + +The scalar xi_ell is standard Gaussian. For any a in X*, + + Cov(a(f),xi_ell)=a(Qell)/sqrt(v_ell)=a(h_ell), + Cov(a(g_ell),xi_ell)=0. (R3c) + +The pair (g_ell,xi_ell) is jointly Gaussian since it is a continuous linear image +of f. The vanishing cross-covariances imply independence. This Banach-valued +independence can be checked on a countable separating family of derivative +point-evaluations and then extended to the Borel sigma algebra. Indeed C2 norm +balls are generated by derivative evaluations of orders at most two on S using +suprema on the countable dense set. No probability measure on a nonseparable +norm-dual is introduced. + +Because H embeds continuously in X, D_chi'(f)|_H is continuous. If it is nonzero, +it cannot vanish on the dense h_ell family. Thus at every charted connection +satisfying the A3–A4 premise, at least one direction has + + D_chi'(f)[h_ell] != 0. (R3d) + +This proves the needed A5 direction/decomposition statement for the new source. +It does not prove A3–A4's nonvanishing premise. + +## 8. A6 applied to these charts, not to an uncorrected predecessor + +Assume A2-D and the A3–A4 premise. For each fixed chi and ell define + + B_chi,ell={f in U_chi^rob:D_chi(f)=0, + D_chi'(f)[h_ell]!=0}. (R4a) + +This is Borel: U_chi^rob is open, and both scalar functions are continuous there. +Fix a residual g in (R3b). The validity set + + I_g={t in R:g+t h_ell in U_chi^rob} + +is open and is a countable disjoint union of open intervals. On each interval +F_g(t)=D_chi(g+t h_ell) is C1. At every zero contributing to B_chi,ell, F_g'(t) is +nonzero. The scalar inverse/implicit-function theorem makes that zero isolated +among the zeros in its interval. Such a subset of R is countable: each point can +be assigned a rational-endpoint isolating interval containing no other zero. +Accumulation at singular zeros or at interval boundaries is allowed and does +not destroy this countability argument. + +The conditional scalar law is standard Gaussian, by the INDEPENDENT residual +construction, so it charges that countable set with probability zero for every +fixed g. The inverse image of (R4a) under (g,t)->g+t h_ell is Borel, so Tonelli +applies to the residual law times the scalar Gaussian law. Hence mu(B_chi,ell)=0. +By (R2b) and (R3d), + + Connection intersect Omega_gen subset union_chi,ell B_chi,ell. + +The union is countable and Borel null. If the connection event itself has not +separately been proved Borel, its immediate conclusion is outer measure zero, +and it is measurable and null in the completed Gaussian probability space. +With the separate assumption mu(Omega_gen)=1 this gives the conditional almost- +sure conclusion. Fields outside Omega_gen along a shift line are not assumed +absent; only the open validity intervals and their regular zeros are used. + +This completes A6's application to the actual successor predicate, CONDITIONAL +on the inputs explicitly stated above. The full C103 or any downstream regional +estimate still requires its own premise and review chain. + +## 9. Boundary examples that the new predicate actually excludes + +The BR torus example is F(x,y)=sin(2pi x)(2-cos(2pi y)). Its two saddles on y=0 +are connected; central Sigma={(1,y):0<=y<=1/200} is first hit at its lower endpoint. +All the old strict speed, gradient and angle margins can hold. Vertical field +translation moves the branch below the segment. The new P3 excludes the unshifted +field because F2 fails. This does not exclude the connection from the UNION of +new charts: a central segment with endpoints on opposite sides of the hit and +smaller positive margins supplies a valid chart. + +Simply replacing the closed segment by its relative interior is not enough. +For a concrete smooth embedded arc on 0<=t<=5/2, use + + gamma_eps(t)=((t-1)(t-2),(t-1)^2+eps), + Sigma={(0,y):0<=y<=2}. + +At eps=0 there is a transverse endpoint contact at t=1 and an interior contact +at t=2. A rule that ignores the first contact and asks only for the first INTERIOR +hit chooses t=2. For every small positive eps it chooses t=1 instead. The arcs +converge in C1, yet that rule is discontinuous. Our F1 sees the earlier closed +contact and F2 rejects its endpoint at eps=0. This is a geometric first-hit +counterexample, not a newly asserted gradient connection on the torus. + +The launch and terminal slacks are independently necessary. On gamma(t)=(t-1,1/2) +for 0<=t<=1, the hit is transverse and interior but at terminal time; shifting +x slightly negative makes it miss the section on that domain. An arc starting +on the section has first contact at zero and is likewise excluded. Compact tube +clearance must include the whole prefix, not merely its hit: a path can leave a +tube and return before a good transverse hit. Every local label is checked, since +a discontinuous local launch would invalidate even a well-behaved central hit. + +## 10. What the finite controls can and cannot establish + +The standard-library program tests rational piecewise-affine paths against a +closed vertical segment and an open rectangular tube. It certifies only that +finite model and is deliberately stricter at polyline corners than the smooth +lemma: its transverse hit must lie inside one affine piece. It neither samples +an ODE nor certifies arbitrary fields' gradient minima, stable manifolds or +infinite-dimensional chart membership. + +Tests exercise the real endpoint/earlier-contact/terminal/tube/local-label +failures, strict scalar gradient margins, rational moving-hit models, the smooth +polynomial first-interior counterexample, exact finite Gaussian covariance +splitting, finite evaluation rank, and exclusion of singular slicing zeros. +Semantic mutants independently remove each important condition. The tests do +not substitute for R1's compact-prefix argument, the infinite-dimensional RKHS +density proof, A2 regularity or the Tonelli measurability argument. + +The current proof is an additive source-level alternative. Independent review +must decide the R1/R2/R3/R4 claims at their exact dependency scope. Publishing it, +passing its tests or merging it as a candidate does not flip the predecessor's +AMEND, assert an independently closed A2–A4 chain, or promote C103. diff --git a/frontiers/sard_g_robust_charts_20260929/README.md b/frontiers/sard_g_robust_charts_20260929/README.md new file mode 100644 index 000000000..c4746231f --- /dev/null +++ b/frontiers/sard_g_robust_charts_20260929/README.md @@ -0,0 +1,30 @@ +# SARD-G: the missing robust first-contact source application + +Author-side interface repair, nonauthor analytic review required. Scientific effect NONE. + +[PROOF.md](PROOF.md) supplies an actual successor predicate at every local and +central section. It proves first CLOSED contact persistence using an early compact +prefix and a transverse terminal interval, retains endpoint/time/open-tube margins, +and supplies countable chart coverage. The original AMEND texts are untouched. + +It also replaces the unneeded norm-dense Banach-dual construction by rational +finite combinations of dense point evaluations, whose covariance images are dense +in the Cameron–Martin space. Gaussian independence and Borel/regular-zero slicing +are then proved on the corrected charts. + +A2-T (local-branch continuity) and A2-D (C1 parameter regularity) are DISTINCT named +premises. The conditional slicing conclusion also needs the original A3–A4 +nonvanishing input and the separate generic full-measure input. This packet does +not certify those inputs, any C103 regional estimate, RN/JETMOD or a 3D theorem. + +Run from this directory: + + python -B -S verify.py --output /path/to/new-output + python -B -O -S verify.py --output /path/to/other-new-output + +Each invocation runs 19 finite tests and rejects 8 semantic mutants in BOTH modes. +The polyline checker is a finite illustration, not a numerical field-membership +algorithm; hits at polyline corners are deliberately not certified. No sampled +gradient minimum is asserted to be a continuum certificate. The executable +verifies this exact flat source packet but does not fetch or replay upstream +proofs. SOURCE_MAP.json pins those separately read sources. diff --git a/frontiers/sard_g_robust_charts_20260929/RECONNAISSANCE.md b/frontiers/sard_g_robust_charts_20260929/RECONNAISSANCE.md new file mode 100644 index 000000000..4be5c9d34 --- /dev/null +++ b/frontiers/sard_g_robust_charts_20260929/RECONNAISSANCE.md @@ -0,0 +1,25 @@ +# Dependency-focused reconnaissance — 29 September 2026 + +The exact SG/BR/RI project sources were read through the GitHub connector. The +new source applies Harper's geometric proposal and supplies the missing early- +prefix proof; it does not claim invention of transverse-hit persistence, RKHS +reproducing identities, Gaussian regression, Lindelof countability or Tonelli. + +Primary-source records read in this pass: + +- Martin Hairer, An Introduction to Stochastic PDEs, arXiv:0907.4178v2 (2023 + revision). https://arxiv.org/abs/0907.4178 . Abstract and version record only, + not a full-text theorem import. The direction/decomposition proof is displayed + directly in this packet rather than inferred from that abstract. +- C. M. Judd, P. Collins, B. Krauskopf, H. M. Osinga, Tangency bifurcations of + global Poincare maps, University of Bristol working-paper record (2007). + https://research-information.bris.ac.uk/en/publications/tangency-bifurcations-of-global-poincare-maps/ + Abstract-level context: global sections can give discontinuous or undefined + return maps despite the local transverse theorem. Its full proof was not read + and no claim here is imported from it. + +The broader search also located MIT's Poincare-section lecture notes, but those +notes were not consumed at theorem level. No new Consensus call was made in this +pass; the preceding pass recorded its monthly quota limit. None of these discovery +records is represented as a new analytic review, exhaustive novelty audit, or +proof of invariant-manifold differentiability at the exact C2 topology. diff --git a/frontiers/sard_g_robust_charts_20260929/RESULTS.json b/frontiers/sard_g_robust_charts_20260929/RESULTS.json new file mode 100644 index 000000000..76c28f9fb --- /dev/null +++ b/frontiers/sard_g_robust_charts_20260929/RESULTS.json @@ -0,0 +1,8 @@ +{ + "tests_per_mode": 19, + "semantic_mutants_per_mode": 8, + "identical_output_pairs": 9, + "all_intended_failures": true, + "scientific_effect": "NONE", + "continuum_proof_verified_by_code": false +} diff --git a/frontiers/sard_g_robust_charts_20260929/SOURCE_FILES.json b/frontiers/sard_g_robust_charts_20260929/SOURCE_FILES.json new file mode 100644 index 000000000..a2f72b0cf --- /dev/null +++ b/frontiers/sard_g_robust_charts_20260929/SOURCE_FILES.json @@ -0,0 +1,53 @@ +{ + "schema": 1, + "files": [ + { + "path": "PROOF.md", + "bytes": 25022, + "sha256": "b91b9f792c6322204a0f2a573b2ca76d5c951e49ddd7caa6ffd1abed0aa79e79", + "git_blob": "7e2237063a8dd0120e9d5bd15a3caaa32e8495fa" + }, + { + "path": "README.md", + "bytes": 1693, + "sha256": "71e5a4c08e9daa08e331e735a3e7f8c0409da0d4821b70cdd65b573a0d46a387", + "git_blob": "c4746231fa43e1ccd754e2d5f3277b5e268e7aea" + }, + { + "path": "RECONNAISSANCE.md", + "bytes": 1577, + "sha256": "f6aeb058052b74a5ef00e893b383b1da9cab78e2e2a95174d9c57f8eca9cbfaa", + "git_blob": "4be5c9d348d884a75bff3f75026f97c530b4a86b" + }, + { + "path": "RESULTS.json", + "bytes": 201, + "sha256": "29c96c87073f800fd9104914ab3b2d0625b03bb28ec935ad1b8e09c6704d12ae", + "git_blob": "76c28f9fbe16ba456e431f8dc0866042bc6ee8d4" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 1644, + "sha256": "f248f92eca8cfd39f56ff26b23512be4fb14855105e45888d92a13586a5bd03f", + "git_blob": "bcf52b3cd64ab80f7338776888a996f6a6061d1f" + }, + { + "path": "charts.py", + "bytes": 4931, + "sha256": "99270bf5959a8534eb53306f572843a3c8d1e89bb669b68bce1a70621aaae74f", + "git_blob": "4096b52c98ae54a8d02753688584d3b2c83a72bc" + }, + { + "path": "test_charts.py", + "bytes": 4515, + "sha256": "8b03e49bc885c6bbac392e4bcf23bbf6a2ba20684856eb0bb10b83cec8214644", + "git_blob": "79a28fe42be24cb17512b01c240384ff5f555f8b" + }, + { + "path": "verify.py", + "bytes": 4688, + "sha256": "4f0b32879d1502dfdb95b3892e5e7cfa91a7deb3b8e6974e0d98021238791064", + "git_blob": "d83f30056f3453f077a68bc120bf63b3fc1aa64e" + } + ] +} diff --git a/frontiers/sard_g_robust_charts_20260929/SOURCE_MAP.json b/frontiers/sard_g_robust_charts_20260929/SOURCE_MAP.json new file mode 100644 index 000000000..bcf52b3cd --- /dev/null +++ b/frontiers/sard_g_robust_charts_20260929/SOURCE_MAP.json @@ -0,0 +1,39 @@ +{ + "scientific_effect": "NONE", + "sources": [ + { + "id": "SG", + "repository": "d6g8k5htny-coder/main", + "commit": "a1fc9581291b6f81c76c903c96a13955b51f8d54", + "path": "research/q0/sard_g/SARD_G_EXECUTION_REPAIR_20260925.md", + "git_blob": "8f86e0c9ef91fde473e2344a3e461c31f63f8529", + "use": "Explicit predecessor predicate and conditional A2–A4; new source replaces chart/direction/slicing application, not the original file." + }, + { + "id": "BR", + "repository": "d6g8k5htny-coder/main", + "commit": "f43f243c54e12c63fc2c23c89c5b2998766f21b7", + "path": "reviews/sard_g_successor_a1_a6_20260926/REVIEW.md", + "git_blob": "9fc61b47c2b4c4bcc3898a6c61a6dcf9cbe1d136", + "use": "Exact AMEND, endpoint and early-contact boundaries, completed-measure qualification, and no dual-separability assumption." + }, + { + "id": "RI", + "repository": "d6g8k5htny-coder/Math-", + "commit": "0b0b281989db62ccf3ff5e1327df6f9efda073ea", + "path": "incoming/grok-cycle4-20260926/harper/SARD_G_A1_RELATIVE_INTERIOR_LEMMA.md", + "git_blob": "0ee24f953a4402e58c97ac6d3897eb80d17513a9", + "use": "Harper robust first-interior-hit proposal, now explicitly applied in P1–P4 with a full early-prefix proof." + } + ], + "unproved_here": [ + "A2-T local branch C1-arc continuity", + "A2-D C1 dependence in C2 field topology", + "A3–A4 directional nonvanishing", + "generic full-measure premise", + "C103 regional Kac–Rice estimates" + ], + "upstream_bytes_locally_replayed": false, + "new_nonauthor_review_required": true, + "existing_status_changed": false +} diff --git a/frontiers/sard_g_robust_charts_20260929/charts.py b/frontiers/sard_g_robust_charts_20260929/charts.py new file mode 100644 index 000000000..4096b52c9 --- /dev/null +++ b/frontiers/sard_g_robust_charts_20260929/charts.py @@ -0,0 +1,112 @@ +"""Exact finite first-contact and Gaussian-slicing illustrations. + +Polyline controls are stricter than the smooth-arc theorem: a certified hit must +lie inside a single affine piece. This is not a numerical ODE or SARD-G verifier. +""" +from fractions import Fraction as F + +MUTANT=None + +def _data(path, section): + pts=[tuple(F(v) for v in p) for p in path] + lo,hi=map(F,section) + if len(pts)<2 or any(len(p)!=3 for p in pts) or not lo=q[0] for p,q in zip(pts,pts[1:])): + raise ValueError('path times must start at zero and increase strictly') + return pts,lo,hi + +def closed_contacts(path,section): + """All first-contact candidates with the CLOSED vertical segment x=0.""" + pts,lo,hi=_data(path,section);hits=[] + for i,(p,q) in enumerate(zip(pts,pts[1:])): + t0,x0,y0=p;t1,x1,y1=q + if x1!=x0: + u=-x0/(x1-x0) + if 0<=u<=1 and lo<=y0+u*(y1-y0)<=hi: + hits.append(dict(time=t0+u*(t1-t0),height=y0+u*(y1-y0), + speed=(x1-x0)/(t1-t0),interior_piece=0margin:return False + if MUTANT!='allow-terminal' and not pts[-1][0]-tau>margin:return False + endpoint_ok= min(height-lo,hi-height)>margin + if MUTANT=='allow-endpoint':endpoint_ok=min(height-lo,hi-height)>=margin + if not endpoint_ok:return False + inside_piece=h['interior_piece'] + if MUTANT=='allow-terminal' and tau==pts[-1][0]:inside_piece=True + if not inside_piece or not abs(h['speed'])>margin:return False + prefix=[(p[1],p[2]) for p in pts if p[0]margin for x,y in prefix):return False + return True + +def chart_hits(paths,section,tube): + paths=list(paths) + if not paths:raise ValueError('at least one declared hit required') + if MUTANT=='skip-local':paths=paths[-1:] + return all(robust_hit(p,section,tube) for p in paths) + +def gradient_slack(minimum,eta): + minimum,eta=F(minimum),F(eta) + if eta<=0:raise ValueError('positive exclusion threshold required') + return minimum>=eta if MUTANT=='nonstrict-gradient' else minimum>eta + +def gaussian_split(Q,a): + """Rational unstandardized form: xi=a.F, b=Qa/Var(xi), g=F-b xi.""" + a=list(map(F,a));Q=[list(map(F,row)) for row in Q];n=len(a) + if n==0 or len(Q)!=n or any(len(row)!=n for row in Q): + raise ValueError('matching square covariance and vector required') + if any(Q[i][j]!=Q[j][i] for i in range(n) for j in range(n)): + raise ValueError('symmetric covariance required') + v=[sum((Q[i][j]*a[j] for j in range(n)),F(0)) for i in range(n)] + var=sum((a[i]*v[i] for i in range(n)),F(0)) + if var<=0:raise ValueError('positive scalar variance required') + b=[x/var for x in v] + R=[[Q[i][j]-(0 if MUTANT=='leave-covariance' else v[i]*v[j]/var) + for j in range(n)] for i in range(n)] + return var,b,R + +def rank(A): + M=[list(map(F,row)) for row in A] + if not M:return 0 + if any(len(row)!=len(M[0]) for row in M):raise ValueError('rectangular matrix required') + k=0 + for j in range(len(M[0])): + pivot=next((i for i in range(k,len(M)) if M[i][j]),None) + if pivot is None:continue + M[k],M[pivot]=M[pivot],M[k] + z=M[k][j];M[k]=[v/z for v in M[k]] + for i in range(k+1,len(M)): + z=M[i][j];M[i]=[v-z*w for v,w in zip(M[i],M[k])] + k+=1 + if k==len(M):break + return k + +def regular_zero(coefficients,x): + coeff=list(map(F,coefficients));x=F(x) + value=sum((a*x**i for i,a in enumerate(coeff)),F(0)) + deriv=sum((i*coeff[i]*x**(i-1) for i in range(1,len(coeff))),F(0)) + return value==0 and (True if MUTANT=='count-singular-zero' else deriv!=0) diff --git a/frontiers/sard_g_robust_charts_20260929/test_charts.py b/frontiers/sard_g_robust_charts_20260929/test_charts.py new file mode 100644 index 000000000..79a28fe42 --- /dev/null +++ b/frontiers/sard_g_robust_charts_20260929/test_charts.py @@ -0,0 +1,104 @@ +"""Exact finite illustrations. They do not verify any infinite-dimensional premise.""" +from fractions import Fraction as F +import unittest +import charts as c + +SECTION=(F(0),F(1)) +TUBE=(-3,3,-2,3) +GOOD=[(0,-1,F(1,2)),(2,1,F(1,2))] + +class ChartTests(unittest.TestCase): + def test_endpoint_hit_excluded(self): + self.assertFalse(c.robust_hit([(0,-1,0),(2,1,0)],SECTION,TUBE)) + + def test_earlier_endpoint_not_hidden_by_later_interior(self): + path=[(0,-1,-1),(2,1,1),(3,1,F(1,2)),(5,-1,F(1,2))] + self.assertFalse(c.robust_hit(path,SECTION,TUBE)) + self.assertEqual(c.closed_contacts(path,SECTION)[0]['time'],1) + + def test_terminal_hit_excluded(self): + self.assertFalse(c.robust_hit([(0,-1,F(1,2)),(1,0,F(1,2))],SECTION,TUBE)) + + def test_launch_on_section_excluded(self): + self.assertFalse(c.robust_hit([(0,0,F(1,2)),(2,1,F(1,2))],SECTION,TUBE)) + + def test_compact_prefix_tube_clearance(self): + path=[(0,-1,F(1,2)),(1,-1,4),(2,-1,F(1,2)),(4,1,F(1,2))] + self.assertFalse(c.robust_hit(path,SECTION,TUBE)) + + def test_tube_boundary_excluded(self): + path=[(0,-3,F(1,2)),(4,1,F(1,2))] + self.assertFalse(c.robust_hit(path,SECTION,TUBE)) + + def test_strict_gradient_threshold(self): + self.assertFalse(c.gradient_slack(F(1),F(1))) + self.assertTrue(c.gradient_slack(F(3,2),F(1))) + + def test_transverse_corner_not_certified(self): + path=[(0,-1,F(1,2)),(1,0,F(1,2)),(2,-1,F(1,2))] + self.assertFalse(c.robust_hit(path,SECTION,TUBE)) + + def test_robust_interior_family(self): + for eps in [F(i,100) for i in range(-20,21)]: + p=[(0,-1,F(1,2)+eps),(2,1,F(1,2)+eps)] + self.assertTrue(c.robust_hit(p,SECTION,TUBE)) + self.assertEqual(c.closed_contacts(p,SECTION)[0]['time'],1) + + def test_hitting_time_continuity_model(self): + for eps in (F(-1,8),F(0),F(1,8)): + p=[(0,-1+eps,F(1,2)),(2,1+eps,F(1,2))] + self.assertTrue(c.robust_hit(p,SECTION,TUBE)) + self.assertEqual(c.closed_contacts(p,SECTION)[0]['time'],1-eps) + + def test_earlier_collinear_contact_excluded(self): + p=[(0,0,-1),(2,0,1),(3,1,F(1,2)),(5,-1,F(1,2))] + self.assertFalse(c.robust_hit(p,SECTION,TUBE)) + self.assertEqual(c.closed_contacts(p,SECTION)[0]['time'],1) + + def test_relative_interior_only_time_jumps(self): + # Smooth embedded gamma(t)=((t-1)(t-2),(t-1)^2+eps), roots at1,2. + for eps in (F(0),F(1,100),F(1,10000)): + interior=[t for t in (1,2) if 0<(t-1)**2+eps<2] + self.assertEqual(min(interior),2 if eps==0 else 1) + self.assertEqual(min(t for t in (1,2) if 0<=(t-1)**2+eps<=2),1) + + def test_gaussian_residual_orthogonality(self): + Q=[[F(2),F(1)],[F(1),F(3)]];a=[F(1),F(2)] + var,b,R=c.gaussian_split(Q,a) + self.assertEqual(var,18) + self.assertEqual(sum(x*y for x,y in zip(a,b)),1) + self.assertEqual([sum(row[j]*a[j] for j in range(2)) for row in R],[0,0]) + for i in range(2): + for j in range(2): + self.assertEqual(R[i][j]+var*b[i]*b[j],Q[i][j]) + + def test_degenerate_gaussian_direction_rejected(self): + with self.assertRaises(ValueError):c.gaussian_split([[1,1],[1,1]],[1,-1]) + + def test_distinct_evaluations_span_polynomials(self): + for n in range(1,7): + V=[[F(i)**j for j in range(n)] for i in range(n)] + self.assertEqual(c.rank(V),n) + self.assertEqual(c.rank(V+[V[0]]),n) + + def test_regular_zeros_only(self): + # p(t)=t(t-1)^2; the zero at1 has derivative0. + self.assertTrue(c.regular_zero([0,1,-2,1],0)) + self.assertFalse(c.regular_zero([0,1,-2,1],1)) + self.assertFalse(c.regular_zero([0,1,-2,1],2)) + + def test_all_local_sections_checked(self): + bad=[(0,-1,0),(2,1,0)] + self.assertFalse(c.chart_hits([bad,GOOD],SECTION,TUBE)) + self.assertTrue(c.chart_hits([GOOD,GOOD],SECTION,TUBE)) + + def test_positive_quantitative_margins(self): + self.assertTrue(c.robust_hit(GOOD,SECTION,TUBE,margin=F(1,4))) + self.assertFalse(c.robust_hit(GOOD,SECTION,TUBE,margin=F(1,2))) + + def test_invalid_path_and_section(self): + with self.assertRaises(ValueError):c.robust_hit([(0,-1,0),(0,1,0)],SECTION,TUBE) + with self.assertRaises(ValueError):c.robust_hit(GOOD,(1,0),TUBE) + with self.assertRaises(ValueError):c.robust_hit(GOOD,SECTION,TUBE,margin=F(-1)) + +if __name__=='__main__':unittest.main() diff --git a/frontiers/sard_g_robust_charts_20260929/verify.py b/frontiers/sard_g_robust_charts_20260929/verify.py new file mode 100644 index 000000000..d83f30056 --- /dev/null +++ b/frontiers/sard_g_robust_charts_20260929/verify.py @@ -0,0 +1,95 @@ +"""Verify exact packet membership, both Python modes and intended semantic failures.""" +import argparse +import hashlib +import io +import json +from pathlib import Path +import subprocess +import sys +import unittest + +ROOT=Path(__file__).resolve().parent +MUTANTS={ + 'allow-endpoint':'test_endpoint_hit_excluded', + 'ignore-earlier-closed':'test_earlier_endpoint_not_hidden_by_later_interior', + 'allow-terminal':'test_terminal_hit_excluded', + 'skip-tube':'test_compact_prefix_tube_clearance', + 'skip-local':'test_all_local_sections_checked', + 'nonstrict-gradient':'test_strict_gradient_threshold', + 'leave-covariance':'test_gaussian_residual_orthogonality', + 'count-singular-zero':'test_regular_zeros_only', +} + +def require(ok,message): + if not ok:raise ValueError(message) + +def decode(text): + def unique(pairs): + d={} + for k,v in pairs: + require(k not in d,'duplicate JSON key: '+k);d[k]=v + return d + return json.loads(text,object_pairs_hook=unique) + +def identity(path): + require(path.is_file() and not path.is_symlink(),'regular source required') + data=path.read_bytes() + return dict(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') + rows=decode((ROOT/'SOURCE_FILES.json').read_text())['files'] + names=[row['path'] for row in rows] + require(len(names)==len(set(names)) and all(Path(n).name==n and n!='SOURCE_FILES.json' for n in names), + 'unique flat manifest paths required') + require(sorted(p.name for p in ROOT.iterdir())==sorted(names+['SOURCE_FILES.json']), 'source membership differs') + for row in rows: + require(identity(ROOT/row['path'])=={k:row[k] for k in ('bytes','sha256','git_blob')}, + 'source identity differs: '+row['path']) + return {p.name:identity(p) for p in sorted(ROOT.iterdir())} + +def child(mutant): + import charts,test_charts + charts.MUTANT=mutant + result=unittest.TextTestRunner(stream=io.StringIO()).run(unittest.defaultTestLoader.loadTestsFromModule(test_charts)) + print(json.dumps(dict(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(out): + out=out.resolve() + require(not out.exists() and not out.is_relative_to(ROOT),'new output outside packet required') + before=sources();out.mkdir(parents=True);records={} + 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) + (out/(case+'_'+mode+'.stdout')).write_bytes(run.stdout) + (out/(case+'_'+mode+'.stderr')).write_bytes(run.stderr) + obj=decode(run.stdout.decode()) + require(not run.stderr and not obj['errors'],'execution error: '+case) + require(obj['tests']==19,'wrong test count') + if case=='baseline':require(run.returncode==0 and obj['passed'] and not obj['failures'],'baseline failed') + else:require(run.returncode==1 and not obj['passed'] and MUTANTS[case] in obj['failures'], + 'intended semantic assertion absent: '+case) + pair.append(run.stdout) + require(pair[0]==pair[1],'Python modes disagree: '+case) + records[case]=decode(pair[0].decode()) + summary=dict(tests_per_mode=19,semantic_mutants_per_mode=8,identical_output_pairs=9, + all_intended_failures=True,scientific_effect='NONE',continuum_proof_verified_by_code=False) + require(summary==decode((ROOT/'RESULTS.json').read_text()),'stored summary differs') + require(before==sources(),'source changed during replay') + (out/'REPORT.json').write_text(json.dumps(dict(summary=summary,cases=records,source_identities=before),indent=2,sort_keys=True)+'\n') + print(json.dumps(summary,indent=2,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);a=p.parse_args() + require(a.child or a.mutant is None,'mutant requires child mode') + raise SystemExit(child(a.mutant) if a.child else replay(a.output))