Update app.py

app.py

@@ -1,63 +1,200 @@
 import gradio as gr
 import numpy as np
+import plotly.graph_objects as go
+import sympy
 import cv2
 import time
-import sys
-import os
+from collections import Counter
 
-# --- SSIM CALCULATION (Signal Fidelity) ---
-def calculate_ssim(img1, img2):
+# ==========================================
+# PART 1: MATHEMATICAL PRIMITIVES (THEORY)
+# ==========================================
+
+def get_gpf(n):
+    """Returns the Greatest Prime Factor of n."""
+    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
+
+def visualize_prime_network(max_integer, show_links):
     """
-    Calculates Structural Similarity Index (SSIM).
-    1.0 = Perfect Copy. <0.8 = Noticeable Degradation.
+    Visualizes the Radial Prime Topology.
+    - Nodes: Integers.
+    - Layout: Radial Mod 10 (Clockwise from Top).
+    - Connections: Composites tethered to their GPF Base.
     """
+    fig = go.Figure()
+    
+    positions = {} 
+    gpf_map = {}   
+    prime_children_count = Counter() 
+    
+    # 1. Calculate Positions (Mod 10 Dial)
+    for n in range(1, max_integer + 1):
+        # 0 at Top (pi/2), Clockwise rotation
+        angle = np.pi/2 - (2 * np.pi * (n % 10)) / 10
+        radius = n 
+        x = radius * np.cos(angle)
+        y = radius * np.sin(angle)
+        positions[n] = (x, y)
+        
+        if n > 1:
+            if not sympy.isprime(n):
+                gpf = get_gpf(n)
+                gpf_map[n] = gpf
+                prime_children_count[gpf] += 1
+
+    # 2. Draw Connectivity (The Tessellation)
+    if show_links:
+        edge_x, edge_y = [], []
+        for n, base in gpf_map.items():
+            if base in positions:
+                x0, y0 = positions[n]
+                x1, y1 = positions[base]
+                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'
+        ))
+
+    # 3. Draw Nodes
+    prime_x, prime_y, prime_size, prime_text = [], [], [], []
+    comp_x, comp_y, comp_text = [], [], []
+    
+    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)
+            weight = prime_children_count[n]
+            # Logarithmic sizing based on "Gravity" (number of composites anchored)
+            size = 5 + (np.log(weight + 1) * 6) 
+            prime_size.append(size)
+            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>Base: {gpf_map.get(n)}")
+
+    fig.add_trace(go.Scatter(
+        x=comp_x, y=comp_y,
+        mode='markers',
+        marker=dict(size=3, color='#ff0055', opacity=0.5), # Red dust
+        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')), # Cyan anchors
+        text=prime_text, hoverinfo='text', name='Primes'
+    ))
+
+    # 4. Draw Radial 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='#333', width=1, dash='dot'),
+            showlegend=False
+        ))
+
+    fig.update_layout(
+        title=f"Radial Prime-Indexed Topology (Max: {max_integer})",
+        template="plotly_dark",
+        xaxis=dict(showgrid=False, zeroline=False, visible=False),
+        yaxis=dict(showgrid=False, zeroline=False, visible=False),
+        width=800, height=800,
+        showlegend=True
+    )
+    return fig
+
+def visualize_gpf_counts(sequence_length):
+    """Visualizes the 'Heat' generated by each Prime Base."""
+    gpf_counts = Counter()
+    for n in range(4, sequence_length):
+        if not sympy.isprime(n):
+            gpf = get_gpf(n)
+            gpf_counts[gpf] += 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', # LOGOS Orange
+        name="Composite Count"
+    ))
+    
+    fig.update_layout(
+        title="Composite Density by Greatest Prime Factor (GPF)",
+        xaxis_title="Prime Base (P)",
+        yaxis_title="Composites Anchored",
+        template="plotly_dark",
+        xaxis=dict(type='category')
+    )
+    return fig
+
+# ==========================================
+# PART 2: DSP ENGINE (PRACTICE)
+# ==========================================
+
+def calculate_ssim(img1, img2):
+    """Calculates Structural Similarity Index (1.0 = Perfect)."""
     C1 = (0.01 * 255)**2
     C2 = (0.03 * 255)**2
-    
     img1 = img1.astype(np.float64)
     img2 = img2.astype(np.float64)
-    
     kernel = cv2.getGaussianKernel(11, 1.5)
     window = np.outer(kernel, kernel.transpose())
-    
     mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5]
     mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
