Update app.py

app.py

@@ -4,91 +4,69 @@ import plotly.graph_objects as go
 import sympy
 import cv2
 import time
-import sys
-import os
 from collections import Counter
 
 # ==========================================
-# PART 1: THEORETICAL PRIMITIVES
+# PART 1: THEORETICAL VISUALIZATIONS
 # ==========================================
 
 def get_gpf(n):
-    """Returns the Greatest Prime Factor of n."""
+    """Returns the Greatest Prime Factor."""
     if n <= 1: return 1
     i = 2
-    gpf = 1
     while i * i <= n:
         if n % i:
             i += 1
         else:
             n //= i
-            gpf = i
-    if n > 1:
-        gpf = n
-    return gpf
+    return n
 
 def visualize_potentiality_flow():
     """
-    Visualizes the 'Arrow' logic: Mod 10 digits directing flow into Prime Potentiality.
-    Uses a Sankey Diagram to show 1, 3, 7, 9 as the only valid paths to 'P_n'.
+    Tab 1: Directed Graph (Sankey) showing Digit Constraints.
     """
-    # Nodes: [0: Source] -> [1-10: Digits 0-9] -> [11: Composite Sink] -> [12: Prime Potential]
-    labels = ["Integer Stream"] + [f"Ends in {i}" for i in range(10)] + ["Composite Sink (Ground)", "Prime Potential (P_n)"]
+    labels = ["Integer Stream"] + [f"Ends in {i}" for i in range(10)] + ["Composite Sink", "Prime Potential (P_n)"]
+    sources, targets, values, colors = [], [], [], []
     
-    sources = []
-    targets = []
-    values = []
-    colors = []
-    
-    # Link Source to Digits
+    # Layer 1: Stream -> Digits
     for i in range(10):
-        sources.append(0)
-        targets.append(i + 1)
-        values.append(10)
-        colors.append("#444") # Neutral stream
+        sources.append(0); targets.append(i+1); values.append(10); colors.append("#444")
 
-    # Link Digits to Destination
-    prime_lanes = [1, 3, 7, 9] # Digits 1, 3, 7, 9
-    
+    # Layer 2: Digits -> Destination
+    prime_lanes = [1, 3, 7, 9]
     for i in range(10):
-        sources.append(i + 1)
+        sources.append(i+1)
         if i in prime_lanes:
-            targets.append(12) # To Prime Potential
-            values.append(10)
-            colors.append("#00ffea") # Cyan Signal
+            targets.append(12) # Prime Potential
+            colors.append("#00ffea") # Cyan
         else:
-            targets.append(11) # To Composite Sink
-            values.append(10)
-            colors.append("#ff0055") # Red Ground
+            targets.append(11) # Sink
+            colors.append("#ff0055") # Red
+        values.append(10)
 
     fig = go.Figure(data=[go.Sankey(
-        node = dict(
-            pad = 15, thickness = 20,
-            line = dict(color = "black", width = 0.5),
-            label = labels,
-            color = ["white"] + ["#333"]*10 + ["#ff0055", "#00ffea"]
-        ),
-        link = dict(
-            source = sources, target = targets, value = values, color = colors
-        ))])
-
-    fig.update_layout(title="Directed Graph: Mod 10 Prime Constraints", template="plotly_dark", height=600)
+        node=dict(pad=15, thickness=20, line=dict(color="black", width=0.5), label=labels, color=["white"]+["#333"]*10+["#ff0055", "#00ffea"]),
+        link=dict(source=sources, target=targets, value=values, color=colors)
+    )])
+    fig.update_layout(title="Prime Potentiality Flow (Mod 10 Constraints)", template="plotly_dark", height=600)
     return fig
 
 def visualize_prime_network(max_integer, show_links):
-    """Visualizes the Radial Prime Topology with GPF Gravity."""
+    """
+    Tab 2: Radial Topology.
+    """
     fig = go.Figure()
-    positions, gpf_map, prime_children_count = {}, {}, Counter()
+    positions, gpf_map, prime_counts = {}, {}, Counter()
     
     for n in range(1, max_integer + 1):
         angle = np.pi/2 - (2 * np.pi * (n % 10)) / 10 # Clockwise from Top
         radius = n 
