Update app.py

app.py

@@ -4,14 +4,14 @@ import plotly.graph_objects as go
 import sympy
 import networkx as nx
 
-# --- MODULE 1: PRIME POTENTIALITY MATRIX (Mod 10 Waterfall) ---
-def generate_potentiality_matrix(sequence_length, persistence_threshold):
+# --- MODULE 1: PRIME POTENTIALITY MATRIX (The Stream) ---
+def generate_potentiality_matrix(sequence_length):
     """
     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, 3, 7, 9 are the 'Active Lanes' (Rivers).
     """
-    # 1. Create the Integer Stream (The Canvas)
-    # We use a standard integer range because Primes exists *within* this potential
+    # 1. Create the Integer Stream
+    # We go deep (up to 5000+) to show the river effect
     integers = np.arange(sequence_length)
     
     # 2. Mod 10 Alignment (The "Natural" Width)
@@ -23,19 +23,16 @@ def generate_potentiality_matrix(sequence_length, persistence_threshold):
     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
+    # 0 = Composite Ground, 0.5 = Potential Lane, 1.0 = Kinetic Prime
     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  
+        if sympy.isprime(int(val)) and val > 5:
+            matrix_values[i] = 1.0  # Kinetic Signal (Prime)
         elif val % 2 == 0 or val % 5 == 0:
-            # Structurally Composite (0, 2, 4, 5, 6, 8) = Persistence/Ground
-            matrix_values[i] = 0.0 
+            matrix_values[i] = 0.0  # Ground State (Composite)
         else:
-            # Composite but in a Prime Lane (e.g. 9, 21, 27) = "Potential"
-            matrix_values[i] = 0.3 
+            matrix_values[i] = 0.2  # Potential Energy (Odd Composite in Prime Lane)
 
     # Reshape to Mod 10 Grid
     grid = matrix_values.reshape(rows, width)
@@ -45,16 +42,16 @@ def generate_potentiality_matrix(sequence_length, persistence_threshold):
         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)
+            [0.0, "#0a0a0a"],  # Pitch Black: Ground State
+            [0.2, "#1a1a40"],  # Deep Blue: Potential Lane
+            [1.0, "#00ffea"]   # Cyan Neon: Kinetic Prime
         ],
         showscale=False,
         hoverinfo='x+y+z'
     ))
     
     fig.update_layout(
-        title=f"Prime Potentiality Matrix (Mod 10 alignment)",
+        title=f"Prime Potentiality Rivers (Mod 10)",
         xaxis_title="Modulus 10 Residue (Last Digit)",
         yaxis_title="Sequence Depth (Time)",
         template="plotly_dark",
@@ -63,97 +60,92 @@ def generate_potentiality_matrix(sequence_length, persistence_threshold):
     )
     return fig
 
-# --- MODULE 2: NESTED MATROSKA NETWORK (Hexagonal Shells) ---
-def visualize_matroska_network(shells, show_connectors):
+# --- MODULE 2: MATROSKA TOPOLOGY (The Machine) ---
+def visualize_prime_matroska(shells, show_feed):
     """
-    Constructs the Matroska Network using Hexagonal Tiling.
-    Each shell represents a Prime Modulo Domain.
+    Constructs the Radial Prime-Indexed Topology.
+    Concentric Shells (Domains) intersected by Mod 10 Prime Vectors.
     """
     fig = go.Figure()
     
-    # 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 "Prime Vectors" (Spokes)
+    # These are the rails the data travels on
+    max_radius = shells * 10
+    for i in range(10):
+        angle = (2 * np.pi * i) / 10
+        # Color logic: 1,3,7,9 are "Hot" (Prime capable), others are "Cold"
+        is_prime_lane = i in [1, 3, 7, 9]
+        color = "#00ffea" if is_prime_lane else "#333"
+        width = 2 if is_prime_lane else 1
         
