spec(miner): Rydberg-braid signature extraction implementation

- arXiv API integration for quantum defect papers
- Pattern matching for delta_0/delta_2 extraction
- Braid signature detection: delta_0 * n ≈ 2α

Build: 2987 jobs, 0 errors

AGENTS.md

@@ -367,6 +367,7 @@ Current Research Stack cornfield ref (for cross-repo lookup only):
    introduced in receipts, gates, or cross-module interfaces must be added there
    with a source-module citation before they are used.
 - `specs/rydberg_braid_cross_domain_scan.md` — Cross-domain validation spec: mine recent physics literature for 1/n residuals matching eigensolid signature.
+- `infra/sigs/rydberg_miner.py` — arXiv API miner to detect braid signature in quantum defect residuals.
 - `formal/CoreFormalism/HachimojiLUT.lean` — Virtual LUT hierarchy, phase embedding,
     manifold position. §5 binaryLUT_exists proved (trivial constant-Φ solution).
 - `formal/CoreFormalism/HachimojiBridging.lean` — Bridge module for BMCTE→Hachimoji link.

docs/PROJECT_MAP.json

@@ -1,6 +1,6 @@
 {
   "schema": "silversight_project_map_v1",
-  "generated_at": "2026-06-23T01:13:22.207438+00:00",
+  "generated_at": "2026-06-23T01:22:57.555788+00:00",
   "repo": "https://github.com/allaunthefox/SilverSight",
   "local_path": "/home/allaun/SilverSight",
   "summary": {
@@ -542,7 +542,7 @@
       "research_stack_source": null,
       "role": "",
       "receipt_boundary": false,
-      "line_count": 3018
+      "line_count": 3022
     },
     {
       "path": "docs/PROJECT_MAP.md",
@@ -556,7 +556,7 @@
       "research_stack_source": null,
       "role": "",
       "receipt_boundary": false,
-      "line_count": 218
+      "line_count": 217
     },
     {
       "path": "docs/RRC_PLACEMENT.md",
@@ -2088,12 +2088,16 @@
       "imports": [
         "json",
         "urllib.request",
-        "typing"
+        "urllib.parse",
+        "xml.etree.ElementTree",
+        "re",
+        "typing",
+        "pathlib"
       ],
       "research_stack_source": null,
       "role": "",
       "receipt_boundary": false,
-      "line_count": 32
+      "line_count": 144
     },
     {
       "path": "lake-manifest.json",

docs/PROJECT_MAP.md

@@ -1,6 +1,6 @@
 # SilverSight Project Map
 
-**Generated:** 2026-06-23T01:13:22.207438+00:00
+**Generated:** 2026-06-23T01:22:57.555788+00:00
 
 **Source repo:** https://github.com/allaunthefox/SilverSight
 

infra/sigs/rydberg_miner.py

@@ -1,32 +1,144 @@
-Cross-domain signature miner for eigensolid validation.
+#!/usr/bin/env python3
+"""Cross-domain signature miner for eigensolid validation.
 
 APIs: NASA ADS (no key required for basic search), CORE, arXiv OAI-PMH.
 Output: signatures/cross_domain_signatures.json
-</think>
-# Phase 1: Quantum Defect Miner
+
+This miner looks for the BraidCore signature: delta(n)*n -> 2*alpha ≈ 0.0146
+in quantum defect residuals across physics literature.
+"""
+
 import json
 import urllib.request
-from typing import List, Dict
+import urllib.parse
+import xml.etree.ElementTree as ET
+import re
+from typing import List, Dict, Optional
+from pathlib import Path
 
-def fetch_ads_papers(query: str, rows: int = 100) -> List[Dict]:
-    """Fetch papers from NASA ADS API."""
-    url = f"https://api.adsabs.harvard.edu/v1/search/query?q={query}&fl=title,abstract,doi,year&rows={rows}"
-    # Note: Real implementation needs proper User-Agent
-    # This is stubbed for structure
-    return []
+TWO_ALPHA = 0.0146  # BraidCore prediction: 2 * 1/137
 
-def extract_delta_values(papers: List[Dict]) -> Dict:
-    """Extract delta(n) values from paper text."""
-    # Parse abstracts for patterns like "delta_0=0.033(7)" "delta_2=-0.20(2)"
-    pass
+def fetch_arxiv_papers(query: str, rows: int = 100) -> List[Dict]:
+    """Fetch papers from arXiv API (no auth required)."""
+    encoded_query = urllib.parse.quote(query)
+    url = f"https://export.arxiv.org/api/query?search_query=all:{encoded_query}&start=0&max_results={rows}"
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "SilverSight-Miner/1.0"})
+        with urllib.request.urlopen(req, timeout=15) as response:
+            xml = response.read().decode()
+            root = ET.fromstring(xml)
+            ns = {"atom": "http://www.w3.org/2005/Atom"}
+            papers = []
+            for entry in root.findall("atom:entry", ns):
+                title = entry.findtext("atom:title", "", ns)
+                summary = entry.findtext("atom:summary", "", ns)
+                link = entry.findtext("atom:id", "", ns)
+                papers.append({"title": title, "abstract": summary, "link": link})
+            return papers
+    except Exception as e:
+        print(f"arXiv fetch error: {e}")
+        return []
 
