Remote inverse separation: sharp power-two boundary and negative moment asymptotics

.github/workflows/remote-inverse-separation.yml

@@ -0,0 +1,33 @@
+name: Remote inverse-separation finite controls
+
+'on':
+  pull_request:
+    paths:
+      - 'frontiers/remote_inverse_separation_20260928/**'
+      - '.github/workflows/remote-inverse-separation.yml'
+  push:
+    branches: [main]
+    paths:
+      - 'frontiers/remote_inverse_separation_20260928/**'
+      - '.github/workflows/remote-inverse-separation.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  exact-inverse-separation:
+    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: Verify exact packet and both-mode intended negatives
+        run: |
+          set -euo pipefail
+          python -B -S frontiers/remote_inverse_separation_20260928/verify.py --output "${RUNNER_TEMP}/inverse-separation-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}"
+          git diff --exit-code

frontiers/remote_inverse_separation_20260928/README.md

@@ -0,0 +1,26 @@
+# Remote inverse separation — author-side mathematical candidate
+
+[PROOF.md](PROOF.md) extends the microscopic moment law to -2<p<1 and proves a
+fixed-r positive diagonal intensity j_r(delta)~J_r delta. Inverse-separation
+moments are finite exactly below power2, with logarithmic divergence at2.
+The scaled factorial-pair separation has small-value probability asymptotic to
+(J_0/(2A_0))epsilon^2, and its finite inverse moments converge. No event-conditioned
+pair sampling, persistence-partner law, same-index threshold, shrinking rho,
+or arbitrary coupled-cutoff limit is asserted.
+
+Scientific effect NONE. Source-bound nonauthor analytic review is required.
+The note uses the original RP pair-law source; it does not duplicate or discharge
+RD's pending positive-distance moment transition. Its code is a new finite
+power/threshold companion, not a recovery of any unavailable author executable.
+
+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
+
+Both entries run12 tests and8 semantic negatives in EACH Python mode, checking
+flat source membership, bytes, SHA256/Git identities and intended assertion
+failures. Output must be new and outside the packet. These finite controls do
+not prove the Gaussian support, conditioning, Kac-Rice or limiting arguments.
+SOURCE_MAP.json pins the analytic inputs but the packet runner does not replay
+or independently validate those complete upstream manuscripts.

frontiers/remote_inverse_separation_20260928/RECONNAISSANCE.md

@@ -0,0 +1,28 @@
+# Dependency-focused primary-source reconnaissance — 28 September 2026
+
+Read scope: primary arXiv abstract records and author institutional metadata;
+not a full-text novelty audit or a claim of historical priority.
+
+- Jean-Marc Azaïs and Céline Delmas, *Mean number and correlation function of
+  critical points of isotropic Gaussian fields and some results on GOE random
+  matrices*, arXiv:1911.02300, https://arxiv.org/abs/1911.02300 . The paper already
+  treats dimension-dependent short-range correlations and adjacent-index
+  attraction. The underlying collision mechanism is not claimed as a new
+  invention. The present theorem keeps a particular pinned full-determinant
+  tilt and a shrinking height window on a fixed remote region; those hypotheses
+  must be proved rather than attributed to the abstract.
+- Stephen Muirhead, *A second moment bound for critical points of planar Gaussian
+  fields in shrinking height windows*, arXiv:1901.11336,
+  https://arxiv.org/abs/1901.11336 . Published in Statistics & Probability Letters
+  160 (2020), article108698, as confirmed by the author's Monash publication
+  record. This is relevant shrinking-window context, not a direct assertion of
+  the inverse-separation threshold under this conditioned law.
+
+The new argument is a source-consumer extension of the exact RP/RM/RC manuscripts
+listed in SOURCE_MAP.json. The gradient-only fixed-r frame and the value-divided
+r-blow-up frame are deliberately separated. No external abstract is used as a
+substitute for a covariance floor or a weighted Kac-Rice theorem.
+
+Consensus's monthly quota was exhausted earlier in this same campaign. No new
+Consensus result or full-text read is claimed in this continuation. Broad search
+would be required before any novelty or first-discovery assertion.

frontiers/remote_inverse_separation_20260928/RESULTS.json

@@ -0,0 +1,8 @@
+{
+  "tests_per_mode": 12,
+  "semantic_mutants_per_mode": 8,
+  "identical_output_pairs": 9,
+  "all_intended_failures": true,
+  "scientific_effect": "NONE",
+  "continuum_analysis_verified_by_code": false
+}

frontiers/remote_inverse_separation_20260928/SOURCE_FILES.json

