Session 8: Risk Management & Value at Risk

Contents

Session 8: Risk Management & Value at Risk#

Quantifying and Managing Portfolio Risk#

Learning Objectives#

By the end of this session, you will be able to:

  1. Calculate Value at Risk (VaR) - Measure potential portfolio losses using historical, parametric, and Monte Carlo methods

  2. Implement Risk Monitoring Systems - Build automated risk alerts with limit monitoring and breach detection

  3. Conduct Stress Testing - Analyze portfolio performance under extreme market scenarios

  4. Validate Risk Models - Backtest VaR calculations and ensure model accuracy

  5. Present Risk Analysis Professionally - Communicate risk findings clearly in video presentations

Section 1: The Financial Hook - When Risk Models Failed Spectacularly#

The $4.6 Billion Wake-Up Call#

In 1998, Long-Term Capital Management (LTCM) - a hedge fund run by Nobel Prize winners and Wall Street legends - collapsed spectacularly:

LTCM’s Fatal Flaw:

  • Had the most sophisticated risk models on Wall Street

  • Calculated daily VaR at $45 million (they could lose at most $45M on a typical day)

  • August 1998: Lost $550 million in ONE DAY (12x their VaR!)

  • Total loss: $4.6 billion in 4 months

  • Required Federal Reserve orchestrated bailout

  • Note: VaR is conventionally reported as a positive number representing a potential loss, even though the calculation may yield a negative value.

The Lesson: Even the best risk models fail when they’re needed most. But having NO risk management is far worse.

Modern Risk Management Success#

JP Morgan’s Daily Discipline:

  • Reviews VaR across all trading desks every morning at 7:30 AM

  • Average daily trading VaR: $50-100 million

  • Survived 2008 crisis better than any major bank

  • CEO Jamie Dimon: “We manage risk, not avoid it”

What is Value at Risk (VaR)?#

Value at Risk (VaR) answers one simple question: “What’s the most I can lose on a normal bad day?” VaR is conventionally reported as a positive number representing a potential loss, even though the calculation may yield a negative value.

Think of VaR like a weather forecast:

  • A weather app might say: “95% chance it won’t rain more than 2 inches tomorrow”

  • VaR says: “95% chance we won’t lose more than $X tomorrow”

  • Both help you prepare for likely scenarios (but extreme events can still surprise you!)

The VaR Framework:

📊 RISK MEASUREMENT HIERARCHY

Daily Monitoring:
├── VaR (95%): Expected worst daily loss
├── VaR (99%): More conservative measure
└── Expected Shortfall: Average loss beyond VaR

Risk Types:
├── Market Risk: Price movements
├── Credit Risk: Counterparty defaults
├── Liquidity Risk: Can't sell positions
└── Operational Risk: System failures

Professional Standards:
├── Basel III: Banks must calculate VaR daily
├── SEC Requirements: Fund risk disclosure
└── GIPS Standards: Performance reporting

Real-World Impact#

Goldman Sachs Risk Dashboard (typical day):

  • Trading VaR: $95 million

  • Actual P&L: +$45 million

  • VaR Utilization: 47% of limit

  • Status: Within risk appetite

Contrast with Archegos Capital (March 2021):

  • No proper VaR limits

  • Leveraged 5:1 using derivatives

  • Lost $20 billion in 2 days

  • Banks lost $10 billion on exposures

🎯 AI Learning Support - Understanding Risk Management#

Learning Goal: Develop intuition for why systematic risk measurement prevents catastrophic losses

Starting Prompt: “Explain what Value at Risk measures in portfolio management”

🚀 Hints to Improve Your Prompt:

  • Add specific confidence levels (95% vs 99%)

  • Include time horizons (daily vs monthly VaR)

  • Ask about different calculation methods

  • Request real-world examples from major banks

💡 Better Version Hints:

  • Compare VaR limitations vs benefits

  • Include stress testing beyond VaR

  • Ask about regulatory requirements

  • Request crisis period examples (2008, 2020)

🎯 Your Challenge: Create a prompt that helps you understand when VaR works well and when it fails

Section 2: Foundational Financial Concepts & Models#

Core Risk Management Concepts#

1. Value at Risk (VaR) Fundamentals#

What is VaR? VaR is a statistical measure that quantifies the potential loss in value of a portfolio over a defined time period for a given confidence interval. If your 1-day 95% VaR is $100,000, it means you’re 95% confident you won’t lose more than $100,000 tomorrow.

Three Ways to Calculate VaR:

  1. Historical VaR: Uses actual past returns

    • Pros: No distribution assumptions, captures real market behavior

    • Cons: Assumes history repeats, misses unprecedented events

  2. Parametric VaR: Assumes normal distribution

    • Pros: Quick calculation, well-understood statistics

    • Cons: Markets aren’t normal, underestimates tail risk

  3. Monte Carlo VaR: Simulates thousands of scenarios

    • Pros: Flexible, can model complex portfolios

    • Cons: Computationally intensive, model dependent

Mathematical Formulas:

Parametric VaR: \(\text{VaR} = \text{Portfolio Value} \times (\mu - \sigma \times z_{\alpha})\)

Where:

  • \(\mu\) = expected portfolio return (often assumed to be 0 for daily VaR)

  • \(\sigma\) = portfolio standard deviation (volatility)

  • \(z_{\alpha}\) = critical value from normal distribution

    • For 95% confidence: \(z = 1.645\)

    • For 99% confidence: \(z = 2.326\)

Note on the Formula: - For simplicity, especially over short horizons like one day, the expected return (μ) is often assumed to be zero. The formula then simplifies to Portfolio Value * σ * z_α. However, the more complete formula includes the expected return, which can be significant over longer periods. - VaR is conventionally reported as a positive number representing a potential loss, even though the calculation may yield a negative value.

Portfolio Volatility: $\(\sigma_p = \sqrt{\sum_{i=1}^{n} \sum_{j=1}^{n} w_i w_j \sigma_i \sigma_j \rho_{ij}}\)$

Where:

  • \(w_i, w_j\) = asset weights

  • \(\sigma_i, \sigma_j\) = asset volatilities

  • \(\rho_{ij}\) = correlation between assets i and j

2. Expected Shortfall (ES)#