-    
     mu1_sq = mu1**2
     mu2_sq = mu2**2
     mu1_mu2 = mu1 * mu2
-    
     sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq
     sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq
     sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
-    
     ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
     return ssim_map.mean()
 
-# --- THE LOGOS ENGINE (In-Memory Implementation) ---
-def run_logos_pipeline(image, heat_tolerance, noise_level, use_checksum):
+def run_logos_pipeline(image, heat_tolerance, noise_level):
     """
-    Simulates the Full DSP Pipeline:
-    Source -> Noise -> Bake (Encode) -> Transmit -> Eat (Decode) -> SSIM Check
+    Runs the Real DSP Pipeline: Source -> Noise -> SPCW Encode -> Decode -> SSIM
     """
     if image is None: return None, None, "No Signal"
     
-    # 1. PRE-PROCESS & NOISE INJECTION
+    # 1. Pre-process
     if len(image.shape) == 3:
         gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
     else:
         gray = image
-        
     h, w = gray.shape
     
-    # Add Gaussian Noise (Simulate Interference)
+    # 2. Noise Injection (Simulate Transmission Interference)
     if noise_level > 0:
-        noise = np.random.normal(0, noise_level * 25, gray.shape).astype(np.int16)
+        noise = np.random.normal(0, noise_level * 20, gray.shape).astype(np.int16)
         noisy_signal = np.clip(gray + noise, 0, 255).astype(np.uint8)
     else:
         noisy_signal = gray.copy()
 
-    # 2. BAKE (Encoding) - Adaptive Quadtree
+    # 3. THE BAKER (Adaptive Quadtree Decomposition)
     start_time = time.time()
     atoms = []
     
@@ -65,16 +202,10 @@ def run_logos_pipeline(image, heat_tolerance, noise_level, use_checksum):
         region = noisy_signal[y:y+h, x:x+w]
         if region.size == 0: return
         
-        # Heat Calculation (Variance)
+        # Heat = Variance of the signal
         heat = np.std(region)
         
-        # Harmonic Checksum Logic (Simulated)
-        # If enabled, we use Prime Resonance to 'smooth' high-frequency noise
-        if use_checksum and heat < (heat_tolerance * 150):
-             # Force Persistence if "Harmonically Stable" even if noisy
-             heat = 0 
-        
-        # Decision: Split or Persist
+        # Split Decision (The SPCW Phase Logic)
         if heat > (heat_tolerance * 100) and w > 4:
             hw, hh = w // 2, h // 2
             recursive_bake(x, y, hw, hh)
@@ -82,72 +213,87 @@ def run_logos_pipeline(image, heat_tolerance, noise_level, use_checksum):
             recursive_bake(x, y+hh, hw, h-hh)
             recursive_bake(x+hw, y+hh, w-hw, h-hh)
         else:
-            # ENCODE ATOM (Persistence State)
+            # Persistence State (00)
             avg_val = int(np.mean(region))
             atoms.append((x, y, w, h, avg_val))
 
     recursive_bake(0, 0, w, h)
-    encode_time = time.time() - start_time
+    latency = (time.time() - start_time) * 1000 # ms
     
-    # 3. EAT (Reconstruction)
+    # 4. THE PLAYER (Reconstruction)
     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
-        
-        # Visualize Heat Map (Red=Small/Hot, Cyan=Large/Cool)
-        is_hot = cw < 8
+        # Visualization: Small=Hot(Red), Large=Cold(Cyan)
+        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)
 
-    # 4. ANALYTICS (DSP Stats)
-    ssim_score = calculate_ssim(gray, reconstructed)
-    compression_ratio = 100 * (1 - (len(atoms) * 512) / (w * h)) # approx atom size
+    # 5. Telemetry
+    ssim = calculate_ssim(gray, reconstructed)
+    comp_ratio = 100 * (1 - (len(atoms) * 5) / (w * h)) # approx
     
     stats = (
-        f"--- DSP TELEMETRY ---\n"
-        f"Stream Latency: {encode_time*1000:.1f} ms\n"
-        f"Atom Count: {len(atoms)}\n"
-        f"Compression: {compression_ratio:.1f}%\n"
-        f"Signal Fidelity (SSIM): {ssim_score:.4f} / 1.0\n"
-        f"Status: {'CRITICAL' if ssim_score < 0.8 else 'STABLE'}"
+        f"DSP TELEMETRY\n"
+        f"-------------\n"
+        f"Latency: {latency:.1f} ms\n"
+        f"Atoms: {len(atoms)}\n"
+        f"Compression: ~{comp_ratio:.1f}%\n"
+        f"SSIM (Fidelity): {ssim:.4f}\n"
+        f"Noise Floor: {noise_level}"
     )
     
