Problem: enhance and formulate the interface uiux and the results of Portfolio vs Portfolio and Portfolio vs Benchmark
make sure you return the full updated code segemnts to me
### Code Segments for Portfolio vs Portfolio and Portfolio vs Benchmark

#### 1. **Function: `run_portfolio_comparison`**
   - **File:** `portfolio_optimizer.py`
   - **Relevance:** This function is central to running comparisons between portfolios and benchmarks. It handles the logic for both "Portfolio vs Benchmark" and "Portfolio vs Portfolio" comparisons, ensuring that the relevant data is processed and metrics are calculated.
   - **Code Segment:**
     ```python
     @handle_exceptions
     def run_portfolio_comparison(comparison_type, portfolio1, portfolio2=None):
         """
         Generalized function to run portfolio comparisons.

         Parameters:
         - comparison_type (str): "vs_benchmark" or "vs_portfolio"
         - portfolio1 (dict): Primary portfolio.
         - portfolio2 (dict, optional): Secondary portfolio for "vs_portfolio".

         Returns:
         - dict: Backtest results or error.
         """
         try:
             if comparison_type == "vs_benchmark":
                 # Handle primary portfolio data
                 available, missing, price_data = handle_portfolio_data(portfolio1)
                 if not available:
                     return {"error": "No valid tickers with available data."}
                 
                 # Adjust allocations based on available tickers
                 allocations = adjust_allocations([portfolio1['allocations'][portfolio1['selected'].index(t)] for t in available])
                 
                 # Perform backtest for the portfolio
                 returns, cum_returns = backtest(
                     weights=np.array(allocations) / 100,
                     prices=price_data[available],
                     rebalance_freq=portfolio1['rebalance_freq'],
                     broker_fee=portfolio1['broker_fee']
                 )
                 if cum_returns.empty:
                     return {"error": "Cumulative returns are empty."}
                 
                 # Download benchmark data
                 benchmark_data = download_data(
                     [portfolio1['benchmark_symbol']],
                     portfolio1['start_date'].strftime('%Y-%m-%d'),
                     portfolio1['end_date'].strftime('%Y-%m-%d')
                 )
                 if benchmark_data.empty:
                     return {"error": "Benchmark data could not be downloaded."}
                 
                 # Process benchmark data and handle potential errors
                 try:
                     benchmark_returns, benchmark_cum_returns, benchmark_metrics = process_benchmark(benchmark_data, returns, portfolio1)
                 except ValueError as ve:
                     return {"error": str(ve)}
                 except Exception as e:
                     return {"error": f"Benchmark processing failed: {e}"}
                 
                 # Calculate metrics for the portfolio without benchmark comparison
                 portfolio_metrics = calculate_metrics(returns, cum_returns, portfolio1['rf_rate'])
                 
                 # Compile backtest results
                 backtest_results = {
                     'returns': returns,
                     'cum_returns': cum_returns,
                     'weights': allocations,
                     'price_data': price_data[available],
                     'available_selected': available,
                     'metrics': portfolio_metrics,
                     'benchmark_returns': benchmark_returns,
                     'benchmark_cum_returns': benchmark_cum_returns,
                     'benchmark_metrics': benchmark_metrics
                 }
                 
                 return {"backtest_results": backtest_results}

             elif comparison_type == "vs_portfolio":
                 # Determine overlapping date range between the two portfolios
                 overlap_start = max(portfolio1['start_date'], portfolio2['start_date'])
                 overlap_end = min(portfolio1['end_date'], portfolio2['end_date'])
                 if overlap_start >= overlap_end:
                     return {"error": "No overlapping date ranges."}
                 
                 # Handle data for both portfolios within the overlapping date range
                 available_a, missing_a, price_data_a = handle_portfolio_data(portfolio1, (overlap_start, overlap_end))
                 available_b, missing_b, price_data_b = handle_portfolio_data(portfolio2, (overlap_start, overlap_end))
                 if not available_a or not available_b:
                     return {"error": "One of the portfolios has no valid tickers with available data."}
                 
                 # Adjust allocations based on available tickers for both portfolios
                 allocations_a = adjust_allocations([portfolio1['allocations'][portfolio1['selected'].index(t)] for t in available_a])
                 allocations_b = adjust_allocations([portfolio2['allocations'][portfolio2['selected'].index(t)] for t in available_b])
                 
                 # Perform backtest for both portfolios
                 returns_a, cum_returns_a = backtest(
                     weights=np.array(allocations_a) / 100,
                     prices=price_data_a[available_a],
                     rebalance_freq=portfolio1['rebalance_freq'],
                     broker_fee=portfolio1['broker_fee']
                 )
                 returns_b, cum_returns_b = backtest(
                     weights=np.array(allocations_b) / 100,
                     prices=price_data_b[available_b],
                     rebalance_freq=portfolio2['rebalance_freq'],
                     broker_fee=portfolio2['broker_fee']
                 )
                 if cum_returns_a.empty or cum_returns_b.empty:
                     return {"error": "One of the cumulative returns is empty."}
                 
                 # Align two portfolios' returns
                 common_index = cum_returns_a.index.intersection(cum_returns_b.index)
                 if common_index.empty:
                     return {"error": "No overlapping dates after backtesting."}
                 returns_a = returns_a.loc[common_index]
                 returns_b = returns_b.loc[common_index]
                 cum_returns_a = cum_returns_a.loc[common_index]
                 cum_returns_b = cum_returns_b.loc[common_index]
                 
                 # Calculate metrics for both portfolios
                 metrics_a = calculate_metrics(returns_a, cum_returns_a, portfolio1['rf_rate'])
                 metrics_b = calculate_metrics(returns_b, cum_returns_b, portfolio2['rf_rate'])
                 
                 # Compile backtest results
                 backtest_results = {
                     'returns_a': returns_a,
                     'cum_returns_a': cum_returns_a,
                     'weights_a': allocations_a,
                     'price_data_a': price_data_a[available_a],
                     'metrics_a': metrics_a,
                     'returns_b': returns_b,
                     'cum_returns_b': cum_returns_b,
                     'weights_b': allocations_b,
                     'price_data_b': price_data_b[available_b],
                     'metrics_b': metrics_b
                 }
                 return {"backtest_results": backtest_results}
         except Exception as e:
             return {"error": f"An unexpected error occurred: {e}"}
     ```

