Create app.py

app.py

@@ -0,0 +1,1039 @@
+import yfinance as yf
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import streamlit as st
+from sklearn.linear_model import RANSACRegressor, LinearRegression
+from scipy.stats import linregress
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+# Helper function to fetch stock data
+def fetch_stock_data(ticker: str, start_date: str, end_date: str) -> pd.DataFrame:
+    return yf.download(ticker, start=start_date, end=end_date)
+
+# Helper function to plot rolling volatility and volatility of volatility
+def plot_rolling_volatility(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    data['Rolling_Volatility'] = data['Return'].rolling(window=21).std() * np.sqrt(252)
+    data['Vol_of_Vol'] = data['Rolling_Volatility'].rolling(window=21).std()
+
+    fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Volatility', 'Volatility of Volatility'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price'), row=1, col=1)
+    fig.add_trace(go.Scatter(x=data.index, y=data['Rolling_Volatility'], mode='lines', name='Rolling Volatility', line=dict(color='red')), row=2, col=1)
+    fig.add_trace(go.Scatter(x=data.index, y=data['Vol_of_Vol'], mode='lines', name='Volatility of Volatility', line=dict(color='blue')), row=3, col=1)
+
+    fig.update_layout(title='Rolling Volatility and Volatility of Volatility', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling Sharpe ratio
+def plot_rolling_sharpe(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    rolling_sharpe = np.sqrt(252) * data['Return'].rolling(252).mean() / data['Return'].rolling(252).std()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Sharpe Ratio'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price'), row=1, col=1)
+    fig.add_trace(go.Scatter(x=data.index, y=rolling_sharpe, mode='lines', name='Rolling Sharpe Ratio', line=dict(color='green')), row=2, col=1)
+    fig.add_hline(y=1, line=dict(color='red', dash='dash'), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Sharpe Ratio with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling Treynor ratio
+# Helper function to calculate and plot rolling Treynor Ratio
+def plot_rolling_treynor(data: pd.DataFrame, market_data: pd.DataFrame, window_size: int = 252) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    market_data['Return'] = market_data['Close'].pct_change()
+
+    # Align indices
+    market_data = market_data.reindex(data.index, method='ffill')
+
+    covariance = data['Return'].rolling(window=window_size).cov(market_data['Return'])
+    variance = market_data['Return'].rolling(window=window_size).var()
+    rolling_beta = covariance / variance
+    avg_rolling_returns = data['Return'].rolling(window=window_size).mean()
+    risk_free_rate = 0
+    data['Rolling_Treynor_Ratio'] = (avg_rolling_returns - risk_free_rate) / rolling_beta
+
+    fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Benchmark Price', 'Rolling Treynor Ratio'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=market_data.index, y=market_data['Close'], mode='lines', name='Benchmark Price', line=dict(color='blue')), row=2, col=1)
+    fig.add_trace(go.Scatter(x=data.index, y=data['Rolling_Treynor_Ratio'], mode='lines', name='Rolling Treynor Ratio', line=dict(color='red')), row=3, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Treynor Ratio with Stock Price and Benchmark', xaxis_title='Date')
+    return fig
+    
+# Helper function to calculate and plot rolling beta
+def plot_rolling_beta(data: pd.DataFrame, market_data: pd.DataFrame, window: int = 60) -> go.Figure:
+    data['Return'] = data['Close'].pct_change().dropna()
+    market_data['Market_Return'] = market_data['Close'].pct_change().dropna()
+    
+    # Align dates and remove rows with missing data
+    aligned_data = pd.concat([data['Return'], market_data['Market_Return']], axis=1).dropna()
+    
+    ransac = RANSACRegressor()
+    ols = LinearRegression()
+    rolling_beta_ransac = []
+    rolling_beta_ols = []
+
+    for i in range(len(aligned_data) - window):
+        X = aligned_data['Market_Return'].iloc[i:i+window].values.reshape(-1, 1)
+        y = aligned_data['Return'].iloc[i:i+window].values
+
+        ransac.fit(X, y)
+        beta_ransac = ransac.estimator_.coef_[0]
+        rolling_beta_ransac.append(beta_ransac)
+
+        ols.fit(X, y)
+        beta_ols = ols.coef_[0]
+        rolling_beta_ols.append(beta_ols)
+
+    # Convert lists to series with appropriate index
+    rolling_beta_ransac = pd.Series(rolling_beta_ransac, index=aligned_data.index[window:])
+    rolling_beta_ols = pd.Series(rolling_beta_ols, index=aligned_data.index[window:])
+
+    fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Benchmark Price', 'Rolling Beta (RANSAC & OLS)'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=market_data.index, y=market_data['Close'], mode='lines', name='Benchmark Price', line=dict(color='blue')), row=2, col=1)
+    fig.add_trace(go.Scatter(x=rolling_beta_ransac.index, y=rolling_beta_ransac, mode='lines', name='Rolling Beta (RANSAC)', line=dict(color='red')), row=3, col=1)
+    fig.add_trace(go.Scatter(x=rolling_beta_ols.index, y=rolling_beta_ols, mode='lines', name='Rolling Beta (OLS)', line=dict(color='green')), row=3, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Beta with Stock Price and Benchmark', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling Jensen's alpha
+def plot_rolling_alpha(data: pd.DataFrame, market_data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    market_data['Return'] = market_data['Close'].pct_change()
+
+    window_size = 252
+    rolling_alpha = []
+
+    for i in range(len(data) - window_size):
+        window = data['Return'].iloc[i:i + window_size]
+        market_window = market_data['Return'].iloc[i:i + window_size]
+        beta = window.cov(market_window) / market_window.var()
+        expected_return = beta * market_window.mean()
+        alpha = window.mean() - expected_return
+        rolling_alpha.append(alpha)
+
+    rolling_alpha = pd.Series(rolling_alpha, index=data.index[window_size:])
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Jensen\'s Alpha'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=rolling_alpha.index, y=rolling_alpha, mode='lines', name='Rolling Jensen\'s Alpha', line=dict(color='green')), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Jensen\'s Alpha with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling Value at Risk (VaR)
+def plot_rolling_var(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    rolling_var_90 = data['Return'].rolling(252).quantile(0.10).dropna()
+    rolling_var_95 = data['Return'].rolling(252).quantile(0.05).dropna()
+    rolling_var_97 = data['Return'].rolling(252).quantile(0.03).dropna()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling VaR'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=rolling_var_90.index, y=rolling_var_90, mode='lines', name='Rolling VaR 90%', line=dict(color='cyan')), row=2, col=1)
+    fig.add_trace(go.Scatter(x=rolling_var_95.index, y=rolling_var_95, mode='lines', name='Rolling VaR 95%', line=dict(color='blue')), row=2, col=1)
+    fig.add_trace(go.Scatter(x=rolling_var_97.index, y=rolling_var_97, mode='lines', name='Rolling VaR 97%', line=dict(color='purple')), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year VaR with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling Conditional VaR (CVaR)
+def plot_rolling_cvar(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+
+    def conditional_var(x, alpha=0.05):
+        var = np.percentile(x, alpha * 100)
+        return np.mean(x[x < var])
+
+    rolling_cvar_95 = data['Return'].rolling(252).apply(conditional_var, raw=True).dropna()
+    rolling_cvar_90 = data['Return'].rolling(252).apply(lambda x: conditional_var(x, alpha=0.1), raw=True).dropna()
+    rolling_cvar_97 = data['Return'].rolling(252).apply(lambda x: conditional_var(x, alpha=0.03), raw=True).dropna()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling CVaR'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=rolling_cvar_95.index, y=rolling_cvar_95, mode='lines', name='Rolling CVaR 95%', line=dict(color='blue')), row=2, col=1)
+    fig.add_trace(go.Scatter(x=rolling_cvar_90.index, y=rolling_cvar_90, mode='lines', name='Rolling CVaR 90%', line=dict(color='green')), row=2, col=1)
+    fig.add_trace(go.Scatter(x=rolling_cvar_97.index, y=rolling_cvar_97, mode='lines', name='Rolling CVaR 97%', line=dict(color='orange')), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year CVaR with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling Tail Ratio
+def plot_rolling_tail_ratio(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    tail_ratio = data['Return'].rolling(252).apply(lambda x: np.abs(np.percentile(x, 95)) / np.abs(np.percentile(x, 5))).dropna()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Tail Ratio'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=tail_ratio.index, y=tail_ratio, mode='lines', name='Tail Ratio', line=dict(color='purple')), row=2, col=1)
+    fig.add_hline(y=1, line=dict(color='red', dash='dash'), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Tail Ratio with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling Omega Ratio
+def plot_rolling_omega(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    MAR = 0  # Minimum Acceptable Return
+    omega_ratio = data['Return'].rolling(252).apply(lambda x: np.sum(x[x > MAR] - MAR) / np.sum(MAR - x[x < MAR])).dropna()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Omega Ratio'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=omega_ratio.index, y=omega_ratio, mode='lines', name='Omega Ratio', line=dict(color='green')), row=2, col=1)
+    fig.add_hline(y=1, line=dict(color='red', dash='dash'), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Omega Ratio with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling Sortino Ratio
+def plot_rolling_sortino(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    MAR = 0  # Minimum Acceptable Return
+    sortino_ratio = data['Return'].rolling(252).apply(lambda x: np.mean(x - MAR) / np.sqrt(np.mean(np.minimum(0, x - MAR) ** 2))).dropna()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Sortino Ratio'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=sortino_ratio.index, y=sortino_ratio, mode='lines', name='Sortino Ratio', line=dict(color='green')), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Sortino Ratio with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling Calmar Ratio
+def plot_rolling_calmar(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    calmar_ratio = data['Return'].rolling(252).apply(lambda x: (1 + x).cumprod()[-1] ** (252.0 / len(x)) / np.abs(np.min((1 + x).cumprod() / (1 + x).cumprod().cummax()) - 1)).dropna()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Calmar Ratio'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=calmar_ratio.index, y=calmar_ratio, mode='lines', name='Calmar Ratio', line=dict(color='green')), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Calmar Ratio with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling stability
+def plot_rolling_stability(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    stability = data['Return'].rolling(252).apply(lambda x: np.std(np.log1p(x).cumsum() - linregress(np.arange(len(x)), np.log1p(x).cumsum()).intercept - linregress(np.arange(len(x)), np.log1p(x).cumsum()).slope * np.arange(len(x)))).dropna()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Stability'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=stability.index, y=stability, mode='lines', name='Stability', line=dict(color='purple')), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Stability of Returns with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to plot rolling maximum drawdown
+def plot_rolling_drawdown(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    rolling_cumulative = (1 + data['Return']).cumprod()
+    rolling_max = rolling_cumulative.rolling(252, min_periods=1).max()
+    rolling_drawdown = (rolling_cumulative - rolling_max) / rolling_max
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Maximum Drawdown'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=rolling_drawdown.index, y=rolling_drawdown, mode='lines', name='Maximum Drawdown', line=dict(color='red')), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Maximum Drawdown with Stock Price', xaxis_title='Date')
+    return fig
+
+# Helper function to calculate and plot rolling capture ratios
+def plot_rolling_capture(data: pd.DataFrame, market_data: pd.DataFrame, window_size: int = 252) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    market_data['Return'] = market_data['Close'].pct_change()
+
+    # Align indices
+    market_data = market_data.reindex(data.index, method='ffill')
+
+    def calculate_capture(stock_returns, market_returns, is_upside=True):
+        if is_upside:
+            relevant_returns = stock_returns[market_returns > 0]
+            relevant_market_returns = market_returns[market_returns > 0]
+        else:
+            relevant_returns = stock_returns[market_returns < 0]
+            relevant_market_returns = market_returns[market_returns < 0]
+        return relevant_returns.sum() / relevant_market_returns.sum()
+
+    def compute_rolling_captures(stock_returns, market_returns, window):
+        upside_captures = []
+        downside_captures = []
+
+        for idx in range(len(stock_returns) - window + 1):
+            current_window_stock = stock_returns.iloc[idx: idx + window]
+            current_window_market = market_returns.iloc[idx: idx + window]
+
+            if len(current_window_market[current_window_market > 0]) == 0 or len(current_window_market[current_window_market < 0]) == 0:
+                upside = np.nan
+                downside = np.nan
+            else:
+                upside = calculate_capture(current_window_stock, current_window_market, is_upside=True)
+                downside = calculate_capture(current_window_stock, current_window_market, is_upside=False)
+
+            upside_captures.append(upside)
+            downside_captures.append(downside)
+
+        # Padding the initial values with NaNs to make the length equal to original data
+        nan_padding = [np.nan] * (window - 1)
+        upside_captures = nan_padding + upside_captures
+        downside_captures = nan_padding + downside_captures
+
+        return upside_captures, downside_captures
+
+    data['rolling_upside_capture'], data['rolling_downside_capture'] = compute_rolling_captures(
+        data['Return'], market_data['Return'], window_size
+    )
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Capture Ratios'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=data.index, y=data['rolling_upside_capture'], mode='lines', name='Rolling Upside Capture', line=dict(color='green')), row=2, col=1)
+    fig.add_trace(go.Scatter(x=data.index, y=data['rolling_downside_capture'], mode='lines', name='Rolling Downside Capture', line=dict(color='red')), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Capture Ratios with Stock Price', xaxis_title='Date')
+    return fig
+
+
+# Helper function to plot rolling Pain Index
+def plot_rolling_pain_index(data: pd.DataFrame) -> go.Figure:
+    data['Return'] = data['Close'].pct_change()
+    cumulative_return = (1 + data['Return']).cumprod()
+    running_max = cumulative_return.cummax()
+    drawdown = (cumulative_return - running_max) / running_max
+    pain_index = drawdown.rolling(252).apply(lambda x: np.mean(x[x < 0])).dropna()
+
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                        subplot_titles=('Close Price', 'Rolling Pain Index'))
+
+    fig.add_trace(go.Scatter(x=data.index, y=data['Close'], mode='lines', name='Close Price', line=dict(color='grey')), row=1, col=1)
+    fig.add_trace(go.Scatter(x=pain_index.index, y=pain_index, mode='lines', name='Pain Index', line=dict(color='red')), row=2, col=1)
+
+    fig.update_layout(title='Rolling 1-Year Pain Index with Stock Price', xaxis_title='Date')
+    return fig
+
+# Streamlit app
+st.set_page_config(page_title="Technical Analysis", layout="wide")
+st.title('Technical Analysis Indicators')
+
+# Sidebar for method selection
+selected = st.sidebar.radio("Select Indicator", ["Rolling Volatility", "Rolling Sharpe Ratio", "Rolling Treynor Ratio", "Rolling Beta", "Rolling Jensen's Alpha",
+                                                 "Rolling Value at Risk", "Rolling Conditional VaR", "Rolling Tail Ratio", "Rolling Omega Ratio",
+                                                 "Rolling Sortino Ratio", "Rolling Calmar Ratio", "Rolling Stability", "Rolling Maximum Drawdown",
+                                                 "Rolling Capture Ratios", "Rolling Pain Index"])
+
+# Sidebar for input parameters
+st.sidebar.header("Input Parameters")
+ticker = st.sidebar.text_input('Enter Stock Ticker', 'VOW.DE')
+start_date = st.sidebar.date_input('Start Date', pd.to_datetime('2010-01-01'))
+end_date = st.sidebar.date_input('End Date', pd.to_datetime('2024-12-31'))
+
+# Fetch data
+if 'data' not in st.session_state or st.sidebar.button('Fetch Data'):
+    st.session_state.data = fetch_stock_data(ticker, start_date, end_date)
+
+data = st.session_state.data
+
+# Additional input for Rolling Treynor Ratio, Rolling Beta, Rolling Jensen's Alpha, Rolling Capture Ratios
+if selected in ["Rolling Treynor Ratio", "Rolling Beta", "Rolling Jensen's Alpha", "Rolling Capture Ratios"]:
+    benchmark_ticker = st.sidebar.text_input('Enter Benchmark Ticker', '^GSPC')
+    if 'market_data' not in st.session_state or st.sidebar.button('Fetch Market Data'):
+        st.session_state.market_data = fetch_stock_data(benchmark_ticker, start_date, end_date)
+
+    market_data = st.session_state.market_data
+
+# Display results based on the selected method
+if selected == "Rolling Volatility":
+    st.markdown("""
+    ### Rolling Volatility
+
+    This method calculates the rolling volatility and the volatility of volatility.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Rolling Volatility:**
+       - Compute the rolling standard deviation of the returns over a specified window (e.g., 21 days) and annualize it:
+    """)
+    st.latex(r'''
+    \text{Rolling Volatility}_t = \sqrt{252} \times \text{std}(\text{Return}_{t-n:t})
+    ''')
+    st.markdown("""
+       where \( n \) is the window size (e.g., 21 days).
+
+    3. **Calculate Volatility of Volatility:**
+       - Compute the rolling standard deviation of the rolling volatility over a specified window (e.g., 21 days):
+    """)
+    st.latex(r'''
+    \text{Volatility of Volatility}_t = \text{std}(\text{Rolling Volatility}_{t-n:t})
+    ''')
+
+    st.markdown("""
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling volatility and the volatility of volatility.
+    """)
+
+    fig = plot_rolling_volatility(data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Sharpe Ratio":
+    st.markdown("""
+    ### Rolling Sharpe Ratio
+
+    This method calculates the rolling 1-year Sharpe Ratio.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Rolling Average Return:**
+       - Compute the rolling mean of the returns over a 1-year period (252 trading days):
+    """)
+    st.latex(r'''
+    \text{Rolling Average Return}_t = \text{mean}(\text{Return}_{t-252:t})
+    ''')
+    st.markdown("""
+       
+    3. **Calculate Rolling Standard Deviation:**
+       - Compute the rolling standard deviation of the returns over a 1-year period:
+    """)
+    st.latex(r'''
+    \text{Rolling Std Dev}_t = \text{std}(\text{Return}_{t-252:t})
+    ''')
+    st.markdown("""
+       
+    4. **Calculate Rolling Sharpe Ratio:**
+       - Annualize the Sharpe Ratio by multiplying by the square root of 252:
+    """)
+    st.latex(r'''
+    \text{Rolling Sharpe Ratio}_t = \frac{\text{Rolling Average Return}_t}{\text{Rolling Std Dev}_t} \times \sqrt{252}
+    ''')
+    st.markdown("""
+       
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling Sharpe Ratio.
+    """)
+
+    fig = plot_rolling_sharpe(data)
+    st.plotly_chart(fig)
+
+
+elif selected == "Rolling Treynor Ratio":
+    st.markdown("""
+    ### Rolling Treynor Ratio
+
+    This method calculates the rolling 1-year Treynor Ratio.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock and the benchmark:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Beta:**
+       - Compute the rolling covariance between the stock and benchmark returns, and divide by the rolling variance of the benchmark returns to get the rolling beta:
+    """)
+    st.latex(r'''
+    \beta_t = \frac{\text{Cov}(\text{Return}_{\text{stock}, t}, \text{Return}_{\text{benchmark}, t})}{\text{Var}(\text{Return}_{\text{benchmark}, t})}
+    ''')
+    st.markdown("""
+       where the rolling window size is typically 252 days for 1-year calculations.
+
+    3. **Calculate Average Rolling Returns:**
+       - Compute the rolling mean of the stock returns over the same window:
+    """)
+    st.latex(r'''
+    \text{Average Rolling Return}_t = \frac{1}{n} \sum_{i=t-n+1}^{t} \text{Return}_{\text{stock}, i}
+    ''')
+    st.markdown("""
+       where \( n \) is the window size (e.g., 252 days).
+
+    4. **Calculate Treynor Ratio:**
+       - Compute the Treynor Ratio using the risk-free rate \( R_f \) (assumed to be 0 here for simplicity):
+    """)
+    st.latex(r'''
+    \text{Treynor Ratio}_t = \frac{\text{Average Rolling Return}_t - R_f}{\beta_t}
+    ''')
+    st.markdown("""
+       where \( R_f \) is the risk-free rate.
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Enter the benchmark ticker.
+    3. Click 'Fetch Data' to load the stock and benchmark data.
+    4. The chart will display the rolling Treynor Ratio.
+    """)
+
+    fig = plot_rolling_treynor(data, market_data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Beta":
+    st.markdown("""
+    ### Rolling Beta
+
+    This method calculates the rolling beta of a stock's returns against a benchmark using RANSAC and OLS methods.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock and the benchmark:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Rolling Beta using OLS:**
+       - Perform a linear regression of the stock returns against the benchmark returns over a specified window (e.g., 60 days):
+    """)
+    st.latex(r'''
+    \beta_{OLS} = \frac{\text{Cov}(\text{Return}_{\text{stock}}, \text{Return}_{\text{benchmark}})}{\text{Var}(\text{Return}_{\text{benchmark}})}
+    ''')
+    st.markdown("""
+       where the rolling window size is typically 60 days.
+
+    3. **Calculate Rolling Beta using RANSAC:**
+       - Use the RANSAC algorithm to robustly estimate the beta, reducing the influence of outliers:
+    """)
+    st.latex(r'''
+    \beta_{RANSAC} = \text{RANSAC}(\text{Return}_{\text{benchmark}}, \text{Return}_{\text{stock}})
+    ''')
+    st.markdown("""
+       where the RANSAC algorithm iteratively fits the model and removes outliers.
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Enter the benchmark ticker.
+    3. Click 'Fetch Data' to load the stock and benchmark data.
+    4. The chart will display the rolling beta calculated using both OLS and RANSAC methods.
+    """)
+
+    fig = plot_rolling_beta(data, market_data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Jensen's Alpha":
+    st.markdown("""
+    ### Rolling Jensen's Alpha
+
+    This method calculates the rolling 1-year Jensen's Alpha.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock and the benchmark:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Beta:**
+       - Compute the rolling beta of the stock returns against the benchmark returns over a specified window (e.g., 252 days):
+    """)
+    st.latex(r'''
+    \beta_t = \frac{\text{Cov}(\text{Return}_{\text{stock}, t}, \text{Return}_{\text{benchmark}, t})}{\text{Var}(\text{Return}_{\text{benchmark}, t})}
+    ''')
+    st.markdown("""
+       where the rolling window size is typically 252 days for 1-year calculations.
+
+    3. **Calculate Expected Return:**
+       - Compute the expected return of the stock based on the CAPM model:
+    """)
+    st.latex(r'''
+    \text{Expected Return}_t = R_f + \beta_t (\text{Return}_{\text{benchmark}} - R_f)
+    ''')
+    st.markdown("""
+       where \( R_f \) is the risk-free rate (assumed to be 0 here for simplicity).
+
+    4. **Calculate Jensen's Alpha:**
+       - Compute the Jensen's Alpha as the difference between the actual return and the expected return:
+    """)
+    st.latex(r'''
+    \alpha_t = \text{Return}_{\text{stock}, t} - \text{Expected Return}_t
+    ''')
+    st.markdown("""
+       where \( \alpha_t \) is Jensen's Alpha at time \( t \).
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Enter the benchmark ticker.
+    3. Click 'Fetch Data' to load the stock and benchmark data.
+    4. The chart will display the rolling Jensen's Alpha.
+    """)
+
+    fig = plot_rolling_alpha(data, market_data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Value at Risk":
+    st.markdown("""
+    ### Rolling Value at Risk (VaR)
+
+    This method calculates the rolling 1-year Value at Risk (VaR) at different confidence levels.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Rolling VaR:**
+       - Compute the rolling quantile of the returns over a specified window (e.g., 252 days) for different confidence levels:
+    """)
+    st.latex(r'''
+    \text{VaR}_{\alpha, t} = \text{Quantile}_{\alpha}(\text{Return}_{t-n:t})
+    ''')
+    st.markdown("""
+       where \( \alpha \) is the confidence level (e.g., 0.05 for 95% VaR) and \( n \) is the window size (e.g., 252 days).
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling VaR at different confidence levels (e.g., 90%, 95%, 97%).
+
+    **Results:**
+    The chart shows the close prices along with the rolling VaR at different confidence levels over time.
+    """)
+
+    fig = plot_rolling_var(data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Conditional VaR":
+    st.markdown("""
+    ### Rolling Conditional Value at Risk (CVaR)
+
+    This method calculates the rolling 1-year Conditional Value at Risk (CVaR) at different confidence levels.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Rolling VaR:**
+       - Compute the rolling quantile of the returns over a specified window (e.g., 252 days) for different confidence levels:
+    """)
+    st.latex(r'''
+    \text{VaR}_{\alpha, t} = \text{Quantile}_{\alpha}(\text{Return}_{t-n:t})
+    ''')
+    st.markdown("""
+       where \( \alpha \) is the confidence level (e.g., 0.05 for 95% VaR) and \( n \) is the window size (e.g., 252 days).
+
+    3. **Calculate Rolling CVaR:**
+       - Compute the average of the returns that are below the VaR threshold:
+    """)
+    st.latex(r'''
+    \text{CVaR}_{\alpha, t} = \frac{1}{n} \sum_{i=1}^{n} \text{Return}_{i} \text{ where } \text{Return}_{i} < \text{VaR}_{\alpha, t}
+    ''')
+    st.markdown("""
+       where \( n \) is the number of returns below the VaR threshold.
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling CVaR at different confidence levels (e.g., 90%, 95%, 97%).
+
+    **Results:**
+    The chart shows the close prices along with the rolling CVaR at different confidence levels over time.
+    """)
+
+    fig = plot_rolling_cvar(data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Tail Ratio":
+    st.markdown("""
+    ### Rolling Tail Ratio
+
+    This method calculates the rolling 1-year Tail Ratio.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Tail Ratio:**
+       - Compute the rolling Tail Ratio over a specified window (e.g., 252 days):
+    """)
+    st.latex(r'''
+    \text{Tail Ratio}_t = \frac{|\text{Quantile}_{95}(\text{Return}_{t-n:t})|}{|\text{Quantile}_{5}(\text{Return}_{t-n:t})|}
+    ''')
+    st.markdown("""
+       where \( n \) is the window size (e.g., 252 days).
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling Tail Ratio.
+
+    **Results:**
+    The chart shows the close prices along with the rolling Tail Ratio over time, indicating the balance between extreme positive and negative returns.
+    """)
+
+    fig = plot_rolling_tail_ratio(data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Omega Ratio":
+    st.markdown("""
+    ### Rolling Omega Ratio
+
+    This method calculates the rolling 1-year Omega Ratio.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Omega Ratio:**
+       - Compute the rolling Omega Ratio over a specified window (e.g., 252 days):
+    """)
+    st.latex(r'''
+    \text{Omega Ratio}_t = \frac{\sum (\text{Return}_{i} > MAR) (\text{Return}_{i} - MAR)}{\sum (\text{Return}_{i} < MAR) (MAR - \text{Return}_{i})}
+    ''')
+    st.markdown("""
+       where \( MAR \) is the Minimum Acceptable Return (assumed to be 0 here for simplicity) and \( n \) is the window size (e.g., 252 days).
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling Omega Ratio.
+
+    **Results:**
+    The chart shows the close prices along with the rolling Omega Ratio over time, indicating the risk-return trade-off.
+    """)
+
+    fig = plot_rolling_omega(data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Sortino Ratio":
+    st.markdown("""
+    ### Rolling Sortino Ratio
+
+    This method calculates the rolling 1-year Sortino Ratio.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Rolling Sortino Ratio:**
+       - Compute the rolling Sortino Ratio over a specified window (e.g., 252 days):
+    """)
+    st.latex(r'''
+    \text{Sortino Ratio}_t = \frac{\sqrt{252} \cdot \text{Mean}(\text{Return}_{t-n:t} - MAR)}{\sqrt{\text{Mean}(\min(0, \text{Return}_{t-n:t} - MAR)^2)}}
+    ''')
+    st.markdown("""
+       where \( MAR \) is the Minimum Acceptable Return (assumed to be 0 here for simplicity) and \( n \) is the window size (e.g., 252 days).
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling Sortino Ratio.
+
+    **Results:**
+    The chart shows the close prices along with the rolling Sortino Ratio over time, indicating the risk-adjusted return considering downside risk.
+    """)
+
+    fig = plot_rolling_sortino(data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Calmar Ratio":
+    st.markdown("""
+    ### Rolling Calmar Ratio
+
+    This method calculates the rolling 1-year Calmar Ratio.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Rolling Calmar Ratio:**
+       - Compute the rolling Calmar Ratio over a specified window (e.g., 252 days):
+    """)
+    st.latex(r'''
+    \text{Calmar Ratio}_t = \frac{\text{CAGR}_{t-n:t}}{\text{Max Drawdown}_{t-n:t}}
+    ''')
+    st.markdown("""
+       where \( \text{CAGR} \) is the Compound Annual Growth Rate and \( \text{Max Drawdown} \) is the maximum drawdown over the window \( n \) (e.g., 252 days).
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling Calmar Ratio.
+
+    **Results:**
+    The chart shows the close prices along with the rolling Calmar Ratio over time, indicating the performance of the stock relative to its maximum drawdown.
+    """)
+
+    fig = plot_rolling_calmar(data)
+    st.plotly_chart(fig)
+
+
+elif selected == "Rolling Stability":
+    st.markdown("""
+    ### Rolling Stability
+
+    This method calculates the rolling 1-year stability of returns.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Rolling Stability:**
+       - Compute the rolling stability over a specified window (e.g., 252 days):
+    """)
+    st.latex(r'''
+    \text{Stability}_t = \sqrt{\frac{1}{n-1} \sum_{i=1}^{n} (\log(1 + \text{Return}_{t-i}) - \overline{\log(1 + \text{Return})})^2}
+    ''')
+    st.markdown("""
+       where \( n \) is the window size (e.g., 252 days) and \( \overline{\log(1 + \text{Return})} \) is the mean of the log returns over the window.
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling stability.
+
+    **Results:**
+    The chart shows the close prices along with the rolling stability over time, indicating the consistency of returns.
+    """)
+
+    fig = plot_rolling_stability(data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Maximum Drawdown":
+    st.markdown("""
+    ### Rolling Maximum Drawdown
+
+    This method calculates the rolling 1-year maximum drawdown.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Rolling Maximum Drawdown:**
+       - Compute the cumulative returns and the maximum drawdown over a specified window (e.g., 252 days):
+    """)
+    st.latex(r'''
+    \text{Cumulative Return}_t = \prod_{i=1}^{t} (1 + \text{Return}_i)
+    ''')
+    st.latex(r'''
+    \text{Max Drawdown}_t = \frac{\text{Cumulative Return}_t - \text{Rolling Max Cumulative Return}_t}{\text{Rolling Max Cumulative Return}_t}
+    ''')
+    st.markdown("""
+       where the Rolling Max Cumulative Return is the maximum cumulative return over the window.
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling maximum drawdown.
+
+    **Results:**
+    The chart shows the close prices along with the rolling maximum drawdown over time, indicating the peak-to-trough decline during a specified period.
+    """)
+
+    fig = plot_rolling_drawdown(data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Capture Ratios":
+    st.markdown("""
+    ### Rolling Capture Ratios
+
+    This method calculates the rolling 1-year upside and downside capture ratios.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock and the benchmark:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Upside Capture Ratio:**
+       - Compute the ratio of the sum of the stock's returns to the sum of the benchmark's returns during periods when the benchmark's returns are positive:
+    """)
+    st.latex(r'''
+    \text{Upside Capture Ratio}_t = \frac{\sum_{i=1}^{t} \text{Return}_{\text{stock}, i}}{\sum_{i=1}^{t} \text{Return}_{\text{benchmark}, i}}, \quad \text{if } \text{Return}_{\text{benchmark}, i} > 0
+    ''')
+    st.markdown("""
+    3. **Calculate Downside Capture Ratio:**
+       - Compute the ratio of the sum of the stock's returns to the sum of the benchmark's returns during periods when the benchmark's returns are negative:
+    """)
+    st.latex(r'''
+    \text{Downside Capture Ratio}_t = \frac{\sum_{i=1}^{t} \text{Return}_{\text{stock}, i}}{\sum_{i=1}^{t} \text{Return}_{\text{benchmark}, i}}, \quad \text{if } \text{Return}_{\text{benchmark}, i} < 0
+    ''')
+    st.markdown("""
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Enter the benchmark ticker.
+    3. Click 'Fetch Data' to load the stock and benchmark data.
+    4. The chart will display the rolling capture ratios.
+
+    **Results:**
+    The chart shows the close prices along with the rolling upside and downside capture ratios over time, indicating the stock's performance relative to the benchmark during up and down market conditions.
+    """)
+
+    fig = plot_rolling_capture(data, market_data)
+    st.plotly_chart(fig)
+
+elif selected == "Rolling Pain Index":
+    st.markdown("""
+    ### Rolling Pain Index
+
+    This method calculates the rolling 1-year pain index.
+
+    **Methodology:**
+
+    1. **Calculate Returns:**
+       - Compute the daily returns of the stock:
+    """)
+    st.latex(r'''
+    \text{Return}_t = \frac{P_t - P_{t-1}}{P_{t-1}}
+    ''')
+    st.markdown("""
+       where \( P_t \) is the closing price at time \( t \).
+
+    2. **Calculate Cumulative Returns:**
+       - Compute the cumulative returns over time:
+    """)
+    st.latex(r'''
+    \text{Cumulative Return}_t = \prod_{i=1}^{t} (1 + \text{Return}_i)
+    ''')
+    st.markdown("""
+    3. **Calculate Drawdowns:**
+       - Determine the drawdowns by comparing the cumulative returns to their running maximum:
+    """)
+    st.latex(r'''
+    \text{Drawdown}_t = \frac{\text{Cumulative Return}_t - \text{Running Max Cumulative Return}_t}{\text{Running Max Cumulative Return}_t}
+    ''')
+    st.markdown("""
+    4. **Calculate Rolling Pain Index:**
+       - Compute the average drawdown over a specified window (e.g., 252 days) where the drawdown is negative:
+    """)
+    st.latex(r'''
+    \text{Pain Index} = \frac{1}{n} \sum_{i=1}^{n} \text{Drawdown}_i \quad \text{for } \text{Drawdown}_i < 0
+    ''')
+    st.markdown("""
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Click 'Fetch Data' to load the stock data.
+    3. The chart will display the rolling pain index.
+
+    **Results:**
+    The chart shows the close prices along with the rolling pain index over time, indicating the average drawdown experienced over a specified period.
+    """)
+
+    fig = plot_rolling_pain_index(data)
+    st.plotly_chart(fig)
+
+hide_streamlit_style = """
+<style>
+#MainMenu {visibility: hidden;}
+footer {visibility: hidden;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)