@@ -0,0 +1,54 @@
+{
+  "schema": 1,
+  "scientific_effect": "NONE",
+  "files": [
+    {
+      "path": "PROOF.md",
+      "bytes": 18054,
+      "sha256": "95a9aa75e4a254a8f50efc16ee00a78a2ea1481f4013a708dfcbb77dcad4c393",
+      "git_blob": "1b24d0f6d07f84706a0a8e9b25e111e6eff93a2b"
+    },
+    {
+      "path": "README.md",
+      "bytes": 1502,
+      "sha256": "5213369ccafd2cc65992a181eca9d30d874e8ad5c2445516a56bef0fc4b5d06b",
+      "git_blob": "83167187c809f7cb6723bea8369dc29a2eaf8f73"
+    },
+    {
+      "path": "RECONNAISSANCE.md",
+      "bytes": 1795,
+      "sha256": "51d0f1132965fb0f0e2207b85a9f23835e9cda078c9784a0da5cfe2a82ade67a",
+      "git_blob": "1e67139c1cf90edc5c72c282a46294f2e68d1386"
+    },
+    {
+      "path": "RESULTS.json",
+      "bytes": 204,
+      "sha256": "21578b27a2fdd655c0cff256c26bd76babb5661ae7df79e56009ce3965e719bb",
+      "git_blob": "c67569f164239d6af1299a8c5112a9ee092cc962"
+    },
+    {
+      "path": "SOURCE_MAP.json",
+      "bytes": 2384,
+      "sha256": "54b2259bb54430391b5ff9529003beec4fa39186c6440f3de9cae0184c0814b1",
+      "git_blob": "e6a9299daed339e4ec30e99816950398b785c705"
+    },
+    {
+      "path": "inverse.py",
+      "bytes": 2446,
+      "sha256": "e37c380eafcafad1dd815f3ecebd47b1fa9e41be93f5bd5ffe8dfbe2311ec175",
+      "git_blob": "d63833225f11715270889a0093da7c3313b9754e"
+    },
+    {
+      "path": "test_inverse.py",
+      "bytes": 3590,
+      "sha256": "ff421fac99b83f0434af293968676c151b144c97edca8a69c21805fd0961d49e",
+      "git_blob": "3c22788edd413151797196e9224bea5aa8935cc3"
+    },
+    {
+      "path": "verify.py",
+      "bytes": 4860,
+      "sha256": "21b54f9156096d6c0cecb1d521474ab8c5c3b51ad817f5889cd6f617c24bf060",
+      "git_blob": "d74dd57fd6dfd1c2ff104d9b3728ea5e0ab85a45"
+    }
+  ]
+}

frontiers/remote_inverse_separation_20260928/SOURCE_MAP.json

@@ -0,0 +1,52 @@
+{
+  "scientific_effect": "NONE",
+  "source_repository": "d6g8k5htny-coder/Math-",
+  "sources": [
+    {
+      "id": "RM",
+      "commit": "5a5b97d2c518dd5c04c89d17029ec96e721d3b78",
+      "path": "frontiers/remote_window_20260924/PROOF.md",
+      "bytes": 18355,
+      "sha256": "a332bae9bdc0106ce17047f7e0409cc3d94eb610a0c7b74ba5ba2d01a1620cb7",
+      "git_blob": "b383bfcc88ec4ad497dff01fb6640e429ba24a84",
+      "use": "Exact law, weighted Kac-Rice/field marks, conditional moments and full normalizer."
+    },
+    {
+      "id": "RC",
+      "commit": "5a5b97d2c518dd5c04c89d17029ec96e721d3b78",
+      "path": "frontiers/remote_collision_20260928/PROOF.md",
+      "bytes": 26002,
+      "sha256": "b9b8b58fd8266db7ffe6537078003888ef138b445d3289ec5588f116af9050c2",
+      "git_blob": "7b48a88e2af54e759e89a8c8219573bb450a65ea",
+      "use": "Pair Kac-Rice, collision regression floor and moments, separated-pair bound."
+    },
+    {
+      "id": "RP",
+      "commit": "0507e3a1dbd3dede84cbeb805947c70aa16ebc36",
+      "path": "frontiers/window_multiplicity_laws_20260928/REMOTE_PAIR_LAW.md",
+      "bytes": 15878,
+      "sha256": "b818a11f1abcf37616d592ecda6341b0d99365cf3ac5047bc2dbaede95da4c5e",
+      "git_blob": "3fb602040b37158b16ba61bdfc62cc8df1ccc616",
+      "use": "Blown-up L1 density and determinant limits, fixed-Borel translation, exact A0 and sampling convention.",
+      "review": "Math-#116 comment5880900642, Anthropic analytic review; published review-code packet separate."
+    },
+    {
+      "id": "RD",
+      "role": "comparison_only_not_consumed",
+      "commit": "0507e3a1dbd3dede84cbeb805947c70aa16ebc36",
+      "path": "frontiers/window_multiplicity_laws_20260928/REMOTE_DISTANCE_MOMENTS.md",
+      "bytes": 11097,
+      "sha256": "b40dc67a0c4760d3db796914bdc50cbbd5fd1371786772fa919a3a100467b41d",
+      "git_blob": "d077743b7fda8b1bb2e1bafdab97d01bb9e321b1",
+      "use": "Only identifies the prior p>=0 scope. Its p=1 transition and upper tail are not premises."
+    }
+  ],
+  "new_obligations": [
+    "Fixed-r gradient-only collision coefficient and positive support",
+    "Height-indicator convergence and arbitrary fixed-Borel radial asymptotic",
+    "Contact matching J_r/r^3 and inverse-moment weighted domination"
+  ],
+  "blocked_executable_consumed_or_retried": false,
+  "upstream_full_replay_by_packet_runner": false,
+  "nonauthor_acceptance": false
+}

