Update app.py

app.py

@@ -1020,8 +1020,145 @@ def create_diagnostic_plots(z, w):
     )
     return fig
 
-def create_dual_holography_plot(z1, phi1, z2, phi2, resolution, wavelength, title1="Primary", title2="Comparison"):
-    """Creates side-by-side holographic visualizations for comparison."""
+def create_enhanced_holography_plot(z, phi, resolution, wavelength, field_depth=5, interference_strength=1.0, colormap="Wavelength", title="Holographic Field"):
+    """Creates an enhanced holographic visualization with advanced mathematical features."""
+    field_data = generate_holographic_field(z, phi, resolution)
+    if field_data is None: 
+        return go.Figure(layout={"title": "Insufficient data for enhanced holography"})
+
+    grid_x, grid_y, grid_phi = field_data
+    mag_phi = np.abs(grid_phi) * interference_strength
+    phase_phi = np.angle(grid_phi)
+
+    # Enhanced wavelength to colorscale mapping with more sophisticated colors
+    def wavelength_to_rgb_enhanced(wl):
+        if 380 <= wl < 420: return f'rgb({int(255 * (420-wl)/40)}, 0, 255)'  # Violet
+        elif 420 <= wl < 440: return f'rgb(0, 0, 255)'  # Blue  
+        elif 440 <= wl < 490: return f'rgb(0, {int(255 * (wl-440)/50)}, 255)'  # Cyan
+        elif 490 <= wl < 510: return f'rgb(0, 255, {int(255 * (510-wl)/20)})'  # Green
+        elif 510 <= wl < 580: return f'rgb({int(255 * (wl-510)/70)}, 255, 0)'  # Yellow
+        elif 580 <= wl < 645: return f'rgb(255, {int(255 * (645-wl)/65)}, 0)'  # Orange
+        elif 645 <= wl <= 750: return f'rgb(255, 0, 0)'  # Red
+        return 'rgb(255,255,255)'
+    
+    # Choose colorscale based on mode
+    if colormap == "Wavelength":
+        mid_color = wavelength_to_rgb_enhanced(wavelength)
+        custom_colorscale = [[0, 'rgb(10,0,20)'], [0.3, 'rgb(30,20,60)'], [0.5, mid_color], 
+                           [0.7, 'rgb(255,200,150)'], [1, 'rgb(255,255,255)']]
+    elif colormap == "Phase":
+        custom_colorscale = 'hsv'
+    elif colormap == "Magnitude":
+        custom_colorscale = 'hot'
+    elif colormap == "Interference":
+        custom_colorscale = [[0, 'rgb(0,0,100)'], [0.25, 'rgb(0,100,200)'], [0.5, 'rgb(255,255,0)'], 
+                           [0.75, 'rgb(255,100,0)'], [1, 'rgb(255,0,0)']]
+    else:  # Custom
+        custom_colorscale = 'viridis'
+
+    fig = go.Figure()
+    
+    # Multi-layer holographic surface with depth
+    for depth_layer in range(field_depth):
+        layer_alpha = 1.0 - (depth_layer * 0.15)  # Fade deeper layers
+        layer_offset = depth_layer * 0.1
+        
+        fig.add_trace(go.Surface(
+            x=grid_x, y=grid_y, z=mag_phi + layer_offset,
+            surfacecolor=phase_phi if colormap == "Phase" else mag_phi,
+            colorscale=custom_colorscale,
+            opacity=layer_alpha,
+            showscale=(depth_layer == 0),  # Only show colorbar for top layer
+            colorbar=dict(title='Holographic Field Intensity', x=1.02),
+            name=f'Field Layer {depth_layer+1}',
+            contours_z=dict(
+                show=True, 
+                usecolormap=True, 
+                highlightcolor="rgba(255,255,255,0.8)", 
+                project_z=True,
+                highlightwidth=2
+            )
+        ))
+    
+    # Enhanced data points with size based on magnitude
+    point_sizes = np.abs(phi) * 5 + 2  # Dynamic sizing
+    fig.add_trace(go.Scatter3d(
+        x=np.real(z), y=np.imag(z), z=np.abs(phi) + 0.1,
+        mode='markers',
+        marker=dict(
+            size=point_sizes,
+            color=np.angle(phi), 
+            colorscale='rainbow',
+            symbol='diamond',
+            opacity=0.9,
+            line=dict(width=1, color='white')
+        ),
+        name='Signal Constellation',
+        hovertemplate='<b>Signal Point</b><br>Re(z): %{x:.3f}<br>Im(z): %{y:.3f}<br>|φ|: %{z:.3f}<extra></extra>'
+    ))
+    
+    # Enhanced vector flow field with adaptive density
+    if resolution >= 40:  # Only show for sufficient resolution
+        grad_y, grad_x = np.gradient(mag_phi)
+        sample_rate = max(1, resolution // 20)  # Adaptive sampling
+        
+        fig.add_trace(go.Cone(
+            x=grid_x[::sample_rate, ::sample_rate].flatten(), 
+            y=grid_y[::sample_rate, ::sample_rate].flatten(), 
+            z=mag_phi[::sample_rate, ::sample_rate].flatten(),
+            u=-grad_x[::sample_rate, ::sample_rate].flatten(), 
+            v=-grad_y[::sample_rate, ::sample_rate].flatten(), 
+            w=np.full_like(mag_phi[::sample_rate, ::sample_rate].flatten(), -0.05),
+            sizemode="absolute", 
+            sizeref=0.08 * interference_strength,
+            anchor="tip",
+            colorscale='greys',
+            showscale=False,
+            opacity=0.6,
+            name='Field Gradient'
+        ))
+
+    fig.update_layout(
+        title={
+            'text': f"🌟 {title}<br><sub>Enhanced Holographic Field Reconstruction (λ={wavelength}nm)</sub>",
+            'x': 0.5,
+            'xanchor': 'center'
+        },
+        scene=dict(
+            xaxis_title="Re(z) - Complex Embedding",
+            yaxis_title="Im(z) - Phase Encoding",
+            zaxis_title="|Φ| - Holographic Intensity",
+            camera=dict(eye=dict(x=1.8, y=1.8, z=1.5)),
+            aspectmode='cube',
+            bgcolor='rgba(5,5,15,1)'
+        ),
+        margin=dict(l=0, r=0, b=0, t=80),
+        paper_bgcolor='rgba(10,10,25,1)',
+        plot_bgcolor='rgba(5,5,15,1)'
+    )
+    return fig
+
+def create_dual_holography_plot(z1, phi1, z2, phi2, resolution, wavelength, field_depth=5, 
+                               interference_strength=1.0, view_mode="Side-by-Side", colormap="Wavelength",
+                               title1="Primary", title2="Comparison"):
+    """Creates enhanced side-by-side holographic visualizations with multiple view modes."""
+    
+    if view_mode == "Side-by-Side":
+        return create_side_by_side_holography(z1, phi1, z2, phi2, resolution, wavelength, 
+                                            field_depth, interference_strength, colormap, title1, title2)
+    elif view_mode == "Overlay":
+        return create_overlay_holography(z1, phi1, z2, phi2, resolution, wavelength,
+                                       field_depth, interference_strength, colormap, title1, title2)
+    elif view_mode == "Difference":
+        return create_difference_holography(z1, phi1, z2, phi2, resolution, wavelength,
+                                          field_depth, interference_strength, colormap, title1, title2)
+    else:  # Animation
+        return create_animated_holography(z1, phi1, z2, phi2, resolution, wavelength,
+                                        field_depth, interference_strength, colormap, title1, title2)
+
+def create_side_by_side_holography(z1, phi1, z2, phi2, resolution, wavelength, field_depth, 
+                                  interference_strength, colormap, title1, title2):
+    """Enhanced side-by-side comparison with mathematical precision."""
     field_data1 = generate_holographic_field(z1, phi1, resolution)
     field_data2 = generate_holographic_field(z2, phi2, resolution)
     
@@ -1031,80 +1168,377 @@ def create_dual_holography_plot(z1, phi1, z2, phi2, resolution, wavelength, titl
     grid_x1, grid_y1, grid_phi1 = field_data1
     grid_x2, grid_y2, grid_phi2 = field_data2
     
-    mag_phi1, phase_phi1 = np.abs(grid_phi1), np.angle(grid_phi1)
-    mag_phi2, phase_phi2 = np.abs(grid_phi2), np.angle(grid_phi2)
-
-    # Wavelength to colorscale mapping
-    def wavelength_to_rgb(wl):
-        if 380 <= wl < 440: return f'rgb({int(-(wl - 440) / (440 - 380) * 255)}, 0, 255)'
-        elif 440 <= wl < 495: return f'rgb(0, {int((wl - 440) / (495 - 440) * 255)}, 255)'
-        elif 495 <= wl < 570: return f'rgb(0, 255, {int(-(wl - 570) / (570 - 495) * 255)})'
-        elif 570 <= wl < 590: return f'rgb({int((wl - 570) / (590 - 570) * 255)}, 255, 0)'
-        elif 590 <= wl < 620: return f'rgb(255, {int(-(wl - 620) / (620 - 590) * 255)}, 0)'
-        elif 620 <= wl <= 750: return 'rgb(255, 0, 0)'
-        return 'rgb(255,255,255)'
+    # Enhanced color mapping
+    def get_enhanced_colorscale(colormap, wavelength):
+        if colormap == "Wavelength":
+            # Sophisticated wavelength-based colors
+            if 380 <= wavelength < 450:
+                return [[0, 'rgb(20,0,60)'], [0.5, 'rgb(120,0,255)'], [1, 'rgb(200,150,255)']]
+            elif 450 <= wavelength < 550:
+                return [[0, 'rgb(0,20,60)'], [0.5, 'rgb(0,120,255)'], [1, 'rgb(150,200,255)']]
+            elif 550 <= wavelength < 650:
+                return [[0, 'rgb(0,60,20)'], [0.5, 'rgb(120,255,0)'], [1, 'rgb(200,255,150)']]
+            else:
+                return [[0, 'rgb(60,20,0)'], [0.5, 'rgb(255,120,0)'], [1, 'rgb(255,200,150)']]
+        elif colormap == "Phase":
+            return 'hsv'
+        elif colormap == "Magnitude":
+            return 'hot'
+        elif colormap == "Interference":
+            return [[0, 'rgb(0,0,100)'], [0.3, 'rgb(0,150,255)'], [0.6, 'rgb(255,255,0)'], [1, 'rgb(255,0,0)']]
+        return 'viridis'
+    
+    custom_colorscale = get_enhanced_colorscale(colormap, wavelength)
     
-    mid_color = wavelength_to_rgb(wavelength)
-    custom_colorscale = [[0, 'rgb(20,0,40)'], [0.5, mid_color], [1, 'rgb(255,255,255)']]
-
     fig = make_subplots(
         rows=1, cols=2,
         specs=[[{'type': 'scene'}, {'type': 'scene'}]],
-        subplot_titles=[title1, title2]
+        subplot_titles=[f"🎵 {title1}", f"🔗 {title2}"],
+        horizontal_spacing=0.05
     )
 
-    # Left plot (Primary)
-    fig.add_trace(go.Surface(
-        x=grid_x1, y=grid_y1, z=mag_phi1,
-        surfacecolor=phase_phi1,
-        colorscale=custom_colorscale,
-        cmin=-np.pi, cmax=np.pi,
-        showscale=False,
-        name=title1,
-        contours_z=dict(show=True, usecolormap=True, highlightcolor="limegreen", project_z=True)
-    ), row=1, col=1)
+    # Enhanced processing for both fields
+    mag_phi1 = np.abs(grid_phi1) * interference_strength
+    mag_phi2 = np.abs(grid_phi2) * interference_strength
+    phase_phi1 = np.angle(grid_phi1)
+    phase_phi2 = np.angle(grid_phi2)
+
+    # Left plot (Primary) with multiple layers
+    for layer in range(min(field_depth, 3)):  # Limit for performance
+        layer_alpha = 1.0 - (layer * 0.2)
+        layer_offset = layer * 0.05
+        
+        fig.add_trace(go.Surface(
+            x=grid_x1, y=grid_y1, z=mag_phi1 + layer_offset,
+            surfacecolor=phase_phi1 if colormap == "Phase" else mag_phi1,
+            colorscale=custom_colorscale,
+            opacity=layer_alpha,
+            showscale=False,
+            name=f'{title1} Layer {layer+1}',
+            contours_z=dict(show=True, usecolormap=True, project_z=True)
+        ), row=1, col=1)
     
-    # Right plot (Comparison)
-    fig.add_trace(go.Surface(
-        x=grid_x2, y=grid_y2, z=mag_phi2,
-        surfacecolor=phase_phi2,
-        colorscale=custom_colorscale,
-        cmin=-np.pi, cmax=np.pi,
-        showscale=False,
-        name=title2,
-        contours_z=dict(show=True, usecolormap=True, highlightcolor="limegreen", project_z=True)
-    ), row=1, col=2)
+    # Right plot (Comparison)  
+    for layer in range(min(field_depth, 3)):
+        layer_alpha = 1.0 - (layer * 0.2)
+        layer_offset = layer * 0.05
+        
+        fig.add_trace(go.Surface(
+            x=grid_x2, y=grid_y2, z=mag_phi2 + layer_offset,
+            surfacecolor=phase_phi2 if colormap == "Phase" else mag_phi2,
+            colorscale=custom_colorscale,
+            opacity=layer_alpha,
+            showscale=False,
+            name=f'{title2} Layer {layer+1}',
+            contours_z=dict(show=True, usecolormap=True, project_z=True)
+        ), row=1, col=2)
 
-    # Add data points
+    # Enhanced data points for both sides
     if z1 is not None and phi1 is not None:
+        point_sizes1 = np.abs(phi1) * 3 + 1
         fig.add_trace(go.Scatter3d(
             x=np.real(z1), y=np.imag(z1), z=np.abs(phi1) + 0.05,
-            mode='markers', marker=dict(size=3, color='black', symbol='x'),
-            name=f'{title1} Points', showlegend=False
+            mode='markers',
+            marker=dict(size=point_sizes1, color=np.angle(phi1), colorscale='rainbow', 
+                       symbol='diamond', opacity=0.8, line=dict(width=1, color='white')),
+            name=f'{title1} Constellation',
+            showlegend=False,
+            hovertemplate=f'<b>{title1}</b><br>Re(z): %{{x:.3f}}<br>Im(z): %{{y:.3f}}<br>|φ|: %{{z:.3f}}<extra></extra>'
         ), row=1, col=1)
     
     if z2 is not None and phi2 is not None:
+        point_sizes2 = np.abs(phi2) * 3 + 1
         fig.add_trace(go.Scatter3d(
             x=np.real(z2), y=np.imag(z2), z=np.abs(phi2) + 0.05,
-            mode='markers', marker=dict(size=3, color='black', symbol='x'),
-            name=f'{title2} Points', showlegend=False
+            mode='markers',
+            marker=dict(size=point_sizes2, color=np.angle(phi2), colorscale='rainbow',
+                       symbol='diamond', opacity=0.8, line=dict(width=1, color='white')),
+            name=f'{title2} Constellation',
+            showlegend=False,
+            hovertemplate=f'<b>{title2}</b><br>Re(z): %{{x:.3f}}<br>Im(z): %{{y:.3f}}<br>|φ|: %{{z:.3f}}<extra></extra>'
         ), row=1, col=2)
 
+    # Mathematical precision layout
     fig.update_layout(
-        title="Side-by-Side Cross-Species Holographic Comparison",
+        title={
+            'text': "🌟 Cross-Species Holographic Field Comparison<br><sub>Mathematical precision visualization of interspecies communication geometry</sub>",
+            'x': 0.5,
+            'xanchor': 'center'
+        },
         scene=dict(
             xaxis_title="Re(z)", yaxis_title="Im(z)", zaxis_title="|Φ|",
-            camera=dict(eye=dict(x=1.5, y=1.5, z=1.5))
+            camera=dict(eye=dict(x=1.5, y=1.5, z=1.5)),
+            bgcolor='rgba(5,5,15,1)',
+            aspectmode='cube'
         ),
         scene2=dict(
             xaxis_title="Re(z)", yaxis_title="Im(z)", zaxis_title="|Φ|",
-            camera=dict(eye=dict(x=1.5, y=1.5, z=1.5))
+            camera=dict(eye=dict(x=1.5, y=1.5, z=1.5)),
+            bgcolor='rgba(5,5,15,1)',
+            aspectmode='cube'
+        ),
+        margin=dict(l=0, r=0, b=0, t=80),
+        paper_bgcolor='rgba(10,10,25,1)',
+        plot_bgcolor='rgba(5,5,15,1)'
+    )
+    return fig
+
+def create_overlay_holography(z1, phi1, z2, phi2, resolution, wavelength, field_depth, 
+                             interference_strength, colormap, title1, title2):
+    """Create overlaid holographic fields showing interference patterns."""
+    field_data1 = generate_holographic_field(z1, phi1, resolution)
+    field_data2 = generate_holographic_field(z2, phi2, resolution)
+    
+    if field_data1 is None or field_data2 is None:
+        return go.Figure(layout={"title": "Insufficient data for overlay holography"})
+    
+    # Combine the fields for interference analysis
+    grid_x1, grid_y1, grid_phi1 = field_data1
+    grid_x2, grid_y2, grid_phi2 = field_data2
+    
+    # Create interference pattern
+    combined_field = grid_phi1 + grid_phi2 * 0.7  # Weighted combination
+    interference_magnitude = np.abs(combined_field) * interference_strength
+    interference_phase = np.angle(combined_field)
+    
+    fig = go.Figure()
+    
+    # Main interference surface
+    fig.add_trace(go.Surface(
+        x=grid_x1, y=grid_y1, z=interference_magnitude,
+        surfacecolor=interference_phase,
+        colorscale='rainbow',
+        name='Interference Pattern',
+        colorbar=dict(title='Phase Interference'),
+        contours_z=dict(show=True, usecolormap=True, project_z=True)
+    ))
+    
+    # Add both signal constellations with different symbols
+    if z1 is not None and phi1 is not None:
+        fig.add_trace(go.Scatter3d(
+            x=np.real(z1), y=np.imag(z1), z=np.abs(phi1) + 0.1,
+            mode='markers',
+            marker=dict(size=6, color='red', symbol='circle', opacity=0.8),
+            name=title1
+        ))
+    
+    if z2 is not None and phi2 is not None:
+        fig.add_trace(go.Scatter3d(
+            x=np.real(z2), y=np.imag(z2), z=np.abs(phi2) + 0.1,
+            mode='markers',
+            marker=dict(size=6, color='blue', symbol='square', opacity=0.8),
+            name=title2
+        ))
+    
+    fig.update_layout(
+        title=f"🌊 Holographic Interference: {title1} ⚡ {title2}",
+        scene=dict(
+            xaxis_title="Re(z)", yaxis_title="Im(z)", zaxis_title="Interference |Φ|",
+            bgcolor='rgba(5,5,15,1)'
         ),
         margin=dict(l=0, r=0, b=0, t=60),
-        height=600
+        paper_bgcolor='rgba(10,10,25,1)'
     )
     return fig
 
+def create_difference_holography(z1, phi1, z2, phi2, resolution, wavelength, field_depth,
+                                interference_strength, colormap, title1, title2):
+    """Show the mathematical difference between holographic fields."""
+    field_data1 = generate_holographic_field(z1, phi1, resolution)
+    field_data2 = generate_holographic_field(z2, phi2, resolution)
+    
+    if field_data1 is None or field_data2 is None:
+        return go.Figure(layout={"title": "Insufficient data for difference analysis"})
+    
+    grid_x1, grid_y1, grid_phi1 = field_data1
+    grid_x2, grid_y2, grid_phi2 = field_data2
+    
+    # Calculate difference field
+    difference_field = grid_phi1 - grid_phi2
+    diff_magnitude = np.abs(difference_field)
+    diff_phase = np.angle(difference_field)
+    
+    fig = go.Figure()
+    
+    # Difference surface
+    fig.add_trace(go.Surface(
+        x=grid_x1, y=grid_y1, z=diff_magnitude,
+        surfacecolor=diff_phase,
+        colorscale='RdBu',
+        name='Field Difference',
+        colorbar=dict(title='Difference Magnitude'),
+        contours_z=dict(show=True, usecolormap=True, project_z=True)
+    ))
+    
+    fig.update_layout(
+        title=f"🔍 Holographic Difference Analysis: {title1} - {title2}",
+        scene=dict(
+            xaxis_title="Re(z)", yaxis_title="Im(z)", zaxis_title="Difference |Φ|",
+            bgcolor='rgba(15,5,5,1)'
+        ),
+        margin=dict(l=0, r=0, b=0, t=60),
+        paper_bgcolor='rgba(25,10,10,1)'
+    )
+    return fig
+
+def create_animated_holography(z1, phi1, z2, phi2, resolution, wavelength, field_depth,
+                              interference_strength, colormap, title1, title2):
+    """Create animated transition between holographic fields."""
+    # For now, return the overlay version with animation notation
+    # Full animation would require Plotly animation frames
+    fig = create_overlay_holography(z1, phi1, z2, phi2, resolution, wavelength, 
+                                   field_depth, interference_strength, colormap, title1, title2)
+    
+    fig.update_layout(
+        title=f"🎬 Animated Holographic Transition: {title1} ↔ {title2}<br><sub>Interactive transition between communication states</sub>"
+    )
+    return fig
+
+def create_enhanced_entropy_plot(phi1, phi2, title1="Primary", title2="Comparison"):
+    """Creates enhanced information entropy geometry analysis."""
+    if phi1 is None or phi2 is None or len(phi1) < 2 or len(phi2) < 2:
+        return go.Figure(layout={"title": "Insufficient data for entropy analysis"})
+
+    # Calculate comprehensive entropy metrics
+    def calculate_entropy_metrics(phi):
+        magnitudes = np.abs(phi)
+        phases = np.angle(phi)
+        
+        # Shannon entropy
+        mag_hist, _ = np.histogram(magnitudes, bins=20, density=True)
+        phase_hist, _ = np.histogram(phases, bins=20, density=True)
+        mag_entropy = shannon_entropy(mag_hist + 1e-12)  # Avoid log(0)
+        phase_entropy = shannon_entropy(phase_hist + 1e-12)
+        
+        # Geometric entropy
+        geometric_entropy = np.std(magnitudes) * np.std(phases)
+        
+        # Complexity measures
+        magnitude_complexity = np.var(magnitudes) / (np.mean(magnitudes) + 1e-12)
+        phase_complexity = np.var(phases) / (np.pi**2 / 3)  # Normalized by max variance
+        
+        return {
+            'mag_entropy': mag_entropy,
+            'phase_entropy': phase_entropy,
+            'geometric_entropy': geometric_entropy,
+            'magnitude_complexity': magnitude_complexity,
+            'phase_complexity': phase_complexity,
+            'total_entropy': mag_entropy + phase_entropy
+        }
+    
+    metrics1 = calculate_entropy_metrics(phi1)
+    metrics2 = calculate_entropy_metrics(phi2)
+    
+    fig = make_subplots(
+        rows=2, cols=3,
+        subplot_titles=[
+            f'{title1}: Magnitude Distribution', f'{title2}: Magnitude Distribution', 'Entropy Comparison',
+            f'{title1}: Phase Distribution', f'{title2}: Phase Distribution', 'Complexity Analysis'
+        ],
+        specs=[[{'type': 'xy'}, {'type': 'xy'}, {'type': 'xy'}],
+               [{'type': 'xy'}, {'type': 'xy'}, {'type': 'xy'}]]
+    )
+    
+    # Magnitude distributions
+    fig.add_trace(go.Histogram(x=np.abs(phi1), nbinsx=30, name=f'{title1} Magnitude', 
+                              marker_color='rgba(255,100,100,0.7)'), row=1, col=1)
+    fig.add_trace(go.Histogram(x=np.abs(phi2), nbinsx=30, name=f'{title2} Magnitude',
+                              marker_color='rgba(100,100,255,0.7)'), row=1, col=2)
+    
+    # Phase distributions  
+    fig.add_trace(go.Histogram(x=np.angle(phi1), nbinsx=30, name=f'{title1} Phase',
+                              marker_color='rgba(255,150,100,0.7)'), row=2, col=1)
+    fig.add_trace(go.Histogram(x=np.angle(phi2), nbinsx=30, name=f'{title2} Phase',
+                              marker_color='rgba(100,150,255,0.7)'), row=2, col=2)
+    
+    # Entropy comparison
+    entropy_categories = ['Magnitude', 'Phase', 'Geometric', 'Total']
+    entropy_values1 = [metrics1['mag_entropy'], metrics1['phase_entropy'], 
+                      metrics1['geometric_entropy'], metrics1['total_entropy']]
+    entropy_values2 = [metrics2['mag_entropy'], metrics2['phase_entropy'],
+                      metrics2['geometric_entropy'], metrics2['total_entropy']]
+    
+    fig.add_trace(go.Bar(x=entropy_categories, y=entropy_values1, name=title1,
+                        marker_color='rgba(255,100,100,0.8)'), row=1, col=3)
+    fig.add_trace(go.Bar(x=entropy_categories, y=entropy_values2, name=title2,
+                        marker_color='rgba(100,100,255,0.8)'), row=1, col=3)
+    
+    # Complexity analysis
+    complexity_categories = ['Magnitude Complexity', 'Phase Complexity']
+    complexity_values1 = [metrics1['magnitude_complexity'], metrics1['phase_complexity']]
+    complexity_values2 = [metrics2['magnitude_complexity'], metrics2['phase_complexity']]
+    
+    fig.add_trace(go.Bar(x=complexity_categories, y=complexity_values1, name=f'{title1} Complexity',
+                        marker_color='rgba(255,200,100,0.8)', showlegend=False), row=2, col=3)
+    fig.add_trace(go.Bar(x=complexity_categories, y=complexity_values2, name=f'{title2} Complexity',
+                        marker_color='rgba(100,200,255,0.8)', showlegend=False), row=2, col=3)
+    
+    fig.update_layout(
+        title="📊 Enhanced Information Entropy Geometry Analysis",
+        height=600,
+        showlegend=True,
+        paper_bgcolor='rgba(10,10,25,1)',
+        plot_bgcolor='rgba(5,5,15,1)'
+    )
+    
+    return fig
+
+def create_enhanced_phase_analysis(phi1, phi2, z1, z2, title1="Primary", title2="Comparison"):
+    """Creates comprehensive phase space analysis."""
+    if phi1 is None or phi2 is None:
+        return go.Figure(layout={"title": "Insufficient data for phase analysis"})
+    
+    fig = make_subplots(
+        rows=2, cols=2,
+        subplot_titles=[
+            'Complex Plane Trajectories', 'Phase Evolution',
+            'Magnitude vs Phase', 'Cross-Correlation Analysis'
+        ],
+        specs=[[{'type': 'xy'}, {'type': 'xy'}],
+               [{'type': 'xy'}, {'type': 'xy'}]]
+    )
+    
+    # Complex plane trajectories
+    fig.add_trace(go.Scatter(x=np.real(phi1), y=np.imag(phi1), mode='lines+markers',
+                            name=f'{title1} Trajectory', line=dict(color='red', width=2),
+                            marker=dict(size=4)), row=1, col=1)
+    fig.add_trace(go.Scatter(x=np.real(phi2), y=np.imag(phi2), mode='lines+markers', 
+                            name=f'{title2} Trajectory', line=dict(color='blue', width=2),
+                            marker=dict(size=4)), row=1, col=1)
+    
+    # Phase evolution
+    phases1 = np.angle(phi1)
+    phases2 = np.angle(phi2)
+    t1 = np.arange(len(phases1))
+    t2 = np.arange(len(phases2))
+    
+    fig.add_trace(go.Scatter(x=t1, y=phases1, mode='lines', name=f'{title1} Phase',
+                            line=dict(color='red', width=2)), row=1, col=2)
+    fig.add_trace(go.Scatter(x=t2, y=phases2, mode='lines', name=f'{title2} Phase',
+                            line=dict(color='blue', width=2)), row=1, col=2)
+    
+    # Magnitude vs Phase scatter
+    fig.add_trace(go.Scatter(x=np.abs(phi1), y=phases1, mode='markers',
+                            name=f'{title1} Mag-Phase', marker=dict(color='red', size=6, opacity=0.7)), row=2, col=1)
+    fig.add_trace(go.Scatter(x=np.abs(phi2), y=phases2, mode='markers',
+                            name=f'{title2} Mag-Phase', marker=dict(color='blue', size=6, opacity=0.7)), row=2, col=1)
+    
+    # Cross-correlation analysis
+    if len(phi1) == len(phi2):
+        correlation = np.correlate(np.abs(phi1), np.abs(phi2), mode='full')
+        lags = np.arange(-len(phi2)+1, len(phi1))
+        fig.add_trace(go.Scatter(x=lags, y=correlation, mode='lines',
+                                name='Cross-Correlation', line=dict(color='green', width=2)), row=2, col=2)
+    
+    fig.update_layout(
+        title="🌀 Enhanced Phase Space Analysis",
+        height=600,
+        paper_bgcolor='rgba(10,10,25,1)',
+        plot_bgcolor='rgba(5,5,15,1)'
+    )
+    
+    return fig
+
 def create_dual_diagnostic_plots(z1, w1, z2, w2, title1="Primary", title2="Comparison"):
     """Creates side-by-side diagnostic plots for cross-species comparison."""
     fig = make_subplots(
@@ -1390,58 +1824,260 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="cyan")) a
                 outputs=manifold_outputs
             )
         
