# ===================================================================
# MODULE 6, LESSON 6: QUANTUM COMPUTING IN FINANCE
# ===================================================================

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.optimize import minimize
from scipy.stats import norm
import warnings
warnings.filterwarnings('ignore')

# Set style
sns.set_style("whitegrid")
np.random.seed(42)

print("="*70)
print("QUANTUM COMPUTING AND ITS POTENTIAL IN FINANCE")
print("="*70)

# ----------------------------------------------------------------
# PART A: PORTFOLIO OPTIMISATION (QUANTUM-INSPIRED)
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Portfolio Optimisation – Quantum-Inspired Approach")
print("-"*60)

# Generate synthetic asset returns
n_assets = 10
n_days = 500
returns = np.random.multivariate_normal(
    np.random.uniform(0.0003, 0.001, n_assets),
    np.random.uniform(0.01, 0.03, (n_assets, n_assets)) * 0.5 + np.diag(np.random.uniform(0.02, 0.04, n_assets)),
    n_days
)

# Calculate mean returns and covariance
mu = returns.mean(axis=0)
sigma = np.cov(returns.T)

print(f"Number of assets: {n_assets}")
print(f"Mean returns: {mu[:5].round(6)}...")
print(f"Covariance matrix shape: {sigma.shape}")

# Classical Markowitz optimisation
def portfolio_volatility(weights, sigma):
    return np.sqrt(weights.T @ sigma @ weights)

def portfolio_return(weights, mu):
    return weights.T @ mu

def negative_sharpe(weights, mu, sigma, risk_free=0.0001):
    ret = portfolio_return(weights, mu)
    vol = portfolio_volatility(weights, sigma)
    return -(ret - risk_free) / vol

# Constraints
constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
bounds = tuple((0, 1) for _ in range(n_assets))

# Optimise
result = minimize(negative_sharpe, np.ones(n_assets)/n_assets, args=(mu, sigma),
                  method='SLSQP', bounds=bounds, constraints=constraints)
optimal_weights = result.x

print(f"\nOptimal Portfolio (Max Sharpe):")
print(f"  Return: {portfolio_return(optimal_weights, mu)*100:.4f}%")
print(f"  Volatility: {portfolio_volatility(optimal_weights, sigma)*100:.4f}%")
print(f"  Sharpe Ratio: {portfolio_return(optimal_weights, mu)/portfolio_volatility(optimal_weights, sigma):.4f}")

print("\nOptimal Weights (Top 5):")
top_weights = pd.DataFrame({
    'Asset': [f'Asset_{i}' for i in range(n_assets)],
    'Weight': optimal_weights
}).sort_values('Weight', ascending=False)
print(top_weights.head(5).to_string(index=False))

# ----------------------------------------------------------------
# PART B: QUANTUM MONTE CARLO – OPTION PRICING (SIMULATED)
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Quantum Monte Carlo for Option Pricing (Simulated)")
print("-"*60)

# European call option pricing using Monte Carlo (classical)
def european_call_monte_carlo(S0, K, T, r, sigma, n_paths):
    """Price a European call option using Monte Carlo."""
    Z = np.random.standard_normal(n_paths)
    ST = S0 * np.exp((r - 0.5 * sigma**2) * T + sigma * np.sqrt(T) * Z)
    payoffs = np.maximum(ST - K, 0)
    price = np.exp(-r * T) * np.mean(payoffs)
    std_error = np.std(payoffs) / np.sqrt(n_paths)
    return price, std_error

# Parameters
S0 = 100  # Initial stock price
K = 105   # Strike price
T = 1     # 1 year
r = 0.05  # Risk-free rate
sigma = 0.20  # Volatility

# Classical Monte Carlo
n_paths_values = [1000, 10000, 100000, 1000000]
prices = []
errors = []
times = []

print("Classical Monte Carlo Option Pricing:")
for n_paths in n_paths_values:
    price, std_err = european_call_monte_carlo(S0, K, T, r, sigma, n_paths)
    prices.append(price)
    errors.append(std_err)
    print(f"  Paths: {n_paths:8d}, Price: ${price:.4f}, Error: ${std_err:.4f}")