frontiers/remote_inverse_separation_20260928/inverse.py

@@ -0,0 +1,66 @@
+"""Exact scalar companions; not a Gaussian covariance or Kac-Rice verifier."""
+from fractions import Fraction as F
+
+MUTANT = None
+
+def gradient_density_power(d: int) -> int:
+    if type(d) is not int or d<2:
+        raise ValueError('fixed integer dimension at least two required')
+    return -(d+3) if MUTANT=='height-jacobian-in-gradient-frame' else -d
+
+def radial_power(d: int) -> int:
+    determinants=0 if MUTANT=='drop-soft-determinants' else 2
+    return d-1+gradient_density_power(d)+determinants
+
+def envelope_integral(p: F) -> F:
+    p=F(p)
+    if not -2<p<1:
+        raise ValueError('weighted envelope requires -2<p<1')
+    return 1/(p+2)+1/(1-p)
+
+def overlap_coefficient(p: F) -> F:
+    p=F(p)
+    if p<=-2:
+        raise ValueError('origin integral requires p>-2')
+    numerator=1 if MUTANT=='lose-overlap-three' else 3
+    return numerator/((p+2)*(p+5))
+
+def moment_finite(p: F) -> bool:
+    return F(p)>=-2 if MUTANT=='include-divergent-endpoint' else F(p)>-2
+
+def inverse_cutoff(q: int, lo: F, hi: F):
+    if type(q) is not int or q<0 or not F(0)<lo<hi:
+        raise ValueError('nonnegative integer inverse power and 0<lo<hi required')
+    if q==2:
+        return {'kind':'log','ratio':hi/lo,'coefficient':F(1)}
+    return (hi**(2-q)-lo**(2-q))/(2-q)
+
+def small_cdf_coefficient(J: F, A: F) -> F:
+    if J<=0 or A<=0:
+        raise ValueError('positive intensity and mass required')
+    return J/A if MUTANT=='lose-cdf-half' else J/(2*A)
+
+def fold_data(delta: F, T: F, transverse: list[F]) -> dict:
+    if delta<=0 or not transverse:
+        raise ValueError('positive separation and nonempty transverse block required')
+    detA=F(1)
+    for a in transverse:detA*=a
+    gradient=lambda x:[T*x*x/2-T*delta*x/2]+[F(0)]*len(transverse)
+    value=lambda x:T*x**3/6-T*delta*x*x/4
+    left=-T*delta*detA/2;right=T*delta*detA/2
+    gap=value(delta)-value(F(0))
+    if MUTANT=='reverse-height-sign':gap=-gap
+    return {'gradients':(gradient(F(0)),gradient(delta)),
+            'height_difference':gap,'determinants':(left,right),
+            'absolute_product':abs(left*right)}
+
+def height_width_power() -> int:
+    return 6 if MUTANT=='two-height-windows-at-fixed-r' else 3
+
+def microscopic_power(p: F) -> F:
+    return F(5)+F(p)
+
+def pair_weight(n: int) -> int:
+    if type(n) is not int or n<0:
+        raise ValueError('nonnegative integer count required')
+    return int(n>=2) if MUTANT=='event-not-factorial-weight' else n*(n-1)

frontiers/remote_inverse_separation_20260928/test_inverse.py

