Add computational math lab and benchmarking features

Introduces a new 'Math Lab' mode in the app with random graph generation and Bellman-Ford algorithm benchmarking. Adds experiments.py for scientific graph generation and benchmarking utilities, and extends Graph class with adjacency matrix conversion and population methods.

app.py

@@ -3,11 +3,13 @@ import graphviz
 import json
 import os
 import pandas as pd
+import time
 from datetime import datetime
 import google.generativeai as genai
 from graph_module import Graph
 from algorithms import bellman_ford_list
 from leads_manager import get_analytics
+import experiments
 
 # --- CONFIG ---
 st.set_page_config(layout="wide", page_title="SellMe AI Engine")
@@ -358,6 +360,69 @@ def draw_graph(graph_data, current_node, predicted_path):
 
 # --- MAIN APP ---
 st.sidebar.title("🛠️ SellMe Control")
+app_mode = st.sidebar.selectbox("Mode", ["Sales Bot Demo", "🧪 Math Lab"])
+
+if app_mode == "🧪 Math Lab":
+    st.title("🧪 Computational Math Lab")
+    
+    tab1, tab2 = st.tabs(["🎲 Random Graph", "⚡ Performance"])
+    
+    with tab1:
+        st.header("Random Graph Generation (Erdős-Rényi)")
+        c1, c2 = st.columns(2)
+        n = c1.slider("Number of Vertices (N)", 5, 50, 10, step=5)
+        density = c2.slider("Edge Density", 0.1, 1.0, 0.3)
+        
+        if st.button("Generate Graph"):
+            # Generate
+            graph = experiments.generate_random_graph(n, density)
+            
+            # Show Adjacency Matrix
+            st.subheader("Adjacency Matrix")
+            matrix = graph.to_adjacency_matrix()
+            # Convert float('inf') to string "∞" for display
+            display_matrix = [[("∞" if x == float('inf') else x) for x in row] for row in matrix]
+            df_matrix = pd.DataFrame(display_matrix)
+            st.dataframe(df_matrix)
+            
+            # Show Graphviz
+            st.subheader("Visual Representation")
+            # We can reuse draw_graph but need to adapt arguments roughly
+            # Creating a fake structure to reuse draw_graph or just drawing simple one here.
+            # draw_graph expects (graph, node_to_id, id_to_node, nodes, edges) tuple + current_node + path
+            
+            dot = graphviz.Digraph()
+            dot.attr(rankdir='LR')
+            for i in range(graph.num_vertices):
+                dot.node(str(i), label=f"Node {i}")
+            
+            for u, neighbors in graph.adj_list.items():
+                for v, w in neighbors:
+                    dot.edge(str(u), str(v), label=str(w))
+            
+            st.graphviz_chart(dot)
+
+    with tab2:
+        st.header("Algorithm Benchmarking")
+        st.markdown("**Algorithm:** Bellman-Ford (Adjacency List)")
+        st.markdown("**Theoretical Complexity:** $O(V \\cdot E)$")
+        
+        bench_density = st.slider("Benchmark Density", 0.1, 1.0, 0.5)
+        if st.button("Run Benchmarks 🚀"):
+            with st.spinner("Running experiments..."):
+                sizes = [10, 50, 100, 200]
+                results = experiments.run_benchmark(sizes, bench_density)
+            
+            # Results
+            df_res = pd.DataFrame(results, columns=["Vertices", "Time (seconds)"])
+            st.table(df_res)
+            
+            # Chart
+            st.line_chart(df_res.set_index("Vertices")["Time (seconds)"])
+            
+    st.stop() # Stop here so we don't render the Sales Bot Demo
+
+# --- SALES BOT DEMO CONTINUES BELOW ---
 
 # --- API KEY SETUP (Robust) ---
 api_key = None

experiments.py