What is Expected Shortfall? Expected Shortfall (also called Conditional VaR) measures the average loss when things go worse than your VaR threshold. If VaR tells you the “edge of the cliff,” ES tells you “how far you might fall.”

Formula: $\(\text{ES} = \text{Average of all losses beyond VaR threshold}\)$

3. Risk Metrics Beyond VaR#

Metric

What It Measures

Use Case

Maximum Drawdown

Largest peak-to-trough decline

Long-term risk tolerance

Volatility

Standard deviation of returns

General risk measure

Beta

Sensitivity to market moves

Systematic risk

Tracking Error

Deviation from benchmark

Active management risk

Sharpe Ratio

Return per unit of risk

Risk-adjusted performance

4. Stress Testing#

What is Stress Testing? Stress testing analyzes how your portfolio would perform in extreme scenarios - like market crashes, interest rate spikes, or credit crises. Think of it as asking “what if the worst happens?”

Common Stress Scenarios:

  • Historical scenarios (2008 crisis, COVID crash)

  • Hypothetical scenarios (10% interest rates)

  • Reverse stress tests (what would cause 25% loss?)

Risk Management Process#

Professional Risk Management Cycle:

  1. Identify: What risks does the portfolio face?

  2. Measure: Quantify using VaR, ES, stress tests

  3. Monitor: Track against limits continuously

  4. Control: Take action when limits breached

  5. Report: Communicate to stakeholders

  6. Review: Validate and improve models

🎯 AI Learning Support - Risk Calculation Methods#

Learning Goal: Understand different approaches to calculating portfolio risk

Starting Prompt: “Compare different methods for calculating Value at Risk”

🚀 Hints to Improve Your Prompt:

  • Specify portfolio types (equity, multi-asset)

  • Include pros/cons of each method

  • Ask for numerical examples

  • Request accuracy comparisons

💡 Better Version Hints:

  • Include correlation effects

  • Ask about non-normal distributions

  • Request computational requirements

  • Include regulatory preferences

🎯 Your Challenge: Create a prompt comparing VaR calculation methods for a specific portfolio you’re interested in

Section 3: The Financial Gym - Partner Practice & AI Copilot Learning#

Hands-On Risk Management Exercises#

Exercise 1: Calculate Your First VaR#

Individual Task (15 minutes):

Calculate VaR for a simple portfolio using all three methods:

import numpy as np
import pandas as pd

# Simple VaR calculation example
# Step 1: Define portfolio
portfolio_value = 1000000  # $1 million portfolio
confidence_level = 0.95    # 95% confidence

# Step 2: Historical returns (simplified example)
# In practice, you'd download real data
daily_returns = np.array([-0.02, 0.01, -0.015, 0.008, -0.025, 
                         0.012, -0.005, 0.018, -0.01, 0.005,
                         -0.03, 0.02, -0.008, 0.015, -0.012])

# Step 3: Calculate Historical VaR
# Sort returns from worst to best
sorted_returns = np.sort(daily_returns)
print(f"Sorted returns: {sorted_returns[:5]}...")  # Show worst 5

# Find the 5th percentile (for 95% confidence)
var_index = int((1 - confidence_level) * len(sorted_returns))
historical_var = sorted_returns[var_index]
historical_var_dollar = abs(historical_var) * portfolio_value

print(f"\nHistorical VaR:")
print(f"  Daily VaR: {historical_var:.3%}")
print(f"  Dollar VaR: ${historical_var_dollar:,.0f}")

# Step 4: Calculate Parametric VaR
mean_return = np.mean(daily_returns)
std_return = np.std(daily_returns)
z_score = 1.645  # 95% confidence

parametric_var = mean_return - (z_score * std_return)
parametric_var_dollar = abs(parametric_var) * portfolio_value

print(f"\nParametric VaR:")
print(f"  Mean return: {mean_return:.3%}")
print(f"  Std deviation: {std_return:.3%}")
print(f"  Daily VaR: {parametric_var:.3%}")
print(f"  Dollar VaR: ${parametric_var_dollar:,.0f}")

# Step 5: Simple Monte Carlo VaR
np.random.seed(42)  # For reproducibility
n_simulations = 10000

# Generate random returns
simulated_returns = np.random.normal(mean_return, std_return, n_simulations)

# Calculate VaR from simulations
var_percentile = (1 - confidence_level) * 100
monte_carlo_var = np.percentile(simulated_returns, var_percentile)
monte_carlo_var_dollar = abs(monte_carlo_var) * portfolio_value

print(f"\nMonte Carlo VaR ({n_simulations} simulations):")
print(f"  Daily VaR: {monte_carlo_var:.3%}")
print(f"  Dollar VaR: ${monte_carlo_var_dollar:,.0f}")

🎯 AI Learning Support - VaR Implementation#

Learning Goal: Learn to implement VaR calculations step-by-step

Starting Prompt: “Help me implement Value at Risk calculation in Python”

🚀 Hints to Improve Your Prompt:

  • Specify which VaR method to implement

  • Include portfolio details

  • Ask for code comments

  • Request error handling

💡 Better Version Hints:

  • Include multiple asset portfolios

  • Add correlation considerations

  • Request visualization code

  • Include confidence interval options

🎯 Your Challenge: Modify the code to calculate 99% VaR and compare with 95% VaR

Exercise 2: Partner Teaching - Risk Limits#

AI Collaboration Phase (10 minutes): Work with AI to understand risk limit setting, then teach your partner.

Partner Discussion Points:

  1. How do you set appropriate VaR limits?

  2. What happens when limits are breached?

  3. How often should you monitor risk?

  4. What’s the difference between hard and soft limits?

🎯 AI Learning Support - Risk Limit Framework#

Learning Goal: Understand how to set and monitor risk limits effectively

Starting Prompt: “Explain how to set risk limits for portfolio management”

🚀 Hints to Improve Your Prompt:

  • Include portfolio size and type

  • Add regulatory considerations

  • Ask about breach procedures

  • Request escalation frameworks

💡 Better Version Hints:

  • Compare limit types (VaR, exposure, concentration)

  • Include dynamic limit adjustment

  • Ask about limit utilization tracking

  • Request committee governance structure

🎯 Your Challenge: Design a risk limit framework for a $100 million equity portfolio