-        with gr.TabItem("Interactive Holography"):
+        with gr.TabItem("🔬 Interactive Holography Laboratory"):
+            gr.Markdown("""
+            # 🌟 **CMT Holographic Information Geometry Engine** 
+            *Transform audio signals into mathematical holographic fields revealing hidden geometric structures*
+            
+            Based on the **Holographic Information Geometry** framework - each vocalization becomes a complex holographic field showing:
+            - **Geometric Embedding**: 1D signals mapped to complex plane constellations
+            - **Mathematical Illumination**: Lens functions (Γ, ζ, Ai, J₀) probe latent structures  
+            - **Holographic Superposition**: Phase/magnitude interference creates information geometry
+            - **Field Reconstruction**: Continuous holographic visualization of discrete transformations
+            """)
+            
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("### Cross-Species Holography Controls")
-                    
-                    # Species selection and automatic pairing
-                    species_dropdown = gr.Dropdown(
-                        label="Select Species", 
-                        choices=["Dog", "Human"], 
-                        value="Dog"
-                    )
+                    # Advanced Species Selection with Smart Pairing
+                    with gr.Accordion("🎯 **Cross-Species Communication Mapping**", open=True):
+                        gr.Markdown("*Automatically finds geometric neighbors across species for grammar analysis*")
+                        
+                        species_dropdown = gr.Dropdown(
+                            label="🧬 Primary Species", 
+                            choices=["Dog", "Human"], 
+                            value="Dog",
+                            info="Select primary species for holographic analysis"
+                        )
+                        
+                        # Primary file selection with enhanced info
+                        dog_files = df_combined[df_combined["source"] == "Dog"]["filepath"].astype(str).tolist()
+                        human_files = df_combined[df_combined["source"] == "Human"]["filepath"].astype(str).tolist()
+                        
+                        primary_dropdown = gr.Dropdown(
+                            label="🎵 Primary Vocalization", 
+                            choices=dog_files, 
+                            value=dog_files[0] if dog_files else None,
+                            info="Select the primary audio for holographic transformation"
+                        )
+                        
+                        neighbor_dropdown = gr.Dropdown(
+                            label="🔗 Cross-Species Geometric Neighbor", 
+                            choices=human_files, 
+                            value=human_files[0] if human_files else None,
+                            interactive=True,
+                            info="Auto-detected or manually select geometric neighbor"
+                        )
+                        
+                        # Similarity metrics display
+                        similarity_info = gr.HTML(
+                            label="🧮 Geometric Similarity Analysis",
+                            value="<i>Select vocalizations to see geometric similarity metrics</i>"
+                        )
                     