# Quantum Monte Carlo (Quadratic speedup: O(1/n_paths) instead of O(1/sqrt(n_paths)))
# For demonstration, we simulate the quantum speedup
print("\nQuantum Monte Carlo (Quadratic Speedup):")
# Quantum speedup means you need far fewer samples for the same accuracy
# Simulate by showing the same accuracy with sqrt(n_paths) samples
q_paths = [100, 1000, 10000, 100000]  # sqrt of classical samples
q_prices = []
for n_paths in q_paths:
    price, std_err = european_call_monte_carlo(S0, K, T, r, sigma, n_paths)
    q_prices.append(price)
    print(f"  Paths: {n_paths:8d}, Price: ${price:.4f}, Error: ${std_err:.4f}")

print("\nQuantum Advantage: Achieve same accuracy with ~1% of classical samples.")

# ----------------------------------------------------------------
# PART C: RISK SIMULATION – QUANTUM SPEEDUP
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Risk Simulation with Quantum Speedup")
print("-"*60)

# Simulate VaR using Monte Carlo with different sample sizes
def simulate_var(returns, weights, n_paths, confidence=0.95):
    """Simulate portfolio VaR."""
    # Generate portfolio returns
    port_returns = returns @ weights
    # Bootstrap to create many scenarios
    indices = np.random.choice(len(port_returns), (n_paths, len(port_returns)), replace=True)
    portfolio_scenarios = port_returns[indices].mean(axis=1) * 252  # Annualised
    # Compute VaR
    var = -np.percentile(portfolio_scenarios, (1 - confidence) * 100)
    return var

# Use the optimal weights from above
n_paths_test = [100, 1000, 10000, 100000]
var_results = []

print(f"Portfolio VaR (95%, annualised):")
for n_paths in n_paths_test:
    var = simulate_var(returns, optimal_weights, n_paths)
    var_results.append(var)
    print(f"  Paths: {n_paths:8d}, VaR: {var*100:.2f}%")

# Simulate quantum speedup (fewer paths)
print("\nQuantum Risk Simulation:")
for n_paths in [10, 100, 1000, 10000]:
    var = simulate_var(returns, optimal_weights, n_paths)
    print(f"  Paths: {n_paths:8d}, VaR: {var*100:.2f}%")

# ----------------------------------------------------------------
# PART D: GROVER'S SEARCH – FRAUD DETECTION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Grover's Search for Fraud Detection (Simulated)")
print("-"*60)

# Simulate a search problem: Find fraudulent transactions
# In classical: O(N), Quantum: O(sqrt(N))

n_transactions = 10000
fraudulent_prob = 0.001  # 0.1% fraud rate
is_fraud = np.random.binomial(1, fraudulent_prob, n_transactions)

# Classical search
def classical_search(data, target_value=1):
    """Classical linear search."""
    for i, val in enumerate(data):
        if val == target_value:
            return i
    return -1

# Find a fraudulent transaction
classical_result = classical_search(is_fraud)

print(f"Total transactions: {n_transactions}")
print(f"Fraudulent transactions: {is_fraud.sum()}")
print(f"Classical search found fraud at index: {classical_result}")

# Quantum speedup: Grover's algorithm would find in O(sqrt(N)) iterations
n_sqrt = int(np.sqrt(n_transactions))
print(f"\nGrover's Search (Quantum): Would find a fraudulent transaction in ~{n_sqrt} steps")
print(f"  Classical: {n_transactions} steps")
print(f"  Quantum: {n_sqrt} steps")
print(f"  Speedup: {n_transactions/n_sqrt:.0f}x")

# ----------------------------------------------------------------
# PART E: QUANTUM LINEAR ALGEBRA – CREDIT SCORING
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Quantum Linear Algebra for Credit Scoring")
print("-"*60)

# Simulate a linear regression problem: Y = X * beta
n_samples = 1000
n_features = 20

X = np.random.normal(0, 1, (n_samples, n_features))
true_beta = np.random.normal(0, 0.5, n_features)
y = X @ true_beta + np.random.normal(0, 0.1, n_samples)

# Classical solution
# beta = (X^T X)^-1 X^T y
XtX = X.T @ X
Xty = X.T @ y
beta_classical = np.linalg.solve(XtX, Xty)