Exercise 3: Build a Risk Alert System#

Group Challenge (20 minutes):

Create a simple risk monitoring system with alerts:

# Risk Monitoring System
# Step 1: Define risk limits
risk_limits = {
    'var_limit': 0.02,          # 2% daily VaR limit
    'loss_limit': 0.05,         # 5% loss triggers alert
    'volatility_spike': 1.5,    # 50% volatility increase
    'concentration_limit': 0.20  # 20% single position limit
}

# Step 2: Check current risk metrics
current_metrics = {
    'current_var': 0.025,       # Current VaR is 2.5%
    'daily_loss': 0.03,         # Lost 3% today
    'volatility_ratio': 1.8,    # Volatility 80% above normal
    'max_position': 0.15        # Largest position is 15%
}

# Step 3: Monitor and alert
print("=== RISK MONITORING SYSTEM ===")
alerts = []

# Check each limit
if current_metrics['current_var'] > risk_limits['var_limit']:
    alert = f"⚠️ VaR BREACH: {current_metrics['current_var']:.1%} > {risk_limits['var_limit']:.1%}"
    alerts.append(alert)
    print(alert)

if current_metrics['daily_loss'] > risk_limits['loss_limit']:
    alert = f"🚨 LOSS LIMIT BREACH: {current_metrics['daily_loss']:.1%} loss"
    alerts.append(alert)
    print(alert)

if current_metrics['volatility_ratio'] > risk_limits['volatility_spike']:
    alert = f"⚠️ VOLATILITY SPIKE: {current_metrics['volatility_ratio']:.1f}x normal"
    alerts.append(alert)
    print(alert)

# Step 4: Summary and actions
print(f"\nTotal Alerts: {len(alerts)}")
if len(alerts) > 0:
    print("\nREQUIRED ACTIONS:")
    print("1. Review all positions immediately")
    print("2. Consider reducing exposure")
    print("3. Report to risk committee")
else:
    print("✅ All risk metrics within limits")

Reciprocal Teaching Component#

Teaching Requirements:

  1. Explain VaR calculation to your partner

  2. Walk through the alert system logic

  3. Discuss what actions to take on alerts

  4. Compare different risk measures

🎯 AI Learning Support - Risk System Design#

Learning Goal: Design effective risk monitoring and alert systems

Starting Prompt: “How do I build a risk monitoring system for portfolios?”

🚀 Hints to Improve Your Prompt:

  • Include specific metrics to monitor

  • Add alert priority levels

  • Ask for automation approaches

  • Request reporting templates

💡 Better Version Hints:

  • Include real-time monitoring needs

  • Add dashboard design elements

  • Request integration with trading systems

  • Include audit trail requirements

🎯 Your Challenge: Enhance the system to send email alerts when limits are breached

Section 4: The Financial Coaching - Your DRIVER Learning Guide#

Complete Risk Management Case Study: Hedge Fund Risk System#

You’ve been hired as the Risk Manager for Apex Capital, a $2 billion hedge fund. Recent market volatility has the board demanding better risk controls.

D - Define & Discover#

Objective: Understand the fund’s risk profile and requirements

# Hedge Fund Risk Assessment
# Step 1: Define fund characteristics
fund_aum = 2_000_000_000  # $2 billion
leverage = 2.0            # 2:1 leverage
gross_exposure = fund_aum * leverage
strategies = ['long/short equity', 'merger arbitrage', 'convertible arbitrage']

print(f"=== APEX CAPITAL RISK PROFILE ===")
print(f"AUM: ${fund_aum/1e9:.1f} billion")
print(f"Leverage: {leverage:.1f}x")
print(f"Gross Exposure: ${gross_exposure/1e9:.1f} billion")
print(f"Strategies: {', '.join(strategies)}")

# Step 2: Define risk parameters
risk_params = {
    'target_volatility': 0.12,      # 12% annual volatility target
    'max_var_95': 0.02,            # 2% daily VaR limit
    'max_drawdown': 0.10,          # 10% drawdown limit
    'stress_loss_limit': 0.15,     # 15% stress scenario limit
    'margin_buffer': 1.5           # 50% margin buffer required
}

print(f"\nRisk Management Parameters:")
for param, value in risk_params.items():
    print(f"  {param}: {value:.1%}" if value < 1 else f"  {param}: {value:.1f}x")

# Step 3: Identify key risks
key_risks = {
    'market_risk': 'Equity market exposure and factor risks',
    'leverage_risk': 'Amplified losses from 2x leverage',
    'liquidity_risk': 'Position concentration in small-caps',
    'model_risk': 'Arbitrage models may fail in crisis'
}

print(f"\nKey Risk Factors:")
for risk_type, description in key_risks.items():
    print(f"  {risk_type}: {description}")

🎯 AI Learning Support - Hedge Fund Risk#

Learning Goal: Understand unique risk challenges in leveraged hedge fund portfolios

Starting Prompt: “Explain risk management for hedge funds vs traditional portfolios”

🚀 Hints to Improve Your Prompt:

  • Include leverage considerations

  • Add strategy-specific risks

  • Ask about prime broker requirements

  • Request liquidity management approaches

💡 Better Version Hints:

  • Compare different hedge fund strategies

  • Include counterparty risk aspects

  • Ask about regulatory requirements

  • Request crisis management protocols

🎯 Your Challenge: Design risk limits appropriate for a leveraged hedge fund

R - Represent#

Objective: Map out the complete risk management framework

# Risk Management Framework Design
# Step 1: Create risk measurement hierarchy
print("=== RISK MEASUREMENT FRAMEWORK ===")

# Portfolio composition (simplified)
portfolio = {
    'long_equity': 1_200_000_000,
    'short_equity': -800_000_000,
    'merger_arb': 400_000_000,
    'convert_arb': 200_000_000,
    'cash': 200_000_000
}

# Step 2: Calculate exposures
gross_long = sum(v for v in portfolio.values() if v > 0)
gross_short = abs(sum(v for v in portfolio.values() if v < 0))
net_exposure = sum(portfolio.values())
gross_exposure = gross_long + gross_short

