Merged App (Retry)

app.py

@@ -1,85 +1,85 @@
-"""
-LOGOS v1.0 - Hugging Face Space
-Primary: Chat (casual language)
-Secondary: Mod-10 Tension Web
-"""
-
 import gradio as gr
 import numpy as np
 import plotly.graph_objects as go
 import sympy
-import math
+import time
 import os
 import sys
-import threading
-import subprocess
-import requests
+from collections import Counter
 
+# Ensure logos package is importable
 current_dir = os.path.dirname(os.path.abspath(__file__))
 if current_dir not in sys.path:
     sys.path.insert(0, current_dir)
 
-# --- LOGOS CORE ---
-MTL_AVAILABLE = False
+# --- LOGOS CORE IMPORTS ---
 try:
     from logos.mtl.interpreter import MTLInterpreter
+    from logos.memory.prime_db import PrimeTokenDB
+    from logos.models.polar_matroska import PolarMatroska
     MTL_AVAILABLE = True
+    print("[LOGOS] MTL Interpreter & Models loaded successfully")
+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:
-    pass
+    DSPBridge = None
+    PRIME_MODULO = 9973
 
-ROUTER_URL = "http://localhost:5000"
+# --- PROTOCOL 26: START NEURAL ROUTER ---
+import threading
+import subprocess
 
 def start_neural_router():
+    print("[SYSTEM] Igniting Neural Router (Port 5000)...")
     try:
-        subprocess.Popen(
-            [sys.executable, "-m", "logos.server"],
+        process = subprocess.Popen(
+            [sys.executable, "-m", "logos.server"], 
             env={**os.environ, "PYTHONPATH": current_dir},
-            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1
         )
-    except:
-        pass
+        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()
+        
+    except Exception as e:
+        print(f"[X] Failed to start Neural Router: {e}")
 
 threading.Thread(target=start_neural_router, daemon=True).start()
 
-# =============================================================================
-# CHAT - Casual Language Interface
-# =============================================================================
-def chat_handler(message, history):
-    """Handle casual language input."""
-    if not message.strip():
-        return history
-    
-    history = history + [[message, None]]
-    msg = message.lower().strip()
-    
+# --- THEME LOADING ---
+def load_css():
     try:
-        # Try router first
-        payload = {"messages": [{"role": "user", "content": message}], "model": "logos-matroska-router"}
-        resp = requests.post(f"{ROUTER_URL}/v1/chat/completions", json=payload, timeout=60)
-        if resp.status_code == 200:
-            bot = resp.json()['choices'][0]['message']['content']
-        else:
-            bot = "Router unavailable. Start: python -m logos.server"
+        with open(os.path.join(current_dir, "style.css"), "r") as f:
+            return f.read()
     except:
-        bot = "Connect to Neural Router on port 5000"
-    
-    history[-1][1] = bot
-    return history
+        return ""
 
-<<<<<<< HEAD
-# =============================================================================
-# TENSION WEB VISUALIZATION - Mod 10 Radial Network
-# =============================================================================
-def create_tension_web():
-    """
-    Mod-10 Tension Web - Radial network with connections.
-    Each mod-10 lane (1,3,7,9) is a spoke.
-    Nodes connected by factor relationships.
-    """
-    fig = go.Figure()
+# --- MTL INTERPRETER INTERFACE ---
+def execute_mtl(code: str) -> str:
+    """Execute MTL code and return result."""
+    if not MTL_AVAILABLE:
+        return "MTL Interpreter not available in this environment"
     
-    # Genesis primes on the spokes
-=======
+    try:
+        interpreter = MTLInterpreter()
+        result = interpreter.execute(code)
+        return f"Result: {result}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
 def run_mtl_demo() -> str:
     """Run a demonstration of MTL capabilities."""
     if not MTL_AVAILABLE:
@@ -88,372 +88,142 @@ def run_mtl_demo() -> str:
     try:
         mtl = MTLInterpreter()
         output = []
-        
         output.append("=== LOGOS MTL DEMONSTRATION ===\n")
-        
-        # Basic arithmetic
         output.append("[1] Tensor Multiplication")
         r = mtl.execute('(mult [2] [3])')
         output.append(f"    (mult [2] [3]) = {r}  (MECHANISM x RESULT = FLIP)")
         
-        # Logic gates
         output.append("\n[2] Logic Gates")
         r = mtl.execute('(or [2] [3])')
         output.append(f"    (or [2] [3]) = {r}  (LCM - Superposition)")
         r = mtl.execute('(and [6] [10])')
         output.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}")
         