-                    # Primary file selection (filtered by species)
-                    dog_files = df_combined[df_combined["source"] == "Dog"]["filepath"].astype(str).tolist()
-                    human_files = df_combined[df_combined["source"] == "Human"]["filepath"].astype(str).tolist()
+                    # Mathematical Lens Configuration
+                    with gr.Accordion("🔬 **Mathematical Lens Configuration**", open=True):
+                        gr.Markdown("*Configure the mathematical illumination functions*")
+                        
+                        holo_lens_dropdown = gr.Dropdown(
+                            label="📐 Mathematical Lens Function", 
+                            choices=["gamma", "zeta", "airy", "bessel"], 
+                            value="gamma",
+                            info="Γ(z): Recursion | ζ(z): Primes | Ai(z): Oscillation | J₀(z): Waves"
+                        )
+                        
+                        # Advanced holographic parameters
+                        with gr.Row():
+                            holo_resolution_slider = gr.Slider(
+                                label="🎛️ Field Resolution", 
+                                minimum=20, maximum=150, step=5, value=60,
+                                info="Higher = more detail, slower processing"
+                            )
+                            
+                            field_depth_slider = gr.Slider(
+                                label="📏 Field Depth", 
+                                minimum=1, maximum=10, step=1, value=5,
+                                info="Z-axis interpolation layers"
+                            )
+                        
+                        with gr.Row():
+                            holo_wavelength_slider = gr.Slider(
+                                label="🌈 Illumination Wavelength (nm)", 
+                                minimum=380, maximum=750, step=5, value=550,
+                                info="380nm=Violet, 550nm=Green, 750nm=Red"
+                            )
+                            
+                            interference_strength = gr.Slider(
+                                label="⚡ Interference Strength", 
+                                minimum=0.1, maximum=2.0, step=0.1, value=1.0,
+                                info="Holographic interference amplitude"
+                            )
+                        
+                        # Advanced encoding parameters
+                        with gr.Accordion("⚙️ **Advanced Encoding Parameters**", open=False):
+                            encoding_mode = gr.Dropdown(
+                                label="🔄 Encoding Mode",
+                                choices=["Standard", "Multi-View", "Frequency-Locked", "Phase-Coherent"],
+                                value="Multi-View",
+                                info="Different geometric embedding strategies"
+                            )
+                            
+                            with gr.Row():
+                                phase_modulation = gr.Slider(
+                                    label="🌀 Phase Modulation",
+                                    minimum=0.0, maximum=2.0, step=0.1, value=1.0,
+                                    info="Controls structured phase encoding intensity"
+                                )
+                                
+                                magnitude_scaling = gr.Slider(
+                                    label="📊 Magnitude Scaling", 
+                                    minimum=0.1, maximum=3.0, step=0.1, value=1.0,
+                                    info="Amplifies signal magnitude in complex plane"
+                                )
                     