print(f"Exposure Analysis:")
print(f"  Gross Long: ${gross_long/1e6:,.0f}M")
print(f"  Gross Short: ${gross_short/1e6:,.0f}M")
print(f"  Net Exposure: ${net_exposure/1e6:,.0f}M")
print(f"  Gross Exposure: ${gross_exposure/1e6:,.0f}M")
print(f"  Gross/Net Ratio: {gross_exposure/net_exposure:.1f}x")

# Step 3: Risk bucketing
risk_buckets = {
    'equity_market_risk': 0.60,
    'credit_spread_risk': 0.20,
    'volatility_risk': 0.10,
    'liquidity_risk': 0.10
}

print(f"\nRisk Decomposition:")
for risk_type, weight in risk_buckets.items():
    print(f"  {risk_type}: {weight:.0%} of total risk")

# Step 4: Monitoring frequency
monitoring_schedule = {
    'var_calculation': 'Real-time',
    'stress_testing': 'Daily',
    'liquidity_analysis': 'Daily',
    'factor_analysis': 'Weekly',
    'comprehensive_review': 'Monthly'
}

print(f"\nRisk Monitoring Schedule:")
for task, frequency in monitoring_schedule.items():
    print(f"  {task}: {frequency}")

🎯 AI Learning Support - Risk Framework Design#

Learning Goal: Build comprehensive risk frameworks for complex portfolios

Starting Prompt: “Help me design a risk management framework for a hedge fund”

🚀 Hints to Improve Your Prompt:

  • Include specific strategy types

  • Add technology requirements

  • Ask for governance structure

  • Request reporting hierarchy

💡 Better Version Hints:

  • Include risk committee structure

  • Add model validation requirements

  • Request documentation standards

  • Include regulatory reporting needs

🎯 Your Challenge: Create a visual representation of the risk management process

I - Implement#

Objective: Build the risk measurement and monitoring system

# Risk System Implementation
import numpy as np

# Step 1: Generate sample returns for different strategies
np.random.seed(42)
days = 252

# Strategy correlations and volatilities
strategy_vols = {
    'long_equity': 0.15,
    'short_equity': 0.12,
    'merger_arb': 0.08,
    'convert_arb': 0.10
}

# Generate correlated returns (simplified)
long_returns = np.random.normal(0.0004, strategy_vols['long_equity']/np.sqrt(252), days)
short_returns = np.random.normal(0.0002, strategy_vols['short_equity']/np.sqrt(252), days)
merger_returns = np.random.normal(0.0003, strategy_vols['merger_arb']/np.sqrt(252), days)
convert_returns = np.random.normal(0.0003, strategy_vols['convert_arb']/np.sqrt(252), days)

# Step 2: Calculate portfolio returns
portfolio_weights = {
    'long_equity': 1200/2000,
    'short_equity': -800/2000,
    'merger_arb': 400/2000,
    'convert_arb': 200/2000
}

portfolio_returns = []
for i in range(days):
    daily_return = (
        portfolio_weights['long_equity'] * long_returns[i] +
        portfolio_weights['short_equity'] * short_returns[i] +
        portfolio_weights['merger_arb'] * merger_returns[i] +
        portfolio_weights['convert_arb'] * convert_returns[i]
    )
    portfolio_returns.append(daily_return)

portfolio_returns = np.array(portfolio_returns)

# Step 3: Calculate VaR
confidence_level = 0.95
var_percentile = (1 - confidence_level) * 100
historical_var = np.percentile(portfolio_returns, var_percentile)
var_dollar = abs(historical_var) * fund_aum

print(f"=== DAILY RISK REPORT ===")
print(f"Portfolio VaR (95%): {abs(historical_var):.2%}")
print(f"Dollar VaR: ${var_dollar/1e6:.1f}M")
print(f"VaR Limit: {risk_params['max_var_95']:.1%}")

# Check limit
if abs(historical_var) > risk_params['max_var_95']:
    print(f"🚨 VaR LIMIT BREACH!")
else:
    print(f"✅ VaR within limit")

# Step 4: Calculate other risk metrics
volatility = np.std(portfolio_returns) * np.sqrt(252)
sharpe = (np.mean(portfolio_returns) * 252 - 0.02) / volatility
max_drawdown = np.min(np.minimum.accumulate(portfolio_returns.cumsum()))

print(f"\nRisk Metrics:")
print(f"  Annualized Volatility: {volatility:.1%}")
print(f"  Sharpe Ratio: {sharpe:.2f}")
print(f"  Maximum Drawdown: {max_drawdown:.1%}")

# Step 5: Expected Shortfall
tail_returns = portfolio_returns[portfolio_returns <= historical_var]
expected_shortfall = np.mean(tail_returns)
es_dollar = abs(expected_shortfall) * fund_aum

print(f"\nTail Risk Analysis:")
print(f"  Expected Shortfall: {abs(expected_shortfall):.2%}")
print(f"  Dollar ES: ${es_dollar/1e6:.1f}M")
print(f"  ES/VaR Ratio: {abs(expected_shortfall/historical_var):.2f}")

🎯 AI Learning Support - Risk Implementation#

Learning Goal: Implement professional-grade risk calculations

Starting Prompt: “Show me how to calculate portfolio risk metrics in Python”

🚀 Hints to Improve Your Prompt:

  • Include specific metrics needed

  • Add multi-asset considerations

  • Ask for optimization tips

  • Request validation methods

💡 Better Version Hints:

  • Include correlation matrices

  • Add factor model approaches

  • Request incremental VaR

  • Include marginal risk contributions

🎯 Your Challenge: Extend the system to calculate risk contributions by strategy

V - Validate#

Objective: Ensure risk measurements are accurate and reliable

# Risk Model Validation
# Step 1: Backtest VaR model
print("=== VAR MODEL VALIDATION ===")

# Count VaR breaches
var_threshold = historical_var
breaches = np.sum(portfolio_returns <= var_threshold)
breach_rate = breaches / len(portfolio_returns)
expected_breach_rate = 1 - confidence_level

print(f"VaR Backtesting:")
print(f"  Total observations: {len(portfolio_returns)}")
print(f"  VaR breaches: {breaches}")
print(f"  Actual breach rate: {breach_rate:.1%}")
print(f"  Expected breach rate: {expected_breach_rate:.1%}")
print(f"  Statistical test: {'PASS' if 3 <= breach_rate*100 <= 7 else 'FAIL'}")

