Update app.py

app.py

@@ -6,13 +6,13 @@ from scipy.stats import norm, lognorm
 import seaborn as sns
 
 # Set matplotlib style for professional plots
-plt.style.use('default') # Using 'default' as specified
+plt.style.use('default')
 sns.set_palette("husl")
 
 class TVOGAnalysis:
     def __init__(self):
         self.reset_parameters()
-
+    
     def reset_parameters(self):
         """Reset to default parameters"""
         self.scenarios = 10000
@@ -21,61 +21,55 @@ class TVOGAnalysis:
         self.maturity = 10
         self.sum_assured = 500000
         self.policy_count = 100
-
+        
     def generate_random_numbers(self, scenarios, time_steps):
         """Generate standard normal random numbers"""
         np.random.seed(42)  # For reproducibility
         return np.random.standard_normal((scenarios, time_steps))
-
+    
     def simulate_account_values(self, initial_av, scenarios, time_steps):
         """Simulate account value paths using geometric Brownian motion"""
         dt = 1/12  # Monthly time steps
         rand_nums = self.generate_random_numbers(scenarios, time_steps)
-
+        
         # Initialize account value matrix
         av_paths = np.zeros((scenarios, time_steps + 1))
         av_paths[:, 0] = initial_av
-
+        
         # Simulate paths
         for t in range(time_steps):
             drift = (self.risk_free_rate - 0.5 * self.volatility**2) * dt
             diffusion = self.volatility * np.sqrt(dt) * rand_nums[:, t]
             av_paths[:, t+1] = av_paths[:, t] * np.exp(drift + diffusion)
-
+        
         return av_paths
-
+    
     def calculate_gmab_payouts(self, av_paths):
         """Calculate GMAB payouts at maturity"""
         final_av = av_paths[:, -1]
         guarantee = self.sum_assured * self.policy_count
         payouts = np.maximum(guarantee - final_av, 0)
-
+        
         # Present value of payouts
         discount_factor = np.exp(-self.risk_free_rate * self.maturity)
         pv_payouts = payouts * discount_factor
-
+        
         return pv_payouts, payouts
-
+    
     def black_scholes_put(self, S0, K, T, r, sigma):
         """Black-Scholes-Merton formula for European put option"""