-                    primary_dropdown = gr.Dropdown(
-                        label="Primary Audio File", 
-                        choices=dog_files, 
-                        value=dog_files[0] if dog_files else None
-                    )
+                    # Real-time Analysis Controls  
+                    with gr.Accordion("⚡ **Real-Time Analysis Engine**", open=False):
+                        gr.Markdown("*Live mathematical analysis and pattern detection*")
+                        
+                        with gr.Row():
+                            auto_detect_patterns = gr.Checkbox(
+                                label="🔍 Auto-Detect Patterns",
+                                value=True,
+                                info="Automatically identify geometric structures"
+                            )
+                            
+                            live_updates = gr.Checkbox(
+                                label="📡 Live Updates",
+                                value=False,
+                                info="Real-time holographic field updates"
+                            )
+                        
+                        analysis_depth = gr.Slider(
+                            label="🧬 Analysis Depth",
+                            minimum=1, maximum=5, step=1, value=3,
+                            info="1=Basic | 3=Standard | 5=Deep Mathematical Analysis"
+                        )
+                        
+                        # Pattern detection sensitivity
+                        pattern_sensitivity = gr.Slider(
+                            label="🎯 Pattern Sensitivity",
+                            minimum=0.1, maximum=1.0, step=0.05, value=0.5,
+                            info="Threshold for detecting geometric patterns"
+                        )
                     
