Update app.py

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import numpy as np
 import plotly.graph_objects as go
 import sympy
+import cv2
 from collections import Counter
 
 # --- HELPER: GPF CALCULATION ---
@@ -20,53 +21,75 @@ def get_gpf(n):
         gpf = n
     return gpf
 
-# --- MODULE 1: PRIME POTENTIALITY MATRIX (The Stream) ---
-def generate_potentiality_matrix(sequence_length):
-    """Visualizes the Integer Stream aligned to Mod 10."""
-    integers = np.arange(sequence_length)
-    width = 10 
-    rows = int(np.ceil(sequence_length / width))
+# --- MODULE 1: PRIME POTENTIALITY FLOW (The "Arrows" Matrix) ---
+def generate_potentiality_flow(depth):
+    """
+    Visualizes the Prime Potentiality as a Directed Flow (Sankey/Tree).
+    Shows how last digits (1,3,7,9) propagate potentiality to the next magnitude.
+    """
+    # Nodes: Layers of magnitude (10s, 100s, etc.)
+    # Links: Valid transitions where P_n could exist
     
-    padded_len = rows * width
-    padded_ints = np.pad(integers, (0, padded_len - len(integers)), mode='constant')
+    # Simplified visual logic: Mod 10 transitions
+    # Source: The digit (1, 3, 7, 9)
+    # Target: The next prime candidate
     
-    matrix_values = np.zeros(padded_len)
-    hover_texts = [] 
-
-    for i, val in enumerate(padded_ints):
-        val = int(val)
-        hover_texts.append(f"Integer: ±{val}<br>Mod 10: {val%10}")
+    sources = []
+    targets = []
+    values = []
+    colors = []
+    labels = ["Start"] + [f"Mod {i}" for i in range(10)] + ["Potential Prime"]
+    
+    # Logic: Only 1, 3, 7, 9 allow entry into the "Prime" state
+    prime_endings = [1, 3, 7, 9]
+    
+    # Layer 1: Start -> Mod 10 Buckets
+    for i in range(10):
+        sources.append(0) # Start Node
+        targets.append(i + 1) # Mod Nodes
         
-        if sympy.isprime(val) and val > 5:
-            matrix_values[i] = 1.0  # Kinetic Signal (Prime)
-        elif val % 2 == 0 or val % 5 == 0:
-            matrix_values[i] = 0.0  # Ground State (Composite)
+        if i in prime_endings:
+            values.append(5) # High flow
+            colors.append("#00ffea") # Cyan (Open Path)
         else:
-            matrix_values[i] = 0.2  # Potential Energy (Odd Composite)
+            values.append(1) # Blocked/Low flow
+            colors.append("#333333") # Grey (Blocked)
+
+    # Layer 2: Mod Buckets -> Prime Potential
+    final_node = 11
+    for i in range(10):
+        if i in prime_endings:
+            sources.append(i + 1)
+            targets.append(final_node)
+            values.append(5)
+            colors.append("#00ffea") # Flow continues
+        else:
+            # Dead ends (no link to Prime Potential)
+            pass
+
+    fig = go.Figure(data=[go.Sankey(
+        node = dict(
+            pad = 15,
+            thickness = 20,
+            line = dict(color = "black", width = 0.5),
+            label = labels,
+            color = ["white"] + ["#00ffea" if i in prime_endings else "#ff0055" for i in range(10)] + ["#00ffea"]
+        ),
+        link = dict(
+            source = sources,
+            target = targets,
+            value = values,
+            color = colors
+        ))])
 
-    grid = matrix_values.reshape(rows, width)
-    text_grid = np.array(hover_texts).reshape(rows, width)
-    
-    fig = go.Figure(data=go.Heatmap(
-        z=grid,
-        x=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
-        colorscale=[[0.0, "#0a0a0a"], [0.2, "#1a1a40"], [1.0, "#00ffea"]],
-        showscale=False,
-        text=text_grid,
-        hoverinfo='text'
-    ))
-    
     fig.update_layout(
-        title=f"Prime Potentiality Matrix (Integers ±N)",
-        xaxis_title="Modulus 10 Index",
-        yaxis_title="Integer Depth",
+        title="Prime Potentiality Flow (Digit Constraints)",
         template="plotly_dark",
-        yaxis=dict(autorange="reversed"),
-        height=800
+        height=600
     )
     return fig
 
-# --- MODULE 2: WEIGHTED CONNECTIVITY TOPOLOGY (The Network) ---
+# --- MODULE 2: WEIGHTED CONNECTIVITY TOPOLOGY (The Web) ---
 def visualize_prime_network(max_integer, show_links):
     """Plots ALL integers. Connects Composites to their GPF Base."""
     fig = go.Figure()
@@ -75,7 +98,9 @@ def visualize_prime_network(max_integer, show_links):
     gpf_map = {}   
     prime_children_count = Counter() 
     