-    # Visual Output: Left=Reconstructed, Right=Heatmap Overlay
-    final_output = cv2.cvtColor(reconstructed, cv2.COLOR_GRAY2RGB)
-    
-    return final_output, heatmap_vis, stats
+    return cv2.cvtColor(reconstructed, cv2.COLOR_GRAY2RGB), heatmap_vis, stats
 
-# --- THE INTERFACE ---
-with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
-    gr.Markdown("# LOGOS: DSP Fidelity & Harmonic Checksum Lab")
-    gr.Markdown("Test the **SPCW Phase Determinism** against signal noise. Verify SSIM and Transmission Speed.")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            inp_img = gr.Image(label="Input Signal (Source)", type="numpy", height=300)
-            
-            with gr.Group():
-                gr.Markdown("### DSP Parameters")
-                tol_slider = gr.Slider(0.01, 1.0, value=0.1, label="Heat Tolerance (Persistence)")
-                noise_slider = gr.Slider(0.0, 5.0, value=0.0, label="Signal Noise (Interference)")
-                check_toggle = gr.Checkbox(label="Enable Harmonic Checksum (Prime Correction)", value=False)
-            
-            btn_run = gr.Button("TRANSMIT STREAM", variant="primary")
-            stats_box = gr.Textbox(label="Telemetry", lines=6)
+# ==========================================
+# PART 3: THE INTERFACE
+# ==========================================
+
+def build_demo():
+    with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
+        gr.Markdown("# LOGOS: Systems Architecture Suite")
+        gr.Markdown("Validating **Post-Binary Logic**, **Prime Topology**, and **DSP Signal Integrity**.")
+        
+        with gr.Tabs():
+            # TAB 1: THE THEORY (Visuals)
+            with gr.Tab("1. Radial Prime Topology"):
+                gr.Markdown("The **Natural Tessellation** of the number line. Composites are anchored to their Greatest Prime Factor (GPF).")
+                with gr.Row():
+                    rad_len = gr.Slider(100, 2000, value=500, label="Integer Range")
+                    link_toggle = gr.Checkbox(value=True, label="Show Connectivity (Gravity)")
+                net_plot = gr.Plot(label="Radial View")
+                btn_net = gr.Button("Build Network")
+                btn_net.click(visualize_prime_network, inputs=[rad_len, link_toggle], outputs=net_plot)
             
-        with gr.Column(scale=2):
-            with gr.Tab("Reconstructed Reality"):
-                out_img = gr.Image(label="Decoded Signal", type="numpy")
-            with gr.Tab("Heatmap (Phase Delta)"):
-                heat_img = gr.Image(label="Variable Chunking Visualization", type="numpy")
-
-    btn_run.click(
-        run_logos_pipeline, 
-        inputs=[inp_img, tol_slider, noise_slider, check_toggle], 
-        outputs=[out_img, heat_img, stats_box]
-    )
+            # TAB 2: DENSITY ANALYSIS
+            with gr.Tab("2. GPF Density"):
+                gr.Markdown("Analyzing the 'Heat' generated by each Prime Base.")
+                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)
+
+            # TAB 3: THE LAB (Real Engine)
+            with gr.Tab("3. DSP Fidelity Lab"):
+                gr.Markdown("Test the **SPCW Engine** on real signals. Inject noise, adjust heat tolerance, and measure SSIM.")
+                with gr.Row():
+                    with gr.Column():
+                        inp = gr.Image(label="Source Signal", type="numpy", height=250)
+                        tol = gr.Slider(0.01, 0.5, value=0.1, label="Heat Tolerance (Persistence)")
+                        noise = gr.Slider(0.0, 5.0, value=0.0, label="Noise Injection (Interference)")
+                        btn_run = gr.Button("TRANSMIT STREAM", variant="primary")
+                        out_stats = gr.Textbox(label="Telemetry", lines=5)
+                    
+                    with gr.Column():
+                        out_img = gr.Image(label="Reconstructed Signal")
+                        out_heat = gr.Image(label="Phase Map (Red=Change, Cyan=Persist)")
+                
+                btn_run.click(run_logos_pipeline, inputs=[inp, tol, noise], outputs=[out_img, out_heat, out_stats])
+
+    return demo
 
 if __name__ == "__main__":
+    demo = build_demo()
     demo.launch(ssr_mode=False)