Update app.py

app.py

@@ -292,6 +292,473 @@ df_combined["chaos_score"] = np.log1p(df_combined.get("diag_srl_gamma", 0)) / (d
 _audio_path_cache = {}
 _cmt_data_cache = {}
 
+# Advanced manifold analysis functions
+def calculate_species_boundary(df_combined):
+    """Calculate the geometric boundary between species using support vector machines."""
+    from sklearn.svm import SVC
+    
+    # Prepare data for boundary calculation
+    human_data = df_combined[df_combined['source'] == 'Human'][['x', 'y', 'z']].values
+    dog_data = df_combined[df_combined['source'] == 'Dog'][['x', 'y', 'z']].values
+    
+    # Create binary classification data
+    X = np.vstack([human_data, dog_data])
+    y = np.hstack([np.ones(len(human_data)), np.zeros(len(dog_data))])
+    
+    # Fit SVM for boundary
+    svm = SVC(kernel='rbf', probability=True)
+    svm.fit(X, y)
+    
+    # Create boundary surface
+    x_range = np.linspace(X[:, 0].min(), X[:, 0].max(), 20)
+    y_range = np.linspace(X[:, 1].min(), X[:, 1].max(), 20)
+    z_range = np.linspace(X[:, 2].min(), X[:, 2].max(), 20)
+    
+    xx, yy = np.meshgrid(x_range, y_range)
+    boundary_points = []
+    
+    for z_val in z_range:
+        grid_points = np.c_[xx.ravel(), yy.ravel(), np.full(xx.ravel().shape, z_val)]
+        probabilities = svm.predict_proba(grid_points)[:, 1]
+        
+        # Find points near decision boundary (probability ~ 0.5)
+        boundary_mask = np.abs(probabilities - 0.5) < 0.05
+        if np.any(boundary_mask):
+            boundary_points.extend(grid_points[boundary_mask])
+    
+    return np.array(boundary_points) if boundary_points else None
+
+def create_enhanced_manifold_plot(df_filtered, lens_selected, color_scheme, point_size, 
+                                show_boundary, show_trajectories):
+    """Create the main 3D manifold visualization with all advanced features."""
+    
+    # Get CMT diagnostic values for the selected lens
+    alpha_col = f"diag_alpha_{lens_selected}"
+    srl_col = f"diag_srl_{lens_selected}"
+    
+    # Determine color values based on scheme
+    if color_scheme == "Species":
+        color_values = [1 if s == "Human" else 0 for s in df_filtered['source']]
+        colorscale = [[0, '#1f77b4'], [1, '#ff7f0e']]  # Blue for Dog, Orange for Human
+        colorbar_title = "Species (Blue=Dog, Orange=Human)"
+    elif color_scheme == "Emotion":
+        unique_emotions = df_filtered['label'].unique()
+        emotion_map = {emotion: i for i, emotion in enumerate(unique_emotions)}
+        color_values = [emotion_map[label] for label in df_filtered['label']]
+        colorscale = 'Viridis'
+        colorbar_title = "Emotional State"
+    elif color_scheme == "CMT_Alpha":
+        color_values = df_filtered[alpha_col].values
+        colorscale = 'Plasma'
+        colorbar_title = f"CMT Alpha ({lens_selected})"
+    elif color_scheme == "CMT_SRL":
+        color_values = df_filtered[srl_col].values
+        colorscale = 'Turbo'
+        colorbar_title = f"SRL Complexity ({lens_selected})"
+    else:  # Cluster
+        color_values = df_filtered['cluster'].values
+        colorscale = 'Set3'
+        colorbar_title = "Cluster ID"
+    
+    # Create hover text with rich information
+    hover_text = []
+    for _, row in df_filtered.iterrows():
+        hover_info = f"""
+        <b>{row['source']}</b>: {row['label']}<br>
+        File: {row['filepath']}<br>
+        <b>CMT Diagnostics ({lens_selected}):</b><br>
+        α: {row[alpha_col]:.4f}<br>
+        SRL: {row[srl_col]:.4f}<br>
+        Coordinates: ({row['x']:.3f}, {row['y']:.3f}, {row['z']:.3f})
+        """
+        hover_text.append(hover_info)
+    
+    # Create main scatter plot
+    fig = go.Figure()
+    
+    # Add main data points
+    fig.add_trace(go.Scatter3d(
+        x=df_filtered['x'],
+        y=df_filtered['y'], 
+        z=df_filtered['z'],
+        mode='markers',
+        marker=dict(
+            size=point_size,
+            color=color_values,
+            colorscale=colorscale,
+            showscale=True,
+            colorbar=dict(title=colorbar_title),
+            opacity=0.8,
+            line=dict(width=0.5, color='rgba(50,50,50,0.5)')
+        ),
+        text=hover_text,
+        hovertemplate='%{text}<extra></extra>',
+        name='Communications'
+    ))
+    
+    # Add species boundary if requested
+    if show_boundary:
+        boundary_points = calculate_species_boundary(df_filtered)
+        if boundary_points is not None and len(boundary_points) > 0:
+            fig.add_trace(go.Scatter3d(
+                x=boundary_points[:, 0],
+                y=boundary_points[:, 1],
+                z=boundary_points[:, 2],
+                mode='markers',
+                marker=dict(
+                    size=2,
+                    color='red',
+                    opacity=0.3
+                ),
+                name='Species Boundary',
+                hovertemplate='Species Boundary<extra></extra>'
+            ))
+    
+    # Add trajectories if requested
+    if show_trajectories:
+        # Create trajectories between similar emotional states
+        for emotion in df_filtered['label'].unique():
+            emotion_data = df_filtered[df_filtered['label'] == emotion]
+            if len(emotion_data) > 1:
+                # Connect points within each emotional state
+                x_coords = emotion_data['x'].values
+                y_coords = emotion_data['y'].values  
+                z_coords = emotion_data['z'].values
+                
+                fig.add_trace(go.Scatter3d(
+                    x=x_coords,
+                    y=y_coords,
+                    z=z_coords,
+                    mode='lines',
+                    line=dict(width=2, color='rgba(100,100,100,0.3)'),
+                    name=f'{emotion} trajectory',
+                    showlegend=False,
+                    hovertemplate='%{fullData.name}<extra></extra>'
+                ))
+    
+    # Update layout
+    fig.update_layout(
+        title={
+            'text': "🌌 Universal Interspecies Communication Manifold<br><sub>First mathematical map of cross-species communication geometry</sub>",
+            'x': 0.5,
+            'xanchor': 'center'
+        },
+        scene=dict(
+            xaxis_title='Manifold Dimension 1',
+            yaxis_title='Manifold Dimension 2', 
+            zaxis_title='Manifold Dimension 3',
+            camera=dict(
+                eye=dict(x=1.5, y=1.5, z=1.5)
+            ),
+            bgcolor='rgba(0,0,0,0)',
+            aspectmode='cube'
+        ),
+        margin=dict(l=0, r=0, b=0, t=60),
+        legend=dict(
+            yanchor="top",
+            y=0.99,
+            xanchor="left",
+            x=0.01
+        )
+    )
+    
+    return fig
+
+def create_2d_projection_plot(df_filtered, color_scheme):
+    """Create 2D projection for easier analysis."""
+    fig = go.Figure()
+    
+    # Create color mapping
+    if color_scheme == "Species":
+        color_values = df_filtered['source']
+        color_map = {'Human': '#ff7f0e', 'Dog': '#1f77b4'}
+    else:
+        color_values = df_filtered['label']
+        unique_labels = df_filtered['label'].unique()
+        colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b']
+        color_map = {label: colors[i % len(colors)] for i, label in enumerate(unique_labels)}
+    
+    for value in color_values.unique():
+        data_subset = df_filtered[color_values == value]
+        fig.add_trace(go.Scatter(
+            x=data_subset['x'],
+            y=data_subset['y'],
+            mode='markers',
+            marker=dict(
+                size=8,
+                color=color_map.get(value, '#1f77b4'),
+                opacity=0.7
+            ),
+            name=str(value),
+            text=[f"{row['source']}: {row['label']}" for _, row in data_subset.iterrows()],
+            hovertemplate='%{text}<br>X: %{x:.3f}<br>Y: %{y:.3f}<extra></extra>'
+        ))
+    
+    fig.update_layout(
+        title="2D Manifold Projection (X-Y Plane)",
+        xaxis_title="Manifold Dimension 1",
+        yaxis_title="Manifold Dimension 2",
+        height=400
+    )
+    
+    return fig
+
+def create_density_heatmap(df_filtered):
+    """Create density heatmap showing communication hotspots."""
+    from scipy.stats import gaussian_kde
+    
+    # Create 2D density estimation
+    x = df_filtered['x'].values
+    y = df_filtered['y'].values
+    
+    # Create grid for density calculation
+    x_grid = np.linspace(x.min(), x.max(), 50)
+    y_grid = np.linspace(y.min(), y.max(), 50)
+    X_grid, Y_grid = np.meshgrid(x_grid, y_grid)
+    positions = np.vstack([X_grid.ravel(), Y_grid.ravel()])
+    
+    # Calculate density
+    values = np.vstack([x, y])
+    kernel = gaussian_kde(values)
+    density = np.reshape(kernel(positions).T, X_grid.shape)
+    
+    fig = go.Figure(data=go.Heatmap(
+        z=density,
+        x=x_grid,
+        y=y_grid,
+        colorscale='Viridis',
+        colorbar=dict(title="Communication Density")
+    ))
+    
+    # Overlay actual points
+    fig.add_trace(go.Scatter(
+        x=x, y=y,
+        mode='markers',
+        marker=dict(size=4, color='white', opacity=0.6),
+        name='Actual Communications',
+        hovertemplate='X: %{x:.3f}<br>Y: %{y:.3f}<extra></extra>'
+    ))
+    
+    fig.update_layout(
+        title="Communication Density Heatmap",
+        xaxis_title="Manifold Dimension 1",
+        yaxis_title="Manifold Dimension 2", 
+        height=400
+    )
+    
+    return fig
+
+def create_feature_distributions(df_filtered, lens_selected):
+    """Create feature distribution plots comparing species."""
+    alpha_col = f"diag_alpha_{lens_selected}"
+    srl_col = f"diag_srl_{lens_selected}"
+    
+    fig = make_subplots(
+        rows=2, cols=2,
+        subplot_titles=[
+            f'CMT Alpha Distribution ({lens_selected})',
+            f'SRL Distribution ({lens_selected})',
+            'Manifold X Coordinate',
+            'Manifold Y Coordinate'
+        ]
+    )
+    
+    # Alpha distribution
+    for species in ['Human', 'Dog']:
+        data = df_filtered[df_filtered['source'] == species][alpha_col]
+        fig.add_trace(
+            go.Histogram(x=data, name=f'{species} Alpha', opacity=0.7, nbinsx=20),
+            row=1, col=1
+        )
+    
+    # SRL distribution
+    for species in ['Human', 'Dog']:
+        data = df_filtered[df_filtered['source'] == species][srl_col]
+        fig.add_trace(
+            go.Histogram(x=data, name=f'{species} SRL', opacity=0.7, nbinsx=20),
+            row=1, col=2
+        )
+    
+    # X coordinate distribution
+    for species in ['Human', 'Dog']:
+        data = df_filtered[df_filtered['source'] == species]['x']
+        fig.add_trace(
+            go.Histogram(x=data, name=f'{species} X', opacity=0.7, nbinsx=20),
+            row=2, col=1
+        )
+    
+    # Y coordinate distribution
+    for species in ['Human', 'Dog']:
+        data = df_filtered[df_filtered['source'] == species]['y']
+        fig.add_trace(
+            go.Histogram(x=data, name=f'{species} Y', opacity=0.7, nbinsx=20),
+            row=2, col=2
+        )
+    
+    fig.update_layout(
+        height=300,
+        title_text="Feature Distributions by Species",
+        showlegend=True
+    )
+    
+    return fig
+
+def create_correlation_matrix(df_filtered, lens_selected):
+    """Create correlation matrix of CMT features."""
+    # Select relevant columns for correlation
+    feature_cols = ['x', 'y', 'z'] + [col for col in df_filtered.columns if col.startswith('feature_')]
+    cmt_cols = [f"diag_alpha_{lens_selected}", f"diag_srl_{lens_selected}"]
+    
+    all_cols = feature_cols + cmt_cols
+    available_cols = [col for col in all_cols if col in df_filtered.columns]
+    
+    if len(available_cols) < 2:
+        # Fallback with basic columns
+        available_cols = ['x', 'y', 'z']
+    
+    # Calculate correlation matrix
+    corr_matrix = df_filtered[available_cols].corr()
+    
+    fig = go.Figure(data=go.Heatmap(
+        z=corr_matrix.values,
+        x=corr_matrix.columns,
+        y=corr_matrix.columns,
+        colorscale='RdBu',
+        zmid=0,
+        colorbar=dict(title="Correlation"),
+        text=np.round(corr_matrix.values, 2),
+        texttemplate="%{text}",
+        textfont={"size": 10}
+    ))
+    
+    fig.update_layout(
+        title="Cross-Species Feature Correlations",
+        height=300,
+        xaxis_title="Features",
+        yaxis_title="Features"
+    )
+    
+    return fig
+
+def calculate_statistics(df_filtered, lens_selected):
+    """Calculate comprehensive statistics for the filtered data."""
+    alpha_col = f"diag_alpha_{lens_selected}"
+    srl_col = f"diag_srl_{lens_selected}"
+    
+    stats = {}
+    
+    # Overall statistics
+    stats['total_points'] = len(df_filtered)
+    stats['human_count'] = len(df_filtered[df_filtered['source'] == 'Human'])
+    stats['dog_count'] = len(df_filtered[df_filtered['source'] == 'Dog'])
+    
+    # CMT statistics by species
+    for species in ['Human', 'Dog']:
+        species_data = df_filtered[df_filtered['source'] == species]
+        if len(species_data) > 0:
+            stats[f'{species.lower()}_alpha_mean'] = species_data[alpha_col].mean()
+            stats[f'{species.lower()}_alpha_std'] = species_data[alpha_col].std()
+            stats[f'{species.lower()}_srl_mean'] = species_data[srl_col].mean()
+            stats[f'{species.lower()}_srl_std'] = species_data[srl_col].std()
+    
+    # Geometric separation
+    if stats['human_count'] > 0 and stats['dog_count'] > 0:
+        human_center = df_filtered[df_filtered['source'] == 'Human'][['x', 'y', 'z']].mean()
+        dog_center = df_filtered[df_filtered['source'] == 'Dog'][['x', 'y', 'z']].mean()
+        stats['geometric_separation'] = np.sqrt(((human_center - dog_center) ** 2).sum())
+    
+    return stats
+
+def update_manifold_visualization(species_selection, emotion_selection, lens_selection, 
+                                alpha_range, srl_range, feature_range, point_size,
+                                show_boundary, show_trajectories, color_scheme):
+    """Main update function for the manifold visualization."""
+    
+    # Filter data based on selections
+    df_filtered = df_combined.copy()
+    
+    # Species filter
+    if species_selection:
+        df_filtered = df_filtered[df_filtered['source'].isin(species_selection)]
+    
+    # Emotion filter
+    if emotion_selection:
+        df_filtered = df_filtered[df_filtered['label'].isin(emotion_selection)]
+    
+    # CMT diagnostic filters
+    alpha_col = f"diag_alpha_{lens_selection}"
+    srl_col = f"diag_srl_{lens_selection}"
+    
+    if alpha_col in df_filtered.columns:
+        df_filtered = df_filtered[
+            (df_filtered[alpha_col] >= alpha_range[0]) & 
+            (df_filtered[alpha_col] <= alpha_range[1])
+        ]
+    
+    if srl_col in df_filtered.columns:
+        df_filtered = df_filtered[
+            (df_filtered[srl_col] >= srl_range[0]) & 
+            (df_filtered[srl_col] <= srl_range[1])
+        ]
+    
+    # Feature magnitude filter (using first few feature columns if they exist)
+    feature_cols = [col for col in df_filtered.columns if col.startswith('feature_')]
+    if feature_cols:
+        feature_magnitudes = np.sqrt(df_filtered[feature_cols[:3]].pow(2).sum(axis=1))
+        df_filtered = df_filtered[
+            (feature_magnitudes >= feature_range[0]) & 
+            (feature_magnitudes <= feature_range[1])
+        ]
+    
+    # Create visualizations
+    if len(df_filtered) == 0:
+        empty_fig = go.Figure().add_annotation(
+            text="No data points match the current filters", 
+            xref="paper", yref="paper", x=0.5, y=0.5, showarrow=False
+        )
+        return (empty_fig, empty_fig, empty_fig, empty_fig, empty_fig, 
+                "No data available", "No data available", "No data available")
+    
+    # Main manifold plot
+    manifold_fig = create_enhanced_manifold_plot(
+        df_filtered, lens_selection, color_scheme, point_size, 
+        show_boundary, show_trajectories
+    )
+    
+    # Secondary plots
+    projection_fig = create_2d_projection_plot(df_filtered, color_scheme)
+    density_fig = create_density_heatmap(df_filtered)
+    distributions_fig = create_feature_distributions(df_filtered, lens_selection)
+    correlation_fig = create_correlation_matrix(df_filtered, lens_selection)
+    
+    # Statistics
+    stats = calculate_statistics(df_filtered, lens_selection)
+    
+    # Format statistics HTML
+    species_stats_html = f"""
+    <h4>📊 Data Overview</h4>
+    <p><b>Total Points:</b> {stats['total_points']}</p>
+    <p><b>Human:</b> {stats['human_count']} | <b>Dog:</b> {stats['dog_count']}</p>
+    <p><b>Ratio:</b> {stats['human_count']/(stats['dog_count']+1):.2f}:1</p>
+    """
+    
+    boundary_stats_html = f"""
+    <h4>🔬 Geometric Analysis</h4>
+    <p><b>Lens:</b> {lens_selection.title()}</p>
+    {"<p><b>Separation:</b> {:.3f}</p>".format(stats.get('geometric_separation', 0)) if 'geometric_separation' in stats else ""}
+    <p><b>Dimensions:</b> 3D UMAP</p>
+    """
+    
+    similarity_html = f"""
+    <h4>🔗 Species Comparison</h4>
+    <p><b>Human α:</b> {stats.get('human_alpha_mean', 0):.3f} ± {stats.get('human_alpha_std', 0):.3f}</p>
+    <p><b>Dog α:</b> {stats.get('dog_alpha_mean', 0):.3f} ± {stats.get('dog_alpha_std', 0):.3f}</p>
+    <p><b>Overlap Index:</b> {1 / (1 + stats.get('geometric_separation', 1)):.3f}</p>
+    """
+    
+    return (manifold_fig, projection_fig, density_fig, distributions_fig, correlation_fig,
+            species_stats_html, boundary_stats_html, similarity_html)
+
 def resolve_audio_path(row: pd.Series) -> str:
     """
     Intelligently reconstructs the full path to an audio file
@@ -691,13 +1158,191 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="cyan")) a
     default_primary = file_choices[0] if file_choices else ""
 
     with gr.Tabs():
-        with gr.TabItem("Unified Manifold"):
-            gr.Plot(value=lambda: go.Figure(data=[go.Scatter3d(
-                x=df_combined["x"], y=df_combined["y"], z=df_combined["z"],
-                mode="markers", marker=dict(color=df_combined["cluster"], size=5, colorscale="Viridis", showscale=True, colorbar={"title": "Cluster ID"}),
-                text=df_combined.apply(lambda r: f"{r['source']}: {r.get('label', '')}<br>File: {r['filepath']}", axis=1),
-                hoverinfo="text"
-            )], layout=dict(title="Communication Manifold (UMAP Projection)")), label="UMAP Manifold")
+        with gr.TabItem("🌌 Universal Manifold Explorer"):
+            gr.Markdown("""
+            # 🎯 **First Universal Interspecies Communication Map**
+            *Discover the hidden mathematical geometry underlying human and dog communication*
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 🔬 **Analysis Controls**")
+                    
+                    # Species filtering
+                    species_filter = gr.CheckboxGroup(
+                        label="Species Selection",
+                        choices=["Human", "Dog"],
+                        value=["Human", "Dog"],
+                        info="Select which species to display"
+                    )
+                    
+                    # Emotional state filtering
+                    emotion_filter = gr.CheckboxGroup(
+                        label="Emotional States",
+                        choices=list(df_combined['label'].unique()),
+                        value=list(df_combined['label'].unique()),
+                        info="Filter by emotional expression"
+                    )
+                    
+                    # CMT Lens selection for coloring
+                    lens_selector = gr.Dropdown(
+                        label="Mathematical Lens View",
+                        choices=["gamma", "zeta", "airy", "bessel"],
+                        value="gamma",
+                        info="Choose which mathematical lens to use for analysis"
+                    )
+                    
+                    # Advanced filtering sliders
+                    with gr.Accordion("🎛️ Advanced CMT Filters", open=False):
+                        alpha_range = gr.RangeSlider(
+                            label="CMT Alpha Range (Geometric Consistency)",
+                            minimum=0, maximum=1, value=[0, 1], step=0.01,
+                            info="Filter by geometric consistency measure"
+                        )
+                        
+                        srl_range = gr.RangeSlider(
+                            label="SRL Range (Complexity Level)",
+                            minimum=0, maximum=100, value=[0, 100], step=1,
+                            info="Filter by spike response level (complexity)"
+                        )
+                        
+                        feature_magnitude = gr.RangeSlider(
+                            label="Feature Magnitude Range",
+                            minimum=-3, maximum=3, value=[-3, 3], step=0.1,
+                            info="Filter by overall feature strength"
+                        )
+                    
+                    # Visualization options
+                    with gr.Accordion("🎨 Visualization Options", open=True):
+                        point_size = gr.Slider(
+                            label="Point Size",
+                            minimum=2, maximum=15, value=6, step=1
+                        )
+                        
+                        show_species_boundary = gr.Checkbox(
+                            label="Show Species Boundary",
+                            value=True,
+                            info="Display geometric boundary between species"
+                        )
+                        
+                        show_trajectories = gr.Checkbox(
+                            label="Show Communication Trajectories",
+                            value=False,
+                            info="Display paths between related vocalizations"
+                        )
+                        
+                        color_scheme = gr.Dropdown(
+                            label="Color Scheme",
+                            choices=["Species", "Emotion", "CMT_Alpha", "CMT_SRL", "Cluster"],
+                            value="Species",
+                            info="Choose coloring strategy"
+                        )
+                    
+                    # Real-time analysis
+                    with gr.Accordion("🔍 Real-Time Analysis", open=False):
+                        analysis_button = gr.Button("🔬 Analyze Selected Region", variant="primary")
+                        
+                        selected_info = gr.HTML(
+                            label="Selection Analysis",
+                            value="<i>Select points on the manifold for detailed analysis</i>"
+                        )
+                
+                with gr.Column(scale=3):
+                    # Main 3D manifold plot
+                    manifold_plot = gr.Plot(
+                        label="Universal Communication Manifold",
+                        height=600
+                    )
+                    
+                    # Statistics panel below the plot
+                    with gr.Row():
+                        with gr.Column():
+                            species_stats = gr.HTML(
+                                label="Species Statistics",
+                                value=""
+                            )
+                        
+                        with gr.Column():
+                            boundary_stats = gr.HTML(
+                                label="Boundary Analysis",
+                                value=""
+                            )
+                        
+                        with gr.Column():
+                            similarity_stats = gr.HTML(
+                                label="Cross-Species Similarity",
+                                value=""
+                            )
+            
+            # Secondary analysis views
+            with gr.Row():
+                with gr.Column():
+                    # 2D projection plot
+                    projection_2d = gr.Plot(
+                        label="2D Projection View",
+                        height=400
+                    )
+                
+                with gr.Column():
+                    # Density heatmap
+                    density_plot = gr.Plot(
+                        label="Communication Density Map",
+                        height=400
+                    )
+            
+            # Bottom analysis panel
+            with gr.Row():
+                with gr.Column():
+                    # Feature distribution plots
+                    feature_distributions = gr.Plot(
+                        label="CMT Feature Distributions",
+                        height=300
+                    )
+                
+                with gr.Column():
+                    # Correlation matrix
+                    correlation_matrix = gr.Plot(
+                        label="Cross-Species Feature Correlations",
+                        height=300
+                    )
+            
+            # Wire up all the interactive components
+            manifold_inputs = [
+                species_filter, emotion_filter, lens_selector,
+                alpha_range, srl_range, feature_magnitude, point_size,
+                show_species_boundary, show_trajectories, color_scheme
+            ]
+            
+            manifold_outputs = [
+                manifold_plot, projection_2d, density_plot, 
+                feature_distributions, correlation_matrix,
+                species_stats, boundary_stats, similarity_stats
+            ]
+            
+            # Set up event handlers for real-time updates
+            for component in manifold_inputs:
+                component.change(
+                    update_manifold_visualization,
+                    inputs=manifold_inputs,
+                    outputs=manifold_outputs
+                )
+            
+            # Initialize the plots with default values
+            demo.load(
+                lambda: update_manifold_visualization(
+                    ["Human", "Dog"],  # species_selection
+                    list(df_combined['label'].unique()),  # emotion_selection
+                    "gamma",  # lens_selection
+                    [0, 1],   # alpha_range
+                    [0, 100], # srl_range
+                    [-3, 3],  # feature_range
+                    6,        # point_size
+                    True,     # show_boundary
+                    False,    # show_trajectories
+                    "Species" # color_scheme
+                ),
+                outputs=manifold_outputs
+            )
         
         with gr.TabItem("Interactive Holography"):
             with gr.Row():