# Step 2: Stress test scenarios
print(f"\n=== STRESS TEST RESULTS ===")

stress_scenarios = {
    'equity_crash': -0.20,      # 20% equity market crash
    'credit_crisis': -0.15,     # Credit spread blowout
    'liquidity_freeze': -0.25,  # Cannot exit positions
    'model_failure': -0.10      # Arbitrage convergence fails
}

for scenario, impact in stress_scenarios.items():
    loss = impact * fund_aum
    print(f"{scenario}: {impact:.0%} loss = ${abs(loss)/1e6:.0f}M")

# Step 3: Model sensitivity analysis
print(f"\n=== SENSITIVITY ANALYSIS ===")

# Test different confidence levels
for conf in [0.90, 0.95, 0.99]:
    var_test = np.percentile(portfolio_returns, (1-conf)*100)
    print(f"VaR at {conf:.0%} confidence: {abs(var_test):.2%}")

# Step 4: Validation summary
print(f"\n=== VALIDATION SUMMARY ===")
validation_checks = {
    'Backtest Result': 'PASS' if 3 <= breach_rate*100 <= 7 else 'FAIL',
    'ES/VaR Ratio': 'PASS' if abs(expected_shortfall/historical_var) > 1 else 'FAIL',
    'Stress Test': 'PASS' if all(abs(impact) < 0.30 for impact in stress_scenarios.values()) else 'FAIL',
    'Data Quality': 'PASS'  # Simplified
}

passed = sum(1 for result in validation_checks.values() if result == 'PASS')
print(f"Validation Score: {passed}/{len(validation_checks)}")

for check, result in validation_checks.items():
    print(f"  {check}: {result}")

🎯 AI Learning Support - Model Validation#

Learning Goal: Validate risk models to ensure accuracy and reliability

Starting Prompt: “How do I validate a VaR model for accuracy?”

🚀 Hints to Improve Your Prompt:

  • Include statistical tests required

  • Add regulatory standards

  • Ask about sample size needs

  • Request documentation requirements

💡 Better Version Hints:

  • Include Kupiec and Christoffersen tests

  • Add model comparison methods

  • Request P&L attribution

  • Include model risk framework

🎯 Your Challenge: Design a complete validation framework for production use

E - Evolve#

Objective: Enhance the risk system with advanced features

# Enhanced Risk Features
# Step 1: Factor-based risk decomposition
print("=== FACTOR RISK ANALYSIS ===")

# Simple factor exposures
factor_exposures = {
    'market_beta': 0.8,
    'value_factor': 0.3,
    'momentum_factor': -0.2,
    'volatility_factor': -0.4
}

factor_vols = {
    'market_beta': 0.15,
    'value_factor': 0.08,
    'momentum_factor': 0.10,
    'volatility_factor': 0.12
}

# Calculate factor contributions to risk
print("Factor Risk Contributions:")
total_factor_risk = 0
for factor, exposure in factor_exposures.items():
    factor_risk = abs(exposure) * factor_vols[factor]
    total_factor_risk += factor_risk
    print(f"  {factor}: {factor_risk:.1%}")

print(f"Total Factor Risk: {total_factor_risk:.1%}")

# Step 2: Liquidity risk analysis
print(f"\n=== LIQUIDITY RISK ANALYSIS ===")

position_sizes = {
    'AAPL': 50_000_000,
    'Small_Cap_Basket': 100_000_000,
    'Merger_Targets': 80_000_000,
    'Convertibles': 40_000_000
}

avg_daily_volumes = {
    'AAPL': 5_000_000_000,
    'Small_Cap_Basket': 50_000_000,
    'Merger_Targets': 20_000_000,
    'Convertibles': 10_000_000
}

print("Days to Liquidate (at 20% of volume):")
for position, size in position_sizes.items():
    daily_volume = avg_daily_volumes[position]
    max_daily_trade = daily_volume * 0.20
    days_to_exit = size / max_daily_trade
    print(f"  {position}: {days_to_exit:.1f} days")

# Step 3: Real-time risk dashboard metrics
print(f"\n=== RISK DASHBOARD METRICS ===")

dashboard_metrics = {
    'VaR_Utilization': abs(historical_var) / risk_params['max_var_95'] * 100,
    'Volatility_vs_Target': volatility / risk_params['target_volatility'] * 100,
    'Leverage_Used': leverage,
    'Cash_Buffer': 200_000_000 / fund_aum * 100,
    'Risk_Score': 75  # Composite score
}

for metric, value in dashboard_metrics.items():
    if 'Score' in metric or 'Utilization' in metric:
        print(f"  {metric}: {value:.0f}%")
    else:
        print(f"  {metric}: {value:.1f}")

# Step 4: Risk recommendations
print(f"\n=== RISK RECOMMENDATIONS ===")
if dashboard_metrics['VaR_Utilization'] > 80:
    print("⚠️ Reduce position sizes - approaching VaR limit")
if dashboard_metrics['Volatility_vs_Target'] > 120:
    print("⚠️ Volatility exceeds target - review exposures")
if dashboard_metrics['Cash_Buffer'] < 5:
    print("⚠️ Increase cash buffer for margin calls")

🎯 AI Learning Support - Advanced Risk Features#

Learning Goal: Explore cutting-edge risk management techniques

Starting Prompt: “What advanced risk management features do hedge funds use?”

🚀 Hints to Improve Your Prompt:

  • Include machine learning applications

  • Add real-time monitoring needs

  • Ask about alternative data usage

  • Request automation strategies

💡 Better Version Hints:

  • Include neural network models

  • Add sentiment risk indicators

  • Request regime detection methods

  • Include portfolio insurance strategies

🎯 Your Challenge: Design one innovative risk feature for modern markets

R - Reflect#

Key Insights from Risk Management Implementation:

  1. VaR Has Limitations: It only captures “normal” bad days, not extreme events

  2. Multiple Measures Needed: Combine VaR, ES, stress tests for complete picture

  3. Validation is Critical: Models fail - validate constantly

  4. Speed Matters: Risk changes quickly in leveraged portfolios

Professional Applications:

  • Banks use these systems for regulatory capital

  • Hedge funds for daily risk monitoring

  • Asset managers for client reporting

  • Insurers for reserve calculations