#### 2. **Function: `display_portfolio_vs_benchmark`**
   - **File:** `portfolio_optimizer.py`
   - **Relevance:** This function is responsible for displaying the results of a "Portfolio vs Benchmark" comparison. It includes enhanced visualizations and user experience improvements.
   - **Code Segment:**
     ```python
     def display_portfolio_vs_benchmark(results):
         """
         Enhanced display function for Portfolio vs Benchmark comparison with improved visualizations and UX.
         """
         # Extract data from results
         returns = results['returns']
         cum_returns = results['cum_returns']
         weights = results['weights']
         price_data = results['price_data']
         available_selected = results['available_selected']
         metrics = results['metrics']
         benchmark_metrics = results['benchmark_metrics']
         benchmark_returns = results['benchmark_returns']
         benchmark_cum_returns = results['benchmark_cum_returns']

         # Create tabs for better organization
         main_tab, metrics_tab, risk_tab, analysis_tab = st.tabs([
             "📈 Main Charts", "📊 Performance Metrics", "🎯 Risk Analysis", "🔍 Deep Analysis"
         ])

         with main_tab:
             col1, col2 = st.columns(2)
             with col1:
                 st.subheader("Portfolio Composition")
                 fig_composition = px.pie(
                     values=weights,
                     names=price_data.columns,
                     title="Current Portfolio Allocation",
                     template=THEME
                 )
                 st.plotly_chart(fig_composition, use_container_width=True)

             with col2:
                 st.subheader("Key Performance Indicators")
                 metrics_display = {
                     "Total Return": f"{(cum_returns.iloc[-1] - 1) * 100:.2f}%",
                     "Annualized Return": metrics.get('Annualized Return (CAGR)', 'N/A'),
                     "Sharpe Ratio": metrics.get('Sharpe Ratio', 'N/A'),
                     "Max Drawdown": metrics.get('Maximum Drawdown', 'N/A')
                 }
                 for metric, value in metrics_display.items():
                     st.metric(metric, value)

             # Enhanced Cumulative Returns Plot
             st.subheader("Cumulative Returns Comparison")
             fig_returns = go.Figure()
             fig_returns.add_trace(go.Scatter(
                 x=cum_returns.index,
                 y=cum_returns,
                 name="Portfolio",
                 line=dict(color='cyan', width=2)
             ))
             fig_returns.add_trace(go.Scatter(
                 x=benchmark_cum_returns.index,
                 y=benchmark_cum_returns,
                 name="Benchmark",
                 line=dict(color='orange', width=2, dash='dash')
             ))
             fig_returns.update_layout(
                 template=THEME,
                 hovermode='x unified',
                 height=500
             )
             st.plotly_chart(fig_returns, use_container_width=True)
             # Add after the cumulative returns chart
             create_summary_recommendations('overview', metrics=metrics)

         with metrics_tab:
             st.subheader("Detailed Performance Metrics")
             
             # Create comparison metrics table assuming both metrics and benchmark_metrics have same keys
             portfolio_metrics_df = pd.DataFrame(metrics.items(), columns=['Metric', 'Portfolio'])
             benchmark_metrics_df = pd.DataFrame(benchmark_metrics.items(), columns=['Metric', 'Benchmark'])
             metrics_comparison = pd.merge(portfolio_metrics_df, benchmark_metrics_df, on='Metric', how='outer')

             # Style the metrics table
             def highlight_better(row):
                 styles = [''] * len(row)
                 portfolio_val = row["Portfolio"]
                 benchmark_val = row["Benchmark"]
                 # Skip if either is N/A
                 if portfolio_val == "N/A" or benchmark_val == "N/A":
                     return styles
                 # Convert to float if possible
                 try:
                     portfolio_num = float(portfolio_val.strip('%').strip('$').replace(',', ''))
                     benchmark_num = float(benchmark_val.strip('%').strip('$').replace(',', ''))
                 except:
                     return styles
                 # Determine if higher is better or lower is better based on metric name
                 if any(keyword in row['Metric'] for keyword in ['Drawdown', 'Deviation']):
                     better = portfolio_num < benchmark_num
                 else:
                     better = portfolio_num > benchmark_num
                 styles[1] = 'background-color: lightgreen' if better else 'background-color: lightcoral'
                 return styles
             
             styled_metrics = metrics_comparison.style.apply(highlight_better, axis=1)
             st.dataframe(styled_metrics, height=400)
             # Add after the styled metrics dataframe
             create_summary_recommendations('comparison', metrics=metrics)

         with risk_tab:
             col1, col2 = st.columns(2)
             
             with col1:
                 # Rolling Volatility
                 st.subheader("Rolling Volatility")
                 rolling_vol = returns.rolling(window=30).std() * np.sqrt(252)
                 rolling_vol_bench = benchmark_returns.rolling(window=30).std() * np.sqrt(252)
                 
                 fig_vol = go.Figure()
                 fig_vol.add_trace(go.Scatter(
                     x=rolling_vol.index,
                     y=rolling_vol,
                     name="Portfolio",
                     line=dict(color='cyan')
                 ))
                 fig_vol.add_trace(go.Scatter(
                     x=rolling_vol_bench.index,
                     y=rolling_vol_bench,
                     name="Benchmark",
                     line=dict(color='orange', dash='dash')
                 ))
                 st.plotly_chart(fig_vol, use_container_width=True)

             with col2:
                 # Rolling Beta
                 st.subheader("Rolling Beta")
                 # Rolling correlation is used to compute beta
                 rolling_cov = returns.rolling(window=30).cov(benchmark_returns)
                 rolling_var = benchmark_returns.rolling(window=30).var()
                 rolling_beta = rolling_cov / rolling_var
                 
                 fig_beta = px.line(
                     rolling_beta,
                     title="30-Day Rolling Beta",
                     template=THEME
                 )
                 st.plotly_chart(fig_beta, use_container_width=True)
                 # Add after the rolling beta chart
                 create_summary_recommendations('risk', metrics=metrics)

         with analysis_tab:
             col1, col2 = st.columns(2)
             
             with col1:
                 # Monthly Returns Heatmap
                 st.subheader("Monthly Returns Heatmap")
                 monthly_returns = returns.resample('M').agg(lambda x: (1 + x).prod() - 1)
                 monthly_returns_matrix = monthly_returns.groupby([monthly_returns.index.year, monthly_returns.index.month]).first().unstack()
                 
                 fig_heatmap = px.imshow(
                     monthly_returns_matrix,
                     labels=dict(x="Month", y="Year", color="Returns"),
                     color_continuous_scale="RdYlGn",
                     template=THEME
                 )
                 st.plotly_chart(fig_heatmap, use_container_width=True)

             with col2:
                 # Rolling Correlation
                 st.subheader("Rolling Correlation with Benchmark")
                 rolling_corr = returns.rolling(window=30).corr(benchmark_returns)
                 
                 fig_corr = px.line(
                     rolling_corr,
                     title="30-Day Rolling Correlation",
                     template=THEME
                 )
                 st.plotly_chart(fig_corr, use_container_width=True)

             # Risk Contribution Analysis
             st.subheader("Risk Contribution Analysis")
             risk_contrib = calculate_risk_contribution(price_data[available_selected].pct_change().dropna(), weights)
             fig_risk = px.pie(
                 values=risk_contrib,
                 names=price_data.columns,
                 title="Risk Contribution by Asset",
                 template=THEME
             )
             st.plotly_chart(fig_risk, use_container_width=True)
             # Add after the risk contribution analysis
             create_summary_recommendations('deep', metrics=metrics)
     ```

