Update app.py

app.py

@@ -1,354 +1,176 @@
-import gradio as gr
-import requests
-import time
-import json
-import hashlib
-from collections import deque
-import numpy as np
-from typing import Dict, Any, List
-
-# ======================================================
-# CONFIG & GLOBAL STATE
-# ======================================================
-
-LEDGER: List[Dict[str, Any]] = []
-CHAT_MEMORY: List[str] = []
-OMEGA_MEMORY: deque = deque(maxlen=16)          # Causal smoothing buffer (Ω influence)
+# app.py
+"""
+Dr Moagi IRE Equation • Autonomous Manifold Explorer
+Minimal autonomous simulation of the sealed governing equation
+dΞ/dt = -Λ ∇(Θ(Ξ) + Φ(Ξ) - Ψ(t) + Ω(t))
 
-WORLD_BANK_BASE = "https://api.worldbank.org/v2"
-INDICATORS = {
-    "GDP": "NY.GDP.MKTP.CD",
-    "INFLATION": "FP.CPI.TOTL.ZG",
-    "POPULATION": "SP.POP.TOTL",
-}
+Hugging Face Spaces demo - January 11, 2026
+"""
 
-# Simple semantic intent anchor (toy version of Θ projection target)
-INTENT_ANCHOR = {
-    "stability": 0.92,
-    "transparency": 0.88,
-    "realism": 0.85
+import gradio as gr
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from io import BytesIO
+import base64
+
+# ─── Configuration ────────────────────────────────────────────────
+DEFAULT_PARAMS = {
+    'steps': 600,
+    'dt': 0.075,
+    'noise': 0.38,
+    'lambda_': 3.4,
+    'omega_window': 14,
+    'intent_x': 2.1,
+    'intent_y': 1.4
 }
-COHERENCE_THRESHOLD = 0.65      # Below this → refusal/quarantine
-
-# ======================================================
-# WORLD BANK MACRO FETCH
-# ======================================================
 
-def fetch_indicator(indicator: str, country: str = "WLD", year: str = "2023") -> float | None:
-    try:
-        url = f"{WORLD_BANK_BASE}/country/{country}/indicator/{indicator}?format=json&per_page=1&date={year}"
-        r = requests.get(url, timeout=7)
-        r.raise_for_status()
-        data = r.json()
-        if len(data) > 1 and data[1]:
-            return float(data[1][0].get("value", np.nan))
-        return None
-    except Exception:
-        return None
+COHERENCE_WARN = 0.68
 
-def fetch_macro_anchor(country: str = "WLD", use_live: bool = True) -> Dict[str, Any]:
-    if not use_live:
-        return {"country": country, "gdp": None, "inflation": None, "population": None}
+# ─── Core Simulation ──────────────────────────────────────────────
+def run_ire_simulation(steps, dt, noise_mag, lam, omega_len, intent):
+    device = torch.device("cpu")
     
-    gdp = fetch_indicator(INDICATORS["GDP"], country)
-    inflation = fetch_indicator(INDICATORS["INFLATION"], country)
-    population = fetch_indicator(INDICATORS["POPULATION"], country)
+    intent_target = torch.tensor([intent[0], intent[1]], dtype=torch.float32, device=device)
     
-    return {
-        "country": country,
-        "gdp": gdp if gdp is not None else np.nan,
-        "inflation": inflation if inflation is not None else np.nan,
-        "population": population if population is not None else np.nan,
-    }
-
-# ======================================================
-# BIT + HASH + COHERENCE LAYER
-# ======================================================
-
-def canonical_bytes(obj: Any) -> bytes:
-    return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode('utf-8')
-
-def compute_bit_stats(payload: Dict) -> Dict:
-    b = canonical_bytes(payload)
-    unique = len(set(b))
-    return {
-        "bytes": len(b),
-        "bits": len(b) * 8,
-        "symbol_diversity": unique,
-        "entropy_proxy": round(unique / max(len(b), 1), 6)
-    }
+    Xi = torch.zeros(2, device=device, requires_grad=True)
+    Omega = []
+    trajectory = [Xi.detach().cpu().numpy().copy()]
 
-def hash_record(payload: Dict, prev_hash: str) -> str:
-    data = {"payload": payload, "prev_hash": prev_hash}
-    return hashlib.sha256(canonical_bytes(data)).hexdigest()
+    for step in range(steps):
+        t = step * dt
 
-def compute_coherence_score(values_dict: Dict[str, float]) -> float:
-    """Very simple toy coherence metric (closer to intent anchor = higher score)"""
-    if not values_dict:
-        return 0.0
-    
-    scores = []
-    for k, target in INTENT_ANCHOR.items():
-        if k in values_dict and not np.isnan(values_dict[k]):
-            val = values_dict[k]
-            norm_diff = min(1.0, abs(val - target) / max(abs(target), 0.01))
-            scores.append(1.0 - norm_diff)
-    
-    return round(np.mean(scores) if scores else 0.5, 4)
+        # Potential terms (toy implementations)
+        theta = 0.45 * (intent_target - Xi).pow(2).sum()
+        phi   = 0.28 * torch.sin(3.2 * torch.atan2(Xi[1], Xi[0])) * torch.cos(1.8 * Xi.norm()) + 0.15 * Xi.norm()**2
+        psi   = torch.randn(2, device=device) * noise_mag * (1.0 + 0.35 * torch.sin(t * 0.14))
+        omega_mean = torch.mean(torch.stack(Omega), dim=0) if Omega else torch.zeros(2, device=device)
 
-def omega_smooth(key: str, new_value: float) -> float:
-    """Simple EMA style smoothing (early Ω influence)"""
-    if not OMEGA_MEMORY:
-        OMEGA_MEMORY.append({key: new_value})
-        return new_value
-    
-    prev = OMEGA_MEMORY[-1].get(key, new_value)
-    alpha = 0.3
-    smoothed = alpha * new_value + (1 - alpha) * prev
-    OMEGA_MEMORY.append({key: smoothed})
-    return round(smoothed, 6)
+        potential = theta + phi - psi + omega_mean
 
-# ======================================================
-# SIGNAL GENERATORS (now with smoothing)
-# ======================================================
+        grad = torch.autograd.grad(potential, Xi, create_graph=False)[0]
+        dXi = -lam * grad
 
-def commodity_signal(commodity: str, anchor: float, macro: Dict) -> Dict:
-    gdp_scale = macro.get("gdp", 1e14) / 1e14 if macro.get("gdp") else 1.0
-    supply = anchor * gdp_scale
-    demand = supply * 0.94
-    price_index = round((supply / 12.0) * gdp_scale, 4)
-    
-    smoothed_price = omega_smooth("price_index", price_index)
-    
-    return {
-        "type": "commodity",
-        "commodity": commodity,
-        "supply": round(supply, 4),
-        "demand": round(demand, 4),
-        "price_index": smoothed_price,
-        "currency_flow": round(demand * smoothed_price, 4),
-    }
+        Xi = Xi + dt * dXi
+        Xi = Xi.detach().requires_grad_(True)
 
-def logistics_signal(econ: Dict) -> Dict:
-    friction = abs(econ["supply"] - econ["demand"]) / max(econ["supply"], 1e-9)
-    return {"type": "logistics", "friction": round(friction, 6)}
+        Omega.append(Xi.detach().clone())
+        if len(Omega) > omega_len:
+            Omega.pop(0)
 
-def energy_signal(econ: Dict) -> Dict:
-    return {
-        "type": "energy",
-        "energy_cost_index": round(econ["price_index"] * 0.42, 4),
-        "dependency": "high" if "oil" in econ["commodity"].lower() or "gas" in econ["commodity"].lower() else "moderate"
-    }
+        trajectory.append(Xi.detach().cpu().numpy().copy())
 
-def sentiment_signal(seed: str) -> Dict:
-    import random
-    random.seed(sum(ord(c) for c in seed + str(time.time())[:8]))
-    conf = random.uniform(0.62, 0.91)
-    return {
-        "type": "sentiment",
-        "market_confidence": round(omega_smooth("confidence", conf), 6)
-    }
+    return np.array(trajectory)
 
-# ======================================================
-# LEDGER OPERATIONS
-# ======================================================
 
-def append_to_ledger(payload: Dict, meta: Dict, coherence: float) -> Dict | None:
-    if coherence < COHERENCE_THRESHOLD:
-        return {
-            "status": "refused",
-            "reason": f"Coherence too low: {coherence:.4f} < {COHERENCE_THRESHOLD}",
-            "payload": payload
-        }
-    
-    prev_hash = LEDGER[-1]["hash"] if LEDGER else "GENESIS"
-    record_hash = hash_record(payload, prev_hash)
-    
-    record = {
-        "hash": record_hash,
-        "prev_hash": prev_hash,
-        "payload": payload,
-        "metadata": {**meta, "coherence_score": coherence},
-        "bit_stats": compute_bit_stats(payload),
-        "ts": time.time(),
-    }
+def create_plot(traj, intent, lam, noise, steps):
+    fig, ax = plt.subplots(figsize=(8, 7.2), dpi=100)
     
-    LEDGER.append(record)
-    return record
+    ax.plot(traj[:,0], traj[:,1], 'royalblue', lw=1.3, alpha=0.85, label='trajectory')
+    ax.plot(traj[0,0],  traj[0,1],  'o', ms=10, mec='k', mfc='#00ff9d', label='birth')
+    ax.plot(traj[-1,0], traj[-1,1], 'o', ms=12, mec='k', mfc='#ff3366',  label='present')
 
-def run_tick(commodity: str, anchor: float, country: str, lag_days: int, use_live: bool):
-    t0 = time.time()
-    
-    macro = fetch_macro_anchor(country, use_live)
-    latency = time.time() - t0
-    
-    meta_macro = {
-        "source": "world_bank" if use_live and macro["gdp"] is not None else "synthetic",
-        "country": country,
-        "latency_s": round(latency, 4),
-        "schema": "macro.v1"
-    }
-    
-    # Macro coherence (very basic)
-    macro_coherence = compute_coherence_score({
-        "stability": 1.0 - abs(macro.get("inflation", 0))/10,
-        "realism": 1.0 if macro.get("gdp") is not None else 0.4
-    })
-    
-    macro_record = append_to_ledger({"type": "macro", **macro}, meta_macro, macro_coherence)
-    if macro_record and "status" in macro_record and macro_record["status"] == "refused":
-        return {"status": "macro_refused", "detail": macro_record}, None
-    
-    # Derived signals
-    econ = commodity_signal(commodity, anchor, macro)
-    logi = logistics_signal(econ)
-    ener = energy_signal(econ)
-    sent = sentiment_signal(commodity + country + str(int(time.time())))
-    
-    feat = {
-        "type": "features",
-        "lag_days": lag_days,
-        "projected_price": round(econ["price_index"] * (1 + (1 - sent["market_confidence"]) * 0.07), 6),
-        "volatility_proxy": round(0.012 * lag_days, 6)
-    }
-    
-    results = []
-    for payload, schema in [
-        (econ, "commodity.v1"),
-        (logi, "logistics.v1"),
-        (ener, "energy.v1"),
-        (sent, "sentiment.v1"),
-        (feat, "features.v1")
-    ]:
-        coherence = compute_coherence_score({
-            "stability": 1.0 - abs(logi["friction"]),
-            "transparency": sent["market_confidence"]
-        })
-        
-        meta = {
-            "source": "derived",
-            "schema": schema,
-            "coherence_score": coherence
-        }
-        rec = append_to_ledger(payload, meta, coherence)
-        if rec:
-            results.append(rec)
-    
-    tip = LEDGER[-1] if LEDGER else None
-    return {
-        "status": "tick_complete",
-        "ledger_length": len(LEDGER),
-        "tip_hash": tip["hash"] if tip else None,
-        "latest_coherence": tip["metadata"].get("coherence_score") if tip else None,
-        "records_added": len(results)
-    }, tip["hash"] if tip else None
+    ax.scatter(intent[0], intent[1], s=320, c='gold', marker='*',
+               edgecolor='navy', lw=2, label='semantic intent target')
 
-# ======================================================
-# CHAT INTERFACE - Jarvis X (enhanced awareness)
-# ======================================================
+    # Coherence estimate
+    final_dist = np.linalg.norm(traj[-1] - np.array(intent))
+    coh = max(0.0, 1.0 - final_dist / 4.8)
+    coh_text = f"Coherence: {coh:.3f}"
+    if coh < COHERENCE_WARN:
+        coh_text += "  ⚠ drifting"
 
-def jarvis_x_chat(message: str, history: List):
-    CHAT_MEMORY.append(message)
-    m = message.lower().strip()
-    
-    if not LEDGER:
-        return "The ledger is still in genesis state. Please run a tick first.", history
-    
-    tip = LEDGER[-1]
-    
-    if any(k in m for k in ["latest", "tip", "current"]):
-        return json.dumps({
-            "tip_hash": tip["hash"],
-            "prev_hash": tip["prev_hash"],
-            "coherence": tip["metadata"].get("coherence_score", "N/A"),
-            "type": tip["payload"].get("type"),
-            "timestamp": time.ctime(tip["ts"])
-        }, indent=2), history
-    
-    if "ledger" in m or "size" in m:
-        return f"Current ledger contains {len(LEDGER)} records. Average coherence: {np.mean([r['metadata'].get('coherence_score',0) for r in LEDGER]):.4f}", history
-    
-    if "coherence" in m or "health" in m:
-        coherences = [r["metadata"].get("coherence_score", 0) for r in LEDGER[-12:]]
-        return f"Recent coherence trend (last {len(coherences)}): {coherences}\nAverage: {np.mean(coherences):.4f}", history
-    
-    if "refused" in m or "rejected" in m:
-        refused = [r for r in LEDGER if r["metadata"].get("coherence_score", 1) < COHERENCE_THRESHOLD]
-        return f"{len(refused)} records were refused due to low coherence.", history
+    ax.set_title(
+        f"IRE Autonomous Manifold Evolution\n"
+        f"Λ = {lam:.2f} • noise = {noise:.2f} • steps = {steps}\n"
+        f"{coh_text}",
+        fontsize=13, pad=15
+    )
     
-    return (
-        "Jarvis X online. Available commands:\n"
-        "• latest / tip\n"
-        "• ledger / size\n"
-        "• coherence / health\n"
-        "• refused / rejected\n\n"
-        "The manifold is permeating... speak your intent."
-    ), history
+    ax.set_xlabel("Semantic Dimension 1", fontsize=11)
+    ax.set_ylabel("Semantic Dimension 2", fontsize=11)
+    ax.grid(True, alpha=0.15, linestyle='--')
+    ax.legend(loc='upper right', fontsize=9, framealpha=0.92)
+    ax.set_aspect('equal')
+    ax.set_facecolor('#f8f9fa')
 
-# ======================================================
-# GRADIO INTERFACE
-# ======================================================
+    buf = BytesIO()
+    plt.savefig(buf, format='png', bbox_inches='tight', dpi=120)
+    buf.seek(0)
+    img_base64 = base64.b64encode(buf.read()).decode('ascii')
+    plt.close(fig)
+
+    return f"data:image/png;base64,{img_base64}"
 
-css = """
-.gradio-container {font-family: 'Segoe UI', system-ui;}
-.header {text-align: center; padding: 1rem; background: linear-gradient(90deg, #1e3a8a, #3b82f6);}
-"""
 
-with gr.Blocks(css=css) as app:
+# ─── Gradio Interface ─────────────────────────────────────────────
+with gr.Blocks(title="IRE Equation • Autonomous Manifold") as demo:
     gr.Markdown(
         """
-        # 🌌 CodexFlow • IRE Permeation Engine
-        **Global Virtual Bit + Metadata System with Early Semantic Coherence Enforcement**  
-        _January 11, 2026 — Beyond SOTA prototype_
-        """,
-        elem_classes="header"
+        # Dr Moagi IRE Equation  
+        **Autonomous Semantic Manifold Explorer**  
+        *Minimal canonical implementation — January 11, 2026*
+        
+        dΞ/dt = −Λ ∇(Θ(Ξ) + Φ(Ξ) − Ψ(t) + Ω(t))
+        """
     )
-    
+
     with gr.Row():
-        with gr.Column(scale=2):
-            gr.Markdown("### Data Ingestion & Tick Controls")
-            
-            with gr.Row():
-                commodity = gr.Dropdown(
-                    choices=["Gold", "Oil", "Gas", "Wheat", "Copper", "Lithium"],
-                    value="Gold",
-                    label="Commodity"
-                )
-                anchor = gr.Number(value=1200, label="Physical Anchor (tons/price unit)")
-            
-            with gr.Row():
-                country = gr.Textbox(value="WLD", label="Country Code (WLD = World)")
-                live_data = gr.Checkbox(value=True, label="Use Live World Bank Data")
-                lag_days = gr.Slider(1, 180, value=7, step=1, label="Lag (days)")
+        with gr.Column(scale=1):
+            gr.Markdown("### Control Parameters")
+
+            steps = gr.Slider(200, 1500, value=DEFAULT_PARAMS['steps'], 
+                             step=50, label="Simulation steps")
             
-            run_btn = gr.Button("Run Tick → Permeate Ledger", variant="primary")
+            noise = gr.Slider(0.00, 1.20, value=DEFAULT_PARAMS['noise'], 
+                             step=0.02, label="External noise strength (Ψ)")
             
-            tick_result = gr.JSON(label="Tick Result")
-            current_tip = gr.Textbox(label="Current Tip Hash", interactive=False)
+            lam = gr.Slider(0.5, 10.0, value=DEFAULT_PARAMS['lambda_'], 
+                           step=0.1, label="Constraint strength (Λ)")
             
-            run_btn.click(
-                fn=run_tick,
-                inputs=[commodity, anchor, country, lag_days, live_data],
-                outputs=[tick_result, current_tip]
-            )
-        
-        with gr.Column(scale=1):
-            gr.Markdown("### Jarvis X • Manifold Interface")
-            chat = gr.ChatInterface(
-                fn=jarvis_x_chat,
-                chatbot=gr.Chatbot(height=380),
-                title="Jarvis X Resonance",
-                description="Query the manifold state • coherence • provenance"
+            intent_x = gr.Number(value=DEFAULT_PARAMS['intent_x'], 
+                                label="Intent target X")
+            intent_y = gr.Number(value=DEFAULT_PARAMS['intent_y'], 
+                                label="Intent target Y")
+
+            run_btn = gr.Button("Run Autonomous Evolution", variant="primary")
+
+        with gr.Column(scale=3):
+            output_image = gr.Image(label="Manifold Trajectory", type="filepath")
+            gr.Markdown(
+                """
+                **Legend**  
+                • Green circle → starting point  
+                • Red circle → current position  
+                • Gold star → semantic intent attractor  
+                • Blue path → autonomous trajectory under the sealed equation
+                
+                Higher Λ → stronger law & refusal of drift  
+                Higher noise → more chaotic external pressure
+                """
             )
 
+    # Footer explanation
     gr.Markdown(
         """
         ---
-        **Status**: Early IRE permeation • Λ constraint stub • Ω memory smoothing  
-        **Coherence threshold**: 0.65 • Records refused below this level are quarantined  
-        *Not financial advice — research & provenance-first prototype*
+        **Current status**: 2D toy prototype • pure mathematical core  
+        • constraint-dominant flow • causal memory smoothing • stochastic reality pressure  
+        • No language, no high dimensions, no external data — only the law breathing
         """
     )
 
+    def on_run(steps, noise, lam, ix, iy):
+        traj = run_ire_simulation(steps, DEFAULT_PARAMS['dt'], noise, lam, 
+                                 DEFAULT_PARAMS['omega_window'], (ix, iy))
+        img = create_plot(traj, (ix, iy), lam, noise, steps)
+        return img
+
+    run_btn.click(
+        on_run,
+        inputs=[steps, noise, lam, intent_x, intent_y],
+        outputs=output_image
+    )
+
 if __name__ == "__main__":
-    app.launch()
+    demo.launch()