+    # Pre-calculate positions to ensure density
     for n in range(1, max_integer + 1):
+        # Orientation: 0 at TOP (pi/2), Clockwise
         angle = np.pi/2 - (2 * np.pi * (n % 10)) / 10
         radius = n 
         x = radius * np.cos(angle)
@@ -83,13 +108,12 @@ def visualize_prime_network(max_integer, show_links):
         positions[n] = (x, y)
         
         if n > 1:
-            if sympy.isprime(n):
-                pass
-            else:
+            if not sympy.isprime(n):
                 gpf = get_gpf(n)
                 gpf_map[n] = gpf
                 prime_children_count[gpf] += 1
 
+    # DRAW CONNECTIVITY (The Tessellation)
     if show_links:
         edge_x, edge_y = [], []
         for n, base in gpf_map.items():
@@ -102,11 +126,12 @@ def visualize_prime_network(max_integer, show_links):
         fig.add_trace(go.Scatter(
             x=edge_x, y=edge_y,
             mode='lines',
-            line=dict(color='rgba(100, 100, 100, 0.15)', width=1),
+            line=dict(color='rgba(100, 100, 100, 0.2)', width=0.5),
             hoverinfo='none',
-            name='GPF Links'
+            name='GPF Gravity'
         ))
 
+    # DRAW NODES
     prime_x, prime_y, prime_size, prime_text = [], [], [], []
     comp_x, comp_y, comp_text = [], [], []
     
@@ -116,44 +141,48 @@ def visualize_prime_network(max_integer, show_links):
             prime_x.append(x)
             prime_y.append(y)
             weight = prime_children_count[n]
-            size = 6 + (np.log(weight + 1) * 5) 
+            # Logarithmic size scaling
+            size = 5 + (np.log(weight + 1) * 6) 
             prime_size.append(size)
-            prime_text.append(f"<b>PRIME: {n}</b><br>Constituents: {weight}")
+            prime_text.append(f"<b>PRIME: {n}</b><br>Gravity: {weight}")
         else:
             comp_x.append(x)
             comp_y.append(y)
-            comp_text.append(f"Composite: {n}<br>GPF Base: {gpf_map.get(n)}")
+            comp_text.append(f"Composite: {n}<br>Base: {gpf_map.get(n)}")
 
+    # Composites (Red/Pink Dust)
     fig.add_trace(go.Scatter(
         x=comp_x, y=comp_y,
         mode='markers',
-        marker=dict(size=4, color='#ff0055', opacity=0.5),
+        marker=dict(size=3, color='#ff0055', opacity=0.6),
         text=comp_text,
         hoverinfo='text',
         name='Composites'
     ))
 
+    # Primes (Cyan Anchors)
     fig.add_trace(go.Scatter(
         x=prime_x, y=prime_y,
         mode='markers',
         marker=dict(size=prime_size, color='#00ffea', line=dict(width=1, color='white')),
         text=prime_text,
         hoverinfo='text',
-        name='Primes (Weighted)'
+        name='Prime Anchors'
     ))
 
+    # Radial Spokes Background
     for i in range(10):
         angle = np.pi/2 - (2 * np.pi * i) / 10
         fig.add_trace(go.Scatter(
-            x=[0, max_integer * 1.05 * np.cos(angle)],
-            y=[0, max_integer * 1.05 * np.sin(angle)],
+            x=[0, max_integer * 1.1 * np.cos(angle)],
+            y=[0, max_integer * 1.1 * np.sin(angle)],
             mode='lines',
             line=dict(color='#222', width=1, dash='dot'),
             showlegend=False
         ))
 
     fig.update_layout(
-        title=f"Radial Connectivity Network (Weighted by Composite Generation)",
+        title=f"Radial Prime Connectivity (Max: {max_integer})",
         template="plotly_dark",
         xaxis=dict(showgrid=False, zeroline=False, visible=False),
         yaxis=dict(showgrid=False, zeroline=False, visible=False),
@@ -182,120 +211,134 @@ def visualize_gpf_counts(sequence_length):
     ))
     
     fig.update_layout(
-        title="Composite Density by Greatest Prime Factor (GPF)",
-        xaxis_title="Greatest Prime Factor (P)",
-        yaxis_title="Count of Constituents",
+        title="Composite Density by GPF Base",
+        xaxis_title="Prime Base (P)",
+        yaxis_title="Composites Anchored",
         template="plotly_dark",
         xaxis=dict(type='category')
     )
     return fig
 
