Tension Web topology, builder operations doc, casual chat

app.py

@@ -1,9 +1,7 @@
 """
-LOGOS v1.0 - Logarithmic Ordering Generation Operating Software
-Hugging Face Space Application
-
-Primary: Chat Interface (Neural Router)
-Secondary: Concentric Network Topology
+LOGOS v1.0 - Hugging Face Space
+Primary: Chat (casual language)
+Secondary: Mod-10 Tension Web
 """
 
 import gradio as gr
@@ -17,21 +15,18 @@ import threading
 import subprocess
 import requests
 
-# 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 IMPORTS ---
+# --- LOGOS CORE ---
 MTL_AVAILABLE = False
 try:
     from logos.mtl.interpreter import MTLInterpreter
     MTL_AVAILABLE = True
-    print("[LOGOS] MTL Interpreter loaded")
-except ImportError as e:
-    print(f"[LOGOS] MTL not available: {e}")
+except ImportError:
+    pass
 
-# --- NEURAL ROUTER (Background) ---
 ROUTER_URL = "http://localhost:5000"
 
 def start_neural_router():
@@ -39,382 +34,206 @@ def start_neural_router():
         subprocess.Popen(
             [sys.executable, "-m", "logos.server"],
             env={**os.environ, "PYTHONPATH": current_dir},
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
         )
-        print("[LOGOS] Neural Router started on port 5000")
-    except Exception as e:
-        print(f"[LOGOS] Router failed: {e}")
+    except:
+        pass
 
 threading.Thread(target=start_neural_router, daemon=True).start()
 
 # =============================================================================
-# CUSTOM CSS
-# =============================================================================
-CUSTOM_CSS = """
-.gradio-container {
-    background: linear-gradient(135deg, #0a0e17 0%, #1a1f2e 100%) !important;
-}
-
-.chat-container {
-    border: 1px solid rgba(0, 255, 234, 0.2);
-    border-radius: 12px;
-    background: rgba(17, 24, 39, 0.95);
-}
-
-.header-gradient {
-    background: linear-gradient(90deg, #00ffea, #9d4edd, #ff0055);
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    font-weight: 800;
-}
-
-.status-online { color: #00ffea; }
-.status-offline { color: #ff0055; }
-
-.topology-info {
-    background: rgba(17, 24, 39, 0.9);
-    border: 1px solid rgba(157, 78, 221, 0.3);
-    border-radius: 8px;
-    padding: 1rem;
-}
-"""
-
-# =============================================================================
-# CHAT FUNCTIONS
+# CHAT - Casual Language Interface
 # =============================================================================
-def chat_with_router(message, history):
-    """Send message to LOGOS Neural Router."""
+def chat_handler(message, history):
+    """Handle casual language input."""
     if not message.strip():
         return history
     
-    # Add user message
     history = history + [[message, None]]
+    msg = message.lower().strip()
     
     try:
-        # Try local router first
-        payload = {
-            "messages": [{"role": "user", "content": message}],
-            "model": "logos-matroska-router"
-        }
+        # 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_response = resp.json()['choices'][0]['message']['content']
-        else:
-            bot_response = f"Router Error: {resp.status_code}"
-    except requests.exceptions.ConnectionError:
-        # Router offline - try MTL locally
-        if MTL_AVAILABLE and message.strip().startswith("("):
-            try:
-                mtl = MTLInterpreter()
-                result = mtl.execute(message)
-                bot_response = f"[MTL Direct] {result}"
-            except Exception as e:
-                bot_response = f"[MTL Error] {e}"
+            bot = resp.json()['choices'][0]['message']['content']
         else:
-            bot_response = "Neural Router offline. Start with: python -m logos.server"
-    except Exception as e:
-        bot_response = f"Error: {str(e)}"
+            bot = "Router unavailable. Start: python -m logos.server"
+    except:
+        bot = "Connect to Neural Router on port 5000"
     
-    history[-1][1] = bot_response
+    history[-1][1] = bot
     return history
 
-def get_router_status():
-    """Check if Neural Router is online."""
-    try:
-        resp = requests.get(f"{ROUTER_URL}/v1", timeout=2)
-        if resp.status_code == 200:
-            data = resp.json()
-            return f"🟢 ONLINE | {data.get('system', 'LOGOS')}"
-        return "🟡 Partial"
-    except:
-        return "🔴 OFFLINE"
-
 # =============================================================================
-# NETWORK TOPOLOGY VISUALIZATION
+# TENSION WEB VISUALIZATION - Mod 10 Radial Network
 # =============================================================================
