Update app.py

app.py

@@ -4,6 +4,12 @@ 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(
@@ -12,6 +18,539 @@ 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(')
@@ -44,6 +583,12 @@ 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
     
@@ -80,6 +625,13 @@ 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 = []
@@ -99,6 +651,13 @@ 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
     
@@ -166,6 +725,12 @@ 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
     
@@ -183,6 +748,12 @@ 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
     
@@ -194,6 +765,12 @@ 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
     
@@ -225,6 +802,12 @@ 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
     
@@ -488,905 +1071,126 @@ def generate_z_vs_beta_plot(z_a, y, z_min, z_max, beta_steps, z_steps,
     )
     return fig
 
-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)
-
-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
-
-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
-
-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()
-    
-    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")
-
-    # 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
-
-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
-
-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
-
-    # 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")
-
-    # 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
-
-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
-
-@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
+# Rest of your code for other functions and tabs...
+# [...]
 
-# ----------------- Streamlit UI -----------------
+# ----- Tab 1: z*(β) Curves -----
 st.title("Cubic Root Analysis")
+st.header("Eigenvalue Support Boundaries")
 
-# Define three tabs
-tab1, tab2, tab3 = st.tabs(["z*(β) Curves", "Complex Root Analysis", "Differential Analysis"])
+# Cleaner layout with better column organization
+col1, col2, col3 = st.columns([1, 1, 2])
 
-# ----- 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
-        )
+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")
     
-    # 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")
-    
-    # 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 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 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")
+with col1:
+    method_type = st.radio(
+        "Calculation Method",
+        ["Eigenvalue Method", "Discriminant Method"],
+        index=0  # Default to eigenvalue method
+    )
 
-    # Move show_derivatives to main UI level for better visibility
-    with col2:
-        show_derivatives = st.checkbox("Show derivatives", value=False)
+# 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")
 
-    # 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β²)
-                        """)
+# 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")
 
-# ----- 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.
-                        """)
+# 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")
 
-    # 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 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)
-            
-            # Add comparison option
-            show_theoretical = st.checkbox("Show theoretical boundaries", value=True)
-            show_empirical_stats = st.checkbox("Show empirical statistics", value=True)
+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")
 
-        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}")
+# Move show_derivatives to main UI level for better visibility
+with col2:
+    show_derivatives = st.checkbox("Show derivatives", value=False)
 
-# ----- 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")
+# 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)
         
-        # 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)
+        if fig is not None:
+            st.plotly_chart(fig, use_container_width=True)
             
-            # 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')))
+            # 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β²)
+                    """)
 
-            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β²)
-                """)
+# 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.")