-# --- MODULE 4: VARIABLE SIZE STREAM CHUNKING (Quadtree Logic) ---
-def recursive_quadtree(grid, x, y, w, h, tolerance, chunks):
-    """
-    Simulates the LOGOS Baker. 
-    Recursively splits the grid based on Variance (Heat).
-    """
-    # 1. Extract the region
-    region = grid[y:y+h, x:x+w]
-    # 2. Calculate Heat (Standard Deviation of the signal)
+# --- MODULE 4: REAL IMAGE CHUNKING (USER INPUT) ---
+def recursive_quadtree_image(img_gray, x, y, w, h, tolerance, chunks):
+    """Recursive decomposition on real image data."""
+    # 1. Get Region
+    region = img_gray[y:y+h, x:x+w]
+    if region.size == 0: return
+
+    # 2. Measure Heat (Standard Deviation)
     heat = np.std(region)
     
-    # 3. Decision: Split or Persist?
-    # If heat > tolerance and we aren't at atomic limit (4px), SPLIT
-    if heat > tolerance and w > 4:
+    # 3. Decision
+    # Scale tolerance to 0-255 range approximately
+    tol_val = tolerance * 100 
+    
+    if heat > tol_val and w > 4: # Min size 4px
         hw, hh = w // 2, h // 2
-        # Recursive Descent (Quadtree)
-        recursive_quadtree(grid, x, y, hw, hh, tolerance, chunks)       # TL
-        recursive_quadtree(grid, x+hw, y, w-hw, hh, tolerance, chunks)  # TR
-        recursive_quadtree(grid, x, y+hh, hw, h-hh, tolerance, chunks)  # BL
-        recursive_quadtree(grid, x+hw, y+hh, w-hw, h-hh, tolerance, chunks) # BR
+        recursive_quadtree_image(img_gray, x, y, hw, hh, tolerance, chunks)
+        recursive_quadtree_image(img_gray, x+hw, y, w-hw, hh, tolerance, chunks)
+        recursive_quadtree_image(img_gray, x, y+hh, hw, h-hh, tolerance, chunks)
+        recursive_quadtree_image(img_gray, x+hw, y+hh, w-hw, h-hh, tolerance, chunks)
     else:
-        # PERSIST (00 State): Save as a single chunk
+        # Persist Atom
         chunks.append((x, y, w, h, heat))
 
-def visualize_chunking(tolerance, complexity):
-    """Generates a synthetic 'Heat Map' and applies Variable Chunking."""
-    # 1. Generate Synthetic Data (The "Stream")
-    size = 512
-    x = np.linspace(0, 10, size)
-    y = np.linspace(0, 10, size)
-    X, Y = np.meshgrid(x, y)
+def process_uploaded_image(image, tolerance):
+    """
+    Takes user uploaded image -> Grayscale -> Quadtree -> Visualization.
+    """
+    if image is None:
+        return None
     
-    # Base: Smooth gradient (Persistence Zone)
-    base = np.sin(X) + np.cos(Y)
-    # Noise: High frequency spikes (Heat Zone) concentrated in center
-    noise = np.random.rand(size, size) * complexity * np.exp(-((X-5)**2 + (Y-5)**2)/2)
-    stream_data = base + noise
+    # 1. Preprocess
+    # Convert to grayscale for heat analysis (variance is scalar)
+    if len(image.shape) == 3:
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else:
+        gray = image
+        
+    h, w = gray.shape
     
-    # 2. Perform LOGOS Decomposition
+    # 2. Run LOGOS Baker
     chunks = []
-    recursive_quadtree(stream_data, 0, 0, size, size, tolerance, chunks)
+    recursive_quadtree_image(gray, 0, 0, w, h, tolerance, chunks)
     
-    # 3. Visualization
+    # 3. Visualize
     fig = go.Figure()
     
-    # Background Heatmap
-    fig.add_trace(go.Heatmap(z=stream_data, colorscale='Viridis', showscale=False, hoverinfo='skip'))
+    # Background: The original image (dimmed)
+    # Plotly Image needs to be base64 or array. 
+    # For speed in heatmap, we invert the y-axis logic.
+    fig.add_trace(go.Heatmap(z=np.flipud(gray), colorscale='Gray', showscale=False, opacity=0.3))
     
-    # Draw Quadtree Boxes (The Atoms)
+    # Draw The Atoms (Rectangles)
     shapes = []
     for (cx, cy, cw, ch, heat) in chunks:
-        # Color logic: Small boxes = High Heat (Red), Large boxes = Persistence (Cyan)
-        color = '#ff0055' if cw < 16 else '#00ffea'
-        width = 1 if cw < 16 else 2
-        opacity = 0.6 if cw < 16 else 0.8
+        # High Heat (Small) = Red/Orange
+        # Low Heat (Large) = Cyan/Blue
+        is_hot = cw < 16
+        color = '#ff0055' if is_hot else '#00ffea'
+        width = 1
+        
+        # Plotly shapes use bottom-left origin for some things, but rects are cartesian
+        # We need to map image coords (y down) to plot coords (y up)
+        # Or just tell layout to reverse y.
         
         shapes.append(dict(
-            type="rect", x0=cx, y0=cy, x1=cx+cw, y1=cy+ch,
+            type="rect", 
+            x0=cx, y0=cy, 
+            x1=cx+cw, y1=cy+ch,
             line=dict(color=color, width=width),
-            fillcolor=color, opacity=0.1
+            fillcolor=color, opacity=0.1 if is_hot else 0.05
         ))
         
     fig.update_layout(
-        title=f"Adaptive Stream Chunking (Atoms: {len(chunks)})",
+        title=f"LOGOS Adaptive Compression (Atoms: {len(chunks)})",
         shapes=shapes,
         template="plotly_dark",
         height=800,
         width=800,
-        xaxis=dict(showgrid=False, visible=False),
-        yaxis=dict(showgrid=False, visible=False, autorange="reversed")
+        xaxis=dict(showgrid=False, visible=False, range=[0, w]),
+        yaxis=dict(showgrid=False, visible=False, range=[h, 0], autorange="reversed") # Image coords
     )
     return fig
 
 # --- THE INTERFACE ---
 def build_demo():
     with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
-        gr.Markdown("# LOGOS: Prime-Indexed Topology & Thermal Compression")
+        gr.Markdown("# LOGOS: Prime-Indexed Topology & Compression Validator")
         
-        with gr.Tab("1. Potentiality Matrix"):
-            seq_len = gr.Slider(100, 5000, value=1000, label="Stream Depth")
-            matrix_plot = gr.Plot(label="Mod 10 Matrix")
-            btn_matrix = gr.Button("Generate Matrix")
-            btn_matrix.click(generate_potentiality_matrix, inputs=[seq_len], outputs=matrix_plot)
+        with gr.Tab("1. Prime Potentiality Flow"):
+            gr.Markdown("Visualizing the **Digit Constraints**: Only 1, 3, 7, 9 allow Prime formation.")
+            depth_slider = gr.Slider(10, 100, value=10, label="Visual Depth") # Just for trigger
+            flow_plot = gr.Plot(label="Potentiality Flow")
+            btn_flow = gr.Button("Generate Flow")
+            btn_flow.click(generate_potentiality_flow, inputs=[depth_slider], outputs=flow_plot)
 
-        with gr.Tab("2. Radial Topology"):
-            gr.Markdown("Primes sized by gravity. Lines connect Composites to GPF Base.")
-            rad_len = gr.Slider(100, 1000, value=300, label="Integer Range")
+        with gr.Tab("2. Radial Topology (The Web)"):
+            gr.Markdown("**The Natural Tessellation:** Composites connected to their Prime Base.")
+            rad_len = gr.Slider(100, 2000, value=500, label="Integer Range")
             link_toggle = gr.Checkbox(value=True, label="Show Connectivity")
             matroska_plot = gr.Plot(label="Radial View")
             btn_net = gr.Button("Build Network")
             btn_net.click(visualize_prime_network, inputs=[rad_len, link_toggle], outputs=matroska_plot)
             
         with gr.Tab("3. GPF Density"):
+            gr.Markdown("Counts of composites anchored by each Prime.")
             gpf_len = gr.Slider(100, 10000, value=2500, label="Stream Depth")
             gpf_plot = gr.Plot(label="GPF Distribution")
             btn_gpf = gr.Button("Calculate Density")
             btn_gpf.click(visualize_gpf_counts, inputs=[gpf_len], outputs=gpf_plot)
 
-        with gr.Tab("4. Variable Stream Chunking"):
-            gr.Markdown("Visualizing **Thermal-Aware Compression**. High heat (Variance) = Small Atoms. Low heat = Large Atoms.")
+        with gr.Tab("4. Live Stream Baker"):
+            gr.Markdown("Upload an image to test **Thermal-Aware Chunking**. Drag 'Heat Tolerance' to adjust compression.")
             with gr.Row():
-                tol_slider = gr.Slider(0.01, 1.0, value=0.1, label="Heat Tolerance (Persistence Threshold)")
-                comp_slider = gr.Slider(1.0, 10.0, value=5.0, label="Signal Complexity (Noise)")
+                inp_img = gr.Image(label="Input Stream (Image)", type="numpy")
+                tol_slider = gr.Slider(0.01, 1.0, value=0.15, label="Heat Tolerance (Persistence)")
+            
             chunk_plot = gr.Plot(label="Adaptive Decomposition")
-            btn_chunk = gr.Button("Dissolve Stream")
-            btn_chunk.click(visualize_chunking, inputs=[tol_slider, comp_slider], outputs=chunk_plot)
+            btn_bake = gr.Button("Bake Stream")
+            btn_bake.click(process_uploaded_image, inputs=[inp_img, tol_slider], outputs=chunk_plot)
 
     return demo