Update app.py

app.py

@@ -8,20 +8,62 @@ from PIL import Image
 import time
 import io
 
-# Set page config
+# Set page config with wider layout
 st.set_page_config(
-    page_title="Eigenvalue Analysis",
+    page_title="Eigenvalue Analysis Dashboard",
     page_icon="📊",
-    layout="wide"
+    layout="wide",
+    initial_sidebar_state="expanded"
 )
 
-# Title and description
-st.title("Eigenvalue Analysis Visualization")
+# Apply custom CSS for a dashboard-like appearance
 st.markdown("""
-This application visualizes eigenvalue analysis for matrices with specific properties.
-Adjust the parameters below to generate a plot showing the relationship between empirical
-and theoretical eigenvalues.
-""")
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        color: #1E88E5;
+        text-align: center;
+        margin-bottom: 1rem;
+        padding-bottom: 1rem;
+        border-bottom: 2px solid #f0f0f0;
+    }
+    .dashboard-container {
+        background-color: #f9f9f9;
+        padding: 1.5rem;
+        border-radius: 10px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+        margin-bottom: 1.5rem;
+    }
+    .panel-header {
+        font-size: 1.3rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+        color: #424242;
+        border-left: 4px solid #1E88E5;
+        padding-left: 10px;
+    }
+    .stats-card {
+        background-color: white;
+        padding: 1rem;
+        border-radius: 8px;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+        text-align: center;
+    }
+    .stats-value {
+        font-size: 1.8rem;
+        font-weight: bold;
+        color: #1E88E5;
+    }
+    .stats-label {
+        font-size: 0.9rem;
+        color: #616161;
+        margin-top: 0.3rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Dashboard Header
+st.markdown('<h1 class="main-header">Eigenvalue Analysis Dashboard</h1>', unsafe_allow_html=True)
 
 # Create output directory in the current working directory
 current_dir = os.getcwd()
@@ -32,287 +74,357 @@ os.makedirs(output_dir, exist_ok=True)
 cpp_file = os.path.join(current_dir, "app.cpp")
 executable = os.path.join(current_dir, "eigen_analysis")
 
-# Check if cpp file exists
-if not os.path.exists(cpp_file):
-    st.error(f"C++ source file not found at: {cpp_file}")
-    st.stop()
+# Two-column layout for the dashboard
+left_column, right_column = st.columns([1, 3])
 
-# Compile the C++ code with the right OpenCV libraries
-try:
-    st.info("Compiling C++ code...")
-    compile_commands = [
-        f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv4` -std=c++11",
-        f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv` -std=c++11",
-        f"g++ -o {executable} {cpp_file} -I/usr/include/opencv4 -lopencv_core -lopencv_imgproc -std=c++11"
-    ]
-    
-    compiled = False
-    for cmd in compile_commands:
-        compile_result = subprocess.run(
-            cmd, 
-            shell=True,
-            capture_output=True,
-            text=True
-        )
-        
-        if compile_result.returncode == 0:
-            compiled = True
-            break
+with left_column:
+    st.markdown('<div class="dashboard-container">', unsafe_allow_html=True)
+    st.markdown('<div class="panel-header">Control Panel</div>', unsafe_allow_html=True)
     
-    if not compiled:
-        st.error("All compilation attempts failed. Please check the system requirements.")
+    # Check if cpp file exists and compile if necessary
+    if not os.path.exists(cpp_file):
+        st.error(f"C++ source file not found at: {cpp_file}")
         st.stop()
     
-    # Make sure the executable is executable
-    os.chmod(executable, 0o755)
-    st.success("C++ code compiled successfully")
-    
-except Exception as e:
-    st.error(f"Error during compilation: {str(e)}")
-    st.stop()
-
-# Input parameters sidebar
-st.sidebar.header("Parameters")
-
-# Parameter inputs with defaults and validation
-n = st.sidebar.number_input("Sample size (n)", min_value=5, max_value=100000, value=100, step=5, help="Number of samples")
-p = st.sidebar.number_input("Dimension (p)", min_value=5, max_value=1000000, value=50, step=5, help="Dimensionality")
-a = st.sidebar.number_input("Value for a", min_value=1.1, max_value=10.0, value=2.0, step=0.1, help="Parameter a > 1")
-
-# Automatically calculate y = p/n (as requested)
-y = p/n
-st.sidebar.text(f"Value for y = p/n: {y:.4f}")
-
-# Add fineness control
-st.sidebar.subheader("Calculation Controls")
-fineness = st.sidebar.slider(
-    "Beta points", 
-    min_value=20, 
-    max_value=500, 
-    value=100, 
-    step=10,
-    help="Number of points to calculate along the β axis (0 to 1)"
-)
-
-# Add controls for theoretical calculation precision
-theory_grid_points = st.sidebar.slider(
-    "Theoretical grid points", 
-    min_value=100, 
-    max_value=1000, 
-    value=200, 
-    step=50,
-    help="Number of points in initial grid search for theoretical calculations"
-)
-
-theory_tolerance = st.sidebar.number_input(
-    "Theoretical tolerance", 
-    min_value=1e-12, 
-    max_value=1e-6, 
-    value=1e-10, 
-    format="%.1e",
-    help="Convergence tolerance for golden section search"
-)
-
-# Generate button
-if st.sidebar.button("Generate Plot", type="primary"):
-    # Show progress
-    progress_bar = st.progress(0)
-    status_text = st.empty()
-    
-    try:
-        # Run the C++ executable with the parameters in JSON output mode
-        data_file = os.path.join(output_dir, "eigenvalue_data.json")
-        
-        # Delete previous output if exists
-        if os.path.exists(data_file):
-            os.remove(data_file)
-        
-        # Execute the C++ program
-        cmd = [
-            executable, 
-            str(n), 
-            str(p), 
-            str(a), 
-            str(y), 
-            str(fineness), 
-            str(theory_grid_points),
-            str(theory_tolerance),
-            data_file
-        ]
-        
-        process = subprocess.Popen(
-            cmd, 
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True
-        )
-        
-        # Show output in a status area
-        status_text.text("Starting calculations...")
-        
-        last_progress = 0
-        while process.poll() is None:
-            output = process.stdout.readline()
-            if output:
-                if output.startswith("PROGRESS:"):
-                    try:
-                        # Update progress bar
-                        progress_value = float(output.split(":")[1].strip())
-                        progress_bar.progress(progress_value)
-                        last_progress = progress_value
-                        status_text.text(f"Calculating... {int(progress_value * 100)}% complete")
-                    except:
-                        pass
-                else:
-                    status_text.text(output.strip())
-            time.sleep(0.1)
-        
-        return_code = process.poll()
-        
-        if return_code != 0:
-            error = process.stderr.read()
-            st.error(f"Error executing the analysis: {error}")
-        else:
-            progress_bar.progress(1.0)
-            status_text.text("Calculations complete! Generating plot...")
-            
-            # Load the results from the JSON file
-            with open(data_file, 'r') as f:
-                data = json.load(f)
-            
-            # Create a better plot with matplotlib
-            beta_values = np.array(data['beta_values'])
-            max_eigenvalues = np.array(data['max_eigenvalues'])
-            min_eigenvalues = np.array(data['min_eigenvalues'])
-            theoretical_max = np.array(data['theoretical_max'])
-            theoretical_min = np.array(data['theoretical_min'])
-            
-            # Create the plot
-            fig, ax = plt.subplots(figsize=(12, 9), dpi=100)
-            
-            # Set the background color
-            fig.patch.set_facecolor('#f5f5f5')
-            ax.set_facecolor('#f0f0f0')
-            
-            # Plot the data
-            ax.plot(beta_values, max_eigenvalues, 'r-', linewidth=2, 
-                    label='Empirical Max Eigenvalue', marker='o', markevery=len(beta_values)//20)
-            ax.plot(beta_values, min_eigenvalues, 'b-', linewidth=2, 
-                    label='Empirical Min Eigenvalue', marker='o', markevery=len(beta_values)//20)
-            ax.plot(beta_values, theoretical_max, 'g-', linewidth=2, 
-                    label='Theoretical Max Function', marker='D', markevery=len(beta_values)//20)
-            ax.plot(beta_values, theoretical_min, 'm-', linewidth=2, 
-                    label='Theoretical Min Function', marker='D', markevery=len(beta_values)//20)
-            
-            # Add grid
-            ax.grid(True, linestyle='--', alpha=0.7)
+    # Compile the C++ code with the right OpenCV libraries
+    if not os.path.exists(executable) or st.button("Recompile C++ Code"):
+        with st.spinner("Compiling C++ code..."):
+            compile_commands = [
+                f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv4` -std=c++11",
+                f"g++ -o {executable} {cpp_file} `pkg-config --cflags --libs opencv` -std=c++11",
+                f"g++ -o {executable} {cpp_file} -I/usr/include/opencv4 -lopencv_core -lopencv_imgproc -std=c++11"
+            ]
             
-            # Set labels and title
-            ax.set_xlabel('β', fontsize=14)
-            ax.set_ylabel('Eigenvalues', fontsize=14)
-            ax.set_title(f'Eigenvalue Analysis: n={n}, p={p}, a={a}, y={y:.4f}', fontsize=16)
-            
-            # Add legend
-            ax.legend(loc='best', fontsize=12, framealpha=0.9)
-            
-            # Add formulas as text
-            formula_text1 = r"Max Function: $\max_{k \in (0,\infty)} \frac{y\beta(a-1)k + (ak+1)((y-1)k-1)}{(ak+1)(k^2+k)}$"
-            formula_text2 = r"Min Function: $\min_{t \in (-1/a,0)} \frac{y\beta(a-1)t + (at+1)((y-1)t-1)}{(at+1)(t^2+t)}$"
-            
-            plt.figtext(0.02, 0.02, formula_text1, fontsize=10, color='green')
-            plt.figtext(0.55, 0.02, formula_text2, fontsize=10, color='purple')
-            
-            # Adjust layout
-            plt.tight_layout(rect=[0, 0.05, 1, 0.95])
-            
-            # Save the plot to a buffer
-            buf = io.BytesIO()
-            plt.savefig(buf, format='png', dpi=100)
-            buf.seek(0)
-            
-            # Save to file
-            output_file = os.path.join(output_dir, "eigenvalue_analysis.png")
-            plt.savefig(output_file, format='png', dpi=100)
-            plt.close()
-            
-            # Display the image in Streamlit
-            status_text.success("Analysis completed successfully!")
-            st.image(buf, use_column_width=True)
-            
-            # Provide download button
-            with open(output_file, "rb") as file:
-                btn = st.download_button(
-                    label="Download Plot",
-                    data=file,
-                    file_name=f"eigenvalue_analysis_n{n}_p{p}_a{a}_y{y:.4f}.png",
-                    mime="image/png"
+            compiled = False
+            for cmd in compile_commands:
+                compile_result = subprocess.run(
+                    cmd, 
+                    shell=True,
+                    capture_output=True,
+                    text=True
                 )
+                
+                if compile_result.returncode == 0:
+                    compiled = True
+                    break
             
-            # Add some statistics
-            st.subheader("Statistical Summary")
-            col1, col2 = st.columns(2)
+            if not compiled:
+                st.error("All compilation attempts failed. Please check the system requirements.")
+                st.stop()
             
-            with col1:
-                st.write("### Maximum Eigenvalues")
-                st.write(f"Empirical Max: {max(max_eigenvalues):.6f}")
-                st.write(f"Theoretical Max: {max(theoretical_max):.6f}")
-                st.write(f"Difference: {abs(max(max_eigenvalues) - max(theoretical_max)):.6f}")
-            
-            with col2:
-                st.write("### Minimum Eigenvalues")
-                st.write(f"Empirical Min: {min(min_eigenvalues):.6f}")
-                st.write(f"Theoretical Min: {min(theoretical_min):.6f}")
-                st.write(f"Difference: {abs(min(min_eigenvalues) - min(theoretical_min)):.6f}")
-            
-            # Display calculation settings
-            with st.expander("Calculation Settings"):
-                st.write(f"Beta points: {fineness}")
-                st.write(f"Theoretical grid points: {theory_grid_points}")
-                st.write(f"Theoretical tolerance: {theory_tolerance:.1e}")
-    
-    except Exception as e:
-        st.error(f"An error occurred: {str(e)}")
-
-# Show example plot on startup or previous results
-example_file = os.path.join(output_dir, "eigenvalue_analysis.png")
-if os.path.exists(example_file):
-    # Show the most recent plot by default
-    st.subheader("Current Plot")
-    img = Image.open(example_file)
-    st.image(img, use_column_width=True)
-else:
-    st.info("👈 Set parameters and click 'Generate Plot' to create a visualization.")
-
-# Add information about the analysis
-with st.expander("About Eigenvalue Analysis"):
-    st.markdown("""
-    ## Theory
+            # Make sure the executable is executable
+            os.chmod(executable, 0o755)
+            st.success("C++ code compiled successfully")
     
-    This application visualizes the relationship between empirical and theoretical eigenvalues for matrices with specific properties.
+    # Parameter inputs with defaults and validation
+    st.markdown("### Matrix Parameters")
+    n = st.number_input("Sample size (n)", min_value=5, max_value=1000, value=100, step=5, help="Number of samples")
+    p = st.number_input("Dimension (p)", min_value=5, max_value=1000, value=50, step=5, help="Dimensionality")
+    a = st.number_input("Value for a", min_value=1.1, max_value=10.0, value=2.0, step=0.1, help="Parameter a > 1")
     
-    The analysis examines:
+    # Automatically calculate y = p/n (as requested)
+    y = p/n
+    st.info(f"Value for y = p/n: {y:.4f}")
     
-    - **Empirical Max/Min Eigenvalues**: The maximum and minimum eigenvalues calculated from the generated matrices
-    - **Theoretical Max/Min Functions**: The theoretical bounds derived from mathematical analysis
+    st.markdown("### Calculation Controls")
+    fineness = st.slider(
+        "Beta points", 
+        min_value=20, 
+        max_value=500, 
+        value=100, 
+        step=10,
+        help="Number of points to calculate along the β axis (0 to 1)"
+    )
     
-    ### Key Parameters
+    with st.expander("Advanced Settings"):
+        # Add controls for theoretical calculation precision
+        theory_grid_points = st.slider(
+            "Theoretical grid points", 
+            min_value=100, 
+            max_value=1000, 
+            value=200, 
+            step=50,
+            help="Number of points in initial grid search for theoretical calculations"
+        )
+        
+        theory_tolerance = st.number_input(
+            "Theoretical tolerance", 
+            min_value=1e-12, 
+            max_value=1e-6, 
+            value=1e-10, 
+            format="%.1e",
+            help="Convergence tolerance for golden section search"
+        )
     
-    - **n**: Sample size
-    - **p**: Dimension
-    - **a**: Value > 1 that affects the distribution of eigenvalues
-    - **y**: Value calculated as p/n that affects scaling
+    # Generate button
+    generate_button = st.button("Generate Analysis", type="primary", use_container_width=True)
+    st.markdown('</div>', unsafe_allow_html=True)
     
-    ### Calculation Controls
+    # About section
+    with st.expander("About Eigenvalue Analysis"):
+        st.markdown("""
+        ## Theory
+        
+        This application visualizes the relationship between empirical and theoretical eigenvalues for matrices with specific properties.
+        
+        The analysis examines:
+        
+        - **Empirical Max/Min Eigenvalues**: The maximum and minimum eigenvalues calculated from the generated matrices
+        - **Theoretical Max/Min Functions**: The theoretical bounds derived from mathematical analysis
+        
+        ### Key Parameters
+        
+        - **n**: Sample size
+        - **p**: Dimension
+        - **a**: Value > 1 that affects the distribution of eigenvalues
+        - **y**: Value calculated as p/n that affects scaling
+        
+        ### Calculation Controls
+        
+        - **Beta points**: Number of points calculated along the β range (0 to 1)
+        - **Theoretical grid points**: Number of points in initial grid search for finding theoretical max/min
+        - **Theoretical tolerance**: Convergence tolerance for golden section search algorithm
+        
+        ### Mathematical Formulas
+        
+        Max Function: 
+        max{k ∈ (0,∞)} [yβ(a-1)k + (ak+1)((y-1)k-1)]/[(ak+1)(k²+k)]
+        
+        Min Function: 
+        min{t ∈ (-1/a,0)} [yβ(a-1)t + (at+1)((y-1)t-1)]/[(at+1)(t²+t)]
+        """)
+
+with right_column:
+    # Main visualization area
+    st.markdown('<div class="dashboard-container">', unsafe_allow_html=True)
+    st.markdown('<div class="panel-header">Eigenvalue Analysis Visualization</div>', unsafe_allow_html=True)
     
-    - **Beta points**: Number of points calculated along the β range (0 to 1)
-    - **Theoretical grid points**: Number of points in initial grid search for finding theoretical max/min
-    - **Theoretical tolerance**: Convergence tolerance for golden section search algorithm
+    # Container for the analysis results
+    results_container = st.container()
     
-    ### Mathematical Formulas
+    # Process when generate button is clicked
+    if generate_button:
+        with results_container:
+            # Show progress
+            progress_container = st.container()
+            with progress_container:
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+            
+            try:
+                # Run the C++ executable with the parameters in JSON output mode
+                data_file = os.path.join(output_dir, "eigenvalue_data.json")
+                
+                # Delete previous output if exists
+                if os.path.exists(data_file):
+                    os.remove(data_file)
+                
+                # Execute the C++ program
+                cmd = [
+                    executable, 
+                    str(n), 
+                    str(p), 
+                    str(a), 
+                    str(y), 
+                    str(fineness), 
+                    str(theory_grid_points),
+                    str(theory_tolerance),
+                    data_file
+                ]
+                
+                process = subprocess.Popen(
+                    cmd, 
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True
+                )
+                
+                # Show output in a status area
+                status_text.text("Starting calculations...")
+                
+                last_progress = 0
+                while process.poll() is None:
+                    output = process.stdout.readline()
+                    if output:
+                        if output.startswith("PROGRESS:"):
+                            try:
+                                # Update progress bar
+                                progress_value = float(output.split(":")[1].strip())
+                                progress_bar.progress(progress_value)
+                                last_progress = progress_value
+                                status_text.text(f"Calculating... {int(progress_value * 100)}% complete")
+                            except:
+                                pass
+                        else:
+                            status_text.text(output.strip())
+                    time.sleep(0.1)
+                
+                return_code = process.poll()
+                
+                if return_code != 0:
+                    error = process.stderr.read()
+                    st.error(f"Error executing the analysis: {error}")
+                else:
+                    progress_bar.progress(1.0)
+                    status_text.text("Calculations complete! Generating visualization...")
+                    
+                    # Load the results from the JSON file
+                    with open(data_file, 'r') as f:
+                        data = json.load(f)
+                    
+                    # Extract data
+                    beta_values = np.array(data['beta_values'])
+                    max_eigenvalues = np.array(data['max_eigenvalues'])
+                    min_eigenvalues = np.array(data['min_eigenvalues'])
+                    theoretical_max = np.array(data['theoretical_max'])
+                    theoretical_min = np.array(data['theoretical_min'])
+                    
+                    # Create the plot
+                    fig, ax = plt.subplots(figsize=(12, 8), dpi=100)
+                    
+                    # Set the background color
+                    fig.patch.set_facecolor('#f9f9f9')
+                    ax.set_facecolor('#f0f0f0')
+                    
+                    # Plot the data with improved styling
+                    ax.plot(beta_values, max_eigenvalues, 'r-', linewidth=2.5, 
+                            label='Empirical Max Eigenvalue', marker='o', markevery=len(beta_values)//20, markersize=6)
+                    ax.plot(beta_values, min_eigenvalues, 'b-', linewidth=2.5, 
+                            label='Empirical Min Eigenvalue', marker='o', markevery=len(beta_values)//20, markersize=6)
+                    ax.plot(beta_values, theoretical_max, 'g-', linewidth=2.5, 
+                            label='Theoretical Max Function', marker='D', markevery=len(beta_values)//20, markersize=6)
+                    ax.plot(beta_values, theoretical_min, 'm-', linewidth=2.5, 
+                            label='Theoretical Min Function', marker='D', markevery=len(beta_values)//20, markersize=6)
+                    
+                    # Add grid
+                    ax.grid(True, linestyle='--', alpha=0.7)
+                    
+                    # Set labels and title with better formatting
+                    ax.set_xlabel('β Parameter', fontsize=14, fontweight='bold')
+                    ax.set_ylabel('Eigenvalues', fontsize=14, fontweight='bold')
+                    ax.set_title(f'Eigenvalue Analysis: n={n}, p={p}, a={a}, y={y:.4f}', 
+                                 fontsize=16, fontweight='bold', pad=15)
+                    
+                    # Add legend with improved styling
+                    legend = ax.legend(loc='best', fontsize=12, framealpha=0.9, 
+                                      fancybox=True, shadow=True, borderpad=1)
+                    
+                    # Add formulas as text with better styling
+                    formula_text1 = r"Max Function: $\max_{k \in (0,\infty)} \frac{y\beta(a-1)k + (ak+1)((y-1)k-1)}{(ak+1)(k^2+k)}$"
+                    formula_text2 = r"Min Function: $\min_{t \in (-1/a,0)} \frac{y\beta(a-1)t + (at+1)((y-1)t-1)}{(at+1)(t^2+t)}$"
+                    
+                    plt.figtext(0.02, 0.02, formula_text1, fontsize=10, color='green', 
+                               bbox=dict(facecolor='white', alpha=0.8, edgecolor='green', boxstyle='round,pad=0.5'))
+                    plt.figtext(0.55, 0.02, formula_text2, fontsize=10, color='purple',
+                               bbox=dict(facecolor='white', alpha=0.8, edgecolor='purple', boxstyle='round,pad=0.5'))
+                    
+                    # Adjust layout
+                    plt.tight_layout(rect=[0, 0.05, 1, 0.95])
+                    
+                    # Save the plot to a buffer
+                    buf = io.BytesIO()
+                    plt.savefig(buf, format='png', dpi=100)
+                    buf.seek(0)
+                    
+                    # Save to file
+                    output_file = os.path.join(output_dir, "eigenvalue_analysis.png")
+                    plt.savefig(output_file, format='png', dpi=100)
+                    plt.close()
+                    
+                    # Clear progress container
+                    progress_container.empty()
+                    
+                    # Display the image in Streamlit (with fixed deprecated parameter)
+                    st.image(buf, use_container_width=True)
+                    
+                    # Provide download button
+                    col1, col2, col3 = st.columns([1, 2, 1])
+                    with col2:
+                        with open(output_file, "rb") as file:
+                            btn = st.download_button(
+                                label="Download Plot",
+                                data=file,
+                                file_name=f"eigenvalue_analysis_n{n}_p{p}_a{a}_y{y:.4f}.png",
+                                mime="image/png",
+                                use_container_width=True
+                            )
+                    
+                    # Add statistics section with cards
+                    st.markdown("### Results Summary")
+                    
+                    # Calculate key statistics
+                    emp_max = max(max_eigenvalues)
+                    emp_min = min(min_eigenvalues)
+                    theo_max = max(theoretical_max)
+                    theo_min = min(theoretical_min)
+                    max_diff = abs(emp_max - theo_max)
+                    min_diff = abs(emp_min - theo_min)
+                    
+                    # Display statistics in a card layout
+                    col1, col2, col3, col4 = st.columns(4)
+                    
+                    with col1:
+                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
+                        st.markdown(f'<div class="stats-value">{emp_max:.4f}</div>', unsafe_allow_html=True)
+                        st.markdown('<div class="stats-label">Empirical Maximum</div>', unsafe_allow_html=True)
+                        st.markdown('</div>', unsafe_allow_html=True)
+                    
+                    with col2:
+                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
+                        st.markdown(f'<div class="stats-value">{emp_min:.4f}</div>', unsafe_allow_html=True)
+                        st.markdown('<div class="stats-label">Empirical Minimum</div>', unsafe_allow_html=True)
+                        st.markdown('</div>', unsafe_allow_html=True)
+                    
+                    with col3:
+                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
+                        st.markdown(f'<div class="stats-value">{theo_max:.4f}</div>', unsafe_allow_html=True)
+                        st.markdown('<div class="stats-label">Theoretical Maximum</div>', unsafe_allow_html=True)
+                        st.markdown('</div>', unsafe_allow_html=True)
+                    
+                    with col4:
+                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
+                        st.markdown(f'<div class="stats-value">{theo_min:.4f}</div>', unsafe_allow_html=True)
+                        st.markdown('<div class="stats-label">Theoretical Minimum</div>', unsafe_allow_html=True)
+                        st.markdown('</div>', unsafe_allow_html=True)
+                    
+                    st.markdown("<br>", unsafe_allow_html=True)
+                    
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
+                        st.markdown(f'<div class="stats-value">{max_diff:.4f}</div>', unsafe_allow_html=True)
+                        st.markdown('<div class="stats-label">Max Difference</div>', unsafe_allow_html=True)
+                        st.markdown('</div>', unsafe_allow_html=True)
+                    
+                    with col2:
+                        st.markdown('<div class="stats-card">', unsafe_allow_html=True)
+                        st.markdown(f'<div class="stats-value">{min_diff:.4f}</div>', unsafe_allow_html=True)
+                        st.markdown('<div class="stats-label">Min Difference</div>', unsafe_allow_html=True)
+                        st.markdown('</div>', unsafe_allow_html=True)
+                    
+                    # Add calculation settings
+                    with st.expander("Calculation Details"):
+                        st.markdown(f"""
+                        - **Matrix Dimensions**: {n} × {p}
+                        - **Parameter a**: {a}
+                        - **Parameter y (p/n)**: {y:.4f}
+                        - **Beta points**: {fineness}
+                        - **Theoretical grid points**: {theory_grid_points}
+                        - **Theoretical tolerance**: {theory_tolerance:.1e}
+                        """)
+            
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
     
-    Max Function: 
-    max{k ∈ (0,∞)} [yβ(a-1)k + (ak+1)((y-1)k-1)]/[(ak+1)(k²+k)]
+    else:
+        # Check for existing results
+        example_file = os.path.join(output_dir, "eigenvalue_analysis.png")
+        if os.path.exists(example_file):
+            # Show the most recent plot by default
+            st.image(example_file, use_container_width=True)
+            st.info("This is the most recent analysis result. Adjust parameters and click 'Generate Analysis' to create a new visualization.")
+        else:
+            # Show placeholder
+            st.info("👈 Set parameters and click 'Generate Analysis' to create a visualization.")
     
-    Min Function: 
-    min{t ∈ (-1/a,0)} [yβ(a-1)t + (at+1)((y-1)t-1)]/[(at+1)(t²+t)]
-    """)
+    st.markdown('</div>', unsafe_allow_html=True)