🎯 AI Learning Support - Risk Management Careers#

Learning Goal: Connect risk management skills to career opportunities

Starting Prompt: “What careers are available in financial risk management?”

🚀 Hints to Improve Your Prompt:

  • Include specific role types

  • Add required certifications (FRM, PRM)

  • Ask about career progression

  • Request compensation ranges

💡 Better Version Hints:

  • Include emerging roles in crypto/DeFi

  • Add climate risk positions

  • Request skills for each role

  • Include interview preparation

🎯 Your Challenge: Research three risk management job postings and identify required skills

Section 5: Assignment#

Scenario#

You’re the risk manager at a hedge fund. After a recent 8% single-day loss that your current risk system didn’t predict, the board demands a comprehensive risk management overhaul. You need to implement Value at Risk (VaR) and stress testing to better monitor and control portfolio risk.

Requirements#

Create a video (approximately 10-15 minutes) demonstrating:

  • Portfolio construction with at least 5 securities and risk analysis

  • Implementation of VaR using both historical and parametric methods

  • Stress testing including historical scenarios and custom shocks

  • Risk interpretation and actionable recommendations for risk limits

Execution Format#

  • Use your completed Jupyter notebook or Python script

  • Run your code cell-by-cell while explaining what each part does

  • Show outputs including VaR numbers and stress test results

  • Discuss the limitations of VaR and importance of multiple risk metrics

Deliverables#

  1. Video demonstration showing code execution and analysis

  2. Python code file (.py or .ipynb)

Section 6: Reflect & Connect - Financial Insights Discussion#

Individual Reflection (10 minutes)#

Consider these questions about risk management:

  1. Why do sophisticated risk models sometimes fail catastrophically?

    • Think about model assumptions

    • Consider black swan events

    • Reflect on correlation breakdowns

  2. How does VaR help and hinder decision making?

    • Consider psychological effects

    • Think about overconfidence

    • Reflect on regulatory uses

  3. What’s the difference between risk measurement and risk management?

    • Think about human factors

    • Consider organizational culture

    • Reflect on incentive structures

  4. Why is Expected Shortfall becoming preferred over VaR?

    • Consider tail risk importance

    • Think about coherent risk measures

    • Reflect on regulatory evolution

Partner Discussion (15 minutes)#

Share your insights with a partner:

  1. Compare Risk Philosophies: How conservative vs aggressive should limits be?

  2. Model Selection: Which VaR method works best for different portfolios?

  3. Crisis Management: How would you handle a major risk event?

  4. Career Interests: What risk management roles interest you?

🎯 AI Learning Support - Risk Insights#

Learning Goal: Develop deeper understanding of risk management philosophy

Starting Prompt: “What are the key insights from financial risk management?”

🚀 Hints to Improve Your Prompt:

  • Include specific crisis examples

  • Add behavioral aspects

  • Ask about culture importance

  • Request future trends

💡 Better Version Hints:

  • Include systemic risk concepts

  • Add regulatory evolution

  • Request technology impacts

  • Include ESG risk integration

🎯 Your Challenge: Identify three risk management principles that transcend specific models

Class Synthesis (15 minutes)#

Key Risk Management Principles We Discovered:

  1. Risk Models Are Tools, Not Oracles

    • All models have assumptions and limitations

    • Multiple models provide robustness

    • Human judgment remains essential

  2. Speed and Discipline Save Portfolios

    • Fast risk response prevents small losses becoming large

    • Systematic processes beat ad-hoc decisions

    • Pre-set limits remove emotion from decisions

  3. Tail Risk Matters Most

    • Normal days don’t kill portfolios, extreme days do

    • Expected Shortfall captures tail risk better than VaR

    • Stress testing reveals hidden vulnerabilities

  4. Risk Culture Beats Risk Models

    • Best models fail without proper governance

    • Incentives must align with risk management

    • Everyone owns risk, not just risk managers

Professional Applications#

Career Paths Using These Skills:

  • Market Risk Manager: Monitor trading desk risks at banks

  • Portfolio Risk Analyst: Measure fund risks for asset managers

  • Risk Technology: Build risk systems for financial firms

  • Regulatory Risk: Ensure compliance with Basel III/CFTC rules

  • Consultant: Advise on risk management best practices

Industry Certifications:

  • FRM (Financial Risk Manager) - Comprehensive risk certification

  • PRM (Professional Risk Manager) - Alternative to FRM

  • CFA Level 3 - Portfolio risk management

  • CAIA - Alternative investment risk

Connecting to Future Learning#

This session’s risk principles prepare you for:

  • Session 9: Trading Strategy Development - Risk-aware strategy design

  • Session 10: Fixed Income Analysis - Duration and credit risk

  • Session 11: Options & Derivatives - Hedging with Greeks

  • Session 12: Advanced Portfolio Strategies - Risk parity and beyond

Section 7: Looking Ahead - From Risk Management to Trading Strategies#

Skills You’ve Mastered#

✅ VaR Calculation: Multiple methods for measuring potential losses ✅ Risk Monitoring: Systematic tracking with alerts and limits ✅ Stress Testing: Analyzing extreme scenarios ✅ Model Validation: Ensuring risk measures are accurate ✅ Risk Communication: Presenting complex risks clearly

What’s Coming Next: Trading Strategy Development#

In Session 9, we’ll apply risk management to build trading strategies:

Preview of Key Concepts:

  • Strategy Design: Creating systematic trading rules

  • Backtesting: Testing strategies on historical data

  • Risk Controls: Stop-losses and position sizing

  • Performance Analysis: Sharpe ratios and drawdowns

  • Live Implementation: From backtest to production

Connection to Risk Management:

  • Risk limits determine position sizes

  • VaR constrains strategy leverage

  • Stress tests reveal strategy weaknesses

  • Risk metrics guide strategy selection

Preparation Suggestions#

Before Session 9:

  1. Review VaR calculations from this session

  2. Think about how to incorporate risk limits into trading

  3. Consider what makes a strategy “safe”

  4. Research famous trading strategy failures

Key Question to Ponder: “How would you design a trading strategy that can survive a 2008-style crisis?”

🎯 AI Learning Support - Bridging to Trading#