-        # Synapse
         output.append("\n[4] Knowledge Graph (Synapse)")
         r = mtl.execute('(relate [17] [19])')
         output.append(f"    (relate [17] [19]) = {r}  (IMAGE x TEXT x RELATE)")
         
         output.append("\n=== TURING COMPLETENESS VERIFIED ===")
-        
         return "\n".join(output)
     except Exception as e:
         return f"Demo 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)
-    """
+    """LOGOS Concentric Log Polar Cone Topology."""
     import math
     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'
+        1: '#00ffea', 3: '#ff00ff', 7: '#ffff00', 9: '#00ff00',
+        0: '#333333', 2: '#333333', 4: '#333333', 6: '#333333', 8: '#333333'
     }
-    
-    # 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
-        
-        # Mark primes
-        is_prime = [sympy.isprime(n) for n in nums_in_class]
+    for residue in [1, 3, 7, 9]:
+        nums = [n for n in all_nums if n % 10 == residue]
+        r = [math.log10(n) if n > 0 else 0 for n in nums]
+        theta = [(n % 100) * 3.6 for n in nums]
+        is_prime = [sympy.isprime(n) for n in nums]
         sizes = [12 if p else 4 for p in is_prime]
         colors = [residue_colors[residue] if p else '#555555' 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],
-            hoverinfo='text',
+            r=r, theta=theta, mode='markers',
+            marker=dict(size=sizes, color=colors, line=dict(color='white', width=0.3), opacity=0.8),
+            text=[f"{n} (mod10={residue})" 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))
-        fig.add_trace(go.Scatterpolar(
-            r=[r_ring] * len(theta_ring),
-            theta=theta_ring,
-            mode='lines',
-            line=dict(color='rgba(255,255,255,0.2)', 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')),
-        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)'
-        ),
-        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')
-        )
+         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')),
+         polar=dict(radialaxis=dict(visible=True, range=[0, 3], tickvals=[0, 1, 2, 3], ticktext=['1', '10', '100', '1000']), angularaxis=dict(visible=True), bgcolor='rgba(11,15,25,0.9)'),
+         margin=dict(l=40, r=40, t=40, b=40), height=550,
+         title=dict(text="LOGOS Log Polar Cone", font=dict(color='white'))
     )
     return fig
 
-def get_genesis_block_visual():
-    """Visualize the Genesis Block primes."""
->>>>>>> 512b27f (Fix: LOGOS Log Polar Cone Topology (mod 10 rings, 1/3/7/9 lanes))
-    genesis = {
-        2: (0, "MECHANISM", "#ffffff"),    # Center
-        3: (72, "RESULT", "#00ffea"),      # Cyan spoke
-        5: (144, "CHOICE", "#9d4edd"),     # Purple spoke
-        7: (216, "PERSIST", "#ff0055"),    # Red spoke
-        11: (288, "WHY", "#ffff00"),       # Yellow spoke
-        13: (36, "RELATE", "#ff00ff"),     # Magenta
-        17: (108, "IMAGE", "#00ff00"),     # Green
-        19: (180, "TEXT", "#00aaff"),      # Blue
-        23: (252, "AUDIO", "#ff8800"),     # Orange
-        29: (324, "SIGNAL", "#ff0088"),    # Pink
-    }
-    
-    # Draw connection lines (factors)
-    connection_traces = []
-    for p1, (a1, n1, c1) in genesis.items():
-        for p2, (a2, n2, c2) in genesis.items():
-            if p1 < p2:
-                # Composite = p1 * p2
-                composite = p1 * p2
-                # Draw faint connection line
-                r1, r2 = math.log10(p1 + 1) * 0.8, math.log10(p2 + 1) * 0.8
-                fig.add_trace(go.Scatterpolar(
-                    r=[r1, r2],
-                    theta=[a1, a2],
-                    mode='lines',
-                    line=dict(color='rgba(100,100,150,0.15)', width=1),
-                    showlegend=False,
-                    hoverinfo='skip'
-                ))
-    
-    # Draw prime nodes on spokes
-    for prime, (angle, name, color) in genesis.items():
-        if prime == 2:
-            r = 0.1  # Center
-            size = 40
-        else:
-            r = math.log10(prime) * 0.8
-            size = 25
-        
-        fig.add_trace(go.Scatterpolar(
-            r=[r],
-            theta=[angle],
-            mode='markers+text',
-            marker=dict(color=color, size=size, line=dict(color='white', width=2)),
-            text=[str(prime)],
-            textposition='middle center',
-            textfont=dict(color='black' if prime == 2 else 'white', size=10, family='Arial Black'),
-            name=name,
-            hovertext=f"[{prime}] {name}",
-            hoverinfo='text'
-        ))
-    
-    # Draw mod-10 lanes as subtle radial lines
-    for angle in [0, 36, 72, 108, 144, 180, 216, 252, 288, 324]:
-        fig.add_trace(go.Scatterpolar(
-            r=[0, 1.8],
-            theta=[angle, angle],
-            mode='lines',
-            line=dict(color='rgba(255,255,255,0.08)', width=1),
-            showlegend=False,
-            hoverinfo='skip'
-        ))
-    
-    # Draw concentric rings (decades)
-    for r_val in [0.3, 0.7, 1.1, 1.5]:
-        theta_ring = list(range(0, 361, 5))
-        fig.add_trace(go.Scatterpolar(
-            r=[r_val] * len(theta_ring),
-            theta=theta_ring,
-            mode='lines',
-            line=dict(color='rgba(255,255,255,0.1)', width=1),
-            showlegend=False,
-            hoverinfo='skip'
-        ))
-    
-    fig.update_layout(
-        paper_bgcolor='#0a0e17',
-        plot_bgcolor='#0a0e17',
-        showlegend=False,
-        polar=dict(
-            radialaxis=dict(visible=False, range=[0, 1.8]),
-            angularaxis=dict(visible=False),
-            bgcolor='#0a0e17'
-        ),
-        margin=dict(l=20, r=20, t=50, b=20),
-        height=500,
-        title=dict(
-            text="MOD-10 TENSION WEB",
-            font=dict(color='#00ffea', size=14),
-            x=0.5
-        )
-    )
-    return fig
+def get_polar_matroska_viz():
+    """Visualizes the Active Knowledge Base (Protocol 35)."""
+    if not MTL_AVAILABLE: return None
+    try:
+        pm = PolarMatroska()
+        success = pm.load_knowledge()
+        if not success: return None
+        return pm.visualize()
+    except Exception as e:
+        print(f"PM Viz Error: {e}")
+        return None
 
-# =============================================================================
-# CSS
-# =============================================================================
-CSS = """
-.gradio-container { background: #0a0e17 !important; }
-.chat-box { border: 1px solid rgba(0,255,234,0.3); border-radius: 12px; }
-"""
+# --- UI ---
+PROTOCOL_NAME = "LOGOS v2.0 (Stratos)"
+SUBTITLE = "Protocol 35-44: Matroska + Semantics + Cortex + RPC"
 
-# =============================================================================
-# APP
-# =============================================================================
-with gr.Blocks(css=CSS, title="LOGOS", theme=gr.themes.Base()) as demo:
-    
-    gr.HTML("""
-    <div style="text-align:center; padding:1rem;">
-        <h1 style="color:#00ffea; margin:0;">LOGOS</h1>
-        <p style="color:#666; font-size:0.9rem;">Logarithmic Ordering Generation Operating Software</p>
+def fetch_manifold_diagnostics():
+    """Polls diagnostic state."""
+    status = "ONLINE" if MTL_AVAILABLE else "DEGRADED"
+    html = f"""
+    <div style='background: rgba(0,255,100,0.1); padding: 10px; border: 1px solid #00ff66; border-radius: 5px; color: #00ff66;'>
+        LOGOS SYSTEM: {status}
     </div>
-    """)
+    """
+    return html
+
+with gr.Blocks(title="LOGOS Stratos") as demo:
+    with gr.Link(rel="stylesheet", href="style.css"): pass
+    with gr.Row():
+        gr.Markdown(f"# {PROTOCOL_NAME}\n**{SUBTITLE}**")
     
+    with gr.Row():
+        status_panel = gr.HTML(fetch_manifold_diagnostics())
+
     with gr.Tabs():
-        
-        # TAB 1: CHAT
-        with gr.TabItem("Chat"):
-            chatbot = gr.Chatbot(height=400)
-            msg = gr.Textbox(placeholder="Ask me anything...", label="Message")
+        with gr.Tab("Polar Matroska (Protocol 35)"):
             with gr.Row():
-<<<<<<< HEAD
-                send = gr.Button("Send", variant="primary")
-=======
-                with gr.Column(scale=2):
-                    mtl_input = gr.Textbox(
-                        label="MTL Code",
-                        placeholder="(mult [2] [3])",
-                        lines=3
-                    )
-                    mtl_examples = gr.Examples(
-                        examples=[
-                            ["(mult [2] [3])"],
-                            ["(or [17] [19])"],
-                            ["(and [6] [10])"],
-                            ["(relate [17] [19])"],
-                            ["(fractran [[5 2] [5 3]] 72)"],
-                        ],
-                        inputs=mtl_input
-                    )
-                    mtl_run = gr.Button("Execute MTL", variant="primary")
+                with gr.Column(scale=3):
+                    pm_plot = gr.Plot(label="Knowledge Manifold")
                 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)
+                    pm_btn = gr.Button("Build Network", variant="primary")
+                    pm_stats = gr.Textbox(label="Status")
+                    gr.Markdown("Visualize the Semantic Heat Map. Radius = Binary Entropy. Theta = Prime Sector.")
             
-            mtl_run.click(execute_mtl, inputs=mtl_input, outputs=mtl_output)
-            mtl_demo_btn.click(run_mtl_demo, outputs=mtl_demo_output)
-        
-        # TAB B: GENESIS BLOCK
-        with gr.Tab("Genesis Block"):
+            def load_pm():
+                fig = get_polar_matroska_viz()
+                if fig: return fig, "Network Active"
+                return None, "Network Failed"
+            
+            pm_btn.click(load_pm, outputs=[pm_plot, pm_stats])
+            demo.load(load_pm, outputs=[pm_plot, pm_stats])
+
+        with gr.Tab("MTL Interpreter"):
+            mtl_input = gr.Textbox(label="MTL Code", lines=3, placeholder="(recall \"structure\")")
             with gr.Row():
-                with gr.Column(scale=2):
-                    genesis_plot = gr.Plot(value=get_genesis_block_visual(), 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 |
-                    
-                    *Every concept is a Prime. Every file is a Number.*
-                    """)
-        
-        # TAB C: PRIME TOPOLOGY
+                mtl_run = gr.Button("Execute", variant="primary")
+                mtl_demo = gr.Button("Run Demo")
+            mtl_output = gr.Textbox(label="Result", lines=5)
+            mtl_run.click(execute_mtl, inputs=mtl_input, outputs=mtl_output)
+            mtl_demo.click(run_mtl_demo, outputs=mtl_output)
+
         with gr.Tab("Prime Topology"):
