Create app.py

app.py

@@ -0,0 +1,90 @@
+import gradio as gr
+import numpy as np
+import plotly.graph_objects as go
+import sympy
+import networkx as nx
+
+# --- MODULE 1: SPCW LOGIC (The Primitive) ---
+def generate_spcw_waveform(sequence_length, persistence_factor):
+    """
+    Simulates the Scalar Prime Composite Waveform.
+    High persistence (00) = Low Heat. Change (11) = High Heat.
+    """
+    # 1. Generate Primes (The Logic Backbone)
+    primes = list(sympy.primerange(0, sequence_length))
+    
+    # 2. Simulate "Heat" based on Prime Gaps (your logic)
+    x = np.arange(len(primes))
+    # Synthetic "Heat" metric based on gap delta
+    heat = np.diff(primes, prepend=0) * (1 - persistence_factor)
+    
+    # 3. Create Visualization (The "Heat Map")
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=x, y=primes, mode='lines+markers', name='Prime Scalar'))
+    fig.add_trace(go.Bar(x=x, y=heat, name='Delta Heat (Change Energy)'))
+    
+    fig.update_layout(title="SPCW Persistence & Change Matrix", template="plotly_dark")
+    return fig
+
+# --- MODULE 2: MATROSKA TOPOLOGY (The Network) ---
+def visualize_matroska_network(shells):
+    """
+    Creates a concentric 'Matroska' network visualization.
+    """
+    G = nx.Graph()
+    pos = {}
+    
+    # Create concentric shells
+    for i in range(1, shells + 1):
+        radius = i * 5
+        nodes_in_layer = i * 6  # Hexagonal growth pattern
+        for j in range(nodes_in_layer):
+            node_id = f"L{i}-{j}"
+            angle = (2 * np.pi * j) / nodes_in_layer
+            pos[node_id] = (radius * np.cos(angle), radius * np.sin(angle))
+            G.add_node(node_id, layer=i)
+            
+            # Connect to previous shell (The "Persistence" Link)
+            if i > 1:
+                prev_node = f"L{i-1}-{int(j/nodes_in_layer * ((i-1)*6))}"
+                G.add_edge(node_id, prev_node)
+
+    # Extract positions for Plotly
+    edge_x = []
+    edge_y = []
+    for edge in G.edges():
+        x0, y0 = pos[edge[0]]
+        x1, y1 = pos[edge[1]]
+        edge_x.extend([x0, x1, None])
+        edge_y.extend([y0, y1, None])
+
+    node_x = [pos[node][0] for node in G.nodes()]
+    node_y = [pos[node][1] for node in G.nodes()]
+
+    fig = go.Figure(data=[
+        go.Scatter(x=edge_x, y=edge_y, line=dict(width=0.5, color='#888'), hoverinfo='none', mode='lines'),
+        go.Scatter(x=node_x, y=node_y, mode='markers', marker=dict(color='cyan', size=5))
+    ])
+    fig.update_layout(title="Modular Concentric Prime Matroska Network", showlegend=False, template="plotly_dark")
+    return fig
+
+# --- THE INTERFACE ---
+with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
+    gr.Markdown("# LOGOS: Modular Concentric Prime Matroska Network")
+    gr.Markdown("Interactive architectural validation for SPCW and Nested Domains.")
+    
+    with gr.Tab("SPCW Waveform"):
+        with gr.Row():
+            seq_len = gr.Slider(10, 1000, value=100, label="Sequence Length")
+            per_factor = gr.Slider(0.0, 1.0, value=0.5, label="Persistence Factor (00 State)")
+        spcw_plot = gr.Plot(label="Persistence/Change Matrix")
+        btn_spcw = gr.Button("Generate Waveform")
+        btn_spcw.click(generate_spcw_waveform, inputs=[seq_len, per_factor], outputs=spcw_plot)
+
+    with gr.Tab("Matroska Topology"):
+        shells_slider = gr.Slider(1, 10, value=3, step=1, label="Nesting Depth (Shells)")
+        matroska_plot = gr.Plot(label="Network Topology")
+        btn_net = gr.Button("Build Network")
+        btn_net.click(visualize_matroska_network, inputs=[shells_slider], outputs=matroska_plot)
+
+demo.launch()