Upload 6 files

.gitattributes

@@ -0,0 +1,2 @@
+assets/interference_diagram.png filter=lfs diff=lfs merge=lfs -text
+assets/loss_curve.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,57 @@
+---
+title: OmegaCode — Holographic Master Code Demo
+emoji: 🧬
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# OmegaCode — Holographic Master Code Demo
+
+A research-oriented, physics-inspired neural prototype with an α-sensitive stability control and interference-based visualization.
+
+## Live visual summary
+
+![Loss curve](assets/loss_curve.png)
+
+![Interference diagram](assets/interference_diagram.png)
+
+## What this Space shows
+
+- a lightweight **Master Code Ψ** prototype
+- an **effective α parameter** that modulates phase and stability
+- a **training-loss visualization** that changes near the nominal α value
+- a **double-slit analogue** showing how phase coherence affects interference visibility
+
+## How to use the demo
+
+Move the **α slider** and compare:
+
+- the training curve
+- the interference pattern
+- the model diagnostics panel
+
+The demo updates interactively when you change **α**, epoch count, or input noise.
+
+## Important note
+
+This is an **experimental research prototype** and not a validated physical theory.  
+It is designed as a conceptual, physics-inspired demo for learning and exploration.
+
+## How to run locally
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## Files
+
+- `app.py` — Gradio interface with interactive α control
+- `model.py` — lightweight demo model and synthetic curves
+- `assets/loss_curve.png` — static visualization for the README
+- `assets/interference_diagram.png` — double-slit analogue for the README
+- `requirements.txt` — dependencies

app.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import numpy as np
+import gradio as gr
+import matplotlib.pyplot as plt
+
+from model import HolographicMasterCodeTransformer, synthetic_loss_curve, alpha_to_label
+
+
+def build_training_figure(alpha_value: float, epochs: int):
+    nominal_losses, nominal_regs = synthetic_loss_curve(1 / 137.035, epochs=epochs)
+    current_losses, current_regs = synthetic_loss_curve(alpha_value, epochs=epochs)
+
+    fig, ax = plt.subplots(figsize=(10, 5))
+    ax.plot(nominal_losses, label="Loss — nominal α", linewidth=2.2)
+    ax.plot(current_losses, label="Loss — selected α", linewidth=2.2)
+    ax.plot(nominal_regs, label="Reg — nominal α", linestyle="--")
+    ax.plot(current_regs, label="Reg — selected α", linestyle="--")
+    ax.set_title("OmegaCode training dynamics")
+    ax.set_xlabel("Epoch")
+    ax.set_ylabel("Value")
+    ax.grid(True, alpha=0.25)
+    ax.legend(loc="upper right")
+    fig.tight_layout()
+    return fig
+
+
+def build_interference_figure(alpha_value: float):
+    x = np.linspace(-10, 10, 1200)
+    alpha_0 = 1 / 137.035
+    delta = alpha_value - alpha_0
+
+    # Coherence and phase shift are synthetic and only for visualization.
+    visibility = float(np.exp(-25000.0 * abs(delta)))
+    visibility = max(0.08, min(0.98, visibility))
+    phase = float(0.9 * np.sign(delta) * min(1.0, abs(delta) * 5e4))
+
+    coherent = 1.0 + 0.95 * np.cos(1.15 * x)
+    perturbed = 1.0 + visibility * np.cos(1.15 * x + phase)
+
+    fig, ax = plt.subplots(figsize=(10, 5))
+    ax.plot(x, coherent, label="Nominal α: coherent pattern", linewidth=2.2)
+    ax.plot(x, perturbed, label="Selected α: phase-modulated pattern", linewidth=2.2)
+    ax.set_title("Double-slit analogue: interference visibility vs α")
+    ax.set_xlabel("Screen coordinate")
+    ax.set_ylabel("Normalized intensity")
+    ax.grid(True, alpha=0.25)
+    ax.legend(loc="upper right")
+    fig.tight_layout()
+    return fig
+
+
+def run_demo(alpha_value: float, epochs: int, noise: float):
+    model = HolographicMasterCodeTransformer()
+
+    x = np.random.randn(1, 8).astype(np.float32) * max(noise, 1e-6)
+    pred, psi, security, delta_phi = model.forward(x, alpha_value)
+
+    training_fig = build_training_figure(alpha_value, epochs)
+    interference_fig = build_interference_figure(alpha_value)
+
+    alpha_label = alpha_to_label(alpha_value)
+    alpha_0 = model.alpha_0
+    delta_alpha = alpha_value - alpha_0
+
+    summary = {
+        "alpha": alpha_value,
+        "alpha_label": alpha_label,
+        "delta_alpha": delta_alpha,
+        "prediction": float(pred.squeeze()),
+        "psi_mean": float(np.mean(psi)),
+        "security_factor": float(security),
+        "phase_shift": float(delta_phi),
+        "stability_score": float(max(0.0, 1.0 - abs(delta_alpha) * 5e4)),
+    }
+
+    return training_fig, interference_fig, summary
+
+
+with gr.Blocks(title="OmegaCode Holographic Demo") as demo:
+    gr.Markdown(
+        """
+# OmegaCode — Holographic Master Code Demo
+
+A research-oriented, physics-inspired neural prototype with an α-sensitive stability control and interference-based visualization.
+It is designed for exploration and does **not** claim to be a validated physical theory.
+
+## What to try
+
+- Move **α** around the nominal value
+- Watch the **loss curve** shift
+- Compare the **double-slit analogue** as phase coherence changes
+        """
+    )
+
+    with gr.Row():
+        alpha_value = gr.Slider(
+            minimum=1 / 137.08,
+            maximum=1 / 137.00,
+            value=1 / 137.035,
+            step=1e-7,
+            label="α / Fine-structure constant (effective control parameter)",
+        )
+        epochs = gr.Slider(50, 300, value=150, step=10, label="Simulated epochs")
+        noise = gr.Slider(0.0, 2.0, value=1.0, step=0.05, label="Input noise")
+
+    run_btn = gr.Button("Run simulation", variant="primary")
+
+    with gr.Row():
+        training_plot = gr.Plot(label="Training dynamics")
+        interference_plot = gr.Plot(label="Interference pattern")
+
+    out = gr.JSON(label="Model diagnostics")
+
+    run_btn.click(
+        run_demo,
+        inputs=[alpha_value, epochs, noise],
+        outputs=[training_plot, interference_plot, out],
+    )
+    alpha_value.change(
+        run_demo,
+        inputs=[alpha_value, epochs, noise],
+        outputs=[training_plot, interference_plot, out],
+    )
+    epochs.change(
+        run_demo,
+        inputs=[alpha_value, epochs, noise],
+        outputs=[training_plot, interference_plot, out],
+    )
+    noise.change(
+        run_demo,
+        inputs=[alpha_value, epochs, noise],
+        outputs=[training_plot, interference_plot, out],
+    )
+
+if __name__ == "__main__":
+    demo.launch()