-def create_concentric_topology():
+def create_tension_web():
     """
-    LOGOS Concentric Network Topology.
-    Mod 10 rings with prime lanes (1, 3, 7, 9).
+    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()
     
-    # Color scheme for prime lanes
-    lane_colors = {
-        1: '#00ffea',  # Cyan
-        3: '#ff00ff',  # Magenta
-        7: '#ffff00',  # Yellow
-        9: '#00ff00',  # Green
+    # Genesis primes on the spokes
+    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
     }
     
-    max_n = 200
+    # 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 each prime lane
-    for residue in [1, 3, 7, 9]:
-        nums = [n for n in range(1, max_n) if n % 10 == residue]
-        
-        # Log polar coordinates
-        r = [math.log10(n) if n > 0 else 0 for n in nums]
-        theta = [(n % 100) * 3.6 for n in nums]
-        
-        # Mark primes with larger dots
-        is_prime = [sympy.isprime(n) for n in nums]
-        sizes = [16 if p else 6 for p in is_prime]
-        colors = [lane_colors[residue] if p else '#444' for p in is_prime]
+    # 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=theta,
-            mode='markers',
-            marker=dict(color=colors, size=sizes, opacity=0.9,
-                       line=dict(width=1, color='white')),
-            text=[f"[{n}] {'PRIME' if p else ''}" for n, p in zip(nums, is_prime)],
-            hoverinfo='text',
-            name=f'Lane {residue}'
+            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'
         ))
     
-    # Add decade rings
-    for decade in [10, 100]:
-        r_val = math.log10(decade)
+    # 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=[r_val] * 36,
-            theta=list(range(0, 360, 10)),
+            r=[0, 1.8],
+            theta=[angle, angle],
             mode='lines',
-            line=dict(color='rgba(255,255,255,0.2)', width=1, dash='dot'),
+            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='rgba(0,0,0,0)',
-        plot_bgcolor='rgba(0,0,0,0)',
-        showlegend=True,
-        legend=dict(
-            font=dict(color='white', size=11),
-            bgcolor='rgba(17,24,39,0.8)',
-            bordercolor='rgba(255,255,255,0.1)',
-            x=0.82, y=0.98
-        ),
+        paper_bgcolor='#0a0e17',
+        plot_bgcolor='#0a0e17',
+        showlegend=False,
         polar=dict(
-            radialaxis=dict(
-                visible=True,
-                range=[0, 2.5],
-                ticktext=['1', '10', '100'],
-                tickvals=[0, 1, 2],
-                gridcolor='rgba(255,255,255,0.1)',
-                tickfont=dict(color='#666')
-            ),
-            angularaxis=dict(
-                visible=True,
-                gridcolor='rgba(255,255,255,0.1)',
-                tickfont=dict(color='#666')
-            ),
-            bgcolor='rgba(10,14,23,0.95)'
+            radialaxis=dict(visible=False, range=[0, 1.8]),
+            angularaxis=dict(visible=False),
+            bgcolor='#0a0e17'
         ),
-        margin=dict(l=40, r=40, t=60, b=40),
-        height=550,
+        margin=dict(l=20, r=20, t=50, b=20),
+        height=500,
         title=dict(
-            text="LOGOS Concentric Topology",
-            font=dict(color='#00ffea', size=16),
+            text="MOD-10 TENSION WEB",
+            font=dict(color='#00ffea', size=14),
             x=0.5
         )
     )
     return fig
 
 # =============================================================================
-# MTL FUNCTIONS
+# CSS
 # =============================================================================
-def execute_mtl(code):
-    if not MTL_AVAILABLE:
-        return "MTL not available"
-    if not code.strip():
-        return "Enter MTL code"
-    try:
-        mtl = MTLInterpreter()
-        result = mtl.execute(code)
-        return f">>> {result}"
-    except Exception as e:
-        return f"Error: {e}"
+CSS = """
+.gradio-container { background: #0a0e17 !important; }
+.chat-box { border: 1px solid rgba(0,255,234,0.3); border-radius: 12px; }
+"""
 
 # =============================================================================
-# BUILD APP - Chat First, Topology Second
+# APP
 # =============================================================================
-with gr.Blocks(css=CUSTOM_CSS, title="LOGOS", theme=gr.themes.Base()) as demo:
+with gr.Blocks(css=CSS, title="LOGOS", theme=gr.themes.Base()) as demo:
     
-    # HEADER
     gr.HTML("""
-    <div style="text-align: center; padding: 1.5rem 0;">
-        <h1 style="font-size: 2.5rem; margin: 0;">
-            <span class="header-gradient">LOGOS</span>
-        </h1>
-        <p style="color: #6b7280; margin: 0.5rem 0;">
-            Logarithmic Ordering Generation Operating Software
-        </p>
+    <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>
     </div>
     """)
     
-    # MAIN TABS - Chat is PRIMARY
     with gr.Tabs():
         
-        # ==========================================
-        # TAB 1: CHAT (PRIMARY)
-        # ==========================================
-        with gr.TabItem("💬 Chat", id="chat"):
+        # TAB 1: CHAT
+        with gr.TabItem("Chat"):
+            chatbot = gr.Chatbot(height=400)
+            msg = gr.Textbox(placeholder="Ask me anything...", label="Message")
             with gr.Row():
-                with gr.Column(scale=3):
-                    chatbot = gr.Chatbot(
-                        label="Neural Router",
-                        height=450,
-                        elem_classes=["chat-container"]
-                    )
-                    with gr.Row():
-                        msg = gr.Textbox(
-                            label="Message",
-                            placeholder="Ask LOGOS anything... or enter MTL: (mult [2] [3])",
-                            scale=5
-                        )
-                        send_btn = gr.Button("Send", variant="primary", scale=1)
-                    
-                    with gr.Row():
-                        clear_btn = gr.Button("Clear", size="sm")
-                        status_txt = gr.Textbox(
-                            label="Router Status",
-                            value=get_router_status(),
-                            interactive=False,
-                            scale=2
-                        )
-                
-                with gr.Column(scale=1):
-                    gr.Markdown("""
-                    ### Quick Commands
-                    
-                    **MTL Examples:**
-                    ```
-                    (mult [2] [3])
-                    (or [17] [19])
-                    (relate [17] [19])
-                    ```
-                    
-                    **Swarm Delegation:**
-                    ```
-                    SWARM: analyze project
-                    ```
-                    
-                    **Special Triggers:**
-                    - YouTube URLs → Video Atomizer
-                    - Web URLs → Web Atomizer
-                    - `mcp:` → MCP Agent
-                    """)
+                send = gr.Button("Send", variant="primary")
+                clear = gr.Button("Clear")
             
-            # Event handlers
-            msg.submit(chat_with_router, [msg, chatbot], chatbot).then(
-                lambda: "", None, msg
-            )
-            send_btn.click(chat_with_router, [msg, chatbot], chatbot).then(
-                lambda: "", None, msg
-            )
-            clear_btn.click(lambda: [], None, chatbot)
+            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: NETWORK TOPOLOGY
-        # ==========================================
-        with gr.TabItem("🌐 Topology", id="topology"):
-            with gr.Row():
-                with gr.Column(scale=2):
-                    topology_plot = gr.Plot(
-                        value=create_concentric_topology(),
-                        label="Concentric Prime Manifold"
-                    )
-                
-                with gr.Column(scale=1):
-                    gr.Markdown("""
-                    ### Concentric Topology
-                    
-                    <div class="topology-info">
-                    
-                    **Structure:**
-                    - Rings = Decades (Mod 10)
-                    - Lanes = Prime residues
-                    
-                    **Prime Lanes:**
-                    - 🔵 **1** - ends in 1
-                    - 🟣 **3** - ends in 3
-                    - 🟡 **7** - ends in 7
-                    - 🟢 **9** - ends in 9
-                    
-                    **Key Insight:**
-                    All primes > 5 must end in 1, 3, 7, or 9.
-                    
-                    Large dots = **Primes**
-                    Small dots = **Composites**
-                    
-                    </div>
-                    """)
-                    
-                    refresh_btn = gr.Button("Refresh Topology")
-                    refresh_btn.click(
-                        lambda: create_concentric_topology(),
-                        outputs=topology_plot
-                    )
+        # 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 INTERPRETER
-        # ==========================================
-        with gr.TabItem("⚡ MTL", id="mtl"):
-            with gr.Row():
-                with gr.Column(scale=2):
-                    mtl_input = gr.Textbox(
-                        label="MTL Code",
-                        placeholder="(mult [2] [3])",
-                        value="(mult [2] [3])",
-                        lines=3
-                    )
-                    mtl_run = gr.Button("Execute", variant="primary")
-                    mtl_output = gr.Textbox(label="Result", lines=2)
-                    
-                    gr.Examples(
-                        examples=[
-                            ["(mult [2] [3])"],
-                            ["(or [2] [3])"],
-                            ["(and [6] [10])"],
-                            ["(relate [17] [19])"],
-                            ["(not [6] [6] [42])"],
-                        ],
-                        inputs=mtl_input
-                    )
-                
-                with gr.Column(scale=1):
-                    gr.Markdown("""
-                    ### MTL Reference
-                    
-                    | Operator | Function |
-                    |:---------|:---------|
-                    | `mult` | Multiply |
-                    | `or` | LCM |
-                    | `and` | GCD |
-                    | `not` | Steering |
-                    | `relate` | Synapse |
-                    
-                    **Genesis Primes:**
-                    - [2] MECHANISM
-                    - [3] RESULT
-                    - [7] PERSIST
-                    - [13] RELATE
-                    - [17] IMAGE
-                    - [19] TEXT
-                    """)
+        # 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")
             
-            mtl_run.click(execute_mtl, inputs=mtl_input, outputs=mtl_output)
+            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)
     
-    # FOOTER
-    gr.HTML("""
-    <div style="text-align: center; padding: 1rem 0; color: #4b5563; font-size: 0.8rem;">
-        LOGOS v1.0 • Computing = Routing • Arithmetic is Architecture
-    </div>
-    """)
+    gr.HTML("<div style='text-align:center;color:#444;font-size:0.8rem;padding:1rem;'>LOGOS v1.0</div>")
 
-# LAUNCH
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)

logos/docs/builder_operations.md

@@ -0,0 +1,109 @@
+# MTL Builder Operations
+## Wittgenstein's Language Game Applied to LOGOS
+
+Wittgenstein's "builder's language" (from Philosophical Investigations §2) consists of:
+- **Slab!** (request object)
+- **Block!** (request object)  
+- **Beam!** (request object)
+- **Column!** (request object)
+
+The builder calls, the assistant brings. This is **pure action through naming**.
+
+---
+
+## MTL Mapping
+
+| Builder Language | MTL Operation | Effect |
+|:-----------------|:--------------|:-------|
+| "Slab!" | `(hold 'slab [6])` | Store value 6 under 'slab |
+| "Block!" | `(grab 'slab)` | Retrieve stored value |
+| "Beam those!" | `(connect [A] [B])` | Combine A × B |
+| "That slab!" | `(route [6] [42])` | Move value to domain |
+
+---
+
+## HOLD - The Register
+
+```lisp
+(hold 'x [6])    ; Store 6 as 'x
+(hold 'y [7])    ; Store 7 as 'y
+```
+
+HOLD creates a **named register**. The value persists in `memory`.
+
+---
+
+## GRAB - The Retrieval
+
+```lisp
+(grab 'x)        ; Returns 6
+```
+
+GRAB retrieves from the register. In builder terms: "Give me that slab!"
+
+---
+
+## CASCADE Operations
+
+### Example 1: Store then Retrieve
+```lisp
+(hold 'a [2])           ; a = 2
+(hold 'b [3])           ; b = 3
+(mult (grab 'a) (grab 'b))  ; 2 × 3 = 6
+```
+
+### Example 2: Chain Connections
+```lisp
+(hold 'image [17])
+(hold 'text [19])
+(hold 'relation (connect (grab 'image) (grab 'text)))
+; relation = 17 × 19 = 323
+```
+
+### Example 3: Builder Workflow
+```lisp
+; "Hold the slab, hold the beam, connect them"
+(hold 'slab [5])
+(hold 'beam [7])
+(hold 'structure (mult (grab 'slab) (grab 'beam)))
+; structure = 35
+
+; "Now persist the structure"
+(mult (grab 'structure) [7])  ; 35 × 7 = 245 (with PERSIST flag)
+```
+
+---
+
+## Domain Operations
+
+HOLD/GRAB work within the **active domain**:
+
+```lisp
+(domain [1700])              ; Enter VISUAL domain
+(hold 'frame [17])           ; Store in VISUAL context
+(domain [1900])              ; Switch to TEXT domain  
+(hold 'word [19])            ; Store in TEXT context
+```
+
+---
+
+## The Builder Axiom
+
+> **Calling a value IS moving it.**
+
+In Wittgenstein's game, "Slab!" doesn't describe a slab—it **commands one to appear**.  
+In MTL, `(grab 'x)` doesn't describe x—it **retrieves x to the current context**.
+
+The act of naming is the act of manifesting.
+
+---
+
+## Cascade Patterns
+
+| Pattern | Operations | Result |
+|:--------|:-----------|:-------|
+| Store-Compute-Store | hold→op→hold | Accumulator |
+| Gather-Combine | grab,grab→connect | Composition |
+| Build-Persist | hold→mult [7] | Permanent record |
+| Route-Chain | route→route | Pipeline |
+