-        if sigma <= 0 or T <= 0: # Avoid division by zero or log of non-positive
-            if K > S0 : # Intrinsic value if option is in the money at expiry (simplified)
-                 return K * np.exp(-r * T) - S0 # Simplified, could be just K - S0 for payout
-            else:
-                 return 0.0
-
         d1 = (np.log(S0/K) + (r + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
         d2 = d1 - sigma*np.sqrt(T)
-
+        
         put_price = K*np.exp(-r*T)*norm.cdf(-d2) - S0*norm.cdf(-d1)
         return put_price
 
 def create_dashboard():
     tvog = TVOGAnalysis()
-
-    def update_analysis(scenarios, risk_free_rate, volatility, maturity,
-                        sum_assured, policy_count, min_premium, max_premium, num_points):
-
+    
+    def update_analysis(scenarios, risk_free_rate, volatility, maturity, 
+                       sum_assured, policy_count, min_premium, max_premium, num_points):
+        
         # Update parameters
         tvog.scenarios = int(scenarios)
         tvog.risk_free_rate = risk_free_rate
@@ -83,327 +77,297 @@ def create_dashboard():
         tvog.maturity = maturity
         tvog.sum_assured = sum_assured
         tvog.policy_count = policy_count
-
+        
         # Create model points with varying initial account values
         premiums = np.linspace(min_premium, max_premium, int(num_points))
-        initial_avs = premiums * policy_count # Assuming premium is total, not per policy for AV calc
-
+        initial_avs = premiums * policy_count
+        
         monte_carlo_results = []
         black_scholes_results = []
-
+        
         time_steps = int(maturity * 12)  # Monthly steps
-
-        for initial_av_point in initial_avs: # Changed initial_av to initial_av_point
+        
+        for initial_av in initial_avs:
             # Monte Carlo simulation
-            av_paths = tvog.simulate_account_values(initial_av_point, tvog.scenarios, time_steps)
+            av_paths = tvog.simulate_account_values(initial_av, tvog.scenarios, time_steps)
             pv_payouts, _ = tvog.calculate_gmab_payouts(av_paths)
             mc_tvog = np.mean(pv_payouts)
             monte_carlo_results.append(mc_tvog)
-
+            
             # Black-Scholes-Merton
-            # S0 for BSM is the total initial account value for the block of policies
-            # K is the total guarantee for the block of policies
-            total_initial_av = initial_av_point # This is already total for the policies based on premium * policy_count
-            total_guarantee = sum_assured * policy_count
-
-            bs_tvog = tvog.black_scholes_put(total_initial_av, total_guarantee, maturity,
-                                            risk_free_rate, volatility)
+            guarantee = sum_assured * policy_count
+            bs_tvog = tvog.black_scholes_put(initial_av, guarantee, maturity, 
+                                           risk_free_rate, volatility)
             black_scholes_results.append(bs_tvog)
-
+        
         # Create results DataFrame
-        # Ensure no division by zero for ratio
-        bs_array = np.array(black_scholes_results)
-        mc_array = np.array(monte_carlo_results)
-        ratio_mc_bs = np.divide(mc_array, bs_array, out=np.zeros_like(mc_array, dtype=float), where=bs_array!=0)
-
-
         results_df = pd.DataFrame({
             'Premium_per_Policy': premiums,
-            'Initial_Account_Value_Total': initial_avs,
-            'Monte_Carlo_TVOG_Total': monte_carlo_results,
-            'Black_Scholes_TVOG_Total': black_scholes_results,
-            'Ratio_MC_BS': ratio_mc_bs,
-            'Difference_MC_BS': mc_array - bs_array
+            'Initial_Account_Value': initial_avs,
+            'Monte_Carlo_TVOG': monte_carlo_results,
+            'Black_Scholes_TVOG': black_scholes_results,
+            'Ratio_MC_BS': np.array(monte_carlo_results) / np.array(black_scholes_results),
+            'Difference': np.array(monte_carlo_results) - np.array(black_scholes_results)
         })
-
-        # Select a representative initial AV for detailed plots (e.g., middle one)
-        representative_idx = len(initial_avs) // 2
-        representative_initial_av = initial_avs[representative_idx]
-
-
+        
         # Create plots
         fig1 = create_tvog_comparison_plot(results_df)
-        fig2 = create_sample_paths_plot(tvog, representative_initial_av, time_steps)
-        fig3 = create_distribution_plots(tvog, representative_initial_av, time_steps)
-        fig4 = create_convergence_plot(tvog, representative_initial_av, time_steps)
-
+        fig2 = create_sample_paths_plot(tvog, initial_avs[len(initial_avs)//2], time_steps)
+        fig3 = create_distribution_plots(tvog, initial_avs[len(initial_avs)//2], time_steps)
+        fig4 = create_convergence_plot(tvog, initial_avs[len(initial_avs)//2], time_steps)
+        
         return results_df, fig1, fig2, fig3, fig4
-
+    
     def create_tvog_comparison_plot(results_df):
         """Create TVOG comparison plot"""
         fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
-
+        
         # TVOG Comparison
-        ax1.scatter(results_df['Initial_Account_Value_Total'], results_df['Monte_Carlo_TVOG_Total'],
-                    s=50, alpha=0.7, label='Monte Carlo', color='blue')
-        ax1.scatter(results_df['Initial_Account_Value_Total'], results_df['Black_Scholes_TVOG_Total'],
-                    s=50, alpha=0.7, label='Black-Scholes-Merton', color='red')
-        ax1.set_xlabel('Initial Account Value (Total)')
-        ax1.set_ylabel('TVOG Value (Total)')
+        ax1.scatter(results_df['Initial_Account_Value'], results_df['Monte_Carlo_TVOG'], 
+                   s=50, alpha=0.7, label='Monte Carlo', color='blue')
+        ax1.scatter(results_df['Initial_Account_Value'], results_df['Black_Scholes_TVOG'], 
+                   s=50, alpha=0.7, label='Black-Scholes-Merton', color='red')
+        ax1.set_xlabel('Initial Account Value')
+        ax1.set_ylabel('TVOG Value')
         ax1.set_title('TVOG: Monte Carlo vs Black-Scholes-Merton')
         ax1.legend()
         ax1.grid(True, alpha=0.3)
-
+        
         # Ratio Plot
-        ax2.plot(results_df['Initial_Account_Value_Total'], results_df['Ratio_MC_BS'],
-                 'o-', color='green', markersize=6)
+        ax2.plot(results_df['Initial_Account_Value'], results_df['Ratio_MC_BS'], 
+                'o-', color='green', markersize=6)
         ax2.axhline(y=1, color='red', linestyle='--', alpha=0.7)
-        ax2.set_xlabel('Initial Account Value (Total)')
+        ax2.set_xlabel('Initial Account Value')
         ax2.set_ylabel('Monte Carlo / Black-Scholes Ratio')
         ax2.set_title('Convergence Ratio (MC/BS)')
         ax2.grid(True, alpha=0.3)
-
+        
         plt.tight_layout()
         return fig
-
-    def create_sample_paths_plot(tvog, initial_av_total, time_steps):
-        """Create sample simulation paths plot using total initial AV"""
+    
+    def create_sample_paths_plot(tvog, initial_av, time_steps):
+        """Create sample simulation paths plot"""
         sample_scenarios = min(100, tvog.scenarios)
-        # Simulate paths for the total block of policies
-        av_paths = tvog.simulate_account_values(initial_av_total, sample_scenarios, time_steps)
-
+        av_paths = tvog.simulate_account_values(initial_av, sample_scenarios, time_steps)
+        
         fig, ax = plt.subplots(1, 1, figsize=(12, 6))
+        
         time_axis = np.arange(time_steps + 1) / 12  # Convert to years
-
+        
         for i in range(sample_scenarios):
             ax.plot(time_axis, av_paths[i, :], alpha=0.3, linewidth=0.8)
-
+        
+        # Add mean path
         mean_path = np.mean(av_paths, axis=0)
         ax.plot(time_axis, mean_path, color='red', linewidth=3, label='Mean Path')
-
-        total_guarantee = tvog.sum_assured * tvog.policy_count
-        ax.axhline(y=total_guarantee, color='black', linestyle='--', linewidth=2,
-                   label=f'Total Guarantee Level ({total_guarantee:,.0f})')
-
+        
+        # Add guarantee line
+        guarantee = tvog.sum_assured * tvog.policy_count
+        ax.axhline(y=guarantee, color='black', linestyle='--', linewidth=2, 
+                  label=f'Guarantee Level ({guarantee:,.0f})')
+        
         ax.set_xlabel('Time (Years)')
-        ax.set_ylabel('Total Account Value')
-        ax.set_title(f'Sample Total Account Value Simulation Paths (n={sample_scenarios})')
+        ax.set_ylabel('Account Value')
+        ax.set_title(f'Sample Account Value Simulation Paths (n={sample_scenarios})')
         ax.legend()
         ax.grid(True, alpha=0.3)
-        plt.tight_layout()
+        
         return fig
-
-    def create_distribution_plots(tvog, initial_av_total, time_steps):
-        """Create distribution analysis plots using total initial AV"""
-        # Simulate paths for the total block of policies
-        av_paths = tvog.simulate_account_values(initial_av_total, tvog.scenarios, time_steps)
-        final_av_total = av_paths[:, -1]
-
-        pv_final_av_total = final_av_total * np.exp(-tvog.risk_free_rate * tvog.maturity)
-
+    
+    def create_distribution_plots(tvog, initial_av, time_steps):
+        """Create distribution analysis plots"""
+        av_paths = tvog.simulate_account_values(initial_av, tvog.scenarios, time_steps)
+        final_av = av_paths[:, -1]
+        
+        # Present value of final account values
+        pv_final_av = final_av * np.exp(-tvog.risk_free_rate * tvog.maturity)
+        
         fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
-
-        # Histogram of final total account values
-        ax1.hist(pv_final_av_total, bins=50, density=True, alpha=0.7, color='skyblue')
-
-        S0_total = initial_av_total
+        
+        # Histogram of final account values
+        ax1.hist(pv_final_av, bins=50, density=True, alpha=0.7, color='skyblue')
+        
+        # Theoretical lognormal distribution
+        S0 = initial_av
         sigma = tvog.volatility
         T = tvog.maturity
-        r = tvog.risk_free_rate
-
-        # Theoretical lognormal distribution for total AV
-        # Mean and variance for log(ST)
-        log_mean = np.log(S0_total) + (r - 0.5 * sigma**2) * T
-        log_std = sigma * np.sqrt(T)
-
-        x_range = np.linspace(pv_final_av_total.min(), pv_final_av_total.max(), 1000)
-        theoretical_pdf = lognorm.pdf(x_range, s=log_std, scale=np.exp(log_mean)) # s is shape, loc is 0 by default
+        
+        x_range = np.linspace(pv_final_av.min(), pv_final_av.max(), 1000)
+        theoretical_pdf = lognorm.pdf(x_range, sigma * np.sqrt(T), scale=S0)
         ax1.plot(x_range, theoretical_pdf, 'r-', linewidth=2, label='Theoretical Lognormal')
-
-        ax1.axvline(x=S0_total, color='green', linestyle='--', label=f'Initial Total Value: {S0_total:,.0f}')
-        ax1.axvline(x=np.mean(pv_final_av_total), color='orange', linestyle='--',
-                    label=f'Simulated Mean PV: {np.mean(pv_final_av_total):,.0f}')
-
-        ax1.set_xlabel('Present Value of Final Total Account Value')
+        ax1.axvline(x=S0, color='green', linestyle='--', label=f'Initial Value: {S0:,.0f}')
+        ax1.axvline(x=np.mean(pv_final_av), color='orange', linestyle='--', 
+                   label=f'Simulated Mean: {np.mean(pv_final_av):,.0f}')
+        
+        ax1.set_xlabel('Present Value of Final Account Value')
         ax1.set_ylabel('Density')
-        ax1.set_title('Distribution of Final Total Account Values (PV)')
+        ax1.set_title('Distribution of Final Account Values')
         ax1.legend()
         ax1.grid(True, alpha=0.3)
-
-        # GMAB Payouts for the total block
-        pv_payouts_total, _ = tvog.calculate_gmab_payouts(av_paths) # Uses total guarantee internally
-        non_zero_payouts = pv_payouts_total[pv_payouts_total > 1e-6] # Use a small epsilon for float comparison
-
-        ax2.hist(pv_payouts_total, bins=50, alpha=0.7, color='lightcoral', label="All Scenarios")
-        if len(non_zero_payouts) > 0:
-             ax2.hist(non_zero_payouts, bins=50, alpha=0.8, color='red', label="Non-Zero Payouts")
-
-        ax2.set_xlabel('Total GMAB Payout (Present Value)')
+        
+        # GMAB Payouts
+        pv_payouts, _ = tvog.calculate_gmab_payouts(av_paths)
+        non_zero_payouts = pv_payouts[pv_payouts > 0]
+        
+        ax2.hist(pv_payouts, bins=50, alpha=0.7, color='lightcoral')
+        ax2.set_xlabel('GMAB Payout (Present Value)')
         ax2.set_ylabel('Frequency')
-        ax2.set_title(f'Total GMAB Payout Distribution\n({len(non_zero_payouts)} non-zero payouts)')
+        ax2.set_title(f'GMAB Payout Distribution\n({len(non_zero_payouts)} non-zero payouts)')
         ax2.grid(True, alpha=0.3)
-        ax2.legend()
-
-        stats_text = f'Mean Total Payout: {np.mean(pv_payouts_total):,.0f}\n'
-        stats_text += f'Max Total Payout: {np.max(pv_payouts_total):,.0f}\n'
-        stats_text += f'Payout Probability: {len(non_zero_payouts)/len(pv_payouts_total):.1%}'
-        ax2.text(0.95, 0.95, stats_text, transform=ax2.transAxes,
-                 verticalalignment='top', horizontalalignment='right',
-                 bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
-
+        
+        # Add statistics text
+        stats_text = f'Mean Payout: {np.mean(pv_payouts):,.0f}\n'
+        stats_text += f'Max Payout: {np.max(pv_payouts):,.0f}\n'
+        stats_text += f'Payout Probability: {len(non_zero_payouts)/len(pv_payouts):.1%}'
+        ax2.text(0.95, 0.95, stats_text, transform=ax2.transAxes, 
+                verticalalignment='top', horizontalalignment='right',
+                bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
+        
         plt.tight_layout()
         return fig
-
-    def create_convergence_plot(tvog, initial_av_total, time_steps):
-        """Create convergence analysis plot using total initial AV"""
-        scenario_counts = [100, 500, 1000, 2000, 5000, 10000, 20000] # Expanded
-        current_sim_scenarios = tvog.scenarios # Store original
-        if current_sim_scenarios not in scenario_counts:
-            scenario_counts.append(current_sim_scenarios)
+    
+    def create_convergence_plot(tvog, initial_av, time_steps):
+        """Create convergence analysis plot"""
+        # Test different numbers of scenarios
+        scenario_counts = [100, 500, 1000, 2000, 5000, 10000]
+        if tvog.scenarios not in scenario_counts:
+            scenario_counts.append(tvog.scenarios)
             scenario_counts.sort()
-
-        mc_results_total = []
-        total_guarantee = tvog.sum_assured * tvog.policy_count
-        bs_result_total = tvog.black_scholes_put(initial_av_total, total_guarantee, tvog.maturity,
-                                           tvog.risk_free_rate, tvog.volatility)
-
-        original_seed_state = np.random.get_state() # Save global random state
-
+        
+        mc_results = []
+        
+        guarantee = tvog.sum_assured * tvog.policy_count
+        bs_result = tvog.black_scholes_put(initial_av, guarantee, tvog.maturity, 
+                                         tvog.risk_free_rate, tvog.volatility)
+        
+        np.random.seed(42)  # For reproducible convergence
+        
         for n_scenarios in scenario_counts:
-            np.random.set_state(original_seed_state) # Reset seed for each n_scenarios run
-            # Temporarily set tvog.scenarios for this iteration for payout calc if it uses it
-            # However, simulate_account_values takes n_scenarios directly
-            av_paths = tvog.simulate_account_values(initial_av_total, n_scenarios, time_steps)
-            # calculate_gmab_payouts uses tvog.sum_assured and tvog.policy_count, which are fine
+            av_paths = tvog.simulate_account_values(initial_av, n_scenarios, time_steps)
             pv_payouts, _ = tvog.calculate_gmab_payouts(av_paths)
             mc_tvog = np.mean(pv_payouts)
-            mc_results_total.append(mc_tvog)
-
-        np.random.set_state(original_seed_state) # Restore global random state
-
+            mc_results.append(mc_tvog)
+        
         fig, ax = plt.subplots(1, 1, figsize=(10, 6))
-        ax.plot(scenario_counts, mc_results_total, 'bo-', markersize=8, linewidth=2,
-                label='Monte Carlo Results (Total)')
-        ax.axhline(y=bs_result_total, color='red', linestyle='--', linewidth=2,
-                   label=f'Black-Scholes Result (Total): {bs_result_total:,.0f}')
-
+        
+        ax.plot(scenario_counts, mc_results, 'bo-', markersize=8, linewidth=2, 
+               label='Monte Carlo Results')
+        ax.axhline(y=bs_result, color='red', linestyle='--', linewidth=2, 
+                  label=f'Black-Scholes Result: {bs_result:.0f}')
+        
         ax.set_xlabel('Number of Scenarios')
-        ax.set_ylabel('TVOG Value (Total)')
-        ax.set_title('Monte Carlo Convergence Analysis (Total)')
+        ax.set_ylabel('TVOG Value')
+        ax.set_title('Monte Carlo Convergence Analysis')
         ax.legend()
         ax.grid(True, alpha=0.3)
         ax.set_xscale('log')
-
-        if bs_result_total > 1e-6: # Avoid division by zero
-            final_error = abs(mc_results_total[-1] - bs_result_total) / bs_result_total * 100
-            ax.text(0.02, 0.98, f'Final Error: {final_error:.2f}%',
-                transform=ax.transAxes, verticalalignment='top',
-                bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
-        else:
-            ax.text(0.02, 0.98, f'BS Result near zero',
-                transform=ax.transAxes, verticalalignment='top',
-                bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
-
-        plt.tight_layout()
+        
+        # Add convergence statistics
+        final_error = abs(mc_results[-1] - bs_result) / bs_result * 100
+        ax.text(0.02, 0.98, f'Final Error: {final_error:.2f}%', 
+               transform=ax.transAxes, verticalalignment='top',
+               bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
+        
         return fig
-
+    
     # Create Gradio interface
-    with gr.Blocks(title="TVOG Analysis Dashboard") as app: # No theme specified to use default
+    with gr.Blocks(title="TVOG Analysis Dashboard") as app:
         gr.Markdown("""
         # Time Value of Options and Guarantees (TVOG) Analysis Dashboard
-
-        This dashboard compares Monte Carlo simulation results with Black-Scholes-Merton analytical solutions
+        
+        This dashboard compares Monte Carlo simulation results with Black-Scholes-Merton analytical solutions 
         for Variable Annuity products with Guaranteed Minimum Accumulation Benefits (GMAB).
-
+        
         **Target Users:** Actuaries, Finance Professionals, Economists, and Academics
         """)
-
+        
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Markdown("### Model Parameters")
-                scenarios_input = gr.Slider(
+                
+                scenarios = gr.Slider(
                     minimum=1000, maximum=50000, step=1000, value=10000,
                     label="Number of Monte Carlo Scenarios"
                 )
-                risk_free_rate_input = gr.Slider(
+                
+                risk_free_rate = gr.Slider(
                     minimum=0.001, maximum=0.1, step=0.001, value=0.02,
                     label="Risk-Free Rate (continuous)"
                 )
-                volatility_input = gr.Slider(
+                
+                volatility = gr.Slider(
                     minimum=0.01, maximum=0.5, step=0.01, value=0.03,
                     label="Volatility (σ)"
                 )
-                maturity_input = gr.Slider(
+                
+                maturity = gr.Slider(
                     minimum=1, maximum=30, step=1, value=10,
                     label="Maturity (years)"
                 )
+                
                 with gr.Row():
-                    sum_assured_input = gr.Number(
+                    sum_assured = gr.Number(
                         value=500000, label="Sum Assured per Policy"
                     )
-                    policy_count_input = gr.Number(
-                        value=100, label="Number of Policies", precision=0
+                    policy_count = gr.Number(
+                        value=100, label="Number of Policies"
                     )
-
-                gr.Markdown("### Model Point Range (Based on Premium per Policy)")
+                
+                gr.Markdown("### Model Point Range")
+                
                 with gr.Row():
-                    min_premium_input = gr.Number(
-                        value=3000, label="Min Premium per Policy" # Adjusted default
+                    min_premium = gr.Number(
+                        value=300000, label="Min Premium per Policy"
                     )
-                    max_premium_input = gr.Number(
-                        value=7000, label="Max Premium per Policy" # Adjusted default
+                    max_premium = gr.Number(
+                        value=500000, label="Max Premium per Policy"
                     )
-                num_points_input = gr.Slider(
+                
+                num_points = gr.Slider(
                     minimum=3, maximum=20, step=1, value=9,
                     label="Number of Model Points"
                 )
+                
                 calculate_btn = gr.Button("Run Analysis", variant="primary")
-
+            
             with gr.Column(scale=2):
                 gr.Markdown("### Results Summary")
-                results_table_display = gr.Dataframe(
-                    headers=["Premium per Policy", "Initial Account Value (Total)",
-                             "Monte Carlo TVOG (Total)", "Black-Scholes TVOG (Total)",
-                             "MC/BS Ratio", "Difference (MC-BS)"],
-                    label="TVOG Comparison Results",
-                    wrap=True
+                results_table = gr.Dataframe(
+                    headers=["Premium per Policy", "Initial Account Value", "Monte Carlo TVOG", 
+                            "Black-Scholes TVOG", "MC/BS Ratio", "Difference"],
+                    label="TVOG Comparison Results"
                 )
-        # Tabs for plots, placed after the row with inputs and summary table
-        with gr.Tabs():
-            with gr.TabItem("📈 TVOG Comparison"):
-                tvog_plot_display = gr.Plot(label="TVOG Comparison Analysis")
-            with gr.TabItem("📊 Sample Paths"):
-                paths_plot_display = gr.Plot(label="Sample Simulation Paths")
-            with gr.TabItem("📉 Distribution Analysis"):
-                dist_plot_display = gr.Plot(label="Distribution Analysis")
-            with gr.TabItem("⚙️ Monte Carlo Convergence"):
-                conv_plot_display = gr.Plot(label="Monte Carlo Convergence")
-
+        
+        with gr.Row():
+            tvog_plot = gr.Plot(label="TVOG Comparison Analysis")
+        
+        with gr.Row():
+            paths_plot = gr.Plot(label="Sample Simulation Paths")
+        
+        with gr.Row():
+            dist_plot = gr.Plot(label="Distribution Analysis")
+        
+        with gr.Row():
+            conv_plot = gr.Plot(label="Monte Carlo Convergence")
+        
         # Event handlers
-        inputs_list = [scenarios_input, risk_free_rate_input, volatility_input, maturity_input,
-                       sum_assured_input, policy_count_input, min_premium_input, max_premium_input,
-                       num_points_input]
-        outputs_list = [results_table_display, tvog_plot_display, paths_plot_display,
-                        dist_plot_display, conv_plot_display]
-
         calculate_btn.click(
             fn=update_analysis,
-            inputs=inputs_list,
-            outputs=outputs_list
+            inputs=[scenarios, risk_free_rate, volatility, maturity, 
+                   sum_assured, policy_count, min_premium, max_premium, num_points],
+            outputs=[results_table, tvog_plot, paths_plot, dist_plot, conv_plot]
         )
-
-        # Initial calculation on app load
+        
+        # Initial calculation
         app.load(
             fn=update_analysis,
-            inputs=inputs_list, # Use the same input components
-            outputs=outputs_list
+            inputs=[scenarios, risk_free_rate, volatility, maturity, 
+                   sum_assured, policy_count, min_premium, max_premium, num_points],
+            outputs=[results_table, tvog_plot, paths_plot, dist_plot, conv_plot]
         )
-        return app
+    
+    return app
 
 if __name__ == "__main__":
-    # Ensure that matplotlib does not try to use a GUI backend in environments where it's not available
-    import matplotlib
-    matplotlib.use('Agg') # Use a non-interactive backend like Agg
-
     app = create_dashboard()
     app.launch()