@@ -0,0 +1,133 @@
+import random
+import time
+import statistics
+from graph_module import Graph
+from algorithms import bellman_ford_list
+
+# --- SCIENTIFIC CORE ---
+
+def generate_erdos_renyi(n, density):
+    """
+    Generates a random directed graph using the Erdős-Rényi model.
+    
+    Args:
+        n (int): Number of vertices.
+        density (float): Probability of edge creation (0.0 to 1.0).
+        
+    Returns:
+        Graph: A generated graph object.
+    """
+    graph = Graph(n, directed=True)
+    
+    # Directed graph max edges = n * (n - 1) (no self-loops)
+    max_edges = n * (n - 1)
+    target_edges = int(max_edges * density)
+    
+    # Track existing edges to avoid duplicates
+    existing_edges = set()
+    count = 0
+    
+    # Safety: if target_edges > possible edges, clamp it
+    if target_edges > max_edges:
+        target_edges = max_edges
+        
+    while count < target_edges:
+        u = random.randint(0, n - 1)
+        v = random.randint(0, n - 1)
+        
+        if u != v: # No self-loops
+            edge_key = (u, v)
+            if edge_key not in existing_edges:
+                existing_edges.add(edge_key)
+                weight = random.randint(-2, 10) # Scientific constraint: -2 to 10
+                graph.add_edge(u, v, weight)
+                count += 1
+                
+    return graph
+
+def run_scientific_benchmark(sizes, densities, num_runs=20):
+    """
+    Runs rigorous benchmarks for Bellman-Ford algorithm.
+    CRITICAL: For each pair (n, d), we repeat the experiment num_runs times.
+    
+    Args:
+        sizes (list[int]): List of vertex counts.
+        densities (list[float]): List of edge densities.
+        num_runs (int): Number of repetitions for averaging.
+        
+    Returns:
+        list[dict]: List of result dictionaries ready for DataFrame.
+    """
+    results = []
+    
+    print(f"--- Scientific Benchmark Started (Runs per config: {num_runs}) ---")
+    
+    for n in sizes:
+        for d in densities:
+            times = []
+            edge_counts = []
+            
+            for _ in range(num_runs):
+                # 1. Generate NEW random graph (don't count this in timing)
+                graph = generate_erdos_renyi(n, d)
+                
+                # Count actual edges
+                # Sum of adjacency list lengths
+                e_count = sum(len(graph.adj_list[u]) for u in range(graph.num_vertices))
+                edge_counts.append(e_count)
+                
+                # 2. Start Timer
+                start_time = time.perf_counter()
+                
+                # 3. Run Algorithm (Source = 0)
+                try:
+                    bellman_ford_list(graph, 0)
+                except Exception:
+                    pass # Ignore errors (e.g. negative cycles in random graphs)
+                
+                # 4. Stop Timer
+                end_time = time.perf_counter()
+                times.append(end_time - start_time)
+            
+            # Calculate Averages
+            avg_time = statistics.mean(times)
+            avg_edges = statistics.mean(edge_counts)
+            
+            # 5. Record Data
+            results.append({
+                "Vertices (N)": n,
+                "Density": d,
+                "Avg_Time_Sec": avg_time,
+                "Edges_Count": int(avg_edges),
+                "Runs": num_runs
+            })
+            print(f"Config N={n}, D={d} -> Avg Time: {avg_time:.6f}s")
+            
+    return results
+
+# --- BACKWARD COMPATIBILITY (Aliases) ---
+
+def generate_random_graph(n, density):
+    """Alias for generate_erdos_renyi to support legacy code."""
+    return generate_erdos_renyi(n, density)
+
+def run_benchmark(sizes, density):
+    """
+    Alias supporting legacy list[tuple] return format.
+    Uses run_scientific_benchmark internally with 1 run for speed/demo.
+    """
+    # Wrap density in list, run 1 time (demo mode usually needs speed)
+    # The user asked for rigorous benchmark (20 runs) in the new function, 
+    # but the old function was for a quick demo. 
+    # Let's do 1 run to keep UI responsive, or 5 for better stability?
+    # Let's stick to 1 to match previous "quick" expectation unless specified.
+    
+    raw_results = run_scientific_benchmark(sizes, [density], num_runs=1)
+    
+    # Convert to list of tuples [(N, Time)]
+    return [(r["Vertices (N)"], r["Avg_Time_Sec"]) for r in raw_results]
+
+if __name__ == "__main__":
+    # Test
+    res = run_scientific_benchmark([10, 50], [0.1, 0.5], num_runs=5)
+    print(res)

graph_module.py

@@ -2,19 +2,58 @@ class Graph:
     def __init__(self, num_vertices, directed=True):
         self.num_vertices = num_vertices
         self.directed = directed
-        self.adj_matrix = [[None] * num_vertices for _ in range(num_vertices)]
+        # Using float('inf') for no connection as requested
+        self.adj_matrix = [[float('inf')] * num_vertices for _ in range(num_vertices)]
         self.adj_list = {i: [] for i in range(num_vertices)}
 
     def add_edge(self, u, v, weight):
         if 0 <= u < self.num_vertices and 0 <= v < self.num_vertices:
+            # Directed edge logic
             self.adj_list[u].append((v, weight))
             self.adj_matrix[u][v] = weight
+            
             if not self.directed:
                 self.adj_list[v].append((u, weight))
                 self.adj_matrix[v][u] = weight
         else:
             raise ValueError(f"Vertex index out of bounds: {u}, {v}")
 
+    def to_adjacency_matrix(self):
+        """
+        Returns a 2D list (matrix) of size V x V.
+        matrix[u][v] = weight if edge exists.
+        matrix[u][v] = float('inf') if no edge exists.
+        matrix[u][u] = 0 (distance to self).
+        """
+        # Create a deep copy to avoid modifying internal state if needed, 
+        # or just return internal state if we maintain it strictly.
+        # But user requested "matrix[u][u] = 0". Our internal init uses float('inf').
+        # So we should probably update internal or return a modified copy.
+        # Let's return a generated one if we want to be safe, or update internal.
+        # Updating internal is better for consistency if we use it.
+        # But wait, internal initialized with inf. 
+        # Let's just fix diagonals in internal if they are inf.
+        
+        for i in range(self.num_vertices):
+            self.adj_matrix[i][i] = 0
+            
+        return self.adj_matrix
+
+    def from_adjacency_matrix(self, matrix):
+        """
+        Clears the current graph.
+        Populates the adjacency list based on the matrix values.
+        """
+        self.num_vertices = len(matrix)
+        self.adj_matrix = matrix
+        self.adj_list = {i: [] for i in range(self.num_vertices)}
+        
+        for i in range(self.num_vertices):
+            for j in range(self.num_vertices):
+                w = matrix[i][j]
+                if i != j and w != float('inf'):
+                    self.adj_list[i].append((j, w))
+
     def get_matrix(self):
         return self.adj_matrix