Update app.py

app.py

@@ -4,10 +4,12 @@ import plotly.graph_objects as go
 import sympy
 import cv2
 import time
+import sys
+import os
 from collections import Counter
 
 # ==========================================
-# PART 1: MATHEMATICAL PRIMITIVES (THEORY)
+# PART 1: THEORETICAL PRIMITIVES
 # ==========================================
 
 def get_gpf(n):
@@ -25,224 +27,211 @@ def get_gpf(n):
         gpf = n
     return gpf
 
-def visualize_prime_network(max_integer, show_links):
+def visualize_potentiality_flow():
     """
-    Visualizes the Radial Prime Topology.
-    - Nodes: Integers.
-    - Layout: Radial Mod 10 (Clockwise from Top).
-    - Connections: Composites tethered to their GPF Base.
+    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'.
     """
-    fig = go.Figure()
+    # 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)"]
     
-    positions = {} 
-    gpf_map = {}   
-    prime_children_count = Counter() 
+    sources = []
+    targets = []
+    values = []
+    colors = []
+    
+    # Link Source to Digits
+    for i in range(10):
+        sources.append(0)
+        targets.append(i + 1)
+        values.append(10)
+        colors.append("#444") # Neutral stream
+
+    # Link Digits to Destination
+    prime_lanes = [1, 3, 7, 9] # Digits 1, 3, 7, 9
+    
+    for i in range(10):
+        sources.append(i + 1)
+        if i in prime_lanes:
+            targets.append(12) # To Prime Potential
+            values.append(10)
+            colors.append("#00ffea") # Cyan Signal
+        else:
+            targets.append(11) # To Composite Sink
+            values.append(10)
+            colors.append("#ff0055") # Red Ground
+
+    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)
+    return fig
+
+def visualize_prime_network(max_integer, show_links):
+    """Visualizes the Radial Prime Topology with GPF Gravity."""
+    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
+        angle = np.pi/2 - (2 * np.pi * (n % 10)) / 10 # Clockwise from Top
         radius = n 
-        x = radius * np.cos(angle)
-        y = radius * np.sin(angle)
+        x, y = radius * np.cos(angle), 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
+        if n > 1 and 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'
-        ))
+                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_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"<b>PRIME: {n}</b><br>Gravity: {weight}")
+            prime_text.append(f"PRIME: {n}<br>Gravity: {prime_children_count[n]}")
         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'
-    ))
+            comp_x.append(x); comp_y.append(y)
+            comp_text.append(f"Composite: {n}")
 
-    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'
-    ))
+    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'))
 
-    # 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.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",
-        xaxis=dict(showgrid=False, zeroline=False, visible=False),
-        yaxis=dict(showgrid=False, zeroline=False, visible=False),
-        width=800, height=800,
-        showlegend=True
-    )
+    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))
     return fig
 
 def visualize_gpf_counts(sequence_length):
-    """Visualizes the 'Heat' generated by each Prime Base."""
+    """Visualizes GPF Density."""
     gpf_counts = Counter()
     for n in range(4, sequence_length):
-        if not sympy.isprime(n):
-            gpf = get_gpf(n)
-            gpf_counts[gpf] += 1
-            
+        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', # 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')
-    )
+    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 (PRACTICE)
+# PART 2: DSP ENGINE (AUTOMATED)
 # ==========================================
 
 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)
+    """Calculates Structural Similarity (Quality Metric)."""
+    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)
     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
+    mu1, mu2 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5], cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
+    mu1_sq, mu2_sq, mu1_mu2 = mu1**2, mu2**2, 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()
+    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_pipeline(image, heat_tolerance, noise_level):
+def run_logos_auto_bake(image):
     """
-    Runs the Real DSP Pipeline: Source -> Noise -> SPCW Encode -> Decode -> SSIM
+    AUTOMATED BAKER: No sliders.
+    1. Calculates internal entropy (Global Variance).
+    2. Sets heat tolerance automatically.
+    3. Decomposes stream.
+    4. Validates Delta Heat Checksum.
     """
     if image is None: return None, None, "No Signal"
     
-    # 1. Pre-process
-    if len(image.shape) == 3:
-        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-    else:
-        gray = image
+    # 1. Pre-process (Grayscale)
+    if len(image.shape) == 3: gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+    else: gray = image
     h, w = gray.shape
     
