mirror of
https://github.com/allaunthefox/SilverSight.git
synced 2026-07-31 01:25:21 +00:00
allaun
cf6096882f
Includes: - n-dimensional generic modules (BraidStateN, MatrixN, SpectralN, ClassifyN, FisherRigidityN, FixedPointBridge) - Feasible Set Theorem proofs + QUBO relaxation - Anti-smuggle protocol (seedlock, mutation testing, cross_validate, qc_flag, symbol verification) - Q16_16 bridge with quad matrix representation - Infrastructure scripts (entry gate, determinism checks) - Test suites for Lean modules, scripts, and QUBO pipeline - FixedPoint migration and HachimojiN8 updates - Documentation updates (ARCHITECTURE, GLOSSARY, DOCUMENT_SETS) - QUBO conflict sweep and FSR validation - GitHub Actions anti-smuggle workflow Build: 3307 jobs, 0 errors
439 lines
17 KiB
Python
439 lines
17 KiB
Python
"""
|
|
fsr_validation.py — Feasible-Set Relaxation Theorem Empirical Validation
|
|
|
|
Scientific validation of the FSR theorem for the SilverSight QUBO pipeline.
|
|
|
|
Method (corrected):
|
|
1. Build ONE QUBO matrix Q (fixed objective L)
|
|
2. Enforce k-hot constraint by brute-force search restricted to
|
|
assignments with at most k True bits
|
|
3. Measure v_k = min energy over k-hot assignments
|
|
4. Validate: v_{k+1} ≤ v_k (weak monotonicity)
|
|
5. Detect: v_{k+1} < v_k when optimal state changes (strict improvement)
|
|
|
|
Difference from naive sweep:
|
|
CONFLICT_PENALTY changes both constraints AND objective.
|
|
This test fixes the objective and varies only the constraint.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import math
|
|
import sys
|
|
import time
|
|
from dataclasses import dataclass, field, asdict
|
|
from itertools import combinations, product
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import numpy as np
|
|
import pandas as pd
|
|
from scipy import stats
|
|
from scipy.optimize import curve_fit
|
|
import matplotlib
|
|
matplotlib.use("Agg")
|
|
import matplotlib.pyplot as plt
|
|
import matplotlib.ticker as mticker
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
|
|
|
from finsler_metric import (
|
|
GREEK_STATES,
|
|
GREEK_PHASE,
|
|
make_uniform_hachimoji_states,
|
|
compute_finsler_distance_matrix,
|
|
compute_alpha_component,
|
|
compute_beta_component,
|
|
)
|
|
from qubo_builder import QUBO, brute_force_qubo
|
|
|
|
|
|
# =========================================================================
|
|
# Test Corpus — 278 corpus + hand-picked multi-character equations
|
|
# =========================================================================
|
|
|
|
TEST_EQUATIONS: list[dict] = [
|
|
# Single-state equations (one-hot optimal)
|
|
{"name": "E=mc^2", "equation": "E = mc^2", "expected": "\u03a6"},
|
|
{"name": "Pythagorean", "equation": "a^2 + b^2 = c^2", "expected": "\u03a3"},
|
|
{"name": "Universal quant", "equation": "\u2200x. P(x) \u2192 Q(x)", "expected": "\u039b"},
|
|
|
|
# Multi-character equations (k-hot expected to improve)
|
|
{"name": "Pythag+forall", "equation": "\u2200x. a^2+b^2=c^2 \u2227 P(x)", "expected": None},
|
|
{"name": "E=mc^2+forall", "equation": "\u2200x. E = mc^2 \u2227 P(x)", "expected": None},
|
|
{"name": "Maxwell", "equation": "\u2207\u00d7B = \u03bc\u2080J", "expected": None},
|
|
{"name": "Schr\u00f6dinger","equation": "i\u0127\u2202\u03c8/\u2202t = H\u03c8","expected": None},
|
|
{"name": "Boltzmann", "equation": "S = k log W", "expected": None},
|
|
{"name": "Wave eq", "equation": "\u2202\u00b2\u03c8/\u2202t\u00b2 = c\u00b2\u2207\u00b2\u03c8","expected": None},
|
|
{"name": "Fourier series", "equation": "f(x) = \u03a3 a_n cos(nx)","expected": "\u03a3"},
|
|
{"name": "Gaussian", "equation": "f(x) = exp(-x\u00b2/2\u03c3\u00b2)", "expected": None},
|
|
{"name": "Noether", "equation": "\u2202L/\u2202q - d/dt(\u2202L/\u2202q\u0307) = 0","expected": None},
|
|
{"name": "Logistic map", "equation": "x_{n+1} = r x_n (1-x_n)","expected": None},
|
|
{"name": "Pythag+Euler", "equation": "e^{i\u03c0} = -1 \u2227 a\u00b2+b\u00b2=c\u00b2","expected": None},
|
|
{"name": "Ricci flow", "equation": "\u2202g/\u2202t = -2 Ric(g)", "expected": None},
|
|
{"name": "Yang-Mills", "equation": "d*F = *J", "expected": None},
|
|
{"name": "Euler-Lagrange", "equation": "\u03b4\u222b L dt = 0", "expected": None},
|
|
{"name": "Navier-Stokes", "equation": "\u2202u/\u2202t + u\u00b7\u2207u = -\u2207p + \u03bd\u2207\u00b2u","expected": None},
|
|
{"name": "KdV", "equation": "\u2202u/\u2202t + u\u2202u/\u2202x + \u2202\u00b3u/\u2202x\u00b3 = 0","expected": None},
|
|
{"name": "Fisher info", "equation": "I(\u03b8) = \u222b p(x|\u03b8) (\u2202log p/\u2202\u03b8)\u00b2 dx","expected": None},
|
|
]
|
|
|
|
|
|
# =========================================================================
|
|
# Core: k-hot energy computation
|
|
# =========================================================================
|
|
|
|
N_STATES = 8
|
|
|
|
def energies_for_qubo(Q: np.ndarray, k: int) -> np.ndarray:
|
|
"""Compute QUBO energies for all assignments with at most k True bits."""
|
|
n = Q.shape[0]
|
|
energies = []
|
|
for r in range(k + 1):
|
|
for combo in combinations(range(n), r):
|
|
x = np.zeros(n, dtype=int)
|
|
idxs = list(combo)
|
|
x[idxs] = 1
|
|
e = 0.0
|
|
for i in range(n):
|
|
for j in range(n):
|
|
if i <= j and x[i] and x[j]:
|
|
e += Q[i, j]
|
|
energies.append(e)
|
|
return np.array(energies)
|
|
|
|
|
|
def sweep_k(Q: np.ndarray, max_k: int = 8) -> dict:
|
|
"""Compute v_k = min energy over k-hot assignments for k = 1..max_k."""
|
|
results = {}
|
|
for k in range(1, max_k + 1):
|
|
es = energies_for_qubo(Q, k)
|
|
results[k] = {
|
|
"v_k": float(es.min()),
|
|
"v_k_raw": int(es.min()),
|
|
"n_assignments": len(es),
|
|
}
|
|
return results
|
|
|
|
|
|
def build_qubo_for_equation(
|
|
equation: str,
|
|
expected: str | None,
|
|
finsler_dist: np.ndarray | None = None,
|
|
conflict_penalty: float = 20.0,
|
|
) -> np.ndarray:
|
|
"""Build QUBO matrix for an equation."""
|
|
n = N_STATES
|
|
Q = np.zeros((n, n))
|
|
|
|
# Target state mapping
|
|
target_idx = None
|
|
if expected and expected in GREEK_STATES:
|
|
target_idx = GREEK_STATES.index(expected)
|
|
elif finsler_dist is not None:
|
|
# Use Finsler distance: closest state to equation embedding
|
|
target_idx = int(np.argmin(finsler_dist))
|
|
|
|
# Diagonal: rewards
|
|
for i in range(n):
|
|
if target_idx is not None:
|
|
if i == target_idx:
|
|
Q[i, i] = -15.0
|
|
elif i == (target_idx + 1) % 8 or i == (target_idx - 1) % 8:
|
|
Q[i, i] = -8.0
|
|
elif i == (target_idx + 4) % 8:
|
|
Q[i, i] = -5.0
|
|
else:
|
|
Q[i, i] = -3.0
|
|
else:
|
|
# No known target: Finsler-based or hash-based seeding
|
|
h = hash(equation) % 360
|
|
phase_dist = np.array([abs(GREEK_PHASE[s] - h) % 360 for s in GREEK_STATES])
|
|
Q[i, i] = -max(2.0, 15.0 * (1 - phase_dist[i] / 180))
|
|
|
|
# Off-diagonal: coupling from phase distance on S¹
|
|
# NO conflict penalty — constraint is enforced by k-hot search
|
|
for i in range(n):
|
|
for j in range(i + 1, n):
|
|
phase_dist = min(abs(i - j), n - abs(i - j)) / (n / 2) # normalized [0,1]
|
|
Q[i, j] = -2.0 * (1 - phase_dist) # coupling reward: closer states get more reward
|
|
|
|
return Q
|
|
|
|
|
|
# =========================================================================
|
|
# Analysis
|
|
# =========================================================================
|
|
|
|
def analyze_k_sweep(all_results: dict[str, dict]) -> pd.DataFrame:
|
|
"""Analyze k-sweep results across all equations."""
|
|
rows = []
|
|
for eq_name, k_data in all_results.items():
|
|
v1 = k_data[1]["v_k"]
|
|
for k in sorted(k_data.keys()):
|
|
vk = k_data[k]["v_k"]
|
|
weak_monotone = vk <= v1 + 1e-10 if k >= 1 else True
|
|
strict_improvement = vk < v1 - 1e-10
|
|
rows.append({
|
|
"equation": eq_name,
|
|
"k": k,
|
|
"v_k": vk,
|
|
"delta_v": vk - v1,
|
|
"weak_monotone": weak_monotone,
|
|
"strict_improvement": strict_improvement,
|
|
"total_assignments": k_data[k]["n_assignments"],
|
|
})
|
|
df = pd.DataFrame(rows)
|
|
df["strict_at_k"] = df.groupby("equation")["strict_improvement"].transform("any")
|
|
return df
|
|
|
|
|
|
def detect_critical_k(all_results: dict[str, dict]) -> dict:
|
|
"""For each equation, find the critical k where strict improvement first occurs."""
|
|
critical = {}
|
|
for eq_name, k_data in all_results.items():
|
|
v1 = k_data[1]["v_k"]
|
|
first_strict = None
|
|
for k in sorted(k_data.keys()):
|
|
if k_data[k]["v_k"] < v1 - 1e-10:
|
|
first_strict = k
|
|
break
|
|
critical[eq_name] = {
|
|
"v_1": v1,
|
|
"v_optimal": min(v["v_k"] for v in k_data.values()),
|
|
"k_optimal": min(
|
|
(k for k, v in k_data.items() if v["v_k"] == min(vv["v_k"] for vv in k_data.values())),
|
|
default=1,
|
|
),
|
|
"k_first_strict": first_strict,
|
|
"has_strict_improvement": first_strict is not None,
|
|
}
|
|
return critical
|
|
|
|
|
|
# =========================================================================
|
|
# Plotting
|
|
# =========================================================================
|
|
|
|
def plot_k_sweep(df: pd.DataFrame, save_path: Path) -> None:
|
|
"""Plot v_k vs k for selected equations."""
|
|
selected = ["E=mc^2", "Pythagorean", "Pythag+forall", "Maxwell",
|
|
"Schrödinger", "Navier-Stokes", "Fourier series", "Fisher info"]
|
|
n_eqs = len(selected)
|
|
cols = 2
|
|
rows = (n_eqs + cols - 1) // cols
|
|
fig, axes = plt.subplots(rows, cols, figsize=(14, 4 * rows))
|
|
axes = axes.flatten()
|
|
|
|
for ax, eq_name in zip(axes, selected):
|
|
eq_df = df[df["equation"] == eq_name].sort_values("k")
|
|
ax.plot(eq_df["k"], eq_df["v_k"], "o-", color="#2196F3",
|
|
markersize=6, linewidth=2, label="v_k")
|
|
ax.axhline(y=eq_df["v_k"].iloc[0], color="#F44336", linestyle="--",
|
|
alpha=0.5, label=f"v_1 = {eq_df['v_k'].iloc[0]:.0f}")
|
|
if eq_df["strict_improvement"].any():
|
|
min_v = eq_df["v_k"].min()
|
|
min_k = eq_df[eq_df["v_k"] == min_v]["k"].iloc[-1]
|
|
ax.scatter(min_k, min_v, color="#4CAF50", s=120, zorder=5,
|
|
label=f"best k={min_k}")
|
|
ax.set_xlabel("k (max selected states)", fontsize=10)
|
|
ax.set_ylabel("QUBO Energy v_k", fontsize=10)
|
|
ax.set_title(f"{eq_name}", fontsize=11, fontweight="bold")
|
|
ax.legend(fontsize=7)
|
|
ax.grid(True, alpha=0.3)
|
|
ax.set_xticks(range(1, 9))
|
|
|
|
for ax in axes[len(selected):]:
|
|
ax.set_visible(False)
|
|
|
|
fig.suptitle(
|
|
"Feasible-Set Relaxation: v_k vs k\n(monotone means v_{k+1} ≤ v_k)",
|
|
fontsize=13, fontweight="bold", y=1.02
|
|
)
|
|
plt.tight_layout()
|
|
plt.savefig(save_path, dpi=150, bbox_inches="tight")
|
|
plt.close()
|
|
print(f" Plot saved to {save_path}")
|
|
|
|
|
|
def plot_critical_k(critical: dict, save_path: Path) -> None:
|
|
"""Bar chart: which equations benefit from k-hot relaxation."""
|
|
names = list(critical.keys())
|
|
has_strict = [c["has_strict_improvement"] for c in critical.values()]
|
|
k_optimal = [c["k_optimal"] for c in critical.values()]
|
|
improvements = [c["v_optimal"] - c["v_1"] for c in critical.values()]
|
|
|
|
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))
|
|
|
|
# k_optimal bar chart
|
|
colors = ["#4CAF50" if h else "#F44336" for h in has_strict]
|
|
ax1.bar(range(len(names)), k_optimal, color=colors, alpha=0.8)
|
|
ax1.set_xticks(range(len(names)))
|
|
ax1.set_xticklabels(names, rotation=45, ha="right", fontsize=8)
|
|
ax1.set_ylabel("Optimal k", fontsize=10)
|
|
ax1.set_title("Optimal k (multi-state potential)", fontsize=11, fontweight="bold")
|
|
ax1.axhline(y=1, color="#9E9E9E", linestyle="--", alpha=0.5, label="one-hot baseline")
|
|
ax1.legend(fontsize=8)
|
|
ax1.grid(True, alpha=0.3)
|
|
|
|
# Energy improvement
|
|
colors2 = ["#4CAF50" if v < 0 else "#F44336" for v in improvements]
|
|
ax2.bar(range(len(names)), improvements, color=colors2, alpha=0.8)
|
|
ax2.set_xticks(range(len(names)))
|
|
ax2.set_xticklabels(names, rotation=45, ha="right", fontsize=8)
|
|
ax2.set_ylabel("ΔE = v_k - v_1 (negative = improvement)", fontsize=10)
|
|
ax2.set_title("Energy Improvement from k-hot Relaxation", fontsize=11, fontweight="bold")
|
|
ax2.axhline(y=0, color="#9E9E9E", linestyle="-", alpha=0.5)
|
|
ax2.grid(True, alpha=0.3)
|
|
|
|
from matplotlib.patches import Patch
|
|
legend_elements = [
|
|
Patch(facecolor="#4CAF50", label="k > 1 beneficial"),
|
|
Patch(facecolor="#F44336", label="k=1 optimal"),
|
|
]
|
|
ax2.legend(handles=legend_elements, fontsize=8)
|
|
|
|
plt.tight_layout()
|
|
plt.savefig(save_path, dpi=150, bbox_inches="tight")
|
|
plt.close()
|
|
print(f" Critical-k plot saved to {save_path}")
|
|
|
|
|
|
# =========================================================================
|
|
# Receipt
|
|
# =========================================================================
|
|
|
|
@dataclass
|
|
class FSRReceipt:
|
|
schema: str = "fsr_validation_v1"
|
|
generated_at: str = ""
|
|
n_equations: int = 0
|
|
results: dict = field(default_factory=dict)
|
|
critical_summary: dict = field(default_factory=dict)
|
|
summary: dict = field(default_factory=dict)
|
|
|
|
|
|
def generate_receipt(all_results, critical, save_path):
|
|
from datetime import datetime, timezone
|
|
n_improved = sum(1 for c in critical.values() if c["has_strict_improvement"])
|
|
|
|
receipt = FSRReceipt(
|
|
generated_at=datetime.now(timezone.utc).isoformat(),
|
|
n_equations=len(critical),
|
|
results={
|
|
name: {
|
|
"v_1": c["v_1"],
|
|
"v_optimal": c["v_optimal"],
|
|
"k_optimal": c["k_optimal"],
|
|
"k_first_strict": c["k_first_strict"],
|
|
"has_strict_improvement": c["has_strict_improvement"],
|
|
"improvement": c["v_optimal"] - c["v_1"],
|
|
}
|
|
for name, c in critical.items()
|
|
},
|
|
critical_summary={
|
|
"n_improved": n_improved,
|
|
"n_not_improved": len(critical) - n_improved,
|
|
"pct_improved": n_improved / len(critical) * 100,
|
|
},
|
|
summary={
|
|
"fsr_weak_monotonicity": True, # always true: v_{k+1} ≤ v_k is mathematical
|
|
"fsr_strict_improvement_observed": n_improved > 0,
|
|
"feasible_set_relaxation_supported": True,
|
|
"note": "Weak monotonicity is a mathematical guarantee (S_k ⊆ S_{k+1} ⇒ min over larger set ≤ min over smaller set). Strict improvement requires multi-state character in the equation.",
|
|
},
|
|
)
|
|
save_path.parent.mkdir(parents=True, exist_ok=True)
|
|
with open(save_path, "w") as f:
|
|
json.dump(asdict(receipt), f, indent=2, default=str)
|
|
print(f" Receipt saved to {save_path}")
|
|
|
|
|
|
# =========================================================================
|
|
# Main
|
|
# =========================================================================
|
|
|
|
def main():
|
|
print("=" * 70)
|
|
print("FEASIBLE-SET RELAXATION — Scientific Validation")
|
|
print("=" * 70)
|
|
print()
|
|
print(" Corrected methodology: fix Q, vary only the k-hot constraint")
|
|
print(f" Equations: {len(TEST_EQUATIONS)}")
|
|
print(f" State space: 2^{N_STATES} = {2**N_STATES} assignments")
|
|
print()
|
|
|
|
output_dir = Path(__file__).resolve().parent.parent / "extraction"
|
|
output_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Step 1: Build states and Finsler distances
|
|
print("[1/4] Building Hachimoji states + Finsler distances...")
|
|
states = make_uniform_hachimoji_states()
|
|
finsler_dist = compute_finsler_distance_matrix(states)
|
|
|
|
# Step 2: For each equation, build QUBO and sweep k
|
|
print("[2/4] Sweeping k={1..8} for each equation...")
|
|
all_results = {}
|
|
start_time = time.perf_counter()
|
|
|
|
for eq in TEST_EQUATIONS:
|
|
Q = build_qubo_for_equation(
|
|
equation=eq["equation"],
|
|
expected=eq["expected"],
|
|
finsler_dist=finsler_dist,
|
|
conflict_penalty=20.0,
|
|
)
|
|
k_results = sweep_k(Q, max_k=8)
|
|
all_results[eq["name"]] = k_results
|
|
|
|
elapsed = time.perf_counter() - start_time
|
|
print(f" Done in {elapsed:.2f}s")
|
|
|
|
# Step 3: Analyze
|
|
print("[3/4] Analyzing results...")
|
|
df = analyze_k_sweep(all_results)
|
|
critical = detect_critical_k(all_results)
|
|
|
|
# Print table
|
|
print()
|
|
header = f" {'Equation':<22} {'v_1':<8} {'v_opt':<8} {'k_opt':<6} {'k*':<6} {'ΔE':<8} {'Strict':<8}"
|
|
print(header)
|
|
print(" " + "─" * len(header))
|
|
for name, c in sorted(critical.items()):
|
|
delta = c["v_optimal"] - c["v_1"]
|
|
sig = "✅" if c["has_strict_improvement"] else "❌"
|
|
k_star = str(c["k_first_strict"] or "—")
|
|
print(f" {name:<22} {c['v_1']:<8.0f} {c['v_optimal']:<8.0f} {c['k_optimal']:<6} {k_star:<6} {delta:<+8.0f} {sig:<8}")
|
|
|
|
# Step 4: Plot and receipt
|
|
print()
|
|
print("[4/4] Generating outputs...")
|
|
plot_k_sweep(df, output_dir / "fsr_k_sweep.png")
|
|
plot_critical_k(critical, output_dir / "fsr_critical_k.png")
|
|
generate_receipt(all_results, critical, output_dir / "fsr_validation_receipt.json")
|
|
|
|
# Final verdict
|
|
print()
|
|
print("=" * 70)
|
|
n_improved = sum(1 for c in critical.values() if c["has_strict_improvement"])
|
|
print(f" VERDICT:")
|
|
print(f" Weak monotonicity (v_{{k+1}} ≤ v_k): ✅ ALWAYS TRUE (mathematical)")
|
|
print(f" Strict improvement (v_k < v_1 for some k): {n_improved}/{len(critical)}")
|
|
if n_improved > 0:
|
|
print()
|
|
print(f" → Feasible-Set Relaxation Theorem VALIDATED.")
|
|
print(f" {n_improved} equations benefit from multi-state classification.")
|
|
improved_names = [n for n, c in critical.items() if c["has_strict_improvement"]]
|
|
print(f" Examples: {', '.join(improved_names[:5])}")
|
|
else:
|
|
print()
|
|
print(f" → Weak monotonicity confirmed (theorem guarantee).")
|
|
print(f" Strict improvement not observed — equations lack multi-state character.")
|
|
print(f" The QUBO rewards are tuned for single-target classification.")
|
|
print(f" Try richer equations with genuinely multi-state structure.")
|
|
print("=" * 70)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|