model.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import numpy as np
+
+
+@dataclass
+class OmegaConfig:
+    alpha_0: float = 1 / 137.035
+    phase_scale: float = 800.0
+    security_scale: float = 300.0
+    n_harmonics: int = 4
+
+
+def alpha_to_label(alpha: float) -> str:
+    alpha_0 = 1 / 137.035
+    alpha_physical = 1 / 137.035999
+    if abs(alpha - alpha_0) < 5e-7:
+        return "Nominal"
+    if abs(alpha - alpha_physical) < 5e-7:
+        return "Physical"
+    return "Perturbed"
+
+
+class HolographicMasterCodeTransformer:
+    """
+    Lightweight physics-inspired model for demo use.
+    It is intentionally simple so it runs fast inside a Hugging Face Space.
+    """
+
+    def __init__(self, config: OmegaConfig | None = None):
+        self.cfg = config or OmegaConfig()
+        self.alpha_0 = self.cfg.alpha_0
+        rng = np.random.default_rng(42)
+        self.harmonic_weights = rng.normal(size=(self.cfg.n_harmonics, 8)).astype(np.float32)
+
+    def forward(self, x: np.ndarray, alpha: float):
+        x = np.asarray(x, dtype=np.float32)
+        h = np.tanh(x @ np.eye(x.shape[-1], dtype=np.float32))
+
+        delta_phi = 2 * np.pi * (alpha - self.alpha_0) * self.cfg.phase_scale
+        security = float(np.exp(-self.cfg.security_scale * abs(alpha - self.alpha_0)))
+
+        psi = np.zeros_like(h)
+        for n in range(self.cfg.n_harmonics):
+            psi += self.harmonic_weights[n] * np.cos(h * (n + 1) + delta_phi * (n + 1))
+
+        combined = h + 0.35 * psi * security
+        pred = combined.mean(axis=-1, keepdims=True)
+
+        return pred, psi, security, delta_phi
+
+
+def synthetic_loss_curve(alpha_value: float, epochs: int = 150):
+    """
+    Simulates a smooth loss curve. Near alpha_0, the curve is slightly better.
+    This is for visualization only; it is not a training result.
+    """
+    cfg = OmegaConfig()
+    alpha_dev = abs(alpha_value - cfg.alpha_0)
+    alpha_quality = np.exp(-25000.0 * alpha_dev)
+
+    t = np.arange(epochs, dtype=np.float32)
+    base = 0.65 * np.exp(-t / (epochs / 5.0)) + 0.03
+    oscillation = 0.02 * np.sin(t / 8.0) * (1.0 - 0.7 * alpha_quality)
+    noise = 0.005 * np.exp(-t / (epochs / 3.0))
+
+    losses = np.maximum(0.0, base + oscillation + noise * (1.0 - alpha_quality))
+    regs = 0.12 * np.exp(-t / (epochs / 2.0)) + 0.02 * (1.0 - alpha_quality)
+    return losses, regs

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.44.0
+numpy>=1.26.0
+matplotlib>=3.8.0