#### 3. **Function: `display_portfolio_vs_portfolio`**
   - **File:** `portfolio_optimizer.py`
   - **Relevance:** This function is responsible for displaying the results of a "Portfolio vs Portfolio" comparison. It includes enhanced visualizations and user experience improvements.
   - **Code Segment:**
     ```python
     def display_portfolio_vs_portfolio(results, portfolio1, portfolio2):
         """Displays comparison between two portfolios."""
         # Extract data from results
         returns_a = results.get('returns_a', pd.Series(dtype=float))
         returns_b = results.get('returns_b', pd.Series(dtype=float))
         cum_returns_a = results.get('cum_returns_a', pd.Series(dtype=float))
         cum_returns_b = results.get('cum_returns_b', pd.Series(dtype=float))
         weights_a = results.get('weights_a', [])
         weights_b = results.get('weights_b', [])
         price_data_a = results.get('price_data_a', pd.DataFrame())
         price_data_b = results.get('price_data_b', pd.DataFrame())
         metrics_a = results.get('metrics_a', {})
         metrics_b = results.get('metrics_b', {})

         # Define available_a and available_b based on price data columns
         available_a = list(price_data_a.columns)
         available_b = list(price_data_b.columns)

         # Ensure that available_a and available_b are not empty
         if not available_a:
             st.error(f"No available data for Portfolio '{portfolio1}'.")
             return
         if not available_b:
             st.error(f"No available data for Portfolio '{portfolio2}'.")
             return

         # Create tabs for better organization
         overview_tab, comparison_tab, risk_tab, analysis_tab = st.tabs([
             "📊 Overview", "🔄 Comparison", "🎯 Risk Analysis", "🔍 Deep Analysis"
         ])

         with overview_tab:
             col1, col2 = st.columns(2)
             
             with col1:
                 st.subheader(f"{portfolio1} Composition")
                 fig_comp_a = px.pie(
                     values=weights_a,
                     names=price_data_a.columns,
                     title=f"{portfolio1} Allocation",
                     template=THEME
                 )
                 st.plotly_chart(fig_comp_a, use_container_width=True)

                 # Key metrics for portfolio 1
                 metrics_display_a = {
                     "Total Return": f"{(cum_returns_a.iloc[-1] - 1) * 100:.2f}%",
                     "Annualized Return": metrics_a.get('Annualized Return (CAGR)', 'N/A'),
                     "Sharpe Ratio": metrics_a.get('Sharpe Ratio', 'N/A'),
                     "Max Drawdown": metrics_a.get('Maximum Drawdown', 'N/A')
                 }
                 for metric, value in metrics_display_a.items():
                     st.metric(f"{portfolio1} {metric}", value)

             with col2:
                 st.subheader(f"{portfolio2} Composition")
                 fig_comp_b = px.pie(
                     values=weights_b,
                     names=price_data_b.columns,
                     title=f"{portfolio2} Allocation",
                     template=THEME
                 )
                 st.plotly_chart(fig_comp_b, use_container_width=True)

                 # Key metrics for portfolio 2
                 metrics_display_b = {
                     "Total Return": f"{(cum_returns_b.iloc[-1] - 1) * 100:.2f}%",
                     "Annualized Return": metrics_b.get('Annualized Return (CAGR)', 'N/A'),
                     "Sharpe Ratio": metrics_b.get('Sharpe Ratio', 'N/A'),
                     "Max Drawdown": metrics_b.get('Maximum Drawdown', 'N/A')
                 }
                 for metric, value in metrics_display_b.items():
                     st.metric(f"{portfolio2} {metric}", value)

             # Cumulative Returns Comparison
             st.subheader("Cumulative Returns Comparison")
             fig_returns = go.Figure()
             fig_returns.add_trace(go.Scatter(
                 x=cum_returns_a.index,
                 y=cum_returns_a,
                 name=portfolio1,
                 line=dict(color='cyan', width=2)
             ))
             fig_returns.add_trace(go.Scatter(
                 x=cum_returns_b.index,
                 y=cum_returns_b,
                 name=portfolio2,
                 line=dict(color='orange', width=2)
             ))
             fig_returns.update_layout(
                 template=THEME,
                 hovermode='x unified',
                 height=500
             )
             st.plotly_chart(fig_returns, use_container_width=True)

             # Add after the cumulative returns chart
             create_portfolio_comparison_summary(
                 portfolio1_name=portfolio1,
                 portfolio2_name=portfolio2,
                 metrics_a=metrics_a,
                 metrics_b=metrics_b
             )

         with comparison_tab:
             # Enhanced Performance Metrics Comparison
             st.subheader("Detailed Performance Comparison")
             
             detailed_metrics = [
                 'Annualized Return (CAGR)',
                 'Sharpe Ratio',
                 'Sortino Ratio',
                 'Maximum Drawdown',
                 'Beta',
                 'Alpha (annualized)',
                 'Information Ratio',
                 'Modigliani–Modigliani Measure',
                 'Tracking Error',
                 'Calmar Ratio'
             ]

             comparison_df = pd.DataFrame({
                 'Metric': detailed_metrics,
                 portfolio1: [metrics_a.get(metric, "N/A") for metric in detailed_metrics],
                 portfolio2: [metrics_b.get(metric, "N/A") for metric in detailed_metrics]
             }).set_index('Metric')

             # Style the comparison table
             def highlight_better_performance(row):
                 styles = [''] * len(row)
                 if isinstance(row[portfolio1], (int, float)) and isinstance(row[portfolio2], (int, float)):
                     if 'Drawdown' in row.name or 'Risk' in row.name:
                         better = row[portfolio1] < row[portfolio2]
                     else:
                         better = row[portfolio1] > row[portfolio2]
                     styles[0] = 'background-color: lightgreen' if better else 'background-color: lightcoral'
                     styles[1] = 'background-color: lightgreen' if not better else 'background-color: lightcoral'
                 return styles

             styled_comparison = comparison_df.style.apply(highlight_better_performance, axis=1)
             st.dataframe(styled_comparison, height=400)

             # Rolling Performance Difference
             st.subheader("Rolling Performance Difference")
             rolling_diff = (returns_a - returns_b).rolling(window=30).mean() * 252
             fig_diff = px.line(
                 rolling_diff,
                 title="30-Day Rolling Return Difference",
                 template=THEME
             )
             st.plotly_chart(fig_diff, use_container_width=True)

         with risk_tab:
             st.header("🎯 Risk Analysis")
             col1, col2 = st.columns(2)
             
             with col1:
                 # Rolling Volatility Comparison
                 st.subheader("Rolling Volatility")
                 rolling_vol_a = returns_a.rolling(window=30).std() * np.sqrt(252)
                 rolling_vol_b = returns_b.rolling(window=30).std() * np.sqrt(252)
                 
                 fig_vol = go.Figure()
                 fig_vol.add_trace(go.Scatter(
                     x=rolling_vol_a.index,
                     y=rolling_vol_a,
                     name=portfolio1,
                     line=dict(color='cyan')
                 ))
                 fig_vol.add_trace(go.Scatter(
                     x=rolling_vol_b.index,
                     y=rolling_vol_b,
                     name=portfolio2,
                     line=dict(color='orange')
                 ))
                 st.plotly_chart(fig_vol, use_container_width=True)

             with col2:
                 # Rolling Correlation
                 st.subheader("Rolling Correlation")
                 rolling_corr = returns_a.rolling(window=30).corr(returns_b)
                 fig_corr = px.line(
                     rolling_corr,
                     title="30-Day Rolling Correlation",
                     template=THEME
                 )
                 st.plotly_chart(fig_corr, use_container_width=True)

             st.subheader("Risk Contribution Analysis")
             col3, col4 = st.columns(2)
             
             with col3:
                 # Calculate risk contributions for portfolio1
                 risk_contrib_a = calculate_risk_contribution(
                     price_data_a[available_a].pct_change().dropna(),
                     weights_a
                 )
                 
                 # Create DataFrame for plotting
                 risk_contrib_df_a = pd.DataFrame({
                     'Asset': available_a,
                     'Risk Contribution': risk_contrib_a
                 })
                 
                 fig_risk_a = px.pie(
                     risk_contrib_df_a,
                     values='Risk Contribution',
                     names='Asset',
                     title=f"{portfolio1} Risk Contribution",
                     template=THEME
                 )
                 st.plotly_chart(fig_risk_a, use_container_width=True)

             with col4:
                 # Calculate risk contributions for portfolio2
                 risk_contrib_b = calculate_risk_contribution(
                     price_data_b[available_b].pct_change().dropna(),
                     weights_b
                 )
                 
                 # Create DataFrame for plotting
                 risk_contrib_df_b = pd.DataFrame({
                     'Asset': available_b,
                     'Risk Contribution': risk_contrib_b
                 })
                 
                 fig_risk_b = px.pie(
                     risk_contrib_df_b,
                     values='Risk Contribution',
                     names='Asset',
                     title=f"{portfolio2} Risk Contribution",
                     template=THEME
                 )
                 st.plotly_chart(fig_risk_b, use_container_width=True)

         with analysis_tab:
             st.header("🔍 Deep Analysis")
             # Monthly Returns Heatmap
             st.subheader("Monthly Returns Comparison")
             col5, col6 = st.columns(2)
             
             with col5:
                 monthly_returns_a = returns_a.resample('M').agg(lambda x: (1 + x).prod() - 1)
                 monthly_matrix_a = monthly_returns_a.groupby([monthly_returns_a.index.year, monthly_returns_a.index.month]).first().unstack()
                 fig_heat_a = px.imshow(
                     monthly_matrix_a,
                     title=f"{portfolio1} Monthly Returns",
                     labels=dict(x="Month", y="Year", color="Returns"),
                     color_continuous_scale="RdYlGn",
                     template=THEME
                 )
                 st.plotly_chart(fig_heat_a, use_container_width=True)
             
             with col6:
                 monthly_returns_b = returns_b.resample('M').agg(lambda x: (1 + x).prod() - 1)
                 monthly_matrix_b = monthly_returns_b.groupby([monthly_returns_b.index.year, monthly_returns_b.index.month]).first().unstack()
                 fig_heat_b = px.imshow(
                     monthly_matrix_b,
                     title=f"{portfolio2} Monthly Returns",
                     labels=dict(x="Month", y="Year", color="Returns"),
                     color_continuous_scale="RdYlGn",
                     template=THEME
                 )
                 st.plotly_chart(fig_heat_b, use_container_width=True)

             # Risk-Return Scatter Plot
             st.subheader("🔄 Risk vs Return Scatter Plot")
             fig_risk_return = go.Figure()
             fig_risk_return.add_trace(go.Scatter(
                 x=[returns_a.std() * np.sqrt(252)],
                 y=[returns_a.mean() * 252],
                 mode='markers',
                 marker=dict(
                     size=[w * 100 for w in weights_a],
                     color='cyan'
                 ),
                 text=available_a,
                 name=portfolio1
             ))
             fig_risk_return.add_trace(go.Scatter(
                 x=[returns_b.std() * np.sqrt(252)],
                 y=[returns_b.mean() * 252],
                 mode='markers',
                 marker=dict(
                     size=[w * 100 for w in weights_b],
                     color='orange'
                 ),
                 text=available_b,
                 name=portfolio2
             ))
             fig_risk_return.update_layout(
                 title='🔄 Risk vs Return Scatter Plot',
                 xaxis_title='Annualized Volatility (Std Dev)',
                 yaxis_title='Annualized Return',
                 template=THEME
             )
             st.plotly_chart(fig_risk_return, use_container_width=True)

         # Final Summary
         st.subheader("📝 Summary and Recommendations")
         
         # Calculate overall scores
         score_a = calculate_final_score(metrics_a, metrics_b)
         score_b = calculate_final_score(metrics_b, metrics_a)
         
         col7, col8 = st.columns(2)
         with col7:
             st.metric(f"{portfolio1} Score", f"{score_a:.2f}/100")
         with col8:
             st.metric(f"{portfolio2} Score", f"{score_b:.2f}/100")
         
         # Generate and display recommendations
         recommendations = generate_portfolio_comparison_recommendations(
             portfolio1_name=portfolio1,
             portfolio2_name=portfolio2,
             metrics_a=metrics_a,
             metrics_b=metrics_b
         )
         for rec in recommendations:
             st.markdown(f"• {rec}")

         # Update session state
         update_session_state({
             'comparison_results': results,
             'show_proceed': True
         })
         st.success("Portfolio comparison analysis completed! 🎉")
     ```

### Summary
These code segments are essential for handling the comparison of portfolios against benchmarks and other portfolios. The `run_portfolio_comparison` function orchestrates the comparison logic, while `display_portfolio_vs_benchmark` and `display_portfolio_vs_portfolio` functions are responsible for presenting the results in an enhanced and user-friendly manner. These functions ensure that the relevant data is processed, metrics are calculated, and visualizations are generated to provide meaningful insights into the performance and risk characteristics of the portfolios.