-                    # Automatically found neighbor (from opposite species)
-                    neighbor_dropdown = gr.Dropdown(
-                        label="Auto-Found Cross-Species Neighbor", 
-                        choices=human_files, 
-                        value=human_files[0] if human_files else None,
-                        interactive=True  # Allow manual override
-                    )
+                    # Information Analysis Panels
+                    with gr.Accordion("📊 **Vocalization Analysis**", open=True):
+                        primary_info_html = gr.HTML(
+                            label="🎵 Primary Vocalization Analysis",
+                            value="<i>Select a primary vocalization to see detailed CMT analysis</i>"
+                        )
+                        
+                        neighbor_info_html = gr.HTML(
+                            label="🔗 Neighbor Vocalization Analysis", 
+                            value="<i>Cross-species neighbor will be automatically detected</i>"
+                        )
                     
-                    holo_lens_dropdown = gr.Dropdown(label="CMT Lens", choices=["gamma", "zeta", "airy", "bessel"], value="gamma")
-                    holo_resolution_slider = gr.Slider(label="Field Resolution", minimum=20, maximum=100, step=5, value=40)
-                    holo_wavelength_slider = gr.Slider(label="Illumination Wavelength (nm)", minimum=380, maximum=750, step=5, value=550)
+                    # Audio Players with Enhanced Controls
+                    with gr.Accordion("🔊 **Audio Playback & Analysis**", open=False):
+                        with gr.Row():
+                            primary_audio_out = gr.Audio(
+                                label="🎵 Primary Audio",
+                                show_download_button=True
+                            )
+                            
+                            neighbor_audio_out = gr.Audio(
+                                label="🔗 Neighbor Audio", 
+                                show_download_button=True
+                            )
+                        
+                        # Audio analysis metrics
+                        audio_metrics_html = gr.HTML(
+                            label="📈 Audio Signal Metrics",
+                            value="<i>Play audio files to see signal analysis</i>"
+                        )
+                
+                # Main Visualization Panel
+                with gr.Column(scale=3):
+                    # Enhanced Holographic Visualization
+                    with gr.Accordion("🌌 **Holographic Field Visualization**", open=True):
+                        dual_holography_plot = gr.Plot(
+                            label="🔬 Side-by-Side Holographic Field Reconstruction"
+                        )
+                        
+                        # Advanced visualization controls
+                        with gr.Row():
+                            view_mode = gr.Dropdown(
+                                label="👁️ Visualization Mode",
+                                choices=["Side-by-Side", "Overlay", "Difference", "Animation"],
+                                value="Side-by-Side",
+                                info="Different ways to compare holographic fields"
+                            )
+                            
+                            colormap_selection = gr.Dropdown(
+                                label="🎨 Color Mapping",
+                                choices=["Wavelength", "Phase", "Magnitude", "Interference", "Custom"],
+                                value="Wavelength",
+                                info="Color encoding for holographic visualization"
+                            )
                     