@@ -0,0 +1,79 @@
+"""Exact finite controls; the continuum argument is in PROOF.md."""
+from fractions import Fraction as F
+import unittest
+import inverse as m
+
+class InverseTests(unittest.TestCase):
+    def test_gradient_only_density_jacobian(self):
+        for d in range(2,10):
+            self.assertEqual(m.gradient_density_power(d),-d)
+
+    def test_radial_power_independent_of_dimension(self):
+        for d in range(2,10):
+            self.assertEqual(m.radial_power(d),1)
+
+    def test_microscopic_envelope_domain(self):
+        for p in (F(-7,4), F(-1), F(0), F(1,2)):
+            self.assertEqual(m.envelope_integral(p),1/(p+2)+1/(1-p))
+        for p in (F(-3),F(-2),F(1),F(2)):
+            with self.assertRaises(ValueError):m.envelope_integral(p)
+
+    def test_integrated_overlap_coefficient(self):
+        for p in (F(-7,4),F(-1),F(0),F(1,2),F(2)):
+            self.assertEqual(m.overlap_coefficient(p),1/(p+2)-1/(p+5))
+        self.assertEqual(m.overlap_coefficient(F(0)),F(3,10))
+        with self.assertRaises(ValueError):m.overlap_coefficient(F(-2))
+
+    def test_inverse_endpoint_is_not_finite(self):
+        for q in (F(0),F(1),F(199,100)):
+            self.assertTrue(m.moment_finite(-q))
+        for q in (F(2),F(3),F(10)):
+            self.assertFalse(m.moment_finite(-q))
+
+    def test_fixed_r_cutoff_logarithm(self):
+        self.assertEqual(m.inverse_cutoff(2,F(1,100),F(1,2)),
+                         {'kind':'log','ratio':F(50),'coefficient':F(1)})
+
+    def test_fixed_r_cutoff_powers(self):
+        lo,hi=F(1,100),F(1,2)
+        self.assertEqual(m.inverse_cutoff(0,lo,hi),(hi*hi-lo*lo)/2)
+        self.assertEqual(m.inverse_cutoff(1,lo,hi),hi-lo)
+        self.assertEqual(m.inverse_cutoff(3,lo,hi),1/lo-1/hi)
+        self.assertEqual(m.inverse_cutoff(4,lo,hi),(lo**-2-hi**-2)/2)
+        with self.assertRaises(ValueError):m.inverse_cutoff(3,F(0),hi)
+
+    def test_small_separation_cdf_has_half(self):
+        self.assertEqual(m.small_cdf_coefficient(F(7),F(3)),F(7,6))
+
+    def test_exact_polynomial_fold_data(self):
+        for d in (2,3,4):
+            for delta in (F(1,3),F(1,11)):
+                for T in (F(-5),F(7,3)):
+                    transverse=[F((-1)**i*(i+1)) for i in range(d-1)]
+                    detA=F(1)
+                    for a in transverse:detA*=a
+                    result=m.fold_data(delta,T,transverse)
+                    self.assertEqual(result['gradients'],([F(0)]*d,[F(0)]*d))
+                    self.assertEqual(result['height_difference'],-T*delta**3/12)
+                    self.assertEqual(result['determinants'],(-T*delta*detA/2,T*delta*detA/2))
+                    self.assertEqual(result['absolute_product'],delta**2*T**2*detA**2/4)
+
+    def test_t_to_T_and_coefficient_conversion(self):
+        self.assertEqual(36*F(1,12)**2,F(1,4))
+        self.assertEqual(108/F(12)**2,F(3,4))
+        self.assertEqual(m.height_width_power(),3)
+
+    def test_negative_moment_scaling(self):
+        for q in (F(1,2),F(1),F(3,2)):
+            self.assertEqual(m.microscopic_power(-q),5-q)
+            self.assertEqual(q+m.microscopic_power(-q)-m.microscopic_power(0),0)
+            self.assertGreater(6-m.microscopic_power(-q),0)
+
+    def test_probability_size_bias_not_event_sampling(self):
+        # P(N=2)=1/4, P(N=3)=1/4: pair weighting differs from event weighting.
+        self.assertEqual(m.pair_weight(2),2)
+        self.assertEqual(m.pair_weight(3),6)
+        self.assertEqual(F(1,4)*m.pair_weight(2)/(F(1,4)*m.pair_weight(2)+F(1,4)*m.pair_weight(3)),F(1,4))
+        self.assertNotEqual(F(1,4),F(1,2))
+
+if __name__=='__main__':unittest.main()