print(f"Credit Scoring Model (Linear Regression):")
print(f"  Samples: {n_samples}")
print(f"  Features: {n_features}")
print(f"  Classical solves O({n_features}^3) = {n_features**3} operations")

# Quantum (HHL) would solve in O(log(n_features))
print(f"\nQuantum HHL Algorithm: Would solve in O(log({n_features})) = {np.log(n_features):.2f} operations")
print(f"  Speedup: {n_features**3 / np.log(n_features):.0f}x")

# ----------------------------------------------------------------
# PART F: QUANTUM COMPUTING ROADMAP
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Quantum Computing Roadmap for Banking")
print("-"*60)

roadmap = {
    "Phase 1 (Now – 2 Years)": {
        "Actions": [
            "Build quantum readiness team.",
            "Explore quantum-inspired algorithms (tensor networks).",
            "Run proof-of-concept on NISQ devices.",
            "Train staff in quantum computing fundamentals."
        ],
        "Focus": "Education and exploration."
    },
    "Phase 2 (2 – 5 Years)": {
        "Actions": [
            "Implement hybrid quantum-classical algorithms.",
            "Pilot quantum annealing for optimisation problems.",
            "Develop error mitigation techniques.",
            "Partner with quantum computing vendors (IBM, Google, IonQ)."
        ],
        "Focus": "Hybrid applications and small-scale problem solving."
    },
    "Phase 3 (5 – 10 Years)": {
        "Actions": [
            "Deploy fault-tolerant quantum computing for critical applications.",
            "Scale quantum solutions to large financial problems.",
            "Integrate quantum computing into core financial workflows.",
            "Develop in-house quantum expertise."
        ],
        "Focus": "Full-scale quantum advantage."
    }
}

for phase, details in roadmap.items():
    print(f"\n{phase}:")
    print(f"  Focus: {details['Focus']}")
    print("  Actions:")
    for action in details['Actions']:
        print(f"    • {action}")

# ----------------------------------------------------------------
# PART G: QUANTUM-INSPIRED OPTIMISATION (TENSOR NETWORKS)
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART G: Quantum-Inspired Optimisation (Tensor Networks)")
print("-"*60)

print("""
Tensor Networks are a quantum-inspired technique that can be used today:

1. What are Tensor Networks?
   - Mathematical structures for representing high-dimensional data.
   - Used in quantum many-body physics.
   - Can be applied to optimisation and machine learning.

2. Applications in Finance:
   - Portfolio optimisation with hundreds of assets.
   - Risk factor decomposition.
   - Option pricing with high-dimensional models.

3. Implementation:
   - Libraries: TensorNetwork (Google), quimb, ncon.
   - Can run on classical hardware.
   - Provides a path to quantum readiness.

4. Advantages:
   - Works with classical hardware today.
   - Often provides better results than classical methods.
   - Prepares teams for quantum computing.
""")

# ----------------------------------------------------------------
# PART H: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "="*70)
print("PART H: Summary and Recommendations")
print("="*70)

print("""
Quantum Computing in Finance – Key Takeaways:

1. Potential Advantages:
   - Portfolio Optimisation: Exponential speedup.
   - Option Pricing: Quadratic speedup.
   - Risk Simulation: Quadratic speedup.
   - Fraud Detection: Quadratic speedup.

2. Current State:
   - NISQ devices (50-100 qubits) with high error rates.
   - Fault-tolerant quantum computing is 5-10+ years away.
   - Research is active; banks are investing.

3. Quantum-Inspired:
   - Tensor networks provide benefits today.
   - Hybrid quantum-classical algorithms are being explored.
   - Quantum annealing (D-Wave) for optimisation.

4. Roadmap:
   - Phase 1 (now): Education and exploration.
   - Phase 2 (2-5 years): Hybrid applications.
   - Phase 3 (5-10+ years): Full-scale quantum advantage.

5. Recommendations:
   - Build quantum readiness team.
   - Explore quantum-inspired algorithms.
   - Partner with quantum vendors.
   - Train staff in quantum computing fundamentals.
   - Monitor progress in quantum hardware and algorithms.
""")

print("="*70)
print("END OF LESSON 6 – MODULE 6")
print("END OF MODULE 6")
print("="*70)