Millennium Management Pod Structure Strategy

import numpy as np
import pandas as pd
import yfinance as yf
from datetime import datetime, timedelta
from scipy.optimize import minimize
import warnings
warnings.filterwarnings('ignore')

class MillenniumPodSystem:
    """
    Millennium Management-inspired multi-strategy pod system for retail investors.

    Manages 3-5 independent trading strategies with:
    - Automated stop-loss rules (5% → 50% cut, 10% → termination)
    - Dynamic capital allocation based on Sharpe ratios
    - Monthly rebalancing with position limits
    - Daily risk monitoring and drawdown tracking
    """

    def __init__(self, initial_capital=100000, num_pods=5):
        """
        Initialize pod system.

        Parameters:
        -----------
        initial_capital : float
            Starting portfolio capital (default: $100k)
        num_pods : int
            Number of independent strategies (default: 5)
        """
        self.initial_capital = initial_capital
        self.num_pods = num_pods
        self.current_capital = initial_capital
        self.cash_reserve_pct = 0.10  # 10% cash buffer

        # Pod state tracking
        self.pod_names = [f'Pod_{i+1}' for i in range(num_pods)]
        self.pod_allocations = {}  # Current capital allocation per pod
        self.pod_peaks = {}  # High-water mark for each pod
        self.pod_returns_history = {pod: [] for pod in self.pod_names}
        self.pod_sharpe_ratios = {}
        self.pod_status = {pod: 'active' for pod in self.pod_names}

        # Risk limits (Millennium-style)
        self.stop_loss_levels = {
            'warning': 0.05,      # 5% DD → 50% capital reduction
            'termination': 0.10   # 10% DD → strategy terminated
        }

        # Allocation constraints
        self.min_allocation_pct = 0.10  # Min 10% per active pod
        self.max_allocation_pct = 0.40  # Max 40% per pod (avoid concentration)

        # Initialize equal-weight allocation
        self.initialize_pods()

        print(f"\n{'='*60}")
        print(f"MILLENNIUM POD SYSTEM INITIALIZED")
        print(f"{'='*60}")
        print(f"Initial Capital:     ${self.initial_capital:,.0f}")
        print(f"Number of Pods:      {self.num_pods}")
        print(f"Cash Reserve:        {self.cash_reserve_pct:.0%}")
        print(f"Stop-Loss (Warning): {self.stop_loss_levels['warning']:.0%}")
        print(f"Stop-Loss (Term):    {self.stop_loss_levels['termination']:.0%}")
        print(f"{'='*60}\n")

    def initialize_pods(self):
        """
        Initialize pods with equal-weight capital allocation.
        """
        # Reserve 10% cash, distribute rest equally
        investable_capital = self.initial_capital * (1 - self.cash_reserve_pct)
        equal_weight = investable_capital / self.num_pods

        for pod in self.pod_names:
            self.pod_allocations[pod] = equal_weight
            self.pod_peaks[pod] = equal_weight
            self.pod_sharpe_ratios[pod] = 1.0  # Assume 1.0 Sharpe initially

        print("Initial Pod Allocations (Equal Weight):")
        for pod, capital in self.pod_allocations.items():
            pct = (capital / self.initial_capital) * 100
            print(f"  {pod}: ${capital:,.0f} ({pct:.1f}%)")
        print(f"  Cash Reserve: ${self.initial_capital * self.cash_reserve_pct:,.0f} ({self.cash_reserve_pct:.0%})\n")

    def simulate_pod_returns(self, days=252):
        """
        Simulate daily returns for each pod (for demonstration).

        In production, replace this with actual strategy returns from your
        backtesting systems (e.g., equity L/S, stat arb, volatility, etc.)

        Parameters:
        -----------
        days : int
            Number of trading days to simulate

        Returns:
        --------
        pd.DataFrame
            Daily returns for each pod
        """
        np.random.seed(42)

        # Simulate different Sharpe ratios for each pod
        # Pod 1: High Sharpe (2.0) - Statistical Arbitrage
        # Pod 2: Medium-High (1.6) - Equity Long/Short
        # Pod 3: Medium (1.2) - Volatility Trading
        # Pod 4: Medium (1.4) - Alternative Data
        # Pod 5: Lower (0.9) - Momentum (will get reduced allocation)

        sharpe_targets = [2.0, 1.6, 1.2, 1.4, 0.9]
        volatilities = [0.10, 0.12, 0.15, 0.13, 0.18]  # Annual volatility

        returns_data = {}
        dates = pd.date_range(end=datetime.now(), periods=days, freq='D')

        for i, pod in enumerate(self.pod_names):
            # Target return from Sharpe: Return = RiskFree + Sharpe * Vol
            risk_free = 0.045  # 4.5% annual
            target_return = risk_free + sharpe_targets[i] * volatilities[i]

            # Daily parameters
            daily_return = target_return / 252
            daily_vol = volatilities[i] / np.sqrt(252)

            # Generate returns (with some autocorrelation for realism)
            returns = np.random.normal(daily_return, daily_vol, days)

            # Add momentum/mean-reversion (slight autocorrelation)
            for j in range(1, len(returns)):
                returns[j] += 0.1 * returns[j-1]  # Slight momentum

            returns_data[pod] = returns

        df = pd.DataFrame(returns_data, index=dates)
        return df

    def calculate_drawdown(self, capital_series):
        """
        Calculate drawdown from peak for a capital series.

        Parameters:
        -----------
        capital_series : pd.Series or np.array
            Time series of capital values

        Returns:
        --------
        float
            Current drawdown from peak (as decimal, e.g., 0.05 = 5%)
        """
        if isinstance(capital_series, pd.Series):
            capital_series = capital_series.values

        peak = np.maximum.accumulate(capital_series)
        drawdown = (capital_series - peak) / peak
        return drawdown[-1]

    def calculate_sharpe_ratio(self, returns, risk_free_rate=0.045):
        """
        Calculate annualized Sharpe ratio.

        Parameters:
        -----------
        returns : np.array or pd.Series
            Daily returns
        risk_free_rate : float
            Annual risk-free rate (default: 4.5%)

        Returns:
        --------
        float
            Annualized Sharpe ratio
        """
        if len(returns) < 30:
            return 0.0  # Insufficient data

        mean_return = np.mean(returns) * 252  # Annualize
        volatility = np.std(returns) * np.sqrt(252)  # Annualize

        if volatility == 0:
            return 0.0

        sharpe = (mean_return - risk_free_rate) / volatility
        return sharpe

    def check_stop_losses(self, returns_df):
        """
        Check if any pods have hit stop-loss levels.
        Apply capital reductions or terminations.

        Parameters:
        -----------
        returns_df : pd.DataFrame
            Daily returns for each pod
        """
        print(f"\n{'='*60}")
        print("CHECKING STOP-LOSS TRIGGERS")
        print(f"{'='*60}\n")

        for pod in self.pod_names:
            if self.pod_status[pod] != 'active':
                continue  # Skip terminated pods

            # Calculate pod's cumulative capital
            pod_returns = returns_df[pod]
            cumulative_capital = self.pod_peaks[pod] * (1 + pod_returns).cumprod()

            # Current drawdown
            current_dd = self.calculate_drawdown(cumulative_capital)

            print(f"{pod}:")
            print(f"  Peak Capital:      ${self.pod_peaks[pod]:,.0f}")
            print(f"  Current Capital:   ${cumulative_capital.iloc[-1]:,.0f}")
            print(f"  Drawdown:          {current_dd:.2%}")

            # Check termination level (10%)
            if current_dd <= -self.stop_loss_levels['termination']:
                print(f"  ⚠️  STOP-LOSS TRIGGERED: Terminating {pod}")
                self.pod_status[pod] = 'terminated'
                self.pod_allocations[pod] = 0.0
                print(f"  Status:            TERMINATED\n")
                continue

            # Check warning level (5%)
            elif current_dd <= -self.stop_loss_levels['warning']:
                # Cut allocation by 50%
                old_allocation = self.pod_allocations[pod]
                self.pod_allocations[pod] *= 0.5
                print(f"  ⚠️  WARNING: 5% DD → Cutting allocation by 50%")
                print(f"  Old Allocation:    ${old_allocation:,.0f}")
                print(f"  New Allocation:    ${self.pod_allocations[pod]:,.0f}\n")
            else:
                print(f"  Status:            OK\n")

    def calculate_sharpe_weighted_allocation(self):
        """
        Calculate Sharpe-weighted capital allocation across active pods.

        Returns:
        --------
        dict
            Target allocation for each pod
        """
        # Get Sharpe ratios for active pods
        active_pods = [pod for pod in self.pod_names if self.pod_status[pod] == 'active']

        if len(active_pods) == 0:
            print("⚠️  Warning: No active pods remaining!")
            return {pod: 0.0 for pod in self.pod_names}

        # Calculate raw Sharpe-weighted allocation
        sharpe_values = np.array([max(self.pod_sharpe_ratios[pod], 0) for pod in active_pods])

        if sharpe_values.sum() == 0:
            # All Sharpe ratios are negative → equal weight
            weights = np.ones(len(active_pods)) / len(active_pods)
        else:
            weights = sharpe_values / sharpe_values.sum()

        # Apply constraints (min 10%, max 40%)
        investable_capital = self.current_capital * (1 - self.cash_reserve_pct)

        allocations = {}
        for i, pod in enumerate(active_pods):
            raw_allocation = weights[i] * investable_capital

            # Apply min/max constraints
            allocation = np.clip(
                raw_allocation,
                self.min_allocation_pct * investable_capital,
                self.max_allocation_pct * investable_capital
            )
            allocations[pod] = allocation

        # Normalize to ensure sum = investable_capital
        total_allocated = sum(allocations.values())
        if total_allocated > 0:
            for pod in allocations:
                allocations[pod] = (allocations[pod] / total_allocated) * investable_capital

        # Set terminated pods to 0
        for pod in self.pod_names:
            if self.pod_status[pod] != 'active':
                allocations[pod] = 0.0

        return allocations

    def rebalance_portfolio(self, returns_df):
        """
        Monthly rebalancing: update Sharpe ratios and reallocate capital.

        Parameters:
        -----------
        returns_df : pd.DataFrame
            Historical daily returns for each pod (past 252 days)
        """
        print(f"\n{'='*60}")
        print("MONTHLY REBALANCING")
        print(f"{'='*60}\n")

        # Update Sharpe ratios (rolling 252-day)
        for pod in self.pod_names:
            if self.pod_status[pod] == 'active':
                pod_returns = returns_df[pod].iloc[-252:]  # Past year
                self.pod_sharpe_ratios[pod] = self.calculate_sharpe_ratio(pod_returns)

        # Display Sharpe ratios
        print("Updated Sharpe Ratios:")
        for pod in self.pod_names:
            status = self.pod_status[pod]
            sharpe = self.pod_sharpe_ratios.get(pod, 0)
            print(f"  {pod}: {sharpe:.2f} ({status})")

        # Calculate new Sharpe-weighted allocation
        new_allocations = self.calculate_sharpe_weighted_allocation()

        # Display rebalancing
        print(f"\nRebalancing Portfolio:")
        print(f"{'Pod':<10} {'Old Alloc':<15} {'New Alloc':<15} {'Change':<15}")
        print("-" * 60)

        for pod in self.pod_names:
            old_alloc = self.pod_allocations.get(pod, 0)
            new_alloc = new_allocations.get(pod, 0)
            change = new_alloc - old_alloc

            print(f"{pod:<10} ${old_alloc:>12,.0f}  ${new_alloc:>12,.0f}  ${change:>+12,.0f}")

        # Apply new allocations
        self.pod_allocations = new_allocations

        # Update peaks for active pods
        for pod in self.pod_names:
            if self.pod_status[pod] == 'active':
                self.pod_peaks[pod] = max(self.pod_peaks[pod], self.pod_allocations[pod])

        print(f"\nCash Reserve: ${self.current_capital * self.cash_reserve_pct:,.0f} ({self.cash_reserve_pct:.0%})")
        print(f"{'='*60}\n")

    def run_backtest(self, start_date='2015-01-01', end_date='2025-01-01'):
        """
        Backtest the pod system over historical period.

        Parameters:
        -----------
        start_date, end_date : str
            Backtest date range (YYYY-MM-DD)

        Returns:
        --------
        pd.DataFrame
            Daily portfolio returns and metrics
        """
        print(f"\n{'='*60}")
        print(f"RUNNING BACKTEST: {start_date} to {end_date}")
        print(f"{'='*60}\n")

        # Generate pod returns (in production, use actual strategy returns)
        trading_days = pd.bdate_range(start_date, end_date)
        returns_df = self.simulate_pod_returns(days=len(trading_days))
        returns_df.index = trading_days

        # Portfolio tracking
        portfolio_values = [self.initial_capital]
        portfolio_returns = []

        # Monthly rebalancing schedule (first trading day of each month)
        rebalance_dates = returns_df.resample('MS').first().index

        for date in returns_df.index[1:]:
            # Check if it's a rebalancing date
            if date in rebalance_dates:
                # Use past 252 days for Sharpe calculation
                lookback_returns = returns_df.loc[:date].iloc[-252:]
                self.rebalance_portfolio(lookback_returns)

            # Daily return calculation
            daily_pod_returns = returns_df.loc[date]

            # Portfolio return = weighted sum of pod returns
            portfolio_return = 0
            for pod in self.pod_names:
                if self.pod_status[pod] == 'active' and self.pod_allocations[pod] > 0:
                    weight = self.pod_allocations[pod] / self.current_capital
                    portfolio_return += weight * daily_pod_returns[pod]

            portfolio_returns.append(portfolio_return)

            # Update portfolio value
            new_value = portfolio_values[-1] * (1 + portfolio_return)
            portfolio_values.append(new_value)
            self.current_capital = new_value

            # Check stop-losses weekly (every Friday or last trading day of week)
            if date.weekday() == 4:  # Friday
                self.check_stop_losses(returns_df.loc[:date])

        # Create results DataFrame
        results = pd.DataFrame({
            'date': returns_df.index,
            'portfolio_value': portfolio_values[:-1],  # Align with dates
            'return': [0] + portfolio_returns
        })

        results['cumulative_return'] = (results['portfolio_value'] / self.initial_capital) - 1

        # Calculate performance metrics
        total_return = results['cumulative_return'].iloc[-1]
        n_years = len(results) / 252
        cagr = (1 + total_return) ** (1/n_years) - 1
        volatility = results['return'].std() * np.sqrt(252)
        sharpe = (results['return'].mean() * 252) / volatility
        max_dd = (results['cumulative_return'] - results['cumulative_return'].cummax()).min()

        # Calculate max monthly loss
        monthly_returns = results.set_index('date')['return'].resample('M').apply(lambda x: (1 + x).prod() - 1)
        max_monthly_loss = monthly_returns.min()

        print(f"\n{'='*60}")
        print("BACKTEST RESULTS")
        print(f"{'='*60}")
        print(f"Total Return:        {total_return:>10.1%}")
        print(f"CAGR:                {cagr:>10.1%}")
        print(f"Volatility (ann.):   {volatility:>10.1%}")
        print(f"Sharpe Ratio:        {sharpe:>10.2f}")
        print(f"Max Drawdown:        {max_dd:>10.1%}")
        print(f"Max Monthly Loss:    {max_monthly_loss:>10.1%}")
        print(f"Final Capital:       ${self.current_capital:>12,.0f}")
        print(f"{'='*60}\n")

        # Pod-level performance summary
        print("POD PERFORMANCE SUMMARY:")
        print(f"{'Pod':<10} {'Status':<12} {'Final Sharpe':<15} {'Final Allocation':<20}")
        print("-" * 60)
        for pod in self.pod_names:
            status = self.pod_status[pod]
            sharpe = self.pod_sharpe_ratios.get(pod, 0)
            allocation = self.pod_allocations.get(pod, 0)
            allocation_pct = (allocation / self.current_capital) * 100 if self.current_capital > 0 else 0

            print(f"{pod:<10} {status:<12} {sharpe:>12.2f}  ${allocation:>12,.0f} ({allocation_pct:>5.1f}%)")

        print(f"{'='*60}\n")

        return results


def main():
    """
    Run Millennium-style pod system backtest.
    """
    print("\n" + "="*60)
    print("MILLENNIUM POD STRUCTURE STRATEGY")
    print("Retail Multi-Strategy Implementation")
    print("="*60 + "\n")

    # Initialize pod system
    # In production, you would pass actual strategy objects/classes
    pod_system = MillenniumPodSystem(
        initial_capital=100000,  # $100k starting capital
        num_pods=5               # 5 independent strategies
    )

    # Run backtest
    results = pod_system.run_backtest(
        start_date='2015-01-01',
        end_date='2025-01-01'
    )

    # Additional analysis
    print("\nYEAR-BY-YEAR RETURNS:")
    print("-" * 40)
    results['year'] = pd.to_datetime(results['date']).dt.year
    yearly_returns = results.groupby('year')['return'].apply(lambda x: (1 + x).prod() - 1)

    for year, ret in yearly_returns.items():
        print(f"{year}: {ret:>8.2%}")

    print("\n" + "="*60)
    print("Backtest complete!")
    print("="*60 + "\n")


if __name__ == "__main__":
    main()