-        x, y = radius * np.cos(angle), radius * np.sin(angle)
-        positions[n] = (x, y)
+        positions[n] = (radius * np.cos(angle), radius * np.sin(angle))
+        
         if n > 1 and not sympy.isprime(n):
             gpf = get_gpf(n)
             gpf_map[n] = gpf
-            prime_children_count[gpf] += 1
+            prime_counts[gpf] += 1
 
     if show_links:
         edge_x, edge_y = [], []
@@ -96,50 +74,56 @@ def visualize_prime_network(max_integer, show_links):
             if base in positions:
                 x0, y0 = positions[n]
                 x1, y1 = positions[base]
-                edge_x.extend([x0, x1, None]); edge_y.extend([y0, y1, None])
+                edge_x.extend([x0, x1, None])
+                edge_y.extend([y0, y1, None])
         fig.add_trace(go.Scatter(x=edge_x, y=edge_y, mode='lines', line=dict(color='rgba(100,100,100,0.15)', width=0.5), hoverinfo='none', name='GPF Gravity'))
 
-    prime_x, prime_y, prime_size, prime_text = [], [], [], []
-    comp_x, comp_y, comp_text = [], [], []
+    # Draw Nodes
+    px, py, ps, pt = [], [], [], []
+    cx, cy, ct = [], [], []
     
     for n in range(1, max_integer + 1):
         x, y = positions[n]
         if sympy.isprime(n) or n == 1:
-            prime_x.append(x); prime_y.append(y)
-            size = 5 + (np.log(prime_children_count[n] + 1) * 6)
-            prime_size.append(size)
-            prime_text.append(f"PRIME: {n}<br>Gravity: {prime_children_count[n]}")
+            px.append(x); py.append(y)
+            ps.append(5 + (np.log(prime_counts[n]+1)*6))
+            pt.append(f"PRIME: {n}<br>Gravity: {prime_counts[n]}")
         else:
-            comp_x.append(x); comp_y.append(y)
-            comp_text.append(f"Composite: {n}")
-
-    fig.add_trace(go.Scatter(x=comp_x, y=comp_y, mode='markers', marker=dict(size=3, color='#ff0055', opacity=0.5), text=comp_text, hoverinfo='text', name='Composites'))
-    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'))
+            cx.append(x); cy.append(y)
+            ct.append(f"Composite: {n}")
 
+    fig.add_trace(go.Scatter(x=cx, y=cy, mode='markers', marker=dict(size=3, color='#ff0055', opacity=0.5), text=ct, hoverinfo='text', name='Composites'))
+    fig.add_trace(go.Scatter(x=px, y=py, mode='markers', marker=dict(size=ps, color='#00ffea', line=dict(width=1, color='white')), text=pt, hoverinfo='text', name='Primes'))
+    
+    # Spokes
     for i in range(10):
         angle = np.pi/2 - (2 * np.pi * i) / 10
