Complete rebuild: Premium LOGOS v1.0 Space with Log Polar Cone, MTL Interpreter, Genesis Block

app.py

@@ -1,11 +1,22 @@
+"""
+LOGOS v1.0 - Logarithmic Ordering Generation Operating Software
+Hugging Face Space Application
+
+A structural AI framework where:
+- Every concept is a Prime
+- Every file is a Number
+- Computing = Routing
+"""
+
 import gradio as gr
 import numpy as np
 import plotly.graph_objects as go
 import sympy
-import time
+import math
 import os
 import sys
-from collections import Counter
+import threading
+import subprocess
 
 # Ensure logos package is importable
 current_dir = os.path.dirname(os.path.abspath(__file__))
@@ -13,419 +24,453 @@ if current_dir not in sys.path:
     sys.path.insert(0, current_dir)
 
 # --- LOGOS CORE IMPORTS ---
+MTL_AVAILABLE = False
 try:
     from logos.mtl.interpreter import MTLInterpreter
-    from logos.memory.prime_db import PrimeTokenDB
     MTL_AVAILABLE = True
-    print("[LOGOS] MTL Interpreter loaded successfully")
+    print("[LOGOS] MTL Interpreter loaded")
 except ImportError as e:
-    MTL_AVAILABLE = False
     print(f"[LOGOS] MTL not available: {e}")
 
-try:
-    from logos.dsp_bridge import DSPBridge
-    from logos.logos_core import PRIME_MODULO
-    print(f"[LOGOS] Successfully imported DSPBridge")
-except ImportError:
-    DSPBridge = None
-    PRIME_MODULO = 9973
-
-# --- PROTOCOL 26: START NEURAL ROUTER ---
-import threading
-import subprocess
-
+# --- NEURAL ROUTER (Background) ---
 def start_neural_router():
-    print("[SYSTEM] Igniting Neural Router (Port 5000)...")
     try:
-        process = subprocess.Popen(
-            [sys.executable, "-m", "logos.server"], 
+        subprocess.Popen(
+            [sys.executable, "-m", "logos.server"],
             env={**os.environ, "PYTHONPATH": current_dir},
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            bufsize=1
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL
         )
-        print(f"[OK] Neural Router Process ID: {process.pid}")
-        
-        def stream_logs(p):
-            for line in iter(p.stdout.readline, ''):
-                print(f"[ROUTER] {line.strip()}")
-                
-        threading.Thread(target=stream_logs, args=(process,), daemon=True).start()
-        
+        print("[LOGOS] Neural Router started on port 5000")
     except Exception as e:
-        print(f"[X] Failed to start Neural Router: {e}")
+        print(f"[LOGOS] Router failed: {e}")
 
 threading.Thread(target=start_neural_router, daemon=True).start()
 
-# --- THEME LOADING ---
-def load_css():
-    try:
-        with open(os.path.join(current_dir, "style.css"), "r") as f:
-            return f.read()
-    except:
-        return ""
+# =============================================================================
+# CUSTOM CSS - Premium Dark Theme
+# =============================================================================
+CUSTOM_CSS = """
+:root {
+    --primary: #00ffea;
+    --secondary: #ff0055;
+    --accent: #9d4edd;
+    --bg-dark: #0a0e17;
+    --bg-card: #111827;
+    --text: #e5e7eb;
+    --text-dim: #6b7280;
+}
+
+.gradio-container {
+    background: linear-gradient(135deg, #0a0e17 0%, #1a1f2e 100%) !important;
+    font-family: 'Inter', -apple-system, sans-serif !important;
+}
+
+.header-title {
+    background: linear-gradient(90deg, #00ffea, #9d4edd, #ff0055);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    font-size: 2.5rem !important;
+    font-weight: 800 !important;
+    text-align: center;
+    margin-bottom: 0.5rem;
+}
+
+.header-subtitle {
+    color: #6b7280;
+    text-align: center;
+    font-size: 1rem;
+    margin-bottom: 1.5rem;
+}
+
+.status-card {
+    background: linear-gradient(145deg, #111827, #1f2937);
+    border: 1px solid rgba(0, 255, 234, 0.2);
+    border-radius: 12px;
+    padding: 1rem;
+}
+
+.metric-value {
+    font-size: 1.5rem;
+    font-weight: 700;
+    color: #00ffea;
+}
+
+.metric-label {
+    font-size: 0.75rem;
+    color: #6b7280;
+    text-transform: uppercase;
+}
 
-# --- MTL INTERPRETER INTERFACE ---
+.genesis-table td, .genesis-table th {
+    padding: 8px 16px;
+    border-bottom: 1px solid rgba(255,255,255,0.1);
+}
+
+.genesis-table th {
+    color: #00ffea;
+    font-weight: 600;
+}
+
+.code-output {
+    background: #0d1117 !important;
+    border: 1px solid #30363d !important;
+    border-radius: 8px;
+    font-family: 'JetBrains Mono', 'Fira Code', monospace !important;
+}
+"""
+
+# =============================================================================
+# MTL INTERPRETER FUNCTIONS
+# =============================================================================
 def execute_mtl(code: str) -> str:
-    """Execute MTL code and return result."""
     if not MTL_AVAILABLE:
-        return "MTL Interpreter not available in this environment"
-    
+        return "Error: MTL Interpreter not available"
+    if not code.strip():
+        return "Enter MTL code to execute"
     try:
-        interpreter = MTLInterpreter()
-        result = interpreter.execute(code)
-        return f"Result: {result}"
+        mtl = MTLInterpreter()
+        result = mtl.execute(code)
+        return f">>> {result}"
     except Exception as e:
         return f"Error: {str(e)}"
 
-def run_mtl_demo() -> str:
-    """Run a demonstration of MTL capabilities."""
+def run_full_demo() -> str:
     if not MTL_AVAILABLE:
         return "MTL not available"
     
     try:
         mtl = MTLInterpreter()
-        output = []
+        lines = []
         
-        output.append("=== LOGOS MTL DEMONSTRATION ===\n")
+        lines.append("=" * 50)
+        lines.append("  LOGOS MTL DEMONSTRATION")
+        lines.append("=" * 50)
         
-        # Basic arithmetic
-        output.append("[1] Tensor Multiplication")
+        # Arithmetic
+        lines.append("\n[1] TENSOR ARITHMETIC")
         r = mtl.execute('(mult [2] [3])')
-        output.append(f"    (mult [2] [3]) = {r}  (MECHANISM x RESULT = FLIP)")
+        lines.append(f"    (mult [2] [3]) = {r}")
+        lines.append(f"    MECHANISM x RESULT = FLIP")
         
-        # Logic gates
-        output.append("\n[2] Logic Gates")
+        # Logic Gates
+        lines.append("\n[2] LOGIC GATES")
         r = mtl.execute('(or [2] [3])')
-        output.append(f"    (or [2] [3]) = {r}  (LCM - Superposition)")
+        lines.append(f"    (or [2] [3]) = {r}  (LCM - Superposition)")
         r = mtl.execute('(and [6] [10])')
-        output.append(f"    (and [6] [10]) = {r}  (GCD - Intersection)")
+        lines.append(f"    (and [6] [10]) = {r}  (GCD - Intersection)")
         
         # Factorial
-        output.append("\n[3] Recursive Function (Factorial)")
-        mtl.execute('(defun factorial (n) (if (lt? n 2) 1 (mult n (factorial (sub n 1)))))')
-        r = mtl.execute('(factorial 5)')
-        output.append(f"    (factorial 5) = {r}")
+        lines.append("\n[3] RECURSIVE FUNCTION")
+        mtl.execute('(defun fact (n) (if (lt? n 2) 1 (mult n (fact (sub n 1)))))')
+        r = mtl.execute('(fact 5)')
+        lines.append(f"    (fact 5) = {r}  (5! = 120)")
         
         # Synapse
-        output.append("\n[4] Knowledge Graph (Synapse)")
+        lines.append("\n[4] KNOWLEDGE GRAPH")
         r = mtl.execute('(relate [17] [19])')
-        output.append(f"    (relate [17] [19]) = {r}  (IMAGE x TEXT x RELATE)")
+        lines.append(f"    (relate [17] [19]) = {r}")
+        lines.append(f"    IMAGE x TEXT x RELATE = Synapse")
         
-        output.append("\n=== TURING COMPLETENESS VERIFIED ===")
+        lines.append("\n" + "=" * 50)
+        lines.append("  TURING COMPLETENESS VERIFIED")
+        lines.append("=" * 50)
         
-        return "\n".join(output)
+        return "\n".join(lines)
     except Exception as e:
-        return f"Demo Error: {str(e)}"
+        return f"Error: {str(e)}"
 
-# --- PHYSICS VISUALIZERS ---
-def get_prime_topology(max_n=500):
-    """
-    LOGOS Concentric Log Polar Cone Topology.
-    - Each ring = mod 10 (decade layer)
-    - Special lanes: mod 1, 3, 7, 9 (prime-generating residues)
-    """
-    import math
+# =============================================================================
+# VISUALIZATIONS
+# =============================================================================
+def create_log_polar_cone(max_n=300):
+    """LOGOS Log Polar Cone - Mod 10 Topology"""
     fig = go.Figure()
     
-    # Generate numbers and categorize by mod 10
-    all_nums = list(range(1, max_n))
-    
-    # Color by mod 10 residue class
-    residue_colors = {
-        1: '#00ffea',  # Cyan - Prime lane
-        3: '#ff00ff',  # Magenta - Prime lane
-        7: '#ffff00',  # Yellow - Prime lane
-        9: '#00ff00',  # Green - Prime lane
-        0: '#333333',  # Gray - Even decade
-        2: '#333333', 4: '#333333', 5: '#333333', 
-        6: '#333333', 8: '#333333'
-    }
+    colors = {1: '#00ffea', 3: '#ff00ff', 7: '#ffff00', 9: '#00ff00'}
     
-    # Build traces for each residue class
-    for residue in [1, 3, 7, 9]:  # Prime-generating lanes only
-        nums_in_class = [n for n in all_nums if n % 10 == residue]
-        
-        # Log polar coordinates
-        # r = log10(n) gives concentric rings per decade
-        # theta = (n mod 10) * 36 degrees + offset for spread
-        r = [math.log10(n) if n > 0 else 0 for n in nums_in_class]
-        theta = [(n % 100) * 3.6 for n in nums_in_class]  # Spread within decade
+    for residue in [1, 3, 7, 9]:
+        nums = [n for n in range(1, max_n) if n % 10 == residue]
+        r = [math.log10(n) for n in nums]
+        theta = [(n % 100) * 3.6 for n in nums]
         
-        # Mark primes
-        is_prime = [sympy.isprime(n) for n in nums_in_class]
-        sizes = [12 if p else 4 for p in is_prime]
-        colors = [residue_colors[residue] if p else '#555555' for p in is_prime]
+        is_prime = [sympy.isprime(n) for n in nums]
+        sizes = [14 if p else 5 for p in is_prime]
+        cols = [colors[residue] if p else '#333' for p in is_prime]
         
         fig.add_trace(go.Scatterpolar(
-            r=r, 
-            theta=theta, 
-            mode='markers',
-            marker=dict(
-                color=colors,
-                size=sizes,
-                line=dict(color='white', width=0.3),
-                opacity=0.8
-            ),
-            text=[f"{n} (mod10={residue})" for n in nums_in_class],
+            r=r, theta=theta, mode='markers',
+            marker=dict(color=cols, size=sizes, opacity=0.85),
+            text=[f"{n}" for n in nums],
             hoverinfo='text',
             name=f'Mod {residue}'
         ))
     
-    # Add ring labels for decades
-    for decade in [10, 100]:
-        r_ring = math.log10(decade)
-        theta_ring = list(range(0, 360, 10))
+    # Decade rings
+    for d in [10, 100]:
         fig.add_trace(go.Scatterpolar(
-            r=[r_ring] * len(theta_ring),
-            theta=theta_ring,
+            r=[math.log10(d)] * 36,
+            theta=list(range(0, 360, 10)),
             mode='lines',
-            line=dict(color='rgba(255,255,255,0.2)', width=1, dash='dot'),
+            line=dict(color='rgba(255,255,255,0.15)', width=1, dash='dot'),
             showlegend=False
         ))
     
     fig.update_layout(
-        template="plotly_dark",
         paper_bgcolor='rgba(0,0,0,0)',
         plot_bgcolor='rgba(0,0,0,0)',
         showlegend=True,
-        legend=dict(font=dict(color='white')),
+        legend=dict(font=dict(color='white', size=10), x=0.85, y=0.95),
         polar=dict(
-            radialaxis=dict(
-                visible=True,
-                range=[0, 3],
-                ticktext=['1', '10', '100', '1000'],
-                tickvals=[0, 1, 2, 3],
-                gridcolor='rgba(255,255,255,0.1)'
-            ),
-            angularaxis=dict(
-                visible=True,
-                gridcolor='rgba(255,255,255,0.1)'
-            ),
-            bgcolor='rgba(11,15,25,0.9)'
+            radialaxis=dict(visible=True, range=[0, 2.5], 
+                           ticktext=['1', '10', '100'], tickvals=[0, 1, 2],
+                           gridcolor='rgba(255,255,255,0.08)', color='#666'),
+            angularaxis=dict(visible=True, gridcolor='rgba(255,255,255,0.08)'),
+            bgcolor='rgba(17,24,39,0.95)'
         ),
-        margin=dict(l=40, r=40, t=40, b=40),
-        height=550,
-        title=dict(
-            text="LOGOS Log Polar Cone (Mod 10 Rings)",
-            font=dict(color='white')
-        )
+        margin=dict(l=30, r=30, t=50, b=30),
+        height=480,
+        title=dict(text="Log Polar Cone (Mod 10)", font=dict(color='#00ffea', size=14))
     )
     return fig
 
-def get_genesis_block_visual():
-    """Visualize the Genesis Block primes."""
-    genesis = {
-        2: "MECHANISM", 3: "RESULT", 5: "CHOICE", 7: "PERSIST",
-        11: "WHY", 13: "RELATE", 17: "IMAGE", 19: "TEXT", 23: "AUDIO", 29: "SIGNAL"
-    }
+def create_genesis_chart():
+    """Genesis Block Bar Chart"""
+    genesis = [
+        (2, "MECHANISM", "#00ffea"),
+        (3, "RESULT", "#00d4aa"),
+        (5, "CHOICE", "#00aa88"),
+        (7, "PERSIST", "#ff0055"),
+        (11, "WHY", "#ff3377"),
+        (13, "RELATE", "#9d4edd"),
+        (17, "IMAGE", "#7c3aed"),
+        (19, "TEXT", "#6366f1"),
+        (23, "AUDIO", "#3b82f6"),
+        (29, "SIGNAL", "#0ea5e9"),
+    ]
     
-    fig = go.Figure()
+    primes = [g[0] for g in genesis]
+    labels = [g[1] for g in genesis]
+    colors = [g[2] for g in genesis]
     
-    primes = list(genesis.keys())
-    labels = list(genesis.values())
-    
-    fig.add_trace(go.Bar(
-        x=labels,
-        y=primes,
-        marker=dict(
-            color=primes,
-            colorscale='Plasma',
-        ),
-        text=primes,
-        textposition='auto',
+    fig = go.Figure(go.Bar(
+        x=labels, y=primes,
+        marker=dict(color=colors, line=dict(width=0)),
+        text=primes, textposition='auto', textfont=dict(color='white', size=12)
     ))
     
     fig.update_layout(
-        template="plotly_dark",
         paper_bgcolor='rgba(0,0,0,0)',
         plot_bgcolor='rgba(0,0,0,0)',
-        title="Genesis Block - Prime Axioms",
-        xaxis_title="Concept",
-        yaxis_title="Prime Value",
-        height=400
+        xaxis=dict(tickfont=dict(color='#9ca3af', size=10), gridcolor='rgba(255,255,255,0.05)'),
+        yaxis=dict(tickfont=dict(color='#9ca3af'), gridcolor='rgba(255,255,255,0.05)', title='Prime Value'),
+        margin=dict(l=50, r=20, t=40, b=60),
+        height=350,
+        title=dict(text="Genesis Block Axioms", font=dict(color='#9d4edd', size=14))
     )
     return fig
 
-# --- UI TEXT & CONTEXT ---
-PROTOCOL_NAME = "LOGOS v1.0"
-SUBTITLE = "Logarithmic Ordering Generation Operating Software"
-
-def fetch_manifold_diagnostics():
-    """Polls the router for live physics state."""
-    import requests
+# =============================================================================
+# BUILD THE APP
+# =============================================================================
+with gr.Blocks(css=CUSTOM_CSS, title="LOGOS - Arithmetic OS", theme=gr.themes.Base()) as demo:
     
-    try:
-        resp = requests.get("http://localhost:5000/v1", timeout=1)
-        data = resp.json()
-        state = data.get("manifold_state", {})
-        
-        status_html = f"""
-        <div style='display: flex; gap: 20px; align-items: center;'>
-            <div style='background: rgba(0,255,234,0.1); padding: 10px; border: 1px solid #00ffea; border-radius: 5px;'>
-                <div style='font-size: 10px; color: #888;'>SYSTEM STATUS</div>
-                <div style='font-size: 16px; color: #00ffea; font-weight: bold;'>{data.get('status', 'OFFLINE').upper()}</div>
-            </div>
-            <div style='background: rgba(255,0,85,0.1); padding: 10px; border: 1px solid #ff0055; border-radius: 5px;'>
-                <div style='font-size: 10px; color: #888;'>PROTOCOL</div>
-                <div style='font-size: 16px; color: #ff0055; font-weight: bold;'>SPCW / MTL</div>
-            </div>
-            <div style='background: rgba(157,78,221,0.1); padding: 10px; border: 1px solid #9d4edd; border-radius: 5px;'>
-                <div style='font-size: 10px; color: #888;'>MTL STATUS</div>
-                <div style='font-size: 16px; color: #9d4edd;'>{'ONLINE' if MTL_AVAILABLE else 'OFFLINE'}</div>
+    # HEADER
+    gr.HTML("""
+    <div style="text-align: center; padding: 2rem 0 1rem 0;">
+        <h1 class="header-title">LOGOS</h1>
+        <p class="header-subtitle">Logarithmic Ordering Generation Operating Software</p>
+        <p style="color: #4b5563; font-size: 0.85rem;">
+            Intelligence through structural mathematics • Computing = Routing
+        </p>
+    </div>
+    """)
+    
+    # STATUS BAR
+    with gr.Row():
+        gr.HTML(f"""
+        <div style="display: flex; gap: 1rem; justify-content: center; flex-wrap: wrap; padding: 0.5rem;">
+            <div class="status-card" style="min-width: 120px; text-align: center;">
+                <div class="metric-label">MTL Engine</div>
+                <div class="metric-value">{'ONLINE' if MTL_AVAILABLE else 'OFFLINE'}</div>
             </div>
-        </div>
-        """
-        
-        graph_html = "<div style='padding:20px; color:#666;'>Manifold Active</div>"
-        return status_html, graph_html
-        
-    except Exception as e:
-        status_html = f"""
-        <div style='display: flex; gap: 20px; align-items: center;'>
-            <div style='background: rgba(255,165,0,0.1); padding: 10px; border: 1px solid orange; border-radius: 5px;'>
-                <div style='font-size: 10px; color: #888;'>SYSTEM STATUS</div>
-                <div style='font-size: 16px; color: orange; font-weight: bold;'>STANDALONE</div>
+            <div class="status-card" style="min-width: 120px; text-align: center;">
+                <div class="metric-label">Version</div>
+                <div class="metric-value" style="color: #9d4edd;">1.0</div>
             </div>
-            <div style='background: rgba(0,255,234,0.1); padding: 10px; border: 1px solid #00ffea; border-radius: 5px;'>
-                <div style='font-size: 10px; color: #888;'>MTL INTERPRETER</div>
-                <div style='font-size: 16px; color: #00ffea; font-weight: bold;'>{'ONLINE' if MTL_AVAILABLE else 'OFFLINE'}</div>
+            <div class="status-card" style="min-width: 120px; text-align: center;">
+                <div class="metric-label">Protocol</div>
+                <div class="metric-value" style="color: #ff0055;">SPCW</div>
             </div>
         </div>
-        """
-        return status_html, "<div style='padding:20px; color:#666;'>Router not connected - MTL available for direct use</div>"
-
-# --- APP LAYOUT ---
-with gr.Blocks(theme=gr.themes.Soft(), css=load_css(), title="LOGOS: Arithmetic OS") as demo:
-    
-    # 1. HERO HEADER
-    with gr.Row(elem_classes=["header-row"]):
-        gr.Markdown(f"""
-        # {PROTOCOL_NAME}
-        **{SUBTITLE}**
-        
-        *Intelligence through structural mathematics, not statistical probability.*
         """)
-        
-    # 2. LIVE TELEMETRY
-    with gr.Row():
-        status_panel = gr.HTML(value="Initializing Telemetry...")
     
-    # 3. MAIN INTERFACE
+    # MAIN TABS
     with gr.Tabs():
         
-        # TAB A: MTL INTERPRETER
-        with gr.Tab("MTL Interpreter"):
+        # TAB 1: MTL INTERPRETER
+        with gr.TabItem("MTL Interpreter", id="mtl"):
             with gr.Row():
-                with gr.Column(scale=2):
-                    mtl_input = gr.Textbox(
+                with gr.Column(scale=3):
+                    mtl_code = gr.Code(
                         label="MTL Code",
-                        placeholder="(mult [2] [3])",
-                        lines=3
+                        language="lisp",
+                        value="(mult [2] [3])",
+                        lines=4
                     )
-                    mtl_examples = gr.Examples(
+                    with gr.Row():
+                        run_btn = gr.Button("Execute", variant="primary", size="lg")
+                        demo_btn = gr.Button("Run Demo", variant="secondary")
+                    
+                    gr.Examples(
                         examples=[
                             ["(mult [2] [3])"],
                             ["(or [17] [19])"],
                             ["(and [6] [10])"],
                             ["(relate [17] [19])"],
                             ["(fractran [[5 2] [5 3]] 72)"],
+                            ["(not [6] [6] [42])"],
                         ],
-                        inputs=mtl_input
+                        inputs=mtl_code,
+                        label="Quick Examples"
                     )
-                    mtl_run = gr.Button("Execute MTL", variant="primary")
-                with gr.Column(scale=1):
-                    mtl_output = gr.Textbox(label="Result", lines=3)
-                    mtl_demo_btn = gr.Button("Run Full Demo")
-                    mtl_demo_output = gr.Textbox(label="Demo Output", lines=15)
+                
+                with gr.Column(scale=2):
+                    mtl_result = gr.Textbox(label="Result", lines=2, elem_classes=["code-output"])
+                    demo_output = gr.Textbox(label="Demo Output", lines=18, elem_classes=["code-output"])
             
-            mtl_run.click(execute_mtl, inputs=mtl_input, outputs=mtl_output)
-            mtl_demo_btn.click(run_mtl_demo, outputs=mtl_demo_output)
+            run_btn.click(execute_mtl, inputs=mtl_code, outputs=mtl_result)
+            demo_btn.click(run_full_demo, outputs=demo_output)
         
-        # TAB B: GENESIS BLOCK
-        with gr.Tab("Genesis Block"):
+        # TAB 2: GENESIS BLOCK
+        with gr.TabItem("Genesis Block", id="genesis"):
             with gr.Row():
                 with gr.Column(scale=2):
-                    genesis_plot = gr.Plot(value=get_genesis_block_visual(), label="Prime Axioms")
+                    gr.Plot(value=create_genesis_chart(), label="Prime Axioms")
                 with gr.Column(scale=1):
                     gr.Markdown("""
                     ### The Root Manifold
                     
-                    | Prime | Concept |
-                    |-------|---------|
-                    | [2] | MECHANISM |
-                    | [3] | RESULT |
-                    | [5] | CHOICE |
-                    | [7] | PERSIST |
-                    | [11] | WHY |
-                    | [13] | RELATE |
-                    | [17] | IMAGE |
-                    | [19] | TEXT |
-                    | [23] | AUDIO |
-                    | [29] | SIGNAL |
+                    | Prime | Concept | Domain |
+                    |:------|:--------|:-------|
+                    | **[2]** | MECHANISM | Operator |
+                    | **[3]** | RESULT | Operand |
+                    | **[5]** | CHOICE | Branch |
+                    | **[7]** | PERSIST | Memory |
+                    | **[11]** | WHY | Query |
+                    | **[13]** | RELATE | Link |
+                    | **[17]** | IMAGE | Visual |
+                    | **[19]** | TEXT | Linguistic |
+                    | **[23]** | AUDIO | Acoustic |
+                    | **[29]** | SIGNAL | Raw |
+                    
+                    ---
                     
-                    *Every concept is a Prime. Every file is a Number.*
+                    **Composite Domains:**
+                    - `[6] = 2×3` → FLIP (Action)
+                    - `[42] = 2×3×7` → DEEP STORAGE
+                    - `[323] = 17×19` → VISUAL TEXT
                     """)
         
-        # TAB C: PRIME TOPOLOGY
-        with gr.Tab("Prime Topology"):
+        # TAB 3: PRIME TOPOLOGY
+        with gr.TabItem("Prime Topology", id="topology"):
             with gr.Row():
-                with gr.Column():
-                    prime_plot = gr.Plot(value=get_prime_topology(), label="Log Polar Cone")
-                with gr.Column():
+                with gr.Column(scale=2):
+                    gr.Plot(value=create_log_polar_cone(), label="Log Polar Cone")
+                with gr.Column(scale=1):
                     gr.Markdown("""
-                    ### LOGOS Log Polar Cone Topology
+                    ### Log Polar Cone Topology
+                    
+                    **Concentric Rings = Decades (Mod 10)**
+                    
+                    **Prime Lanes:**
+                    - 🔵 **Mod 1** - Numbers ending in 1
+                    - 🟣 **Mod 3** - Numbers ending in 3  
+                    - 🟡 **Mod 7** - Numbers ending in 7
+                    - 🟢 **Mod 9** - Numbers ending in 9
                     
-                    **Concentric rings = Mod 10 decades**
+                    ---
                     
-                    **Prime Lanes (Mod 10 residues):**
-                    - **Cyan (1)**: Numbers ending in 1
-                    - **Magenta (3)**: Numbers ending in 3
-                    - **Yellow (7)**: Numbers ending in 7
-                    - **Green (9)**: Numbers ending in 9
+                    **Key Insight:**
                     
-                    Large dots = **Primes** (only end in 1,3,7,9)
+                    All primes > 5 end in **1, 3, 7, or 9**.
                     
-                    *Arithmetic is Architecture.*
+                    These are the only residue classes coprime to 10.
+                    
+                    The topology reveals prime distribution patterns through modular arithmetic.
+                    
+                    ---
+                    
+                    *Large dots = Primes*  
+                    *Small dots = Composites*
                     """)
         
-        # TAB D: RECURSIVE REASONING
-        with gr.Tab("Chat"):
-            with gr.Column(elem_classes=["chat-container"]):
-                chatbot = gr.Chatbot(label="LOGOS Router")
-                msg = gr.Textbox(label="Message", placeholder="Ask LOGOS...")
-                clear = gr.Button("Clear")
+        # TAB 4: DOCS
+        with gr.TabItem("Documentation", id="docs"):
+            gr.Markdown("""
+            # LOGOS Architecture
             
-            def user(user_message, history):
-                return "", history + [[user_message, None]]
-
-            def bot(history):
-                user_message = history[-1][0]
-                import requests
-                try:
-                    payload = {
-                        "messages": [{"role": "user", "content": user_message}],
-                        "model": "logos-matroska-router"
-                    }
-                    resp = requests.post("http://localhost:5000/v1/chat/completions", json=payload, timeout=60)
-                    bot_message = resp.json()['choices'][0]['message']['content']
-                except Exception as e:
-                    bot_message = f"Router offline. Try MTL directly: {e}"
-                
-                history[-1][1] = bot_message
-                return history
-
-            msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
-                bot, chatbot, chatbot
-            )
+            ## The Five Imperatives
+            
+            1. **Erasure of Statistical Probability** → Structural certainty via dissolution
+            2. **Solving the Amnesia Crisis** → Matroska topology for context isolation  
+            3. **Structural Fidelity via Baking** → SSIM-based meaning preservation
+            4. **Optimal Agentic Digestion** → Agent Flow for tree-of-atoms optimization
+            5. **Self-Stabilizing Transport** → SPCW protocol with Delta Heat tracking
+            
+            ---
+            
+            ## Core Axiom
+            
+            > **Computing a value IS routing it.**
+            
+            A standard OS checks `if (condition)` then executes a jump.  
+            LOGOS calculates `GCD(State, Filter)` and the result IS the address.
+            
+            ---
+            
+            ## Verified Components
+            
+            | Module | Status | Function |
+            |:-------|:-------|:---------|
+            | MTL Interpreter | ✅ | Turing Complete |
+            | Genesis Kernel | ✅ | Agent Flow Lifecycle |
+            | SPCW Transceiver | ✅ | Binary Transport |
+            | Harmonizer | ✅ | Resonance Filter |
+            | Dissolution Engine | ✅ | Type Detection |
+            
+            ---
+            
+            ## MTL Quick Reference
+            
+            ```lisp
+            ; Arithmetic
+            (mult [2] [3])        ; → 6
+            (div [6] [2])         ; → 3
+            
+            ; Logic Gates
+            (or [2] [3])          ; → 6 (LCM)
+            (and [6] [10])        ; → 2 (GCD)
+            (not [6] [6] [42])    ; → 42 (Steering)
+            
+            ; Knowledge Graph
+            (relate [17] [19])    ; → 4199 (Synapse)
+            (trace 4199 [17])     ; → 17 (Traceability)
             
-    # AUTO-REFRESH LOGIC
-    timer = gr.Timer(5)
-    timer.tick(fetch_manifold_diagnostics, outputs=[status_panel, gr.HTML(visible=False)])
+            ; Recursion
+            (defun fact (n) (if (lt? n 2) 1 (mult n (fact (sub n 1)))))
+            (fact 5)              ; → 120
+            ```
+            """)
     
-    # Load initial state
-    demo.load(fetch_manifold_diagnostics, outputs=[status_panel, gr.HTML(visible=False)])
+    # FOOTER
+    gr.HTML("""
+    <div style="text-align: center; padding: 2rem 0 1rem 0; color: #4b5563; font-size: 0.8rem;">
+        <p>LOGOS v1.0 • Arithmetic is Architecture • 
+        <a href="https://github.com/ANXLOG" style="color: #00ffea;">GitHub</a></p>
+    </div>
+    """)
 
+# LAUNCH
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)