-                    # Information panels
-                    primary_info_html = gr.HTML(label="Primary Audio Info")
-                    neighbor_info_html = gr.HTML(label="Neighbor Audio Info")
+                    # Diagnostic and Analysis Plots
+                    with gr.Accordion("🔍 **Mathematical Diagnostics**", open=True):
+                        dual_diagnostic_plot = gr.Plot(
+                            label="📊 Cross-Species Mathematical Diagnostics"
+                        )
+                        
+                        # Additional analysis plots
+                        with gr.Row():
+                            entropy_plot = gr.Plot(
+                                label="📈 Information Entropy Geometry"
+                            )
+                            
+                            phase_plot = gr.Plot(
+                                label="🌀 Phase Space Analysis"
+                            )
                     
-                    # Audio players
-                    primary_audio_out = gr.Audio(label="Primary Audio")
-                    neighbor_audio_out = gr.Audio(label="Neighbor Audio")
+                    # Mathematical Insights Panel
+                    with gr.Accordion("🧮 **Mathematical Insights & Metrics**", open=True):
+                        with gr.Row():
+                            with gr.Column():
+                                mathematical_metrics = gr.HTML(
+                                    label="📐 Geometric Properties",
+                                    value="<i>Mathematical analysis will appear here</i>"
+                                )
+                            
+                            with gr.Column():
+                                pattern_analysis = gr.HTML(
+                                    label="🔍 Pattern Recognition",
+                                    value="<i>Detected patterns and structures</i>"
+                                )
+                            
+                            with gr.Column():
+                                cross_species_insights = gr.HTML(
+                                    label="🌉 Cross-Species Insights",
+                                    value="<i>Grammar mapping and communication bridges</i>"
+                                )
                     