-    # 2. Noise Injection (Simulate Transmission Interference)
-    if noise_level > 0:
-        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()
-
-    # 3. THE BAKER (Adaptive Quadtree Decomposition)
+    # 2. INTERNAL HEAT CALCULATION (Automatic 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 
+    
     start_time = time.time()
     atoms = []
+    delta_heat_sum = 0
     
+    # 3. RECURSIVE DISSOLUTION
     def recursive_bake(x, y, w, h):
-        region = noisy_signal[y:y+h, x:x+w]
+        nonlocal delta_heat_sum
+        region = gray[y:y+h, x:x+w]
         if region.size == 0: return
         
-        # Heat = Variance of the signal
-        heat = np.std(region)
+        local_heat = np.std(region)
         
-        # Split Decision (The SPCW Phase Logic)
-        if heat > (heat_tolerance * 100) and w > 4:
+        # Split Decision (Phase Change)
+        if local_heat > auto_tolerance and w > 4:
             hw, hh = w // 2, h // 2
             recursive_bake(x, y, hw, hh)
             recursive_bake(x+hw, y, w-hw, hh)
             recursive_bake(x, y+hh, hw, h-hh)
             recursive_bake(x+hw, y+hh, w-hw, h-hh)
         else:
-            # Persistence State (00)
+            # PERSIST ATOM (00 State)
             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
     
-    # 4. THE PLAYER (Reconstruction)
+    # 4. 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
-        # Visualization: Small=Hot(Red), Large=Cold(Cyan)
+        # Visualization: Red=High Freq (Change), Cyan=Low Freq (Persist)
         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)
+        cv2.rectangle(heatmap_vis, (x, y), (x+cw, y+ch), color, -1 if is_hot else 1)
 
-    # 5. Telemetry
-    ssim = calculate_ssim(gray, reconstructed)
-    comp_ratio = 100 * (1 - (len(atoms) * 5) / (w * h)) # approx
+    # 5. TELEMETRY & CHECKSUM
+    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"
     
     stats = (
-        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}"
+        f"LOGOS TELEMETRY [AUTO-PILOT]\n"
+        f"----------------------------\n"
+        f"Global Entropy: {global_variance:.2f}\n"
+        f"Auto-Tolerance: {auto_tolerance:.2f}\n"
+        f"Stream Latency: {latency:.1f} ms\n"
+        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)})"
     )
     
     return cv2.cvtColor(reconstructed, cv2.COLOR_GRAY2RGB), heatmap_vis, stats
@@ -253,44 +242,49 @@ def run_logos_pipeline(image, heat_tolerance, noise_level):
 
 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**.")
+        gr.Markdown("# LOGOS: Systems Architecture & DSP Validator")
+        gr.Markdown("Validating **Directed Prime Constraints**, **Radial Topology**, and **Automated Stream Dissolution**.")
         
         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).")
+            # 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.")
+                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():
                     rad_len = gr.Slider(100, 2000, value=500, label="Integer Range")
-                    link_toggle = gr.Checkbox(value=True, label="Show Connectivity (Gravity)")
+                    link_toggle = gr.Checkbox(value=True, label="Show GPF 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)
             
-            # TAB 2: DENSITY ANALYSIS
-            with gr.Tab("2. GPF Density"):
+            # 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")
                 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.")
+            # 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.")
                 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)")
+                        inp_img = gr.Image(label="Source Signal (Drop 'Hades Frame' Here)", type="numpy", height=300)
                         btn_run = gr.Button("TRANSMIT STREAM", variant="primary")
-                        out_stats = gr.Textbox(label="Telemetry", lines=5)
+                        out_stats = gr.Textbox(label="DSP Telemetry", lines=7)
                     
                     with gr.Column():
                         out_img = gr.Image(label="Reconstructed Signal")
-                        out_heat = gr.Image(label="Phase Map (Red=Change, Cyan=Persist)")
+                        out_heat = gr.Image(label="Dissolution Map (Delta Heat)")
                 
-                btn_run.click(run_logos_pipeline, inputs=[inp, tol, noise], outputs=[out_img, out_heat, out_stats])
+                btn_run.click(run_logos_auto_bake, inputs=[inp_img], outputs=[out_img, out_heat, out_stats])
 
     return demo