Learning Goal: Connect risk management to trading strategy development

Starting Prompt: “How does risk management inform trading strategy design?”

🚀 Hints to Improve Your Prompt:

  • Include position sizing methods

  • Add stop-loss frameworks

  • Ask about regime detection

  • Request strategy stress testing

💡 Better Version Hints:

  • Include Kelly criterion

  • Add risk budgeting for strategies

  • Request drawdown management

  • Include correlation strategies

🎯 Your Challenge: Design risk rules for a momentum trading strategy

Section 8: Appendix - Solutions & Implementation Guide#

Complete Solution Code#

"""
Professional Risk Management System
Complete implementation for institutional use
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import warnings
warnings.filterwarnings('ignore')

# SOLUTION 1: Complete VaR Calculation System
def calculate_var_multiple_methods(returns, portfolio_value, confidence_level=0.95):
    """
    Calculate VaR using three methods
    
    Parameters:
    - returns: array of portfolio returns
    - portfolio_value: total portfolio value
    - confidence_level: VaR confidence level
    
    Returns:
    - Dictionary with VaR calculations
    """
    
    # Method 1: Historical VaR
    var_percentile = (1 - confidence_level) * 100
    historical_var = np.percentile(returns, var_percentile)
    
    # Method 2: Parametric VaR
    mean_return = np.mean(returns)
    std_return = np.std(returns)
    z_score = stats.norm.ppf(1 - confidence_level)
    parametric_var = mean_return - z_score * std_return
    
    # Method 3: Monte Carlo VaR
    n_simulations = 10000
    np.random.seed(42)
    simulated_returns = np.random.normal(mean_return, std_return, n_simulations)
    monte_carlo_var = np.percentile(simulated_returns, var_percentile)
    
    # Calculate Expected Shortfall
    tail_returns = returns[returns <= historical_var]
    expected_shortfall = np.mean(tail_returns) if len(tail_returns) > 0 else historical_var
    
    return {
        'historical_var': historical_var,
        'historical_var_dollar': abs(historical_var) * portfolio_value,
        'parametric_var': parametric_var,
        'parametric_var_dollar': abs(parametric_var) * portfolio_value,
        'monte_carlo_var': monte_carlo_var,
        'monte_carlo_var_dollar': abs(monte_carlo_var) * portfolio_value,
        'expected_shortfall': expected_shortfall,
        'expected_shortfall_dollar': abs(expected_shortfall) * portfolio_value,
        'confidence_level': confidence_level
    }

# SOLUTION 2: Risk Monitoring System
def monitor_risk_limits(current_metrics, risk_limits):
    """
    Monitor portfolio against risk limits
    
    Parameters:
    - current_metrics: dict of current risk measures
    - risk_limits: dict of risk limits
    
    Returns:
    - Dictionary with alerts and required actions
    """
    
    alerts = []
    actions = []
    risk_score = 100  # Start at 100, deduct for violations
    
    # Check each limit
    if current_metrics.get('var') > risk_limits.get('var_limit'):
        alerts.append({
            'type': 'VaR Breach',
            'severity': 'HIGH',
            'message': f"VaR {current_metrics['var']:.2%} exceeds limit {risk_limits['var_limit']:.2%}"
        })
        actions.append('Reduce portfolio risk immediately')
        risk_score -= 25
    
    if current_metrics.get('volatility') > risk_limits.get('volatility_limit'):
        alerts.append({
            'type': 'Volatility Spike',
            'severity': 'MEDIUM',
            'message': f"Volatility {current_metrics['volatility']:.2%} exceeds limit"
        })
        actions.append('Review position sizes')
        risk_score -= 15
    
    if abs(current_metrics.get('drawdown', 0)) > risk_limits.get('drawdown_limit'):
        alerts.append({
            'type': 'Drawdown Limit',
            'severity': 'HIGH',
            'message': f"Drawdown {current_metrics['drawdown']:.2%} exceeds limit"
        })
        actions.append('Implement defensive positioning')
        risk_score -= 20
    
    # Determine overall status
    if risk_score >= 90:
        status = 'GREEN - Normal'
    elif risk_score >= 70:
        status = 'YELLOW - Elevated Risk'
    else:
        status = 'RED - High Risk'
    
    return {
        'alerts': alerts,
        'actions': actions,
        'risk_score': risk_score,
        'status': status
    }

# SOLUTION 3: Stress Testing Framework
def run_stress_tests(portfolio_weights, stress_scenarios):
    """
    Run stress tests on portfolio
    
    Parameters:
    - portfolio_weights: dict of asset weights
    - stress_scenarios: dict of stress scenarios
    
    Returns:
    - Dictionary with stress test results
    """
    
    results = {}
    
    for scenario_name, scenario in stress_scenarios.items():
        # Calculate portfolio impact
        portfolio_impact = 0
        asset_impacts = []
        
        for asset, weight in portfolio_weights.items():
            if asset in scenario['shocks']:
                shock = scenario['shocks'][asset]
                impact = weight * shock
                portfolio_impact += impact
                asset_impacts.append({
                    'asset': asset,
                    'weight': weight,
                    'shock': shock,
                    'contribution': impact
                })
        
        results[scenario_name] = {
            'description': scenario['description'],
            'portfolio_impact': portfolio_impact,
            'asset_impacts': sorted(asset_impacts, 
                                  key=lambda x: abs(x['contribution']), 
                                  reverse=True)
        }
    
    # Find worst scenario
    worst_scenario = min(results.items(), 
                        key=lambda x: x[1]['portfolio_impact'])
    
    return {
        'scenarios': results,
        'worst_scenario': worst_scenario[0],
        'worst_impact': worst_scenario[1]['portfolio_impact']
    }

# SOLUTION 4: VaR Backtesting
def backtest_var(returns, var_estimate, confidence_level):
    """
    Backtest VaR model accuracy
    
    Parameters:
    - returns: historical returns
    - var_estimate: VaR estimate to test
    - confidence_level: VaR confidence level
    
    Returns:
    - Dictionary with backtesting results
    """
    
    # Count violations
    violations = np.sum(returns <= var_estimate)
    total_obs = len(returns)
    violation_rate = violations / total_obs
    expected_rate = 1 - confidence_level
    
    # Kupiec test (simplified)
    # Test if violation rate is statistically different from expected
    lower_bound = expected_rate * 0.6  # Simplified bounds
    upper_bound = expected_rate * 1.4
    
    if lower_bound <= violation_rate <= upper_bound:
        test_result = 'PASS'
    else:
        test_result = 'FAIL'
    
    # Independence test (simplified)
    # Check if violations cluster
    violation_indicators = (returns <= var_estimate).astype(int)
    runs = np.sum(np.diff(violation_indicators) != 0)
    expected_runs = 2 * violations * (total_obs - violations) / total_obs
    
    independence = 'PASS' if 0.8 * expected_runs <= runs <= 1.2 * expected_runs else 'FAIL'
    
    return {
        'violations': violations,
        'total_observations': total_obs,
        'violation_rate': violation_rate,
        'expected_rate': expected_rate,
        'kupiec_test': test_result,
        'independence_test': independence,
        'model_quality': 'GOOD' if test_result == 'PASS' and independence == 'PASS' else 'POOR'
    }

# SOLUTION 5: Risk Dashboard Visualization
def create_risk_dashboard(portfolio_data, risk_metrics, show=True):
    """
    Create comprehensive risk dashboard
    """
    
    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
    fig.suptitle('Risk Management Dashboard', fontsize=16, fontweight='bold')
    
    # Plot 1: Return distribution with VaR/ES
    returns = portfolio_data['returns']
    ax1.hist(returns * 100, bins=50, alpha=0.7, density=True, 
             color='lightblue', edgecolor='black')
    
    # Add VaR and ES lines
    var_line = risk_metrics['historical_var'] * 100
    es_line = risk_metrics['expected_shortfall'] * 100
    
    ax1.axvline(var_line, color='red', linestyle='--', linewidth=2,
                label=f'VaR(95%): {var_line:.2f}%')
    ax1.axvline(es_line, color='darkred', linestyle=':', linewidth=2,
                label=f'ES: {es_line:.2f}%')
    
    ax1.set_xlabel('Daily Return (%)')
    ax1.set_ylabel('Density')
    ax1.set_title('Return Distribution with Risk Measures')
    ax1.legend()
    ax1.grid(True, alpha=0.3)
    
    # Plot 2: VaR comparison
    var_methods = ['Historical', 'Parametric', 'Monte Carlo']
    var_values = [
        abs(risk_metrics['historical_var']) * 100,
        abs(risk_metrics['parametric_var']) * 100,
        abs(risk_metrics['monte_carlo_var']) * 100
    ]
    
    bars = ax2.bar(var_methods, var_values, color=['blue', 'green', 'orange'])
    ax2.set_ylabel('VaR (%)')
    ax2.set_title('VaR Method Comparison')
    ax2.grid(True, alpha=0.3)
    
    # Add value labels
    for bar, val in zip(bars, var_values):
        ax2.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.1,
                f'{val:.2f}%', ha='center', va='bottom')
    
    # Plot 3: Rolling volatility
    if 'rolling_vol' in portfolio_data:
        rolling_vol = portfolio_data['rolling_vol'] * 100
        ax3.plot(rolling_vol, color='purple', linewidth=1.5)
        ax3.axhline(y=rolling_vol.mean(), color='red', linestyle='--', 
                   label=f'Mean: {rolling_vol.mean():.1f}%')
        ax3.fill_between(range(len(rolling_vol)), rolling_vol.mean() - rolling_vol.std(),
                        rolling_vol.mean() + rolling_vol.std(), alpha=0.2, color='red')
        ax3.set_ylabel('Volatility (%)')
        ax3.set_title('Rolling 30-Day Volatility')
        ax3.legend()
        ax3.grid(True, alpha=0.3)
    
    # Plot 4: Risk metrics summary
    metrics_text = f"""Current Risk Metrics:
    
    Portfolio VaR (95%): {abs(risk_metrics['historical_var']):.2%}
    Expected Shortfall: {abs(risk_metrics['expected_shortfall']):.2%}
    Current Volatility: {portfolio_data.get('current_vol', 0.15):.1%}
    Maximum Drawdown: {portfolio_data.get('max_drawdown', -0.10):.1%}
    
    Risk Status: {risk_metrics.get('status', 'NORMAL')}
    Risk Score: {risk_metrics.get('risk_score', 85)}/100
    """
    
    ax4.text(0.1, 0.5, metrics_text, fontsize=12, verticalalignment='center',
             transform=ax4.transAxes, bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
    ax4.axis('off')
    ax4.set_title('Risk Summary')
    
    plt.tight_layout()
    if show:
        plt.show()
    
    return fig

Implementation Notes for Instructors#

Session Pacing Guide:

  • Section 1-2 (30 min): Hook and concepts

  • Section 3 (45 min): Hands-on exercises

  • Section 4 (60 min): DRIVER case study

  • Section 5 (15 min): Assignment explanation

  • Section 6-7 (30 min): Reflection and preview

Common Student Challenges:

  1. VaR Interpretation: Students confuse VaR with maximum possible loss

    • Emphasize it’s a probability statement

    • Show examples where losses exceed VaR

  2. Over-reliance on Models: Students trust VaR too much

    • Show LTCM and other failures

    • Stress importance of stress testing

  3. Implementation Complexity: Students struggle with calculations

    • Start with simple examples

    • Build complexity gradually

Assessment Rubric:

Criteria

Points

Details

VaR Implementation

25

Multiple methods, correct calculations

Risk Monitoring

20

Effective alerts and limits

Stress Testing

20

Relevant scenarios, good analysis

Validation

15

Proper backtesting procedures

Video Quality

20

Clear communication of risk concepts

Additional Resources:

  • Jorion’s “Value at Risk” textbook

  • Basel Committee publications

  • Risk.net articles on VaR evolution

  • Python risk libraries (pyfolio, empyrical)

Data Sources:

  • Yahoo Finance for market data

  • FRED for volatility indices (VIX)

  • Academic datasets for longer histories

  • Simulated data for specific scenarios

Extension Activities:

  1. Implement Expected Shortfall variations

  2. Add GARCH models for volatility

  3. Build factor risk models

  4. Create real-time risk dashboards

Contents