-        # 1. Draw the Shell Boundary (The Domain)
         fig.add_trace(go.Scatter(
-            x=hex_x, y=hex_y,
+            x=[0, max_radius * np.cos(angle)],
+            y=[0, max_radius * np.sin(angle)],
             mode='lines',
-            line=dict(color=colors[(layer-1) % 7], width=2, dash='solid'),
-            name=f"Domain Shell {layer}"
+            line=dict(color=color, width=width),
+            name=f"Mod {i} Vector" if i == 0 else None,
+            showlegend=(i==0)
         ))
-        
-        # 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)
+
+    # 2. Draw the Concentric Shells (Domains)
+    # These are the Matroska Layers
+    for layer in range(1, shells + 1):
+        radius = layer * 10
+        t = np.linspace(0, 2*np.pi, 100)
+        x = radius * np.cos(t)
+        y = radius * np.sin(t)
         
         fig.add_trace(go.Scatter(
-            x=node_x, y=node_y,
-            mode='markers',
-            marker=dict(size=6, color=colors[(layer-1) % 7]),
+            x=x, y=y,
+            mode='lines',
+            line=dict(color='#555', dash='dot'),
+            name=f"Shell {layer}",
             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
+        # 3. Simulate "Data Atoms" residing in the shell
+        # They only land on the Prime Vectors (1, 3, 7, 9)
+        if show_feed:
+            for p_mod in [1, 3, 7, 9]:
+                p_angle = (2 * np.pi * p_mod) / 10
                 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),
+                    x=[radius * np.cos(p_angle)], 
+                    y=[radius * np.sin(p_angle)],
+                    mode='markers',
+                    marker=dict(size=6, color='#ff0055'), # Red = Hot Data
                     showlegend=False
                 ))
 
     fig.update_layout(
-        title="Modular Concentric Prime Matroska (Nested Domains)",
-        showlegend=True,
+        title="Radial Prime-Indexed Matroska Network",
         template="plotly_dark",
         xaxis=dict(showgrid=False, zeroline=False, visible=False),
         yaxis=dict(showgrid=False, zeroline=False, visible=False),
-        width=800, height=800
+        width=800, height=800,
+        showlegend=False
     )
     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 **Mod 10 Potentiality** and **Nested Domains**.")
+    gr.Markdown("# LOGOS: Prime-Indexed Topology")
+    gr.Markdown("Visualizing the **Mod 10 Potentiality Rivers** and the **Radial Matroska Network**.")
     
-    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(100, 10000, value=2000, step=100, label="Sequence Depth")
-        
-        matrix_plot = gr.Plot(label="Mod 10 Waterfall")
+    with gr.Tab("Prime Potentiality (Mod 10)"):
+        gr.Markdown("The vertical 'Rivers' of prime potential (1, 3, 7, 9) vs the Composite banks.")
+        seq_len = gr.Slider(100, 10000, value=2500, label="Stream Depth")
+        matrix_plot = gr.Plot(label="Potentiality Matrix")
         btn_matrix = gr.Button("Generate Matrix")
         btn_matrix.click(generate_potentiality_matrix, inputs=[seq_len], outputs=matrix_plot)
 
-    with gr.Tab("Matroska Topology"):
-        gr.Markdown("Visualizing the concentric dissolution of high-heat data into prime-stable domains.")
+    with gr.Tab("Matroska Network (Radial)"):
+        gr.Markdown("The Destination Topology: Concentric Shells indexed by Prime Moduli.")
         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")
+            shells_slider = gr.Slider(1, 20, value=5, step=1, label="Domain Depth (Shells)")
+            feed_toggle = gr.Checkbox(value=True, label="Show Active Atoms (Feed)")
         
-        matroska_plot = gr.Plot(label="Network Topology")
-        btn_net = gr.Button("Build Network")
-        btn_net.click(visualize_matroska_network, inputs=[shells_slider, show_links], outputs=matroska_plot)
+        matroska_plot = gr.Plot(label="Radial Topology")
+        btn_net = gr.Button("Build Topology")
+        btn_net.click(visualize_prime_matroska, inputs=[shells_slider, feed_toggle], outputs=matroska_plot)
 
 demo.launch()