SilverSight/infra/sigs/rydberg_miner.py

#!/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

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
import urllib.parse
import xml.etree.ElementTree as ET
import re
from typing import List, Dict, Optional
from pathlib import Path

TWO_ALPHA = 0.0146  # BraidCore prediction: 2 * 1/137

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 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__":
    main()