-                with gr.Column(scale=2):
-                    dual_holography_plot = gr.Plot(label="Side-by-Side Holographic Comparison")
-                    dual_diagnostic_plot = gr.Plot(label="Cross-Species Diagnostic Comparison")
+                    # Export and Analysis Tools
+                    with gr.Accordion("💾 **Export & Advanced Analysis**", open=False):
+                        with gr.Row():
+                            export_hologram = gr.Button("💾 Export Holographic Data", variant="secondary")
+                            export_analysis = gr.Button("📊 Export Mathematical Analysis", variant="secondary")
+                            generate_report = gr.Button("📝 Generate Full Report", variant="primary")
+                        
+                        export_status = gr.HTML(
+                            label="📋 Export Status",
+                            value="<i>Ready to export holographic analysis data</i>"
+                        )
 
             def update_file_choices(species):
                 """Update the primary file dropdown based on selected species."""
                 species_files = df_combined[df_combined["source"] == species]["filepath"].astype(str).tolist()
                 return species_files
 
-            def update_cross_species_view(species, primary_file, neighbor_file, lens, resolution, wavelength):
+            def update_enhanced_cross_species_view(species, primary_file, neighbor_file, lens, resolution, 
+                                                   field_depth, wavelength, interference_strength, encoding_mode,
+                                                   phase_modulation, magnitude_scaling, auto_detect_patterns,
+                                                   live_updates, analysis_depth, pattern_sensitivity,
+                                                   view_mode, colormap_selection):
                 if not primary_file:
                     empty_fig = go.Figure(layout={"title": "Please select a primary file."})
                     return empty_fig, empty_fig, "", "", None, None
@@ -1488,25 +2124,44 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="cyan")) a
                 primary_fp = resolve_audio_path(primary_row)
                 neighbor_fp = resolve_audio_path(neighbor_row) if neighbor_row is not None else None
 
-                # Create visualizations
+                # Create enhanced visualizations with new parameters
                 if primary_cmt and neighbor_cmt:
                     primary_title = f"{species}: {primary_row.get('label', 'Unknown')}"
                     neighbor_title = f"{neighbor_row['source']}: {neighbor_row.get('label', 'Unknown')}"
                     
+                    # Enhanced holographic visualization with multiple view modes
                     dual_holo_fig = create_dual_holography_plot(
                         primary_cmt["z"], primary_cmt["phi"],
                         neighbor_cmt["z"], neighbor_cmt["phi"],
-                        resolution, wavelength, primary_title, neighbor_title
+                        resolution, wavelength, field_depth, 
+                        interference_strength, view_mode, colormap_selection,
+                        primary_title, neighbor_title
                     )
                     
+                    # Enhanced diagnostic plots
                     dual_diag_fig = create_dual_diagnostic_plots(
                         primary_cmt["z"], primary_cmt["w"],
                         neighbor_cmt["z"], neighbor_cmt["w"],
                         primary_title, neighbor_title
                     )
+                    
+                    # New enhanced analysis plots
+                    entropy_fig = create_enhanced_entropy_plot(
+                        primary_cmt["phi"], neighbor_cmt["phi"],
+                        primary_title, neighbor_title
+                    )
+                    
+                    phase_fig = create_enhanced_phase_analysis(
+                        primary_cmt["phi"], neighbor_cmt["phi"],
+                        primary_cmt["z"], neighbor_cmt["z"],
+                        primary_title, neighbor_title
+                    )
+                    
                 else:
                     dual_holo_fig = go.Figure(layout={"title": "Error processing audio files"})
                     dual_diag_fig = go.Figure(layout={"title": "Error processing audio files"})