-            with gr.Row():
-                with gr.Column():
-                    prime_plot = gr.Plot(value=get_prime_topology(), label="Log Polar Cone")
-                with gr.Column():
-                    gr.Markdown("""
-                    ### LOGOS Log Polar Cone Topology
-                    
-                    **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
-                    
-                    Large dots = **Primes** (only end in 1,3,7,9)
-                    
-                    *Arithmetic is Architecture.*
-                    """)
-        
-        # 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...")
->>>>>>> 512b27f (Fix: LOGOS Log Polar Cone Topology (mod 10 rings, 1/3/7/9 lanes))
-                clear = gr.Button("Clear")
+            gr.Plot(value=get_prime_topology(), label="Log Polar Cone")
             
-            msg.submit(chat_handler, [msg, chatbot], chatbot).then(lambda: "", None, msg)
-            send.click(chat_handler, [msg, chatbot], chatbot).then(lambda: "", None, msg)
-            clear.click(lambda: [], None, chatbot)
-        
-        # TAB 2: TENSION WEB
-        with gr.TabItem("Topology"):
-            gr.Plot(value=create_tension_web())
-            gr.Markdown("""
-            **Tension Web Structure:**
-            - Center: [2] MECHANISM
-            - Spokes: Genesis Primes (3,5,7,11,13,17,19,23,29)
-            - Connections: Factor relationships
-            - Rings: Log-scale decades
-            """)
-        
-        # TAB 3: MTL
-        with gr.TabItem("MTL"):
-            mtl_in = gr.Textbox(label="Code", value="(mult [2] [3])")
-            mtl_run = gr.Button("Run")
-            mtl_out = gr.Textbox(label="Result")
-            
-            def run_mtl(code):
-                if not MTL_AVAILABLE: return "MTL unavailable"
-                try:
-                    return str(MTLInterpreter().execute(code))
-                except Exception as e:
-                    return str(e)
-            
-            mtl_run.click(run_mtl, mtl_in, mtl_out)
-    
-    gr.HTML("<div style='text-align:center;color:#444;font-size:0.8rem;padding:1rem;'>LOGOS v1.0</div>")
+        with gr.Tab("RPC Validator"):
+             rpc_input = gr.Textbox(label="Stream (Comma Separated Integers)", placeholder="2, 3, 5, 7, 11")
+             rpc_btn = gr.Button("Validate Phase Signal")
+             rpc_out = gr.Textbox(label="RPC Score")
+             
+             def val_rpc(txt):
+                 from logos.analysis.rpc_validator import PhaseSpaceValidator
+                 try:
+                     nums = [int(x.strip()) for x in txt.split(',') if x.strip()]
+                     score = PhaseSpaceValidator().get_rpc_score(nums)
+                     return f"RPC Score: {score:.4f}"
+                 except Exception as e:
+                     return f"Error: {e}"
+             
+             rpc_btn.click(val_rpc, inputs=rpc_input, outputs=rpc_out)
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860, css=load_css())