Update app.py

app.py

@@ -4,87 +4,156 @@ 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):
+# --- MODULE 1: PRIME POTENTIALITY MATRIX (Mod 10 Waterfall) ---
+def generate_potentiality_matrix(sequence_length, persistence_threshold):
     """
-    Simulates the Scalar Prime Composite Waveform.
-    High persistence (00) = Low Heat. Change (11) = High Heat.
+    Visualizes the "Prime Potentiality" by aligning the integer stream to Mod 10.
+    This reveals the 1, 3, 7, 9 'rivers' of potentiality vs the Composite 'banks'.
     """
-    # 1. Generate Primes (The Logic Backbone)
-    primes = list(sympy.primerange(0, sequence_length))
+    # 1. Create the Integer Stream (The Canvas)
+    # We use a standard integer range because Primes exists *within* this potential
+    integers = np.arange(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)
+    # 2. Mod 10 Alignment (The "Natural" Width)
+    width = 10 
+    rows = int(np.ceil(sequence_length / width))
     
-    # 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)'))
+    # Pad to fit perfect 10-column grid
+    padded_len = rows * width
+    padded_ints = np.pad(integers, (0, padded_len - len(integers)), mode='constant')
+    
+    # 3. Calculate "Potentiality" (The Heat)
+    # We want to highlight Primes and their Residues
+    matrix_values = np.zeros(padded_len)
+    
+    for i, val in enumerate(padded_ints):
+        if sympy.isprime(int(val)):
+            # Active Prime = High Heat (Visualized as distinct energy)
+            matrix_values[i] = 1.0  
+        elif val % 2 == 0 or val % 5 == 0:
+            # Structurally Composite (0, 2, 4, 5, 6, 8) = Persistence/Ground
+            matrix_values[i] = 0.0 
+        else:
+            # Composite but in a Prime Lane (e.g. 9, 21, 27) = "Potential"
+            matrix_values[i] = 0.3 
+
+    # Reshape to Mod 10 Grid
+    grid = matrix_values.reshape(rows, width)
+    
+    # 4. Visualization
+    fig = go.Figure(data=go.Heatmap(
+        z=grid,
+        x=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], # Explicit Mod 10 Columns
+        colorscale=[
+            [0.0, "#000000"],  # Black: Ground State (Even/5s)
+            [0.3, "#2A2A5A"],  # Blue: Potential (Odd Composites)
+            [1.0, "#00FFEA"]   # Cyan: Kinetic Prime (The Signal)
+        ],
+        showscale=False,
+        hoverinfo='x+y+z'
+    ))
     
-    fig.update_layout(title="SPCW Persistence & Change Matrix", template="plotly_dark")
+    fig.update_layout(
+        title=f"Prime Potentiality Matrix (Mod 10 alignment)",
+        xaxis_title="Modulus 10 Residue (Last Digit)",
+        yaxis_title="Sequence Depth (Time)",
+        template="plotly_dark",
+        yaxis=dict(autorange="reversed"), # Stream flows down
+        height=800
+    )
     return fig
 
-# --- MODULE 2: MATROSKA TOPOLOGY (The Network) ---
-def visualize_matroska_network(shells):
+# --- MODULE 2: NESTED MATROSKA NETWORK (Hexagonal Shells) ---
+def visualize_matroska_network(shells, show_connectors):
     """
-    Creates a concentric 'Matroska' network visualization.
+    Constructs the Matroska Network using Hexagonal Tiling.
+    Each shell represents a Prime Modulo Domain.
     """
-    G = nx.Graph()
-    pos = {}
+    fig = go.Figure()
     
-    # 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()]
+    # Colors for the "Heat" of each shell
+    colors = ["#FF0000", "#FF7F00", "#FFFF00", "#00FF00", "#0000FF", "#4B0082", "#9400D3"]
+    
+    for layer in range(1, shells + 1):
+        # Hexagonal Geometry Logic
+        # A layer N in a hex grid has 6*N nodes
+        nodes_in_layer = 6 * layer
+        radius = layer * 10  # Spacing between shells
+        
+        # Generating the Hexagon path for this layer
+        # We plot the "Wireframe" of the shell
+        t = np.linspace(0, 2*np.pi, 7) # 7 points to close the loop
+        hex_x = radius * np.cos(t)
+        hex_y = radius * np.sin(t)
+        
+        # 1. Draw the Shell Boundary (The Domain)
+        fig.add_trace(go.Scatter(
+            x=hex_x, y=hex_y,
+            mode='lines',
+            line=dict(color=colors[(layer-1) % 7], width=2, dash='solid'),
+            name=f"Domain Shell {layer}"
+        ))
+        
+        # 2. Draw the Nodes (The Data Atoms)
+        # Distributed along the perimeter
+        node_angles = np.linspace(0, 2*np.pi, nodes_in_layer, endpoint=False)
+        node_x = radius * np.cos(node_angles)
+        node_y = radius * np.sin(node_angles)
+        
+        fig.add_trace(go.Scatter(
+            x=node_x, y=node_y,
+            mode='markers',
+            marker=dict(size=6, color=colors[(layer-1) % 7]),
+            showlegend=False
+        ))
+        
+        # 3. Draw "Nested" Connectors (Inter-Domain Links)
+        # This visualizes the "Dissolution" flow from Outer -> Inner
+        if show_connectors and layer > 1:
+            prev_radius = (layer - 1) * 10
+            # Connect every X nodes to previous layer to show hierarchy
+            for k in range(0, nodes_in_layer, layer): 
+                # Simple radial connection logic for demo
+                fig.add_trace(go.Scatter(
+                    x=[node_x[k], (prev_radius * np.cos(node_angles[k]))],
+                    y=[node_y[k], (prev_radius * np.sin(node_angles[k]))],
+                    mode='lines',
+                    line=dict(color='#333', width=1),
+                    showlegend=False
+                ))
 
-    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")
+    fig.update_layout(
+        title="Modular Concentric Prime Matroska (Nested Domains)",
+        showlegend=True,
+        template="plotly_dark",
+        xaxis=dict(showgrid=False, zeroline=False, visible=False),
+        yaxis=dict(showgrid=False, zeroline=False, visible=False),
+        width=800, height=800
+    )
     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.")
+    gr.Markdown("Interactive architectural validation for **Mod 10 Potentiality** and **Nested Domains**.")
     
-    with gr.Tab("SPCW Waveform"):
+    with gr.Tab("Prime Potentiality Matrix"):
+        gr.Markdown("Visualizing the 1, 3, 7, 9 Prime Avenues vs Composite Persistence.")
         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)
+            seq_len = gr.Slider(100, 10000, value=2000, step=100, label="Sequence Depth")
+        
+        matrix_plot = gr.Plot(label="Mod 10 Waterfall")
+        btn_matrix = gr.Button("Generate Matrix")
+        btn_matrix.click(generate_potentiality_matrix, inputs=[seq_len], outputs=matrix_plot)
 
     with gr.Tab("Matroska Topology"):
-        shells_slider = gr.Slider(1, 10, value=3, step=1, label="Nesting Depth (Shells)")
+        gr.Markdown("Visualizing the concentric dissolution of high-heat data into prime-stable domains.")
+        with gr.Row():
+            shells_slider = gr.Slider(1, 20, value=6, step=1, label="Domain Depth (Shells)")
+            show_links = gr.Checkbox(value=True, label="Show Inter-Domain Links")
+        
         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)
+        btn_net.click(visualize_matroska_network, inputs=[shells_slider, show_links], outputs=matroska_plot)
 
 demo.launch()