Update app.py

app.py

@@ -4,12 +4,6 @@ import numpy as np
 import plotly.graph_objects as go
 from scipy.optimize import fsolve
 from scipy.stats import gaussian_kde
-import os
-import sys
-import tempfile
-import subprocess
-import importlib.util
-import shutil
 
 # Configure Streamlit for Hugging Face Spaces
 st.set_page_config(
@@ -18,539 +12,6 @@ st.set_page_config(
     initial_sidebar_state="collapsed"
 )
 
-# Define C++ extension code as a string
-CPP_CODE = r'''
-#include <pybind11/pybind11.h>
-#include <pybind11/numpy.h>
-#include <pybind11/eigen.h>
-#include <Eigen/Dense>
-#include <vector>
-#include <cmath>
-#include <limits>
-
-namespace py = pybind11;
-
-// Compute the cubic discriminant
-double compute_discriminant(double z, double beta, double z_a, double y_effective) {
-    double a = z * z_a;
-    double b = z * z_a + z + z_a - z_a * y_effective;
-    double c = z + z_a + 1 - y_effective * (beta * z_a + 1 - beta);
-    double d = 1;
-    
-    // Symbolic expression for the cubic discriminant
-    return std::pow((b*c)/(6*a*a) - std::pow(b, 3)/(27*std::pow(a, 3)) - d/(2*a), 2) + 
-           std::pow(c/(3*a) - std::pow(b, 2)/(9*std::pow(a, 2)), 3);
-}
-
-// Find z values where the discriminant equals zero
-std::vector<double> find_z_at_discriminant_zero(double z_a, double y, double beta, 
-                                                double z_min, double z_max, int steps) {
-    // Apply the condition for y
-    double y_effective = y > 1 ? y : 1/y;
-    
-    // Create z grid
-    std::vector<double> z_grid(steps);
-    double step_size = (z_max - z_min) / (steps - 1);
-    for (int i = 0; i < steps; i++) {
-        z_grid[i] = z_min + i * step_size;
-    }
-    
-    // Calculate discriminant values
-    std::vector<double> disc_vals(steps);
-    for (int i = 0; i < steps; i++) {
-        disc_vals[i] = compute_discriminant(z_grid[i], beta, z_a, y_effective);
-    }
-    
-    // Find roots
-    std::vector<double> roots_found;
-    
-    for (int i = 0; i < steps - 1; i++) {
-        double f1 = disc_vals[i];
-        double f2 = disc_vals[i+1];
-        
-        // Skip if NaN
-        if (std::isnan(f1) || std::isnan(f2)) {
-            continue;
-        }
-        
-        // Check for exact zero
-        if (f1 == 0.0) {
-            roots_found.push_back(z_grid[i]);
-        } 
-        else if (f2 == 0.0) {
-            roots_found.push_back(z_grid[i+1]);
-        }
-        // Check for sign change
-        else if (f1 * f2 < 0) {
-            double zl = z_grid[i];
-            double zr = z_grid[i+1];
-            double f1_local = f1;
-            double f2_local = f2;
-            
-            // Use binary search to refine the root
-            for (int j = 0; j < 50; j++) {
-                double mid = 0.5 * (zl + zr);
-                double fm = compute_discriminant(mid, beta, z_a, y_effective);
-                
-                if (fm == 0) {
-                    zl = zr = mid;
-                    break;
-                }
-                
-                if ((fm > 0 && f1_local > 0) || (fm < 0 && f1_local < 0)) {
-                    zl = mid;
-                    f1_local = fm;
-                } else {
-                    zr = mid;
-                    f2_local = fm;
-                }
-            }
-            
-            roots_found.push_back(0.5 * (zl + zr));
-        }
-    }
-    
-    return roots_found;
-}
-
-// Sweep beta values and find z boundary values
-std::tuple<py::array_t<double>, py::array_t<double>, py::array_t<double>> 
-sweep_beta_and_find_z_bounds(double z_a, double y, double z_min, double z_max, int beta_steps, int z_steps) {
-    // Create beta values
-    py::array_t<double> betas(beta_steps);
-    auto betas_ptr = betas.mutable_data();
-    double beta_step = 1.0 / (beta_steps - 1);
-    for (int i = 0; i < beta_steps; i++) {
-        betas_ptr[i] = i * beta_step;
-    }
-    
-    // Initialize arrays for min and max z values
-    py::array_t<double> z_min_values(beta_steps);
-    py::array_t<double> z_max_values(beta_steps);
-    auto z_min_ptr = z_min_values.mutable_data();
-    auto z_max_ptr = z_max_values.mutable_data();
-    
-    for (int i = 0; i < beta_steps; i++) {
-        double beta = betas_ptr[i];
-        std::vector<double> roots = find_z_at_discriminant_zero(z_a, y, beta, z_min, z_max, z_steps);
-        
-        if (roots.size() == 0) {
-            z_min_ptr[i] = std::numeric_limits<double>::quiet_NaN();
-            z_max_ptr[i] = std::numeric_limits<double>::quiet_NaN();
-        } else {
-            // Find min and max roots
-            double min_root = roots[0];
-            double max_root = roots[0];
-            for (size_t j = 1; j < roots.size(); j++) {
-                if (roots[j] < min_root) min_root = roots[j];
-                if (roots[j] > max_root) max_root = roots[j];
-            }
-            z_min_ptr[i] = min_root;
-            z_max_ptr[i] = max_root;
-        }
-    }
-    
-    return std::make_tuple(betas, z_min_values, z_max_values);
-}
-
-// Compute High y Expression curve
-py::array_t<double> compute_high_y_curve(py::array_t<double> betas, double z_a, double y) {
-    // Apply the condition for y
-    double y_effective = y > 1 ? y : 1/y;
-    
-    auto betas_ptr = betas.data();
-    size_t n = betas.size();
-    py::array_t<double> result(n);
-    auto result_ptr = result.mutable_data();
-    
-    double a = z_a;
-    double denominator = 1 - 2*a;
-    
-    if (std::abs(denominator) < 1e-10) {
-        for (size_t i = 0; i < n; i++) {
-            result_ptr[i] = std::numeric_limits<double>::quiet_NaN();
-        }
-    } else {
-        for (size_t i = 0; i < n; i++) {
-            double beta = betas_ptr[i];
-            double numerator = -4*a*(a-1)*y_effective*beta - 2*a*y_effective - 2*a*(2*a-1);
-            result_ptr[i] = numerator/denominator;
-        }
-    }
-    
-    return result;
-}
-
-// Compute alternative low expression
-py::array_t<double> compute_alternate_low_expr(py::array_t<double> betas, double z_a, double y) {
-    // Apply the condition for y
-    double y_effective = y > 1 ? y : 1/y;
-    
-    auto betas_ptr = betas.data();
-    size_t n = betas.size();
-    py::array_t<double> result(n);
-    auto result_ptr = result.mutable_data();
-    
-    for (size_t i = 0; i < n; i++) {
-        double beta = betas_ptr[i];
-        result_ptr[i] = (z_a * y_effective * beta * (z_a - 1) - 2*z_a*(1 - y_effective) - 2*z_a*z_a) / (2 + 2*z_a);
-    }
-    
-    return result;
-}
-
-// Compute max k expression
-py::array_t<double> compute_max_k_expression(py::array_t<double> betas, double z_a, double y, int k_samples=1000) {
-    // Apply the condition for y
-    double y_effective = y > 1 ? y : 1/y;
-    
-    auto betas_ptr = betas.data();
-    size_t n = betas.size();
-    py::array_t<double> result(n);
-    auto result_ptr = result.mutable_data();
-    
-    double a = z_a;
-    
-    // Sample k values on a logarithmic scale
-    std::vector<double> k_values(k_samples);
-    double log_min = -3;
-    double log_max = 3;
-    double log_step = (log_max - log_min) / (k_samples - 1);
-    
-    for (int j = 0; j < k_samples; j++) {
-        k_values[j] = std::pow(10, log_min + j * log_step);
-    }
-    
-    for (size_t i = 0; i < n; i++) {
-        double beta = betas_ptr[i];
-        std::vector<double> values(k_samples);
-        
-        for (int j = 0; j < k_samples; j++) {
-            double k = k_values[j];
-            double numerator = y_effective*beta*(a-1)*k + (a*k+1)*((y_effective-1)*k-1);
-            double denominator = (a*k+1)*(k*k+k);
-            
-            if (std::abs(denominator) < 1e-10) {
-                values[j] = std::numeric_limits<double>::quiet_NaN();
-            } else {
-                values[j] = numerator/denominator;
-            }
-        }
-        
-        // Find max value, ignoring NaNs
-        double max_val = -std::numeric_limits<double>::infinity();
-        bool found_valid = false;
-        
-        for (double val : values) {
-            if (!std::isnan(val) && val > max_val) {
-                max_val = val;
-                found_valid = true;
-            }
-        }
-        
-        result_ptr[i] = found_valid ? max_val : std::numeric_limits<double>::quiet_NaN();
-    }
-    
-    return result;
-}
-
-// Compute min t expression
-py::array_t<double> compute_min_t_expression(py::array_t<double> betas, double z_a, double y, int t_samples=1000) {
-    // Apply the condition for y
-    double y_effective = y > 1 ? y : 1/y;
-    
-    auto betas_ptr = betas.data();
-    size_t n = betas.size();
-    py::array_t<double> result(n);
-    auto result_ptr = result.mutable_data();
-    
-    double a = z_a;
-    
-    if (a <= 0) {
-        for (size_t i = 0; i < n; i++) {
-            result_ptr[i] = std::numeric_limits<double>::quiet_NaN();
-        }
-        return result;
-    }
-    
-    // Create t values from -1/a to 0
-    double lower_bound = -1/a + 1e-10;  // Avoid division by zero
-    double step_size = (-1e-10 - lower_bound) / (t_samples - 1);
-    std::vector<double> t_values(t_samples);
-    
-    for (int j = 0; j < t_samples; j++) {
-        t_values[j] = lower_bound + j * step_size;
-    }
-    
-    for (size_t i = 0; i < n; i++) {
-        double beta = betas_ptr[i];
-        std::vector<double> values(t_samples);
-        
-        for (int j = 0; j < t_samples; j++) {
-            double t = t_values[j];
-            double numerator = y_effective*beta*(a-1)*t + (a*t+1)*((y_effective-1)*t-1);
-            double denominator = (a*t+1)*(t*t+t);
-            
-            if (std::abs(denominator) < 1e-10) {
-                values[j] = std::numeric_limits<double>::quiet_NaN();
-            } else {
-                values[j] = numerator/denominator;
-            }
-        }
-        
-        // Find min value, ignoring NaNs
-        double min_val = std::numeric_limits<double>::infinity();
-        bool found_valid = false;
-        
-        for (double val : values) {
-            if (!std::isnan(val) && val < min_val) {
-                min_val = val;
-                found_valid = true;
-            }
-        }
-        
-        result_ptr[i] = found_valid ? min_val : std::numeric_limits<double>::quiet_NaN();
-    }
-    
-    return result;
-}
-
-// Compute eigenvalue support boundaries
-std::tuple<py::array_t<double>, py::array_t<double>> 
-compute_eigenvalue_support_boundaries(double z_a, double y, py::array_t<double> beta_values, 
-                                      int n_samples = 100, int seeds = 5) {
-    // Apply the condition for y
-    double y_effective = y > 1 ? y : 1/y;
-    
-    auto beta_ptr = beta_values.data();
-    size_t num_betas = beta_values.size();
-    
-    py::array_t<double> min_eigenvalues(num_betas);
-    py::array_t<double> max_eigenvalues(num_betas);
-    auto min_eig_ptr = min_eigenvalues.mutable_data();
-    auto max_eig_ptr = max_eigenvalues.mutable_data();
-    
-    for (size_t i = 0; i < num_betas; i++) {
-        double beta = beta_ptr[i];
-        
-        std::vector<double> min_vals;
-        std::vector<double> max_vals;
-        
-        // Run multiple trials with different seeds
-        for (int seed = 0; seed < seeds; seed++) {
-            // Set random seed
-            srand(seed * 100 + i);
-            
-            // Compute dimension p based on aspect ratio y
-            int n = n_samples;
-            int p = int(y_effective * n);
-            
-            // Constructing T_n (Population / Shape Matrix)
-            int k = int(std::floor(beta * p));
-            
-            // Create diagonal entries
-            std::vector<double> diag_entries(p);
-            for (int j = 0; j < k; j++) {
-                diag_entries[j] = z_a;
-            }
-            for (int j = k; j < p; j++) {
-                diag_entries[j] = 1.0;
-            }
-            
-            // Shuffle the diagonal entries (simple Fisher-Yates shuffle)
-            for (int j = p-1; j > 0; j--) {
-                int idx = rand() % (j+1);
-                std::swap(diag_entries[j], diag_entries[idx]);
-            }
-            
-            // Generate the data matrix X with i.i.d. standard normal entries
-            std::vector<std::vector<double>> X(p, std::vector<double>(n));
-            for (int row = 0; row < p; row++) {
-                for (int col = 0; col < n; col++) {
-                    // Box-Muller transform to generate normal distribution
-                    double u1 = rand() / (RAND_MAX + 1.0);
-                    double u2 = rand() / (RAND_MAX + 1.0);
-                    if (u1 < 1e-10) u1 = 1e-10;  // Avoid log(0)
-                    double z = sqrt(-2.0 * log(u1)) * cos(2.0 * M_PI * u2);
-                    X[row][col] = z;
-                }
-            }
-            
-            // Compute the sample covariance matrix S_n = (1/n) * XX^T
-            std::vector<std::vector<double>> S_n(p, std::vector<double>(p, 0.0));
-            for (int row = 0; row < p; row++) {
-                for (int col = 0; col < p; col++) {
-                    double sum = 0.0;
-                    for (int k = 0; k < n; k++) {
-                        sum += X[row][k] * X[col][k];
-                    }
-                    S_n[row][col] = sum / n;
-                }
-            }
-            
-            // Compute B_n = S_n T_n
-            std::vector<std::vector<double>> B_n(p, std::vector<double>(p, 0.0));
-            for (int row = 0; row < p; row++) {
-                for (int col = 0; col < p; col++) {
-                    B_n[row][col] = S_n[row][col] * diag_entries[col];
-                }
-            }
-            
-            // Use Eigen library to compute eigenvalues
-            Eigen::MatrixXd B_n_eigen(p, p);
-            for (int row = 0; row < p; row++) {
-                for (int col = 0; col < p; col++) {
-                    B_n_eigen(row, col) = B_n[row][col];
-                }
-            }
-            
-            Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> solver(B_n_eigen);
-            Eigen::VectorXd eigenvalues = solver.eigenvalues();
-            
-            // Find min and max eigenvalues
-            if (p > 0) {
-                min_vals.push_back(eigenvalues(0));
-                max_vals.push_back(eigenvalues(p-1));
-            }
-        }
-        
-        // Average over seeds for stability
-        if (!min_vals.empty() && !max_vals.empty()) {
-            double min_sum = 0.0, max_sum = 0.0;
-            for (double val : min_vals) min_sum += val;
-            for (double val : max_vals) max_sum += val;
-            
-            min_eig_ptr[i] = min_sum / min_vals.size();
-            max_eig_ptr[i] = max_sum / max_vals.size();
-        } else {
-            min_eig_ptr[i] = std::numeric_limits<double>::quiet_NaN();
-            max_eig_ptr[i] = std::numeric_limits<double>::quiet_NaN();
-        }
-    }
-    
-    return std::make_tuple(min_eigenvalues, max_eigenvalues);
-}
-
-PYBIND11_MODULE(cubic_cpp, m) {
-    m.doc() = "C++ implementation of cubic root analysis functions";
-    
-    m.def("sweep_beta_and_find_z_bounds", &sweep_beta_and_find_z_bounds, 
-          "Sweep beta values and find z boundary values",
-          py::arg("z_a"), py::arg("y"), py::arg("z_min"), py::arg("z_max"), 
-          py::arg("beta_steps"), py::arg("z_steps"));
-    
-    m.def("compute_high_y_curve", &compute_high_y_curve,
-          "Compute High y Expression curve",
-          py::arg("betas"), py::arg("z_a"), py::arg("y"));
-    
-    m.def("compute_alternate_low_expr", &compute_alternate_low_expr,
-          "Compute alternative low expression",
-          py::arg("betas"), py::arg("z_a"), py::arg("y"));
-    
-    m.def("compute_max_k_expression", &compute_max_k_expression,
-          "Compute max k expression",
-          py::arg("betas"), py::arg("z_a"), py::arg("y"), py::arg("k_samples")=1000);
-    
-    m.def("compute_min_t_expression", &compute_min_t_expression,
-          "Compute min t expression",
-          py::arg("betas"), py::arg("z_a"), py::arg("y"), py::arg("t_samples")=1000);
-    
-    m.def("compute_eigenvalue_support_boundaries", &compute_eigenvalue_support_boundaries,
-          "Compute eigenvalue support boundaries",
-          py::arg("z_a"), py::arg("y"), py::arg("beta_values"), 
-          py::arg("n_samples")=100, py::arg("seeds")=5);
-}
-'''
-
-# Function to build and load the C++ extension
-@st.cache_resource
-def build_cpp_extension():
-    try:
-        # Create temporary directory
-        temp_dir = tempfile.mkdtemp()
-        
-        # Write C++ code to a file
-        cpp_file = os.path.join(temp_dir, "cubic_cpp.cpp")
-        with open(cpp_file, "w") as f:
-            f.write(CPP_CODE)
-        
-        # Check if pybind11 and Eigen are installed
-        try:
-            import pybind11
-            pybind11_include = pybind11.get_include()
-        except ImportError:
-            # Install pybind11 if not available
-            subprocess.check_call([sys.executable, "-m", "pip", "install", "pybind11"])
-            import pybind11
-            pybind11_include = pybind11.get_include()
-        
-        # Try to find Eigen or download it
-        eigen_include = os.path.join(temp_dir, "eigen")
-        if not os.path.exists(eigen_include):
-            os.makedirs(eigen_include)
-            # Download Eigen headers (just the minimal required parts)
-            subprocess.check_call(["wget", "https://gitlab.com/libeigen/eigen/-/archive/3.4.0/eigen-3.4.0.tar.gz", "-O", os.path.join(temp_dir, "eigen.tar.gz")])
-            subprocess.check_call(["tar", "-xzf", os.path.join(temp_dir, "eigen.tar.gz"), "-C", temp_dir])
-            # Move Eigen headers to the include directory
-            eigen_src = os.path.join(temp_dir, "eigen-3.4.0")
-            for folder in ["Eigen", "unsupported"]:
-                if os.path.exists(os.path.join(eigen_src, folder)):
-                    shutil.copytree(os.path.join(eigen_src, folder), os.path.join(eigen_include, folder))
-        
-        # Build the extension module
-        setup_py = os.path.join(temp_dir, "setup.py")
-        with open(setup_py, "w") as f:
-            f.write(f'''
-from setuptools import setup, Extension
-import pybind11
-import os
-
-ext_modules = [
-    Extension(
-        'cubic_cpp',
-        ['cubic_cpp.cpp'],
-        include_dirs=[
-            pybind11.get_include(),
-            os.path.dirname(os.path.abspath(__file__))
-        ],
-        language='c++'
-    )
-]
-
-setup(
-    name='cubic_cpp',
-    ext_modules=ext_modules,
-    py_modules=[],
-)
-''')
-        
-        # Build the extension in place
-        subprocess.check_call([sys.executable, setup_py, "build_ext", "--inplace"], cwd=temp_dir)
-        
-        # Find the compiled module
-        extension_path = None
-        for file in os.listdir(temp_dir):
-            if file.startswith("cubic_cpp") and file.endswith(".so"):
-                extension_path = os.path.join(temp_dir, file)
-                break
-        
-        if extension_path is None:
-            st.warning("Failed to find the compiled C++ extension")
-            return None
-        
-        # Load the module
-        spec = importlib.util.spec_from_file_location("cubic_cpp", extension_path)
-        cubic_cpp = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(cubic_cpp)
-        
-        return cubic_cpp
-    except Exception as e:
-        st.warning(f"Failed to build C++ extension: {str(e)}")
-        return None
-
-# Try to build and load the C++ extension
-cubic_cpp = build_cpp_extension()
-
 def add_sqrt_support(expr_str):
     """Replace 'sqrt(' with 'sp.sqrt(' for sympy compatibility"""
     return expr_str.replace('sqrt(', 'sp.sqrt(')
@@ -583,12 +44,6 @@ def find_z_at_discriminant_zero(z_a, y, beta, z_min, z_max, steps):
     Scan z in [z_min, z_max] for sign changes in the discriminant,
     and return approximated roots (where the discriminant is zero).
     """
-    # Use C++ implementation if available
-    if cubic_cpp is not None:
-        roots = np.array(cubic_cpp.find_z_at_discriminant_zero(z_a, y, beta, z_min, z_max, steps))
-        return roots
-    
-    # Python fallback implementation
     # Apply the condition for y
     y_effective = y if y > 1 else 1/y
     
@@ -625,13 +80,6 @@ def sweep_beta_and_find_z_bounds(z_a, y, z_min, z_max, beta_steps, z_steps):
     for which the discriminant is zero.
     Returns: betas, lower z*(β) values, and upper z*(β) values.
     """
-    # Use C++ implementation if available
-    if cubic_cpp is not None:
-        betas, z_min_values, z_max_values = cubic_cpp.sweep_beta_and_find_z_bounds(
-            z_a, y, z_min, z_max, beta_steps, z_steps)
-        return np.array(betas), np.array(z_min_values), np.array(z_max_values)
-    
-    # Python fallback implementation
     betas = np.linspace(0, 1, beta_steps)
     z_min_values = []
     z_max_values = []
@@ -651,13 +99,6 @@ def compute_eigenvalue_support_boundaries(z_a, y, beta_values, n_samples=100, se
     Compute the support boundaries of the eigenvalue distribution by directly
     finding the minimum and maximum eigenvalues of B_n = S_n T_n for different beta values.
     """
-    # Use C++ implementation if available
-    if cubic_cpp is not None:
-        min_eigenvalues, max_eigenvalues = cubic_cpp.compute_eigenvalue_support_boundaries(
-            z_a, y, beta_values, n_samples, seeds)
-        return np.array(min_eigenvalues), np.array(max_eigenvalues)
-    
-    # Python fallback implementation
     # Apply the condition for y
     y_effective = y if y > 1 else 1/y
     
@@ -725,12 +166,6 @@ def compute_high_y_curve(betas, z_a, y):
     """
     Compute the "High y Expression" curve.
     """
-    # Use C++ implementation if available
-    if cubic_cpp is not None:
-        curve = cubic_cpp.compute_high_y_curve(betas, z_a, y)
-        return np.array(curve)
-    
-    # Python fallback implementation
     # Apply the condition for y
     y_effective = y if y > 1 else 1/y
     
@@ -748,12 +183,6 @@ def compute_alternate_low_expr(betas, z_a, y):
     Compute the alternate low expression:
     (z_a*y*beta*(z_a-1) - 2*z_a*(1-y) - 2*z_a**2) / (2+2*z_a)
     """
-    # Use C++ implementation if available
-    if cubic_cpp is not None:
-        curve = cubic_cpp.compute_alternate_low_expr(betas, z_a, y)
-        return np.array(curve)
-    
-    # Python fallback implementation
     # Apply the condition for y
     y_effective = y if y > 1 else 1/y
     
@@ -765,12 +194,6 @@ def compute_max_k_expression(betas, z_a, y, k_samples=1000):
     """
     Compute max_{k ∈ (0,∞)} (y*beta*(a-1)*k + (a*k+1)*((y-1)*k-1)) / ((a*k+1)*(k^2+k))
     """
-    # Use C++ implementation if available
-    if cubic_cpp is not None:
-        curve = cubic_cpp.compute_max_k_expression(betas, z_a, y, k_samples)
-        return np.array(curve)
-    
-    # Python fallback implementation
     # Apply the condition for y
     y_effective = y if y > 1 else 1/y
     
@@ -802,12 +225,6 @@ def compute_min_t_expression(betas, z_a, y, t_samples=1000):
     """
     Compute min_{t ∈ (-1/a, 0)} (y*beta*(a-1)*t + (a*t+1)*((y-1)*t-1)) / ((a*t+1)*(t^2+t))
     """
-    # Use C++ implementation if available
-    if cubic_cpp is not None:
-        curve = cubic_cpp.compute_min_t_expression(betas, z_a, y, t_samples)
-        return np.array(curve)
-    
-    # Python fallback implementation
     # Apply the condition for y
     y_effective = y if y > 1 else 1/y
     
@@ -1071,126 +488,905 @@ def generate_z_vs_beta_plot(z_a, y, z_min, z_max, beta_steps, z_steps,
     )
     return fig
 
-# Rest of your code for other functions and tabs...
-# [...]
+def compute_cubic_roots(z, beta, z_a, y):
+    """
+    Compute the roots of the cubic equation for given parameters using SymPy for maximum accuracy.
+    """
+    # Apply the condition for y
+    y_effective = y if y > 1 else 1/y
+    
+    # Import SymPy functions
+    from sympy import symbols, solve, im, re, N, Poly
+    
+    # Create a symbolic variable for the equation
+    s = symbols('s')
+    
+    # Coefficients in the form as^3 + bs^2 + cs + d = 0
+    a = z * z_a
+    b = z * z_a + z + z_a - z_a*y_effective
+    c = z + z_a + 1 - y_effective*(beta*z_a + 1 - beta)
+    d = 1
+    
+    # Handle special cases
+    if abs(a) < 1e-10:
+        if abs(b) < 1e-10:  # Linear case
+            roots = np.array([-d/c, 0, 0], dtype=complex)
+        else:  # Quadratic case
+            quad_roots = np.roots([b, c, d])
+            roots = np.append(quad_roots, 0).astype(complex)
+        return roots
+    
+    try:
+        # Create the cubic polynomial
+        cubic_eq = Poly(a*s**3 + b*s**2 + c*s + d, s)
+        
+        # Solve the equation symbolically
+        symbolic_roots = solve(cubic_eq, s)
+        
+        # Convert symbolic roots to complex numbers with high precision
+        numerical_roots = []
+        for root in symbolic_roots:
+            # Use SymPy's N function with high precision
+            numerical_root = complex(N(root, 30))
+            numerical_roots.append(numerical_root)
+        
+        # If we got fewer than 3 roots (due to multiplicity), pad with zeros
+        while len(numerical_roots) < 3:
+            numerical_roots.append(0j)
+            
+        return np.array(numerical_roots, dtype=complex)
+        
+    except Exception as e:
+        # Fallback to numpy if SymPy has issues
+        coeffs = [a, b, c, d]
+        return np.roots(coeffs)
 
-# ----- Tab 1: z*(β) Curves -----
-st.title("Cubic Root Analysis")
-st.header("Eigenvalue Support Boundaries")
+def track_roots_consistently(z_values, all_roots):
+    """
+    Ensure consistent tracking of roots across z values by minimizing discontinuity.
+    """
+    n_points = len(z_values)
+    n_roots = all_roots[0].shape[0]
+    tracked_roots = np.zeros((n_points, n_roots), dtype=complex)
+    tracked_roots[0] = all_roots[0]
+    
+    for i in range(1, n_points):
+        prev_roots = tracked_roots[i-1]
+        current_roots = all_roots[i]
+        
+        # For each previous root, find the closest current root
+        assigned = np.zeros(n_roots, dtype=bool)
+        assignments = np.zeros(n_roots, dtype=int)
+        
+        for j in range(n_roots):
+            distances = np.abs(current_roots - prev_roots[j])
+            
+            # Find the closest unassigned root
+            while True:
+                best_idx = np.argmin(distances)
+                if not assigned[best_idx]:
+                    assignments[j] = best_idx
+                    assigned[best_idx] = True
+                    break
+                else:
+                    # Mark as infinite distance and try again
+                    distances[best_idx] = np.inf
+                    
+                # Safety check if all are assigned (shouldn't happen)
+                if np.all(distances == np.inf):
+                    assignments[j] = j  # Default to same index
+                    break
+        
+        # Reorder current roots based on assignments
+        tracked_roots[i] = current_roots[assignments]
+    
+    return tracked_roots
 
-# Cleaner layout with better column organization
-col1, col2, col3 = st.columns([1, 1, 2])
+def generate_cubic_discriminant(z, beta, z_a, y_effective):
+    """
+    Calculate the cubic discriminant using the standard formula.
+    For a cubic ax^3 + bx^2 + cx + d:
+    Δ = 18abcd - 27a^2d^2 + b^2c^2 - 2b^3d - 9ac^3
+    """
+    a = z * z_a
+    b = z * z_a + z + z_a - z_a*y_effective
+    c = z + z_a + 1 - y_effective*(beta*z_a + 1 - beta)
+    d = 1
+    
+    # Standard formula for cubic discriminant
+    discriminant = (18*a*b*c*d - 27*a**2*d**2 + b**2*c**2 - 2*b**3*d - 9*a*c**3)
+    return discriminant
 
-with col1:
-    z_a_1 = st.number_input("z_a", value=1.0, key="z_a_1")
-    y_1 = st.number_input("y", value=1.0, key="y_1")
+def generate_root_plots(beta, y, z_a, z_min, z_max, n_points):
+    """
+    Generate Im(s) and Re(s) vs. z plots with improved accuracy using SymPy.
+    """
+    if z_a <= 0 or y <= 0 or z_min >= z_max:
+        st.error("Invalid input parameters.")
+        return None, None, None
+
+    # Apply the condition for y
+    y_effective = y if y > 1 else 1/y
+    
+    z_points = np.linspace(z_min, z_max, n_points)
+    
+    # Collect all roots first
+    all_roots = []
+    discriminants = []
+    
+    # Progress indicator
+    progress_bar = st.progress(0)
+    status_text = st.empty()
     
-with col2:
-    z_min_1 = st.number_input("z_min", value=-10.0, key="z_min_1")
-    z_max_1 = st.number_input("z_max", value=10.0, key="z_max_1")
+    for i, z in enumerate(z_points):
+        # Update progress
+        progress_bar.progress((i + 1) / n_points)
+        status_text.text(f"Computing roots for z = {z:.3f} ({i+1}/{n_points})")
+        
+        # Calculate roots using SymPy
+        roots = compute_cubic_roots(z, beta, z_a, y)
+        
+        # Initial sorting to help with tracking
+        roots = sorted(roots, key=lambda x: (abs(x.imag), x.real))
+        all_roots.append(roots)
+        
+        # Calculate discriminant
+        disc = generate_cubic_discriminant(z, beta, z_a, y_effective)
+        discriminants.append(disc)
+    
+    # Clear progress indicators
+    progress_bar.empty()
+    status_text.empty()
+    
+    all_roots = np.array(all_roots)
+    discriminants = np.array(discriminants)
+    
+    # Track roots consistently across z values
+    tracked_roots = track_roots_consistently(z_points, all_roots)
+    
+    # Extract imaginary and real parts
+    ims = np.imag(tracked_roots)
+    res = np.real(tracked_roots)
+    
+    # Create figure for imaginary parts
+    fig_im = go.Figure()
+    for i in range(3):
+        fig_im.add_trace(go.Scatter(x=z_points, y=ims[:, i], mode="lines", name=f"Im{{s{i+1}}}",
+                                    line=dict(width=2)))
+    
+    # Add vertical lines at discriminant zero crossings
+    disc_zeros = []
+    for i in range(len(discriminants)-1):
+        if discriminants[i] * discriminants[i+1] <= 0:  # Sign change
+            zero_pos = z_points[i] + (z_points[i+1] - z_points[i]) * (0 - discriminants[i]) / (discriminants[i+1] - discriminants[i])
+            disc_zeros.append(zero_pos)
+            fig_im.add_vline(x=zero_pos, line=dict(color="red", width=1, dash="dash"))
+    
+    fig_im.update_layout(title=f"Im{{s}} vs. z (β={beta:.3f}, y={y:.3f}, z_a={z_a:.3f})",
+                         xaxis_title="z", yaxis_title="Im{s}", hovermode="x unified")
 
-with col1:
-    method_type = st.radio(
-        "Calculation Method",
-        ["Eigenvalue Method", "Discriminant Method"],
-        index=0  # Default to eigenvalue method
-    )
+    # Create figure for real parts
+    fig_re = go.Figure()
+    for i in range(3):
+        fig_re.add_trace(go.Scatter(x=z_points, y=res[:, i], mode="lines", name=f"Re{{s{i+1}}}",
+                                    line=dict(width=2)))
+    
+    # Add vertical lines at discriminant zero crossings
+    for zero_pos in disc_zeros:
+        fig_re.add_vline(x=zero_pos, line=dict(color="red", width=1, dash="dash"))
+    
+    fig_re.update_layout(title=f"Re{{s}} vs. z (β={beta:.3f}, y={y:.3f}, z_a={z_a:.3f})",
+                         xaxis_title="z", yaxis_title="Re{s}", hovermode="x unified")
+    
+    # Create discriminant plot
+    fig_disc = go.Figure()
+    fig_disc.add_trace(go.Scatter(x=z_points, y=discriminants, mode="lines", 
+                                 name="Cubic Discriminant", line=dict(color="black", width=2)))
+    fig_disc.add_hline(y=0, line=dict(color="red", width=1, dash="dash"))
+    
+    fig_disc.update_layout(title=f"Cubic Discriminant vs. z (β={beta:.3f}, y={y:.3f}, z_a={z_a:.3f})",
+                          xaxis_title="z", yaxis_title="Discriminant", hovermode="x unified")
+    
+    return fig_im, fig_re, fig_disc
 
-# Advanced settings in collapsed expanders
-with st.expander("Method Settings", expanded=False):
-    if method_type == "Eigenvalue Method":
-        beta_steps = st.slider("β steps", min_value=21, max_value=101, value=51, step=10, 
-                              key="beta_steps_eigen")
-        n_samples = st.slider("Matrix size (n)", min_value=100, max_value=2000, value=1000, 
-                            step=100)
-        seeds = st.slider("Number of seeds", min_value=1, max_value=10, value=5, step=1)
-    else:
-        beta_steps = st.slider("β steps", min_value=51, max_value=501, value=201, step=50, 
-                              key="beta_steps")
-        z_steps = st.slider("z grid steps", min_value=1000, max_value=100000, value=50000, 
-                          step=1000, key="z_steps")
+def analyze_complex_root_structure(beta_values, z, z_a, y):
+    """
+    Analyze when the cubic equation switches between having all real roots
+    and having a complex conjugate pair plus one real root.
+    
+    Returns:
+    - transition_points: beta values where the root structure changes
+    - structure_types: list indicating whether each interval has all real roots or complex roots
+    """
+    # Apply the condition for y
+    y_effective = y if y > 1 else 1/y
+    
+    transition_points = []
+    structure_types = []
+    
+    previous_type = None
+    
+    for beta in beta_values:
+        roots = compute_cubic_roots(z, beta, z_a, y)
+        
+        # Check if all roots are real (imaginary parts close to zero)
+        is_all_real = all(abs(root.imag) < 1e-10 for root in roots)
+        
+        current_type = "real" if is_all_real else "complex"
+        
+        if previous_type is not None and current_type != previous_type:
+            # Found a transition point
+            transition_points.append(beta)
+            structure_types.append(previous_type)
+        
+        previous_type = current_type
+    
+    # Add the final interval type
+    if previous_type is not None:
+        structure_types.append(previous_type)
+    
+    return transition_points, structure_types
 
-# Curve visibility options
-with st.expander("Curve Visibility", expanded=False):
-    col_vis1, col_vis2 = st.columns(2)
-    with col_vis1:
-        show_high_y = st.checkbox("Show High y Expression", value=False, key="show_high_y")
-        show_max_k = st.checkbox("Show Max k Expression", value=True, key="show_max_k")
-    with col_vis2:
-        show_low_y = st.checkbox("Show Low y Expression", value=False, key="show_low_y")
-        show_min_t = st.checkbox("Show Min t Expression", value=True, key="show_min_t")
+def generate_roots_vs_beta_plots(z, y, z_a, beta_min, beta_max, n_points):
+    """
+    Generate Im(s) and Re(s) vs. β plots with improved accuracy using SymPy.
+    """
+    if z_a <= 0 or y <= 0 or beta_min >= beta_max:
+        st.error("Invalid input parameters.")
+        return None, None, None
 
-# Custom expressions collapsed by default
-with st.expander("Custom Expression 1 (s-based)", expanded=False):
-    st.markdown("""Enter expressions for s = numerator/denominator 
-                (using variables `y`, `beta`, `z_a`, and `sqrt()`)""")
-    st.latex(r"\text{This s will be inserted into:}")
-    st.latex(r"\frac{y\beta(z_a-1)\underline{s}+(a\underline{s}+1)((y-1)\underline{s}-1)}{(a\underline{s}+1)(\underline{s}^2 + \underline{s})}")
-    s_num = st.text_input("s numerator", value="", key="s_num")
-    s_denom = st.text_input("s denominator", value="", key="s_denom")
+    # Apply the condition for y
+    y_effective = y if y > 1 else 1/y
+    
+    beta_points = np.linspace(beta_min, beta_max, n_points)
+    
+    # Collect all roots first
+    all_roots = []
+    discriminants = []
+    
+    # Progress indicator
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    for i, beta in enumerate(beta_points):
+        # Update progress
+        progress_bar.progress((i + 1) / n_points)
+        status_text.text(f"Computing roots for β = {beta:.3f} ({i+1}/{n_points})")
+        
+        # Calculate roots using SymPy
+        roots = compute_cubic_roots(z, beta, z_a, y)
+        
+        # Initial sorting to help with tracking
+        roots = sorted(roots, key=lambda x: (abs(x.imag), x.real))
+        all_roots.append(roots)
+        
+        # Calculate discriminant
+        disc = generate_cubic_discriminant(z, beta, z_a, y_effective)
+        discriminants.append(disc)
+    
+    # Clear progress indicators
+    progress_bar.empty()
+    status_text.empty()
+    
+    all_roots = np.array(all_roots)
+    discriminants = np.array(discriminants)
+    
+    # Track roots consistently across beta values
+    tracked_roots = track_roots_consistently(beta_points, all_roots)
+    
+    # Extract imaginary and real parts
+    ims = np.imag(tracked_roots)
+    res = np.real(tracked_roots)
+    
+    # Create figure for imaginary parts
+    fig_im = go.Figure()
+    for i in range(3):
+        fig_im.add_trace(go.Scatter(x=beta_points, y=ims[:, i], mode="lines", name=f"Im{{s{i+1}}}",
+                                    line=dict(width=2)))
+    
+    # Add vertical lines at discriminant zero crossings
+    disc_zeros = []
+    for i in range(len(discriminants)-1):
+        if discriminants[i] * discriminants[i+1] <= 0:  # Sign change
+            zero_pos = beta_points[i] + (beta_points[i+1] - beta_points[i]) * (0 - discriminants[i]) / (discriminants[i+1] - discriminants[i])
+            disc_zeros.append(zero_pos)
+            fig_im.add_vline(x=zero_pos, line=dict(color="red", width=1, dash="dash"))
+    
+    fig_im.update_layout(title=f"Im{{s}} vs. β (z={z:.3f}, y={y:.3f}, z_a={z_a:.3f})",
+                         xaxis_title="β", yaxis_title="Im{s}", hovermode="x unified")
 
-with st.expander("Custom Expression 2 (direct z(β))", expanded=False):
-    st.markdown("""Enter direct expression for z(β) = numerator/denominator 
-                (using variables `y`, `beta`, `z_a`, and `sqrt()`)""")
-    z_num = st.text_input("z(β) numerator", value="", key="z_num")
-    z_denom = st.text_input("z(β) denominator", value="", key="z_denom")
+    # Create figure for real parts
+    fig_re = go.Figure()
+    for i in range(3):
+        fig_re.add_trace(go.Scatter(x=beta_points, y=res[:, i], mode="lines", name=f"Re{{s{i+1}}}",
+                                    line=dict(width=2)))
+    
+    # Add vertical lines at discriminant zero crossings
+    for zero_pos in disc_zeros:
+        fig_re.add_vline(x=zero_pos, line=dict(color="red", width=1, dash="dash"))
+    
+    fig_re.update_layout(title=f"Re{{s}} vs. β (z={z:.3f}, y={y:.3f}, z_a={z_a:.3f})",
+                         xaxis_title="β", yaxis_title="Re{s}", hovermode="x unified")
+    
+    # Create discriminant plot
+    fig_disc = go.Figure()
+    fig_disc.add_trace(go.Scatter(x=beta_points, y=discriminants, mode="lines", 
+                                 name="Cubic Discriminant", line=dict(color="black", width=2)))
+    fig_disc.add_hline(y=0, line=dict(color="red", width=1, dash="dash"))
+    
+    fig_disc.update_layout(title=f"Cubic Discriminant vs. β (z={z:.3f}, y={y:.3f}, z_a={z_a:.3f})",
+                          xaxis_title="β", yaxis_title="Discriminant", hovermode="x unified")
+    
+    return fig_im, fig_re, fig_disc
 
-# Move show_derivatives to main UI level for better visibility
-with col2:
-    show_derivatives = st.checkbox("Show derivatives", value=False)
+def generate_phase_diagram(z_a, y, beta_min=0.0, beta_max=1.0, z_min=-10.0, z_max=10.0, 
+                          beta_steps=100, z_steps=100):
+    """
+    Generate a phase diagram showing regions of complex and real roots.
+    
+    Returns a heatmap where:
+    - Value 1 (red): Region with all real roots
+    - Value -1 (blue): Region with complex roots
+    """
+    # Apply the condition for y
+    y_effective = y if y > 1 else 1/y
+    
+    beta_values = np.linspace(beta_min, beta_max, beta_steps)
+    z_values = np.linspace(z_min, z_max, z_steps)
+    
+    # Initialize phase map
+    phase_map = np.zeros((z_steps, beta_steps))
+    
+    # Progress tracking
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    for i, z in enumerate(z_values):
+        # Update progress
+        progress_bar.progress((i + 1) / len(z_values))
+        status_text.text(f"Analyzing phase at z = {z:.2f} ({i+1}/{len(z_values)})")
+        
+        for j, beta in enumerate(beta_values):
+            roots = compute_cubic_roots(z, beta, z_a, y)
+            
+            # Check if all roots are real (imaginary parts close to zero)
+            is_all_real = all(abs(root.imag) < 1e-10 for root in roots)
+            
+            phase_map[i, j] = 1 if is_all_real else -1
+    
+    # Clear progress indicators
+    progress_bar.empty()
+    status_text.empty()
+    
+    # Create heatmap
+    fig = go.Figure(data=go.Heatmap(
+        z=phase_map,
+        x=beta_values,
+        y=z_values,
+        colorscale=[[0, 'blue'], [0.5, 'white'], [1.0, 'red']],
+        zmin=-1,
+        zmax=1,
+        showscale=True,
+        colorbar=dict(
+            title="Root Type",
+            tickvals=[-1, 1],
+            ticktext=["Complex Roots", "All Real Roots"]
+        )
+    ))
+    
+    fig.update_layout(
+        title=f"Phase Diagram: Root Structure (y={y:.3f}, z_a={z_a:.3f})",
+        xaxis_title="β",
+        yaxis_title="z",
+        hovermode="closest"
+    )
+    
+    return fig
 
-# Compute button
-if st.button("Compute Curves", key="tab1_button"):
-    with col3:
-        use_eigenvalue_method = (method_type == "Eigenvalue Method")
-        if use_eigenvalue_method:
-            fig = generate_z_vs_beta_plot(z_a_1, y_1, z_min_1, z_max_1, beta_steps, None,
-                                        s_num, s_denom, z_num, z_denom, show_derivatives, 
-                                        show_high_y, show_low_y, show_max_k, show_min_t,
-                                        use_eigenvalue_method=True, n_samples=n_samples, 
-                                        seeds=seeds)
+@st.cache_data
+def generate_eigenvalue_distribution(beta, y, z_a, n=1000, seed=42):
+    """
+    Generate the eigenvalue distribution of B_n = S_n T_n as n→∞
+    """
+    # Apply the condition for y
+    y_effective = y if y > 1 else 1/y
+    
+    # Set random seed
+    np.random.seed(seed)
+    
+    # Compute dimension p based on aspect ratio y
+    p = int(y_effective * n)
+    
+    # Constructing T_n (Population / Shape Matrix) - using the approach from the second script
+    k = int(np.floor(beta * p))
+    diag_entries = np.concatenate([
+        np.full(k, z_a),
+        np.full(p - k, 1.0)
+    ])
+    np.random.shuffle(diag_entries)
+    T_n = np.diag(diag_entries)
+    
+    # Generate the data matrix X with i.i.d. standard normal entries
+    X = np.random.randn(p, n)
+    
+    # Compute the sample covariance matrix S_n = (1/n) * XX^T
+    S_n = (1 / n) * (X @ X.T)
+    
+    # Compute B_n = S_n T_n
+    B_n = S_n @ T_n
+    
+    # Compute eigenvalues of B_n
+    eigenvalues = np.linalg.eigvalsh(B_n)
+    
+    # Use KDE to compute a smooth density estimate
+    kde = gaussian_kde(eigenvalues)
+    x_vals = np.linspace(min(eigenvalues), max(eigenvalues), 500)
+    kde_vals = kde(x_vals)
+    
+    # Create figure
+    fig = go.Figure()
+    
+    # Add histogram trace
+    fig.add_trace(go.Histogram(x=eigenvalues, histnorm='probability density', 
+                              name="Histogram", marker=dict(color='blue', opacity=0.6)))
+    
+    # Add KDE trace
+    fig.add_trace(go.Scatter(x=x_vals, y=kde_vals, mode="lines", 
+                            name="KDE", line=dict(color='red', width=2)))
+    
+    fig.update_layout(
+        title=f"Eigenvalue Distribution for B_n = S_n T_n (y={y:.1f}, β={beta:.2f}, a={z_a:.1f})",
+        xaxis_title="Eigenvalue",
+        yaxis_title="Density",
+        hovermode="closest",
+        showlegend=True
+    )
+    
+    return fig, eigenvalues
+
+# ----------------- Streamlit UI -----------------
+st.title("Cubic Root Analysis")
+
+# Define three tabs
+tab1, tab2, tab3 = st.tabs(["z*(β) Curves", "Complex Root Analysis", "Differential Analysis"])
+
+# ----- Tab 1: z*(β) Curves -----
+with tab1:
+    st.header("Eigenvalue Support Boundaries")
+    
+    # Cleaner layout with better column organization
+    col1, col2, col3 = st.columns([1, 1, 2])
+    
+    with col1:
+        z_a_1 = st.number_input("z_a", value=1.0, key="z_a_1")
+        y_1 = st.number_input("y", value=1.0, key="y_1")
+        
+    with col2:
+        z_min_1 = st.number_input("z_min", value=-10.0, key="z_min_1")
+        z_max_1 = st.number_input("z_max", value=10.0, key="z_max_1")
+    
+    with col1:
+        method_type = st.radio(
+            "Calculation Method",
+            ["Eigenvalue Method", "Discriminant Method"],
+            index=0  # Default to eigenvalue method
+        )
+    
+    # Advanced settings in collapsed expanders
+    with st.expander("Method Settings", expanded=False):
+        if method_type == "Eigenvalue Method":
+            beta_steps = st.slider("β steps", min_value=21, max_value=101, value=51, step=10, 
+                                  key="beta_steps_eigen")
+            n_samples = st.slider("Matrix size (n)", min_value=100, max_value=2000, value=1000, 
+                                step=100)
+            seeds = st.slider("Number of seeds", min_value=1, max_value=10, value=5, step=1)
         else:
-            fig = generate_z_vs_beta_plot(z_a_1, y_1, z_min_1, z_max_1, beta_steps, z_steps,
-                                        s_num, s_denom, z_num, z_denom, show_derivatives,
-                                        show_high_y, show_low_y, show_max_k, show_min_t,
-                                        use_eigenvalue_method=False)
+            beta_steps = st.slider("β steps", min_value=51, max_value=501, value=201, step=50, 
+                                  key="beta_steps")
+            z_steps = st.slider("z grid steps", min_value=1000, max_value=100000, value=50000, 
+                              step=1000, key="z_steps")
+    
+    # Curve visibility options
+    with st.expander("Curve Visibility", expanded=False):
+        col_vis1, col_vis2 = st.columns(2)
+        with col_vis1:
+            show_high_y = st.checkbox("Show High y Expression", value=False, key="show_high_y")
+            show_max_k = st.checkbox("Show Max k Expression", value=True, key="show_max_k")
+        with col_vis2:
+            show_low_y = st.checkbox("Show Low y Expression", value=False, key="show_low_y")
+            show_min_t = st.checkbox("Show Min t Expression", value=True, key="show_min_t")
+    
+    # Custom expressions collapsed by default
+    with st.expander("Custom Expression 1 (s-based)", expanded=False):
+        st.markdown("""Enter expressions for s = numerator/denominator 
+                    (using variables `y`, `beta`, `z_a`, and `sqrt()`)""")
+        st.latex(r"\text{This s will be inserted into:}")
+        st.latex(r"\frac{y\beta(z_a-1)\underline{s}+(a\underline{s}+1)((y-1)\underline{s}-1)}{(a\underline{s}+1)(\underline{s}^2 + \underline{s})}")
+        s_num = st.text_input("s numerator", value="", key="s_num")
+        s_denom = st.text_input("s denominator", value="", key="s_denom")
+
+    with st.expander("Custom Expression 2 (direct z(β))", expanded=False):
+        st.markdown("""Enter direct expression for z(β) = numerator/denominator 
+                    (using variables `y`, `beta`, `z_a`, and `sqrt()`)""")
+        z_num = st.text_input("z(β) numerator", value="", key="z_num")
+        z_denom = st.text_input("z(β) denominator", value="", key="z_denom")
+
+    # Move show_derivatives to main UI level for better visibility
+    with col2:
+        show_derivatives = st.checkbox("Show derivatives", value=False)
+
+    # Compute button
+    if st.button("Compute Curves", key="tab1_button"):
+        with col3:
+            use_eigenvalue_method = (method_type == "Eigenvalue Method")
+            if use_eigenvalue_method:
+                fig = generate_z_vs_beta_plot(z_a_1, y_1, z_min_1, z_max_1, beta_steps, None,
+                                            s_num, s_denom, z_num, z_denom, show_derivatives, 
+                                            show_high_y, show_low_y, show_max_k, show_min_t,
+                                            use_eigenvalue_method=True, n_samples=n_samples, 
+                                            seeds=seeds)
+            else:
+                fig = generate_z_vs_beta_plot(z_a_1, y_1, z_min_1, z_max_1, beta_steps, z_steps,
+                                            s_num, s_denom, z_num, z_denom, show_derivatives,
+                                            show_high_y, show_low_y, show_max_k, show_min_t,
+                                            use_eigenvalue_method=False)
+            
+            if fig is not None:
+                st.plotly_chart(fig, use_container_width=True)
+                
+                # Curve explanations in collapsed expander
+                with st.expander("Curve Explanations", expanded=False):
+                    if use_eigenvalue_method:
+                        st.markdown("""
+                        - **Upper/Lower Bounds** (Blue): Maximum/minimum eigenvalues of B_n = S_n T_n
+                        - **Shaded Region**: Eigenvalue support region
+                        - **High y Expression** (Green): Asymptotic approximation for high y values
+                        - **Low Expression** (Orange): Alternative asymptotic expression
+                        - **Max k Expression** (Red): $\\max_{k \\in (0,\\infty)} \\frac{y\\beta (a-1)k + \\bigl(ak+1\\bigr)\\bigl((y-1)k-1\\bigr)}{(ak+1)(k^2+k)}$
+                        - **Min t Expression** (Purple): $\\min_{t \\in \\left(-\\frac{1}{a},\\, 0\\right)} \\frac{y\\beta (a-1)t + \\bigl(at+1\\bigr)\\bigl((y-1)t-1\\bigr)}{(at+1)(t^2+t)}$
+                        - **Custom Expression 1** (Magenta): Result from user-defined s substituted into the main formula
+                        - **Custom Expression 2** (Brown): Direct z(β) expression
+                        """)
+                    else:
+                        st.markdown("""
+                        - **Upper z*(β)** (Blue): Maximum z value where discriminant is zero
+                        - **Lower z*(β)** (Blue): Minimum z value where discriminant is zero
+                        - **High y Expression** (Green): Asymptotic approximation for high y values
+                        - **Low Expression** (Orange): Alternative asymptotic expression
+                        - **Max k Expression** (Red): $\\max_{k \\in (0,\\infty)} \\frac{y\\beta (a-1)k + \\bigl(ak+1\\bigr)\\bigl((y-1)k-1\\bigr)}{(ak+1)(k^2+k)}$
+                        - **Min t Expression** (Purple): $\\min_{t \\in \\left(-\\frac{1}{a},\\, 0\\right)} \\frac{y\\beta (a-1)t + \\bigl(at+1\\bigr)\\bigl((y-1)t-1\\bigr)}{(at+1)(t^2+t)}$
+                        - **Custom Expression 1** (Magenta): Result from user-defined s substituted into the main formula
+                        - **Custom Expression 2** (Brown): Direct z(β) expression
+                        """)
+                    if show_derivatives:
+                        st.markdown("""
+                        Derivatives are shown as:
+                        - Dashed lines: First derivatives (d/dβ)
+                        - Dotted lines: Second derivatives (d²/dβ²)
+                        """)
+
+# ----- Tab 2: Complex Root Analysis -----
+with tab2:
+    st.header("Complex Root Analysis")
+    
+    # Create tabs within the page for different plots
+    plot_tabs = st.tabs(["Im{s} vs. z", "Im{s} vs. β", "Phase Diagram", "Eigenvalue Distribution"])
+    
+    # Tab for Im{s} vs. z plot
+    with plot_tabs[0]:
+        col1, col2 = st.columns([1, 2])
+        with col1:
+            beta_z = st.number_input("β", value=0.5, min_value=0.0, max_value=1.0, key="beta_tab2_z")
+            y_z = st.number_input("y", value=1.0, key="y_tab2_z")
+            z_a_z = st.number_input("z_a", value=1.0, key="z_a_tab2_z")
+            z_min_z = st.number_input("z_min", value=-10.0, key="z_min_tab2_z")
+            z_max_z = st.number_input("z_max", value=10.0, key="z_max_tab2_z")
+            with st.expander("Resolution Settings", expanded=False):
+                z_points = st.slider("z grid points", min_value=100, max_value=2000, value=500, step=100, key="z_points_z")
+        if st.button("Compute Complex Roots vs. z", key="tab2_button_z"):
+            with col2:
+                fig_im, fig_re, fig_disc = generate_root_plots(beta_z, y_z, z_a_z, z_min_z, z_max_z, z_points)
+                if fig_im is not None and fig_re is not None and fig_disc is not None:
+                    st.plotly_chart(fig_im, use_container_width=True)
+                    st.plotly_chart(fig_re, use_container_width=True)
+                    st.plotly_chart(fig_disc, use_container_width=True)
+                    
+                    with st.expander("Root Structure Analysis", expanded=False):
+                        st.markdown("""
+                        ### Root Structure Explanation
+                        
+                        The red dashed vertical lines mark the points where the cubic discriminant equals zero.
+                        At these points, the cubic equation's root structure changes:
+                        
+                        - When the discriminant is positive, the cubic has three distinct real roots.
+                        - When the discriminant is negative, the cubic has one real root and two complex conjugate roots.
+                        - When the discriminant is exactly zero, the cubic has at least two equal roots.
+                        
+                        These transition points align perfectly with the z*(β) boundary curves from the first tab,
+                        which represent exactly these transitions in the (β,z) plane.
+                        """)
+
+    # New tab for Im{s} vs. β plot
+    with plot_tabs[1]:
+        col1, col2 = st.columns([1, 2])
+        with col1:
+            z_beta = st.number_input("z", value=1.0, key="z_tab2_beta")
+            y_beta = st.number_input("y", value=1.0, key="y_tab2_beta")
+            z_a_beta = st.number_input("z_a", value=1.0, key="z_a_tab2_beta")
+            beta_min = st.number_input("β_min", value=0.0, min_value=0.0, max_value=1.0, key="beta_min_tab2")
+            beta_max = st.number_input("β_max", value=1.0, min_value=0.0, max_value=1.0, key="beta_max_tab2")
+            with st.expander("Resolution Settings", expanded=False):
+                beta_points = st.slider("β grid points", min_value=100, max_value=1000, value=500, step=100, key="beta_points")
+        if st.button("Compute Complex Roots vs. β", key="tab2_button_beta"):
+            with col2:
+                fig_im_beta, fig_re_beta, fig_disc = generate_roots_vs_beta_plots(
+                    z_beta, y_beta, z_a_beta, beta_min, beta_max, beta_points)
+                
+                if fig_im_beta is not None and fig_re_beta is not None and fig_disc is not None:
+                    st.plotly_chart(fig_im_beta, use_container_width=True)
+                    st.plotly_chart(fig_re_beta, use_container_width=True)
+                    st.plotly_chart(fig_disc, use_container_width=True)
+                    
+                    # Add analysis of transition points
+                    transition_points, structure_types = analyze_complex_root_structure(
+                        np.linspace(beta_min, beta_max, beta_points), z_beta, z_a_beta, y_beta)
+                    
+                    if transition_points:
+                        st.subheader("Root Structure Transition Points")
+                        for i, beta in enumerate(transition_points):
+                            prev_type = structure_types[i]
+                            next_type = structure_types[i+1] if i+1 < len(structure_types) else "unknown"
+                            st.markdown(f"- At β = {beta:.6f}: Transition from {prev_type} roots to {next_type} roots")
+                    else:
+                        st.info("No transitions detected in root structure across this β range.")
+                    
+                    # Explanation
+                    with st.expander("Analysis Explanation", expanded=False):
+                        st.markdown("""
+                        ### Interpreting the Plots
+                        
+                        - **Im{s} vs. β**: Shows how the imaginary parts of the roots change with β. When all curves are at Im{s}=0, all roots are real.
+                        - **Re{s} vs. β**: Shows how the real parts of the roots change with β.
+                        - **Discriminant Plot**: The cubic discriminant changes sign at points where the root structure changes.
+                          - When discriminant < 0: The cubic has one real root and two complex conjugate roots.
+                          - When discriminant > 0: The cubic has three distinct real roots.
+                          - When discriminant = 0: The cubic has multiple roots (at least two roots are equal).
+                        
+                        The vertical red dashed lines mark the transition points where the root structure changes.
+                        """)
+    
+    # Tab for Phase Diagram
+    with plot_tabs[2]:
+        col1, col2 = st.columns([1, 2])
+        with col1:
+            z_a_phase = st.number_input("z_a", value=1.0, key="z_a_phase")
+            y_phase = st.number_input("y", value=1.0, key="y_phase")
+            beta_min_phase = st.number_input("β_min", value=0.0, min_value=0.0, max_value=1.0, key="beta_min_phase")
+            beta_max_phase = st.number_input("β_max", value=1.0, min_value=0.0, max_value=1.0, key="beta_max_phase")
+            z_min_phase = st.number_input("z_min", value=-10.0, key="z_min_phase")
+            z_max_phase = st.number_input("z_max", value=10.0, key="z_max_phase")
+            
+            with st.expander("Resolution Settings", expanded=False):
+                beta_steps_phase = st.slider("β grid points", min_value=20, max_value=200, value=100, step=20, key="beta_steps_phase")
+                z_steps_phase = st.slider("z grid points", min_value=20, max_value=200, value=100, step=20, key="z_steps_phase")
         
-        if fig is not None:
-            st.plotly_chart(fig, use_container_width=True)
+        if st.button("Generate Phase Diagram", key="tab2_button_phase"):
+            with col2:
+                st.info("Generating phase diagram. This may take a while depending on resolution...")
+                fig_phase = generate_phase_diagram(
+                    z_a_phase, y_phase, beta_min_phase, beta_max_phase, z_min_phase, z_max_phase, 
+                    beta_steps_phase, z_steps_phase)
+                
+                if fig_phase is not None:
+                    st.plotly_chart(fig_phase, use_container_width=True)
+                    
+                    with st.expander("Phase Diagram Explanation", expanded=False):
+                        st.markdown("""
+                        ### Understanding the Phase Diagram
+                        
+                        This heatmap shows the regions in the (β, z) plane where:
+                        
+                        - **Red Regions**: The cubic equation has all real roots
+                        - **Blue Regions**: The cubic equation has one real root and two complex conjugate roots
+                        
+                        The boundaries between these regions represent values where the discriminant is zero,
+                        which are the exact same curves as the z*(β) boundaries in the first tab. This phase
+                        diagram provides a comprehensive view of the eigenvalue support structure.
+                        """)
+
+    # Eigenvalue distribution tab
+    with plot_tabs[3]:
+        st.subheader("Eigenvalue Distribution for B_n = S_n T_n")
+        with st.expander("Simulation Information", expanded=False):
+            st.markdown("""
+            This simulation generates the eigenvalue distribution of B_n as n→∞, where:
+            - B_n = (1/n)XX^T with X being a p×n matrix
+            - p/n → y as n→∞
+            - The diagonal entries of T_n follow distribution β·δ(z_a) + (1-β)·δ(1)
+            """)
+        
+        col_eigen1, col_eigen2 = st.columns([1, 2])
+        with col_eigen1:
+            beta_eigen = st.number_input("β", value=0.5, min_value=0.0, max_value=1.0, key="beta_eigen")
+            y_eigen = st.number_input("y", value=1.0, key="y_eigen")
+            z_a_eigen = st.number_input("z_a", value=1.0, key="z_a_eigen")
+            n_samples = st.slider("Number of samples (n)", min_value=100, max_value=2000, value=1000, step=100)
+            sim_seed = st.number_input("Random seed", min_value=1, max_value=1000, value=42, step=1)
             
-            # Curve explanations in collapsed expander
-            with st.expander("Curve Explanations", expanded=False):
-                if use_eigenvalue_method:
-                    st.markdown("""
-                    - **Upper/Lower Bounds** (Blue): Maximum/minimum eigenvalues of B_n = S_n T_n
-                    - **Shaded Region**: Eigenvalue support region
-                    - **High y Expression** (Green): Asymptotic approximation for high y values
-                    - **Low Expression** (Orange): Alternative asymptotic expression
-                    - **Max k Expression** (Red): $\\max_{k \\in (0,\\infty)} \\frac{y\\beta (a-1)k + \\bigl(ak+1\\bigr)\\bigl((y-1)k-1\\bigr)}{(ak+1)(k^2+k)}$
-                    - **Min t Expression** (Purple): $\\min_{t \\in \\left(-\\frac{1}{a},\\, 0\\right)} \\frac{y\\beta (a-1)t + \\bigl(at+1\\bigr)\\bigl((y-1)t-1\\bigr)}{(at+1)(t^2+t)}$
-                    - **Custom Expression 1** (Magenta): Result from user-defined s substituted into the main formula
-                    - **Custom Expression 2** (Brown): Direct z(β) expression
-                    """)
-                else:
-                    st.markdown("""
-                    - **Upper z*(β)** (Blue): Maximum z value where discriminant is zero
-                    - **Lower z*(β)** (Blue): Minimum z value where discriminant is zero
-                    - **High y Expression** (Green): Asymptotic approximation for high y values
-                    - **Low Expression** (Orange): Alternative asymptotic expression
-                    - **Max k Expression** (Red): $\\max_{k \\in (0,\\infty)} \\frac{y\\beta (a-1)k + \\bigl(ak+1\\bigr)\\bigl((y-1)k-1\\bigr)}{(ak+1)(k^2+k)}$
-                    - **Min t Expression** (Purple): $\\min_{t \\in \\left(-\\frac{1}{a},\\, 0\\right)} \\frac{y\\beta (a-1)t + \\bigl(at+1\\bigr)\\bigl((y-1)t-1\\bigr)}{(at+1)(t^2+t)}$
-                    - **Custom Expression 1** (Magenta): Result from user-defined s substituted into the main formula
-                    - **Custom Expression 2** (Brown): Direct z(β) expression
-                    """)
-                if show_derivatives:
-                    st.markdown("""
-                    Derivatives are shown as:
-                    - Dashed lines: First derivatives (d/dβ)
-                    - Dotted lines: Second derivatives (d²/dβ²)
-                    """)
+            # Add comparison option
+            show_theoretical = st.checkbox("Show theoretical boundaries", value=True)
+            show_empirical_stats = st.checkbox("Show empirical statistics", value=True)
+
+        if st.button("Generate Eigenvalue Distribution", key="tab2_eigen_button"):
+            with col_eigen2:
+                # Generate the eigenvalue distribution
+                fig_eigen, eigenvalues = generate_eigenvalue_distribution(beta_eigen, y_eigen, z_a_eigen, n=n_samples, seed=sim_seed)
+                
+                # If requested, compute and add theoretical boundaries
+                if show_theoretical:
+                    # Calculate min and max eigenvalues using the support boundary functions
+                    betas = np.array([beta_eigen])
+                    min_eig, max_eig = compute_eigenvalue_support_boundaries(z_a_eigen, y_eigen, betas, n_samples=n_samples, seeds=5)
+                    
+                    # Add vertical lines for boundaries
+                    fig_eigen.add_vline(
+                        x=min_eig[0], 
+                        line=dict(color="red", width=2, dash="dash"),
+                        annotation_text="Min theoretical",
+                        annotation_position="top right"
+                    )
+                    fig_eigen.add_vline(
+                        x=max_eig[0], 
+                        line=dict(color="red", width=2, dash="dash"),
+                        annotation_text="Max theoretical",
+                        annotation_position="top left"
+                    )
+                
+                # Display the plot
+                st.plotly_chart(fig_eigen, use_container_width=True)
+                
+                # Add comparison of empirical vs theoretical bounds
+                if show_theoretical and show_empirical_stats:
+                    empirical_min = eigenvalues.min()
+                    empirical_max = eigenvalues.max()
+                    
+                    st.markdown("### Comparison of Empirical vs Theoretical Bounds")
+                    col1, col2, col3 = st.columns(3)
+                    with col1:
+                        st.metric("Theoretical Min", f"{min_eig[0]:.4f}")
+                        st.metric("Theoretical Max", f"{max_eig[0]:.4f}")
+                        st.metric("Theoretical Width", f"{max_eig[0] - min_eig[0]:.4f}")
+                    with col2:
+                        st.metric("Empirical Min", f"{empirical_min:.4f}")
+                        st.metric("Empirical Max", f"{empirical_max:.4f}")
+                        st.metric("Empirical Width", f"{empirical_max - empirical_min:.4f}")
+                    with col3:
+                        st.metric("Min Difference", f"{empirical_min - min_eig[0]:.4f}")
+                        st.metric("Max Difference", f"{empirical_max - max_eig[0]:.4f}")
+                        st.metric("Width Difference", f"{(empirical_max - empirical_min) - (max_eig[0] - min_eig[0]):.4f}")
+                
+                # Display additional statistics
+                if show_empirical_stats:
+                    st.markdown("### Eigenvalue Statistics")
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.metric("Mean", f"{np.mean(eigenvalues):.4f}")
+                        st.metric("Median", f"{np.median(eigenvalues):.4f}")
+                    with col2:
+                        st.metric("Standard Deviation", f"{np.std(eigenvalues):.4f}")
+                        st.metric("Interquartile Range", f"{np.percentile(eigenvalues, 75) - np.percentile(eigenvalues, 25):.4f}")
 
-# Display C++ build status
-if cubic_cpp is None:
-    st.warning("C++ extension could not be built. Using Python implementation.")
-else:
-    st.success("C++ extension successfully built and loaded.")
+# ----- Tab 3: Differential Analysis -----
+with tab3:
+    st.header("Differential Analysis vs. β")
+    with st.expander("Description", expanded=False):
+        st.markdown("This page shows the difference between the Upper (blue) and Lower (lightblue) z*(β) curves, along with their first and second derivatives with respect to β.")
+    
+    col1, col2 = st.columns([1, 2])
+    with col1:
+        z_a_diff = st.number_input("z_a", value=1.0, key="z_a_diff")
+        y_diff = st.number_input("y", value=1.0, key="y_diff")
+        z_min_diff = st.number_input("z_min", value=-10.0, key="z_min_diff")
+        z_max_diff = st.number_input("z_max", value=10.0, key="z_max_diff")
+        
+        diff_method_type = st.radio(
+            "Boundary Calculation Method",
+            ["Eigenvalue Method", "Discriminant Method"],
+            index=0,
+            key="diff_method_type"
+        )
+        
+        with st.expander("Resolution Settings", expanded=False):
+            if diff_method_type == "Eigenvalue Method":
+                beta_steps_diff = st.slider("β steps", min_value=21, max_value=101, value=51, step=10, 
+                                         key="beta_steps_diff_eigen")
+                diff_n_samples = st.slider("Matrix size (n)", min_value=100, max_value=2000, value=1000, 
+                                        step=100, key="diff_n_samples")
+                diff_seeds = st.slider("Number of seeds", min_value=1, max_value=10, value=5, step=1,
+                                     key="diff_seeds")
+            else:
+                beta_steps_diff = st.slider("β steps", min_value=51, max_value=501, value=201, step=50, 
+                                         key="beta_steps_diff")
+                z_steps_diff = st.slider("z grid steps", min_value=1000, max_value=100000, value=50000, 
+                                      step=1000, key="z_steps_diff")
+        
+        # Add options for curve selection
+        st.subheader("Curves to Analyze")
+        analyze_upper_lower = st.checkbox("Upper-Lower Difference", value=True)
+        analyze_high_y = st.checkbox("High y Expression", value=False)
+        analyze_alt_low = st.checkbox("Low y Expression", value=False)
+
+    if st.button("Compute Differentials", key="tab3_button"):
+        with col2:
+            use_eigenvalue_method_diff = (diff_method_type == "Eigenvalue Method")
+            
+            if use_eigenvalue_method_diff:
+                betas_diff = np.linspace(0, 1, beta_steps_diff)
+                st.info("Computing eigenvalue support boundaries. This may take a moment...")
+                lower_vals, upper_vals = compute_eigenvalue_support_boundaries(
+                    z_a_diff, y_diff, betas_diff, diff_n_samples, diff_seeds)
+            else:
+                betas_diff, lower_vals, upper_vals = sweep_beta_and_find_z_bounds(
+                    z_a_diff, y_diff, z_min_diff, z_max_diff, beta_steps_diff, z_steps_diff)
+            
+            # Create figure
+            fig_diff = go.Figure()
+            
+            if analyze_upper_lower:
+                diff_curve = upper_vals - lower_vals
+                d1 = np.gradient(diff_curve, betas_diff)
+                d2 = np.gradient(d1, betas_diff)
+                
+                fig_diff.add_trace(go.Scatter(x=betas_diff, y=diff_curve, mode="lines", 
+                                name="Upper-Lower Difference", line=dict(color="magenta", width=2)))
+                fig_diff.add_trace(go.Scatter(x=betas_diff, y=d1, mode="lines", 
+                                name="Upper-Lower d/dβ", line=dict(color="magenta", dash='dash')))
+                fig_diff.add_trace(go.Scatter(x=betas_diff, y=d2, mode="lines", 
+                                name="Upper-Lower d²/dβ²", line=dict(color="magenta", dash='dot')))
+
+            if analyze_high_y:
+                high_y_curve = compute_high_y_curve(betas_diff, z_a_diff, y_diff)
+                d1 = np.gradient(high_y_curve, betas_diff)
+                d2 = np.gradient(d1, betas_diff)
+                
+                fig_diff.add_trace(go.Scatter(x=betas_diff, y=high_y_curve, mode="lines", 
+                                name="High y", line=dict(color="green", width=2)))
+                fig_diff.add_trace(go.Scatter(x=betas_diff, y=d1, mode="lines", 
+                                name="High y d/dβ", line=dict(color="green", dash='dash')))
+                fig_diff.add_trace(go.Scatter(x=betas_diff, y=d2, mode="lines", 
+                                name="High y d²/dβ²", line=dict(color="green", dash='dot')))
+
+            if analyze_alt_low:
+                alt_low_curve = compute_alternate_low_expr(betas_diff, z_a_diff, y_diff)
+                d1 = np.gradient(alt_low_curve, betas_diff)
+                d2 = np.gradient(d1, betas_diff)
+                
+                fig_diff.add_trace(go.Scatter(x=betas_diff, y=alt_low_curve, mode="lines", 
+                                name="Low y", line=dict(color="orange", width=2)))
+                fig_diff.add_trace(go.Scatter(x=betas_diff, y=d1, mode="lines", 
+                                name="Low y d/dβ", line=dict(color="orange", dash='dash')))
+                fig_diff.add_trace(go.Scatter(x=betas_diff, y=d2, mode="lines", 
+                                name="Low y d²/dβ²", line=dict(color="orange", dash='dot')))
+
+            fig_diff.update_layout(
+                title="Differential Analysis vs. β" + 
+                      (" (Eigenvalue Method)" if use_eigenvalue_method_diff else " (Discriminant Method)"),
+                xaxis_title="β",
+                yaxis_title="Value",
+                hovermode="x unified",
+                showlegend=True,
+                legend=dict(
+                    yanchor="top",
+                    y=0.99,
+                    xanchor="left",
+                    x=0.01
+                )
+            )
+            st.plotly_chart(fig_diff, use_container_width=True)
+            
+            with st.expander("Curve Types", expanded=False):
+                st.markdown("""
+                - Solid lines: Original curves
+                - Dashed lines: First derivatives (d/dβ)
+                - Dotted lines: Second derivatives (d²/dβ²)
+                """)