-        fig.add_trace(go.Scatter(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.add_trace(go.Scatter(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 Prime-Indexed Topology (Max: {max_integer})", template="plotly_dark", height=800, width=800, xaxis=dict(visible=False), yaxis=dict(visible=False))
+    fig.update_layout(title=f"Radial Prime-Indexed Topology", template="plotly_dark", height=800, width=800, xaxis=dict(visible=False), yaxis=dict(visible=False))
     return fig
 
 def visualize_gpf_counts(sequence_length):
-    """Visualizes GPF Density."""
+    """
+    Tab 3: GPF Density (The Orange Graph).
+    """
     gpf_counts = Counter()
     for n in range(4, sequence_length):
         if not sympy.isprime(n): gpf_counts[get_gpf(n)] += 1
+    
     sorted_gpfs = sorted(gpf_counts.keys())
     counts = [gpf_counts[p] for p in sorted_gpfs]
+    
     fig = go.Figure(data=go.Bar(x=sorted_gpfs, y=counts, marker_color='#ff7f00', name="Composite Count"))
     fig.update_layout(title="Composite Density by GPF Base", xaxis_title="Prime Base", yaxis_title="Count", template="plotly_dark", xaxis=dict(type='category'))
     return fig
 
 # ==========================================
-# PART 2: DSP ENGINE (AUTOMATED)
+# PART 2: THE REAL AUTO-BAKER (EMBEDDED LOGIC)
 # ==========================================
 
 def calculate_ssim(img1, img2):
-    """Calculates Structural Similarity (Quality Metric)."""
+    """Calculates Quality (SSIM) of the reconstructed signal."""
     C1, C2 = (0.01 * 255)**2, (0.03 * 255)**2
     img1, img2 = img1.astype(np.float64), img2.astype(np.float64)
     kernel = cv2.getGaussianKernel(11, 1.5)
@@ -151,34 +135,29 @@ def calculate_ssim(img1, img2):
     sigma12 = cv2.filter2D(img1*img2, -1, window)[5:-5, 5:-5] - mu1_mu2
     return ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
 
-def run_logos_auto_bake(image):
+def run_auto_bake(image):
     """
-    AUTOMATED BAKER: No sliders.
-    1. Calculates internal entropy (Global Variance).
-    2. Sets heat tolerance automatically.
-    3. Decomposes stream.
-    4. Validates Delta Heat Checksum.
+    THE BAKER (Internal Logic).
+    Calculates Auto-Tolerance based on Global Variance.
+    Decomposes stream and verifies Delta Heat Checksum.
     """
-    if image is None: return None, None, "No Signal"
+    if image is None: return None, None, "Waiting for Signal..."
     
-    # 1. Pre-process (Grayscale)
+    # 1. Pre-process
     if len(image.shape) == 3: gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
     else: gray = image
     h, w = gray.shape
     
-    # 2. INTERNAL HEAT CALCULATION (Automatic Tolerance)
+    # 2. CALCULATION: Internal Entropy -> Auto-Tolerance
     global_variance = np.std(gray)
-    # Heuristic: Higher variance needs higher tolerance to prevent over-splitting, 
-    # OR lower tolerance to capture detail? 
-    # LOGOS Logic: We want to capture the CHANGE. 
-    # Fixed ratio based on the "Hades Frame" success.
-    auto_tolerance = global_variance * 0.15 
+    # The LOGOS constant derived from your testing
+    auto_tolerance = global_variance * 0.2 
     
     start_time = time.time()
     atoms = []
     delta_heat_sum = 0
     
-    # 3. RECURSIVE DISSOLUTION
+    # 3. RECURSIVE DISSOLUTION (Quadtree)
     def recursive_bake(x, y, w, h):
         nonlocal delta_heat_sum
         region = gray[y:y+h, x:x+w]
@@ -186,7 +165,7 @@ def run_logos_auto_bake(image):
         
         local_heat = np.std(region)
         
-        # Split Decision (Phase Change)
+        # Split Logic (Phase Change)
         if local_heat > auto_tolerance and w > 4:
             hw, hh = w // 2, h // 2
             recursive_bake(x, y, hw, hh)
@@ -194,33 +173,31 @@ def run_logos_auto_bake(image):
             recursive_bake(x, y+hh, hw, h-hh)
             recursive_bake(x+hw, y+hh, w-hw, h-hh)
         else:
-            # PERSIST ATOM (00 State)
+            # PERSIST ATOM (00)
             avg_val = int(np.mean(region))
             atoms.append((x, y, w, h, avg_val))
-            # Delta Heat: The "Energy" lost by averaging this block
-            # In a real video stream, this confirms the package integrity
             delta_heat_sum += local_heat
 
     recursive_bake(0, 0, w, h)
-    latency = (time.time() - start_time) * 1000 # ms
+    latency = (time.time() - start_time) * 1000
     
-    # 4. RECONSTRUCTION
+    # 4. RECONSTRUCTION & VISUALIZATION
     reconstructed = np.zeros_like(gray)
     heatmap_vis = np.zeros((h, w, 3), dtype=np.uint8)
     
     for (x, y, cw, ch, val) in atoms:
         reconstructed[y:y+ch, x:x+cw] = val
-        # Visualization: Red=High Freq (Change), Cyan=Low Freq (Persist)
+        # Heatmap: Red = Small (Hot), Cyan = Large (Cold)
         is_hot = cw < 16
         color = (255, 0, 85) if is_hot else (0, 255, 234)
         cv2.rectangle(heatmap_vis, (x, y), (x+cw, y+ch), color, -1 if is_hot else 1)
 
-    # 5. TELEMETRY & CHECKSUM
+    # 5. TELEMETRY
     ssim = calculate_ssim(gray, reconstructed).mean()
     comp_ratio = 100 * (1 - (len(atoms) * 5) / (w * h))
     
-    # The Checksum: Does the heat match the atom count?
-    checksum_valid = "PASS" if delta_heat_sum > 0 else "FAIL"
+    # Checksum Verification
+    checksum_status = "VALID" if delta_heat_sum > 0 else "INVALID"
     
     stats = (
         f"LOGOS TELEMETRY [AUTO-PILOT]\n"
@@ -231,7 +208,7 @@ def run_logos_auto_bake(image):
         f"Atom Count: {len(atoms)}\n"
         f"Compression: {comp_ratio:.1f}%\n"
         f"SSIM Fidelity: {ssim:.4f}\n"
-        f"Delta Heat Checksum: {checksum_valid} ({int(delta_heat_sum)})"
+        f"Delta Heat Checksum: {int(delta_heat_sum)} ({checksum_status})"
     )
     
     return cv2.cvtColor(reconstructed, cv2.COLOR_GRAY2RGB), heatmap_vis, stats
@@ -242,18 +219,15 @@ def run_logos_auto_bake(image):
 
 def build_demo():
     with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
-        gr.Markdown("# LOGOS: Systems Architecture & DSP Validator")
-        gr.Markdown("Validating **Directed Prime Constraints**, **Radial Topology**, and **Automated Stream Dissolution**.")
+        gr.Markdown("# LOGOS: Prime-Indexed Topology & Automated Compression")
         
         with gr.Tabs():
-            # TAB 1: THEORY
-            with gr.Tab("1. Prime Potentiality (Directed Flow)"):
-                gr.Markdown("Visualizing the digit constraints (1, 3, 7, 9) that direct the stream into Prime Potential.")
+            with gr.Tab("1. Prime Potentiality (Flow)"):
+                gr.Markdown("Visualizing the '1, 3, 7, 9' Digit Constraints.")
                 btn_flow = gr.Button("Generate Flow Graph")
                 flow_plot = gr.Plot(label="Sankey Diagram")
                 btn_flow.click(visualize_potentiality_flow, outputs=flow_plot)
 
-            # TAB 2: TOPOLOGY
             with gr.Tab("2. Radial Prime Network"):
                 gr.Markdown("The **Natural Tessellation**: Composites anchored to their GPF Base.")
                 with gr.Row():
@@ -263,7 +237,6 @@ def build_demo():
                 btn_net = gr.Button("Build Network")
                 btn_net.click(visualize_prime_network, inputs=[rad_len, link_toggle], outputs=net_plot)
             
-            # TAB 3: ANALYSIS
             with gr.Tab("3. GPF Density"):
                 gr.Markdown("Analyzing the 'Heat' generated by each Prime Base.")
                 gpf_len = gr.Slider(100, 10000, value=2500, label="Stream Depth")
@@ -271,20 +244,19 @@ def build_demo():
                 btn_gpf = gr.Button("Calculate Density")
                 btn_gpf.click(visualize_gpf_counts, inputs=[gpf_len], outputs=gpf_plot)
 
-            # TAB 4: THE LAB (AUTO)
             with gr.Tab("4. Auto-Stream Baker"):
-                gr.Markdown("**No Sliders.** The system analyzes image entropy and sets the Heat Threshold automatically.")
+                gr.Markdown("**Automated Entropy Analysis.** Drop an image (e.g., Hades Frame) to test the Auto-Tolerance and Checksum.")
                 with gr.Row():
                     with gr.Column():
-                        inp_img = gr.Image(label="Source Signal (Drop 'Hades Frame' Here)", type="numpy", height=300)
+                        inp_img = gr.Image(label="Source Signal", type="numpy", height=300)
                         btn_run = gr.Button("TRANSMIT STREAM", variant="primary")
-                        out_stats = gr.Textbox(label="DSP Telemetry", lines=7)
+                        out_stats = gr.Textbox(label="DSP Telemetry", lines=8)
                     
                     with gr.Column():
                         out_img = gr.Image(label="Reconstructed Signal")
                         out_heat = gr.Image(label="Dissolution Map (Delta Heat)")
                 
-                btn_run.click(run_logos_auto_bake, inputs=[inp_img], outputs=[out_img, out_heat, out_stats])
+                btn_run.click(run_auto_bake, inputs=[inp_img], outputs=[out_img, out_heat, out_stats])
 
     return demo