-def compute_braid_signature(residuals: List[float], n_values: List[int]) -> Dict:
-    """Compute if residuals scale as 2*alpha/n."""
-    # residual * n should ≈ 0.0146
-    pass
+def extract_delta_parameters(text: str) -> Optional[Dict]:
+    """Extract quantum defect parameters from paper text.
+    
+    Looks for patterns like:
+    - delta_0 = 0.03341537(70)
+    - delta_2 = -0.2014(16)
+    - n = 45 to 50
+    - Also looks for numerical values that could be quantum defects
+    """
+    # Match delta_0 and delta_2 values
+    d0_match = re.search(r"delta_?0\s*[=:]?\s*([+-]?\d+\.\d+)(?:\((\d+)\))?", text, re.IGNORECASE)
+    d2_match = re.search(r"delta_?2\s*[=:]?\s*([+-]?\d+\.\d+)(?:\((\d+)\))?", text, re.IGNORECASE)
+    
+    n_match = re.search(r"n\s*=\s*(\d+)\s*(?:to|-)\s*(\d+)", text)
+    
+    # Also look for numerical patterns like "0.033(7)" which could be delta
+    potential_delta = re.search(r"quantum\s*defect.*([+-]?\d+\.\d+)\s*(?:\((\d+)\)|$)", text, re.IGNORECASE)
+    
+    result = {}
+    if d0_match:
+        result["delta_0"] = float(d0_match.group(1))
+        if d0_match.group(2):
+            result["delta_0_err"] = float(f"0.{d0_match.group(2)}")
+    elif potential_delta and "delta_0" not in result:
+        # If no explicit delta_0, take the first numerical value near 0.03
+        val = float(potential_delta.group(1))
+        if 0.02 < val < 0.05:  # Reasonable quantum defect range
+            result["delta_0"] = val
+            result["inferred"] = True
+    if d2_match:
+        result["delta_2"] = float(d2_match.group(1))
+        if d2_match.group(2):
+            result["delta_2_err"] = float(f"0.{d2_match.group(2)}")
+    if n_match:
+        result["n_min"] = int(n_match.group(1))
+        result["n_max"] = int(n_match.group(2))
+    elif "n=" in text.lower():
+        # Look for n=45 style
+        n_single = re.search(r"n\s*=\s*(\d+)", text)
+        if n_single:
+            n_val = int(n_single.group(1))
+            result["n_min"] = n_val
+            result["n_max"] = n_val
+    return result if result else None
+
+def compute_braid_signature(papers: List[Dict]) -> Dict:
+    """Compute if residuals scale as 2*alpha/n.
+    
+    For each paper, extract delta_0 and compute expected residual:
+    residual_theory(n) = 2*alpha/n
+    If measured delta_0 * n ≈ 0.0146, the braid signature is present.
+    """
+    signatures = []
+    for paper in papers:
+        text = f"{paper.get('title', '')} {paper.get('abstract', '')}"
+        params = extract_delta_parameters(text)
+        if params and "delta_0" in params and "n_min" in params:
+            n_avg = (params.get("n_min", 45) + params.get("n_max", 50)) / 2
+            delta_0 = params["delta_0"]
+            
+            # Braid prediction: delta * n ≈ 2*alpha
+            product = delta_0 * n_avg
+            deviation = abs(product - TWO_ALPHA) / TWO_ALPHA
+            
+            signature = {
+                "doi": paper.get("doi", [""])[0] if paper.get("doi") else "",
+                "bibcode": paper.get("bibcode", ""),
+                "delta_0": delta_0,
+                "n_avg": n_avg,
+                "product": product,
+                "expected_two_alpha": TWO_ALPHA,
+                "relative_deviation": deviation,
+                "matches_braid": deviation < 0.5  # Within 50% tolerance
+            }
+            signatures.append(signature)
+    
+    return {"signatures": signatures, "total_analyzed": len(papers)}
+
+def main():
+    queries = [
+        "quantum+defect+delta",
+        "Rydberg+residual",
+        "quantum+defect+scaled"
+    ]
+    
+    all_papers = []
+    for q in queries:
+        papers = fetch_arxiv_papers(q, rows=50)
+        all_papers.extend(papers)
+    
+    results = compute_braid_signature(all_papers)
+    
+    out_dir = Path("signatures")
+    out_dir.mkdir(exist_ok=True)
+    with open(out_dir / "cross_domain_signatures.json", "w") as f:
+        json.dump(results, f, indent=2)
+    
+    print(f"Analyzed {results['total_analyzed']} papers")
+    hits = [s for s in results["signatures"] if s["matches_braid"]]
+    print(f"Found {len(hits)} potential braid signatures")
 
 if __name__ == "__main__":
-    papers = fetch_ads_papers("Rydberg quantum defect systematic")
-    signatures = extract_delta_values(papers)
-    with open("signatures/cross_domain_signatures.json", "w") as f:
-        json.dump(signatures, f)
+    main()