+                    entropy_fig = go.Figure(layout={"title": "Error processing audio files"})
+                    phase_fig = go.Figure(layout={"title": "Error processing audio files"})
 
                 # Build info strings with CMT diagnostic values
                 primary_info = f"""
@@ -1537,7 +2192,99 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="cyan")) a
                 primary_audio = primary_fp if primary_fp and os.path.exists(primary_fp) else None
                 neighbor_audio = neighbor_fp if neighbor_row is not None and neighbor_fp and os.path.exists(neighbor_fp) else None
 
-                return (dual_holo_fig, dual_diag_fig, primary_info, neighbor_info, 
+                # Calculate mathematical insights and similarity metrics
+                if primary_cmt and neighbor_cmt:
+                    # Geometric similarity calculation
+                    primary_centroid = np.mean(primary_cmt["phi"])
+                    neighbor_centroid = np.mean(neighbor_cmt["phi"])
+                    geometric_distance = np.abs(primary_centroid - neighbor_centroid)
+                    
+                    # Pattern coherence analysis
+                    primary_coherence = np.std(np.abs(primary_cmt["phi"])) / (np.mean(np.abs(primary_cmt["phi"])) + 1e-12)
+                    neighbor_coherence = np.std(np.abs(neighbor_cmt["phi"])) / (np.mean(np.abs(neighbor_cmt["phi"])) + 1e-12)
+                    coherence_similarity = 1.0 / (1.0 + abs(primary_coherence - neighbor_coherence))
+                    
+                    # Cross-species communication bridge analysis
+                    phase_correlation = np.corrcoef(np.angle(primary_cmt["phi"]), np.angle(neighbor_cmt["phi"]))[0,1]
+                    if np.isnan(phase_correlation):
+                        phase_correlation = 0.0
+                    
+                    bridge_strength = (coherence_similarity + abs(phase_correlation)) / 2.0
+                    
+                    # Enhanced similarity info
+                    similarity_details = f"""
+                    <h4>🧮 <b>Geometric Similarity Metrics</b></h4>
+                    <div style="background: rgba(20,20,40,0.8); padding: 10px; border-radius: 8px; margin: 5px 0;">
+                        <p><b>🎯 Geometric Distance:</b> {geometric_distance:.4f}</p>
+                        <p><b>📊 Coherence Similarity:</b> {coherence_similarity:.4f}</p>
+                        <p><b>🌊 Phase Correlation:</b> {phase_correlation:.4f}</p>
+                        <p><b>🌉 Communication Bridge:</b> {bridge_strength:.4f}</p>
+                        <p><b>📈 Pattern Match:</b> {(1.0 - geometric_distance) * 100:.1f}%</p>
+                    </div>
+                    """
+                    
+                    # Mathematical insights
+                    math_insights = f"""
+                    <h4>📐 <b>Mathematical Properties</b></h4>
+                    <div style="background: rgba(40,20,20,0.8); padding: 10px; border-radius: 8px; margin: 5px 0;">
+                        <p><b>🎵 {primary_title}:</b></p>
+                        <p>• Field Complexity: {primary_cmt['alpha']:.4f}</p>
+                        <p>• SRL Resonance: {primary_cmt['srl']:.4f}</p>
+                        <p>• Coherence Index: {primary_coherence:.4f}</p>
+                        <br>
+                        <p><b>🔗 {neighbor_title}:</b></p>
+                        <p>• Field Complexity: {neighbor_cmt['alpha']:.4f}</p>
+                        <p>• SRL Resonance: {neighbor_cmt['srl']:.4f}</p>
+                        <p>• Coherence Index: {neighbor_coherence:.4f}</p>
+                    </div>
+                    """
+                    
+                    # Cross-species insights based on mathematical analysis
+                    if bridge_strength > 0.7:
+                        bridge_quality = "🟢 <b>Strong Communication Bridge</b>"
+                        bridge_description = "High geometric similarity suggests potential shared communication patterns."
+                    elif bridge_strength > 0.4:
+                        bridge_quality = "🟡 <b>Moderate Communication Bridge</b>"
+                        bridge_description = "Some shared mathematical structures detected."
+                    else:
+                        bridge_quality = "🔴 <b>Weak Communication Bridge</b>"
+                        bridge_description = "Limited mathematical correspondence between vocalizations."
+                    
+                    cross_species_analysis = f"""
+                    <h4>🌉 <b>Cross-Species Grammar Mapping</b></h4>
+                    <div style="background: rgba(20,40,20,0.8); padding: 10px; border-radius: 8px; margin: 5px 0;">
+                        <p>{bridge_quality}</p>
+                        <p>{bridge_description}</p>
+                        <br>
+                        <p><b>🔍 Pattern Analysis:</b></p>
+                        <p>• Encoding Mode: {encoding_mode}</p>
+                        <p>• Analysis Depth: Level {analysis_depth}</p>
+                        <p>• Detection Sensitivity: {pattern_sensitivity:.2f}</p>
+                        {"<p>• 🔴 <b>Patterns Detected!</b></p>" if auto_detect_patterns and bridge_strength > pattern_sensitivity else ""}
+                    </div>
+                    """
+                    
+                    # Audio metrics
+                    audio_analysis = f"""
+                    <h4>📈 <b>Signal Analysis</b></h4>
+                    <div style="background: rgba(40,40,20,0.8); padding: 10px; border-radius: 8px; margin: 5px 0;">
+                        <p><b>🎵 Primary Signal:</b> {len(primary_cmt['phi'])} samples</p>
+                        <p><b>🔗 Neighbor Signal:</b> {len(neighbor_cmt['phi'])} samples</p>
+                        <p><b>📐 Lens Function:</b> {lens.upper()} (Mathematical Illumination)</p>
+                        <p><b>🌈 Wavelength:</b> {wavelength}nm</p>
+                        <p><b>⚡ Interference:</b> {interference_strength:.1f}x</p>
+                        <p><b>📏 Field Depth:</b> {field_depth} layers</p>
+                    </div>
+                    """
+                else:
+                    similarity_details = "<i>Select vocalizations to see similarity analysis</i>"
+                    math_insights = "<i>Mathematical analysis will appear here</i>"
+                    cross_species_analysis = "<i>Cross-species insights will appear here</i>"
+                    audio_analysis = "<i>Audio signal analysis will appear here</i>"
+
+                return (dual_holo_fig, dual_diag_fig, entropy_fig, phase_fig,
+                        primary_info, neighbor_info, similarity_details,
+                        math_insights, cross_species_analysis, audio_analysis,
                         primary_audio, neighbor_audio)
 
             # Event handlers
@@ -1561,28 +2308,30 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="cyan")) a
                 outputs=[primary_dropdown, neighbor_dropdown]
             )
 
-            cross_species_inputs = [species_dropdown, primary_dropdown, neighbor_dropdown, 
-                                  holo_lens_dropdown, holo_resolution_slider, holo_wavelength_slider]
-            cross_species_outputs = [dual_holography_plot, dual_diagnostic_plot, 
-                                   primary_info_html, neighbor_info_html,
-                                   primary_audio_out, neighbor_audio_out]
-
-            # Only bind change events, not load events to avoid overwhelming initialization
-            primary_dropdown.change(update_cross_species_view, 
-                                   inputs=cross_species_inputs, 
-                                   outputs=cross_species_outputs)
-            neighbor_dropdown.change(update_cross_species_view, 
-                                   inputs=cross_species_inputs, 
-                                   outputs=cross_species_outputs)
-            holo_lens_dropdown.change(update_cross_species_view, 
-                                    inputs=cross_species_inputs, 
-                                    outputs=cross_species_outputs)
-            holo_resolution_slider.change(update_cross_species_view, 
-                                        inputs=cross_species_inputs, 
-                                        outputs=cross_species_outputs)
-            holo_wavelength_slider.change(update_cross_species_view, 
-                                        inputs=cross_species_inputs, 
-                                        outputs=cross_species_outputs)
+            # Enhanced input/output configuration with all new parameters
+            enhanced_inputs = [
+                species_dropdown, primary_dropdown, neighbor_dropdown, 
+                holo_lens_dropdown, holo_resolution_slider, field_depth_slider,
+                holo_wavelength_slider, interference_strength, encoding_mode,
+                phase_modulation, magnitude_scaling, auto_detect_patterns,
+                live_updates, analysis_depth, pattern_sensitivity,
+                view_mode, colormap_selection
+            ]
+            
+            enhanced_outputs = [
+                dual_holography_plot, dual_diagnostic_plot, entropy_plot, phase_plot,
+                primary_info_html, neighbor_info_html, similarity_info,
+                mathematical_metrics, pattern_analysis, cross_species_insights,
+                audio_metrics_html, primary_audio_out, neighbor_audio_out
+            ]
+
+            # Bind all enhanced controls to the new update function
+            for component in enhanced_inputs[2:]:  # Skip species and primary (handled separately)
+                component.change(
+                    update_enhanced_cross_species_view, 
+                    inputs=enhanced_inputs, 
+                    outputs=enhanced_outputs
+                )
 
 if __name__ == "__main__":
     demo.launch(share=True, debug=True)