Implemented

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY app.py .
+COPY simulation_utils.py .
+COPY data/ ./data/
+COPY static/ ./static/
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"]
+

README.md

@@ -1,10 +1,81 @@
----
-title: SafeChoicesSimulation
-emoji: 🌖
-colorFrom: red
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Safe Choices Simulation - Docker Application
+
+A complete Docker-based application for running prediction market simulations using real Polymarket data.
+
+## Structure
+
+- **Backend**: FastAPI server (`app.py`) that runs real simulations using `simulation_utils.py`
+- **Frontend**: Static web interface served by FastAPI
+- **Data**: Market data CSV loaded on startup
+- **Docker**: Containerized application ready for deployment
+
+## Files
+
+- `Dockerfile` - Docker container definition
+- `app.py` - FastAPI backend server
+- `simulation_utils.py` - Core simulation logic
+- `requirements.txt` - Python dependencies
+- `data/` - Market data CSV file
+- `static/` - Frontend HTML, CSS, JavaScript files
+
+## Building and Running
+
+### Build the Docker image:
+```bash
+docker build -t safe-choices-simulation .
+```
+
+### Run the container:
+```bash
+docker run -p 7860:7860 safe-choices-simulation
+```
+
+The application will be available at `http://localhost:7860`
+
+## API Endpoints
+
+- `GET /` - Serves the frontend interface
+- `GET /health` - Health check endpoint
+- `POST /api/simulate` - Run simulations with parameters
+
+### Simulation API Request Format:
+```json
+{
+  "simType": "single" | "threshold" | "multi",
+  "startingCapital": 10000,
+  "numSimulations": 100,
+  "startDate": "2025-01-01",
+  "maxDuration": 365,
+  "minProb7d": 0.90,
+  "minProbCurrent": 0.90,
+  "daysBefore": 1,
+  "skewFactor": 0.1,
+  "targetReturn": 0.0414,  // Optional, for threshold type
+  "numFunds": 5  // Required for multi type
+}
+```
+
+## Features
+
+- **Real Data**: Uses actual Polymarket market data from CSV
+- **Three Simulation Types**:
+  - Single Fund: All capital in one fund
+  - Single Fund Threshold: Stop at target return
+  - Multi Fund: Diversified portfolio
+- **Real-time Progress**: Frontend shows simulation progress
+- **Comprehensive Results**: Statistics, charts, and export capabilities
+
+## Development
+
+To run locally without Docker:
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## Notes
+
+- Maximum 100 simulations per request (for performance)
+- Market data is loaded once on startup
+- All simulations use actual historical market probabilities and outcomes

app.py

@@ -0,0 +1,208 @@
+import os
+import json
+from fastapi import FastAPI, HTTPException
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+import pandas as pd
+import numpy as np
+from simulation_utils import (
+    load_and_filter_data,
+    run_single_fund_simulation,
+    run_multi_fund_simulation
+)
+
+# Initialize FastAPI app
+app = FastAPI(title="Safe Choices Simulation API")
+
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variable to cache loaded data
+market_data = None
+DATA_PATH = "data/all_filtered_markets_full_2024_2025.csv"
+
+# Load market data on startup
+@app.on_event("startup")
+async def load_data():
+    global market_data
+    if os.path.exists(DATA_PATH):
+        print(f"Loading market data from {DATA_PATH}...")
+        market_data = load_and_filter_data(DATA_PATH, start_date='2025-01-01')
+        print(f"Loaded {len(market_data):,} markets")
+    else:
+        print(f"Warning: Data file {DATA_PATH} not found!")
+
+# Request models
+class SimulationParams(BaseModel):
+    simType: str  # 'single', 'threshold', or 'multi'
+    startingCapital: float
+    numSimulations: int
+    startDate: str
+    maxDuration: int
+    minProb7d: float
+    minProbCurrent: float
+    daysBefore: int
+    skewFactor: float
+    targetReturn: Optional[float] = None
+    numFunds: Optional[int] = None
+
+# API Routes
+@app.get("/")
+async def read_root():
+    """Serve the frontend index.html"""
+    return FileResponse("static/index.html")
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "markets_loaded": len(market_data) if market_data is not None else 0
+    }
+
+@app.post("/api/simulate")
+async def run_simulation(params: SimulationParams):
+    """Run simulation based on parameters"""
+    if market_data is None:
+        raise HTTPException(status_code=500, detail="Market data not loaded")
+    
+    if params.numSimulations > 100:
+        raise HTTPException(status_code=400, detail="Maximum 100 simulations allowed")
+    
+    if params.numSimulations < 1:
+        raise HTTPException(status_code=400, detail="At least 1 simulation required")
+    
+    results = {
+        "simType": params.simType,
+        "parameters": params.dict(),
+        "runs": [],
+        "summary": {}
+    }
+    
+    # Run simulations
+    for i in range(params.numSimulations):
+        if params.simType == 'multi':
+            if params.numFunds is None or params.numFunds < 2:
+                raise HTTPException(status_code=400, detail="numFunds required for multi simulation")
+            
+            result = run_multi_fund_simulation(
+                df=market_data,
+                n_funds=params.numFunds,
+                starting_capital=params.startingCapital,
+                start_date=params.startDate,
+                max_duration_days=params.maxDuration,
+                days_before=params.daysBefore,
+                min_prob_7d=params.minProb7d,
+                min_prob_current=params.minProbCurrent,
+                ending_factor_start=0.05,
+                ending_factor_increment=0.001,
+                skew_factor=params.skewFactor,
+                target_return=params.targetReturn,
+                random_seed=i
+            )
+            
+            # Convert to frontend format
+            run = {
+                "finalCapital": float(result['portfolio_final_capital']),
+                "totalReturn": float(result['portfolio_total_return']),
+                "numTrades": int(result['total_trades']),
+                "wentBust": bool(result['surviving_funds'] == 0),
+                "reachedTarget": bool(result.get('funds_reached_target', 0) > 0),
+                "simulationDays": int(max([f['simulation_days'] for f in result['fund_results']]) if result['fund_results'] else 0),
+                "survivingFunds": int(result['surviving_funds']),
+                "fundResults": [
+                    {
+                        "finalCapital": float(f['final_capital']),
+                        "totalReturn": float(f['total_return']),
+                        "numTrades": int(f['num_trades']),
+                        "wentBust": bool(f['went_bust']),
+                        "reachedTarget": bool(f.get('reached_target', False))
+                    }
+                    for f in result['fund_results']
+                ],
+                "capitalHistory": []  # Simplified for API
+            }
+            
+        else:
+            # Single fund or threshold
+            result = run_single_fund_simulation(
+                df=market_data,
+                starting_capital=params.startingCapital,
+                start_date=params.startDate,
+                max_duration_days=params.maxDuration,
+                days_before=params.daysBefore,
+                min_prob_7d=params.minProb7d,
+                min_prob_current=params.minProbCurrent,
+                ending_factor_start=0.05,
+                ending_factor_increment=0.001,
+                skew_factor=params.skewFactor,
+                target_return=params.targetReturn,
+                random_seed=i
+            )
+            
+            # Convert to frontend format
+            run = {
+                "finalCapital": float(result['final_capital']),
+                "totalReturn": float(result['total_return']),
+                "numTrades": int(result['num_trades']),
+                "wentBust": bool(result['went_bust']),
+                "reachedTarget": bool(result.get('reached_target', False)),
+                "simulationDays": int(result['simulation_days']),
+                "capitalHistory": [
+                    {"day": int(dc['day']), "capital": float(dc['capital'])}
+                    for dc in result['daily_capital']
+                ]
+            }
+        
+        results["runs"].append(run)
+    
+    # Calculate summary statistics
+    returns = [r['totalReturn'] for r in results['runs']]
+    capitals = [r['finalCapital'] for r in results['runs']]
+    trades = [r['numTrades'] for r in results['runs']]
+    
+    results["summary"] = {
+        "avgReturn": float(np.mean(returns)),
+        "medianReturn": float(np.median(returns)),
+        "returnVolatility": float(np.std(returns)),
+        "avgFinalCapital": float(np.mean(capitals)),
+        "medianFinalCapital": float(np.median(capitals)),
+        "bustRate": sum(1 for r in results['runs'] if r['wentBust']) / len(results['runs']),
+        "positiveReturnRate": sum(1 for r in returns if r > 0) / len(returns),
+        "avgTrades": float(np.mean(trades)),
+        "return5th": float(np.percentile(returns, 5)),
+        "return95th": float(np.percentile(returns, 95)),
+        "maxDrawdown": float(abs(min(returns)))
+    }
+    
+    # Type-specific stats
+    if params.simType == 'threshold' and params.targetReturn:
+        reached_target = sum(1 for r in results['runs'] if r['reachedTarget'])
+        results["summary"]["targetReachedRate"] = reached_target / len(results['runs'])
+        avg_time = np.mean([r['simulationDays'] for r in results['runs'] if r['reachedTarget']]) if reached_target > 0 else 0
+        results["summary"]["avgTimeToTarget"] = float(avg_time)
+    
+    if params.simType == 'multi':
+        surviving_funds = [r['survivingFunds'] for r in results['runs']]
+        results["summary"]["avgSurvivingFunds"] = float(np.mean(surviving_funds))
+        results["summary"]["survivorshipRate"] = float(np.mean(surviving_funds) / params.numFunds)
+        results["summary"]["portfolioBustRate"] = sum(1 for s in surviving_funds if s == 0) / len(surviving_funds)
+    
+    return results
+
+# Mount static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+

requirements.txt

@@ -0,0 +1,9 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pandas==2.1.3
+numpy==1.26.2
+scipy==1.11.4
+matplotlib==3.8.2
+seaborn==0.13.0
+python-multipart==0.0.6
+

simulation_utils.py

@@ -0,0 +1,815 @@
+"""
+Simulation utilities for Safe Choices prediction market trading simulations.
+
+This module contains shared functions for running Monte Carlo simulations
+of different trading strategies on prediction markets.
+"""
+
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+from scipy import stats
+import matplotlib.pyplot as plt
+import seaborn as sns
+from typing import Tuple, Optional, List, Dict, Any
+
+def load_and_filter_data(csv_path: str, start_date: str = '2025-01-01') -> pd.DataFrame:
+    """
+    Load the market data and filter for simulation period.
+    
+    Args:
+        csv_path: Path to the CSV file containing market data
+        start_date: Start date for simulation (markets must close after this date)
+    
+    Returns:
+        Filtered DataFrame ready for simulation
+    """
+    # Load data
+    df = pd.read_csv(csv_path)
+    
+    # Convert dates - handle timezone awareness
+    df['closingDate'] = pd.to_datetime(df['closingDate'], format='mixed', errors='coerce', utc=True)
+    start_dt = pd.to_datetime(start_date, utc=True)
+    
+    # Filter for markets that close after start date and have complete data
+    mask = (
+        (df['closingDate'] >= start_dt) &
+        (df['outcome'].notna()) &
+        (df['probability7d'].notna()) &
+        (df['probability6d'].notna()) &
+        (df['probability5d'].notna()) &
+        (df['probability4d'].notna()) &
+        (df['probability3d'].notna()) &
+        (df['probability2d'].notna()) &
+        (df['probability1d'].notna())
+    )
+    
+    filtered_df = df[mask].copy().reset_index(drop=True)
+    
+    # Vectorized outcome conversion for speed
+    outcome_map = {'True': 1, 'true': 1, 'FALSE': 0, 'false': 0, True: 1, False: 0}
+    filtered_df['outcome_int'] = filtered_df['outcome'].map(outcome_map)
+    
+    # Fill any remaining NaN outcomes with proper conversion
+    remaining_mask = filtered_df['outcome_int'].isna()
+    if remaining_mask.any():
+        def convert_outcome(value):
+            if pd.isna(value):
+                return None
+            if isinstance(value, (int, float)):
+                return int(value)
+            return 1 if str(value).lower() == 'true' else 0
+        
+        filtered_df.loc[remaining_mask, 'outcome_int'] = filtered_df.loc[remaining_mask, 'outcome'].apply(convert_outcome)
+    
+    # Sort by closing date for better performance in simulations
+    filtered_df = filtered_df.sort_values('closingDate').reset_index(drop=True)
+    
+    return filtered_df
+
+def check_market_eligibility(market_row: pd.Series, days_before: int, 
+                           min_prob_7d: float, min_prob_current: float) -> bool:
+    """
+    Check if a market meets the probability thresholds for investment.
+    
+    Args:
+        market_row: Row from the DataFrame containing market data
+        days_before: Number of days before resolution to check (1-7)
+        min_prob_7d: Minimum probability threshold at 7 days before
+        min_prob_current: Minimum probability threshold at current day
+    
+    Returns:
+        True if market meets criteria, False otherwise
+    """
+    prob_col = f'probability{days_before}d'
+    
+    # Check if required columns exist and have valid data
+    if pd.isna(market_row.get('probability7d')) or pd.isna(market_row.get(prob_col)):
+        return False
+    
+    # Check probability thresholds
+    prob_7d = market_row['probability7d']
+    prob_current = market_row[prob_col]
+    
+    return prob_7d >= min_prob_7d and prob_current >= min_prob_current
+
+def calculate_days_until_resolution(current_date: datetime, closing_date: datetime) -> int:
+    """
+    Calculate days until market resolution.
+    
+    Args:
+        current_date: Current simulation date
+        closing_date: Market closing date
+    
+    Returns:
+        Number of days until resolution
+    """
+    return max(0, (closing_date - current_date).days)
+
+def get_available_markets(df: pd.DataFrame, current_date: datetime, days_before: int,
+                         min_prob_7d: float, min_prob_current: float) -> pd.DataFrame:
+    """
+    Get markets available for investment at current date.
+    
+    Args:
+        df: DataFrame containing market data
+        current_date: Current simulation date
+        days_before: Days before resolution to invest
+        min_prob_7d: Minimum probability at 7 days before
+        min_prob_current: Minimum probability at current day
+    
+    Returns:
+        DataFrame of available markets with their days until resolution
+    """
+    # Vectorized approach - much faster than iterating
+    prob_col = f'probability{days_before}d'
+    
+    # Calculate days until resolution for all markets at once
+    days_until = (df['closingDate'] - current_date).dt.days
+    
+    # Create boolean mask for all conditions at once
+    mask = (
+        (days_until >= days_before) &  # Market resolves in future
+        (df['probability7d'] >= min_prob_7d) &  # 7d probability threshold
+        (df[prob_col] >= min_prob_current) &  # Current day probability threshold
+        (df['probability7d'].notna()) &  # Valid 7d data
+        (df[prob_col].notna()) &  # Valid current day data
+        (df['outcome_int'].notna())  # Valid outcome data
+    )
+    
+    if not mask.any():
+        return pd.DataFrame()
+    
+    # Filter and add days_until_resolution column
+    available_markets = df[mask].copy()
+    available_markets['days_until_resolution'] = days_until[mask]
+    
+    return available_markets
+
+def select_next_market(available_markets: pd.DataFrame, random_state: np.random.RandomState, 
+                      skew_factor: float = 0.1) -> Optional[pd.Series]:
+    """
+    Select the next market to invest in using a left-skewed exponential distribution.
+    
+    Args:
+        available_markets: DataFrame of markets available for investment
+        random_state: Random state for reproducible results
+        skew_factor: Controls the left skew (higher = more skew toward closer markets)
+    
+    Returns:
+        Selected market as Series, or None if no markets available
+    """
+    if len(available_markets) == 0:
+        return None
+    
+    # Configurable market selection with adjustable skew
+    days_until = available_markets['days_until_resolution'].values
+    
+    # Use exponential decay with configurable skew factor
+    # Closer markets (lower days) get exponentially higher weights
+    weights = np.exp(-days_until * skew_factor)
+    
+    # Normalize weights
+    weights = weights / weights.sum()
+    
+    # Select market based on weights
+    selected_idx = random_state.choice(len(available_markets), p=weights)
+    
+    return available_markets.iloc[selected_idx]
+
+def calculate_investment_return(market: pd.Series, days_before: int, capital: float) -> float:
+    """
+    Calculate return from investing in a market.
+    
+    Args:
+        market: Market data as Series
+        days_before: Days before resolution when investment was made
+        capital: Amount invested
+    
+    Returns:
+        Final capital after resolution (capital * (1/probability) if win, 0 if loss)
+    """
+    prob_col = f'probability{days_before}d'
+    probability = market[prob_col]
+    outcome = market['outcome_int']
+    
+    if outcome == 1:  # Market resolved True
+        # Return is capital * (1 / probability)
+        return capital / probability
+    else:  # Market resolved False
+        return 0.0
+
+def run_single_fund_simulation(df: pd.DataFrame, 
+                              starting_capital: float = 10000,
+                              start_date: str = '2025-01-01',
+                              max_duration_days: int = 365,
+                              days_before: int = 1,
+                              min_prob_7d: float = 0.90,
+                              min_prob_current: float = 0.90,
+                              ending_factor_start: float = 0.05,
+                              ending_factor_increment: float = 0.001,
+                              skew_factor: float = 0.1,
+                              target_return: Optional[float] = None,
+                              random_seed: Optional[int] = None) -> Dict[str, Any]:
+    """
+    Run a single fund simulation.
+    
+    Args:
+        df: Market data DataFrame
+        starting_capital: Initial capital
+        start_date: Simulation start date
+        max_duration_days: Maximum simulation duration
+        days_before: Days before resolution to invest
+        min_prob_7d: Minimum probability at 7 days
+        min_prob_current: Minimum probability at investment day
+        ending_factor_start: Starting ending factor
+        ending_factor_increment: Daily increment to ending factor
+        skew_factor: Controls left skew in market selection (higher = more skew)
+        target_return: Target return threshold to stop trading (None = no threshold)
+        random_seed: Random seed for reproducibility
+    
+    Returns:
+        Dictionary containing simulation results
+    """
+    random_state = np.random.RandomState(random_seed)
+    
+    current_date = pd.to_datetime(start_date, utc=True)
+    end_date = current_date + timedelta(days=max_duration_days)
+    capital = starting_capital
+    
+    trades = []
+    daily_capital = []
+    
+    sim_day = 0
+    
+    # Track daily capital less frequently to improve performance
+    last_capital_record = 0
+    
+    while current_date <= end_date and capital > 0:
+        # Check if we've reached target return threshold
+        if target_return is not None:
+            current_return = (capital - starting_capital) / starting_capital
+            if current_return >= target_return:
+                break
+        
+        # Calculate current ending factor
+        ending_factor = ending_factor_start + (ending_factor_increment * sim_day)
+        
+        # Check if we hit ending factor
+        if random_state.random() < ending_factor:
+            break
+        
+        # Get available markets
+        available_markets = get_available_markets(
+            df, current_date, days_before, min_prob_7d, min_prob_current
+        )
+        
+        if len(available_markets) == 0:
+            # No markets available, advance day by larger steps to speed up
+            current_date += timedelta(days=7)  # Skip a week instead of one day
+            sim_day = (current_date - pd.to_datetime(start_date, utc=True)).days
+            continue
+        
+        # Select market
+        selected_market = select_next_market(available_markets, random_state, skew_factor)
+        
+        if selected_market is None:
+            current_date += timedelta(days=7)
+            sim_day = (current_date - pd.to_datetime(start_date, utc=True)).days
+            continue
+        
+        # Calculate investment date and resolution date
+        investment_date = current_date
+        resolution_date = selected_market['closingDate']
+        
+        # Calculate return
+        new_capital = calculate_investment_return(selected_market, days_before, capital)
+        
+        # Record trade (only essential info for speed)
+        trades.append({
+            'trade_number': len(trades) + 1,
+            'investment_date': investment_date,
+            'resolution_date': resolution_date,
+            'probability': selected_market[f'probability{days_before}d'],
+            'capital_invested': capital,
+            'outcome': selected_market['outcome_int'],
+            'capital_after': new_capital,
+            'return': (new_capital - capital) / capital if capital > 0 else 0,
+            'sim_day': sim_day
+        })
+        
+        capital = new_capital
+        
+        # Advance to resolution date + 1 day
+        current_date = resolution_date + timedelta(days=1)
+        sim_day = (current_date - pd.to_datetime(start_date, utc=True)).days
+        
+        # Record daily capital less frequently (every 10th day or trade)
+        if sim_day - last_capital_record >= 10 or len(trades) % 10 == 0:
+            daily_capital.append({
+                'date': current_date,
+                'capital': capital,
+                'day': sim_day
+            })
+            last_capital_record = sim_day
+    
+    # Calculate final statistics
+    total_return = (capital - starting_capital) / starting_capital if starting_capital > 0 else 0
+    num_trades = len(trades)
+    went_bust = capital == 0
+    reached_target = target_return is not None and total_return >= target_return
+    
+    # Determine ending reason
+    if went_bust:
+        ending_reason = 'bust'
+    elif reached_target:
+        ending_reason = 'target_reached'
+    elif current_date <= end_date:
+        ending_reason = 'ending_factor'
+    else:
+        ending_reason = 'max_duration'
+    
+    return {
+        'final_capital': capital,
+        'total_return': total_return,
+        'num_trades': num_trades,
+        'went_bust': went_bust,
+        'reached_target': reached_target,
+        'ending_reason': ending_reason,
+        'simulation_days': sim_day,
+        'trades': trades,
+        'daily_capital': daily_capital,
+        'parameters': {
+            'starting_capital': starting_capital,
+            'start_date': start_date,
+            'max_duration_days': max_duration_days,
+            'days_before': days_before,
+            'min_prob_7d': min_prob_7d,
+            'min_prob_current': min_prob_current,
+            'ending_factor_start': ending_factor_start,
+            'ending_factor_increment': ending_factor_increment,
+            'skew_factor': skew_factor,
+            'target_return': target_return,
+            'random_seed': random_seed
+        }
+    }
+
+def plot_simulation_results(results_list: List[Dict[str, Any]], title: str = "Simulation Results"):
+    """
+    Plot results from multiple simulation runs.
+    
+    Args:
+        results_list: List of simulation result dictionaries
+        title: Plot title
+    """
+    if not results_list:
+        print("No results to plot")
+        return
+    
+    # Extract data
+    final_capitals = [r['final_capital'] for r in results_list]
+    total_returns = [r['total_return'] for r in results_list]
+    num_trades = [r['num_trades'] for r in results_list]
+    bust_rate = sum(1 for r in results_list if r['went_bust']) / len(results_list)
+    
+    # Create plots
+    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+    
+    # Final capital distribution
+    axes[0, 0].hist(final_capitals, bins=50, alpha=0.7, edgecolor='black')
+    axes[0, 0].axvline(np.mean(final_capitals), color='red', linestyle='--', 
+                       label=f'Mean: ${np.mean(final_capitals):,.0f}')
+    axes[0, 0].axvline(np.median(final_capitals), color='green', linestyle='--',
+                       label=f'Median: ${np.median(final_capitals):,.0f}')
+    axes[0, 0].set_xlabel('Final Capital ($)')
+    axes[0, 0].set_ylabel('Frequency')
+    axes[0, 0].set_title('Final Capital Distribution')
+    axes[0, 0].legend()
+    axes[0, 0].grid(True, alpha=0.3)
+    
+    # Return distribution
+    return_pct = [r * 100 for r in total_returns]
+    axes[0, 1].hist(return_pct, bins=50, alpha=0.7, edgecolor='black')
+    axes[0, 1].axvline(np.mean(return_pct), color='red', linestyle='--',
+                       label=f'Mean: {np.mean(return_pct):.1f}%')
+    axes[0, 1].axvline(np.median(return_pct), color='green', linestyle='--',
+                       label=f'Median: {np.median(return_pct):.1f}%')
+    axes[0, 1].axvline(0, color='black', linestyle='-', alpha=0.5, label='Break-even')
+    axes[0, 1].set_xlabel('Total Return (%)')
+    axes[0, 1].set_ylabel('Frequency')
+    axes[0, 1].set_title('Return Distribution')
+    axes[0, 1].legend()
+    axes[0, 1].grid(True, alpha=0.3)
+    
+    # Number of trades distribution
+    axes[1, 0].hist(num_trades, bins=30, alpha=0.7, edgecolor='black')
+    axes[1, 0].axvline(np.mean(num_trades), color='red', linestyle='--',
+                       label=f'Mean: {np.mean(num_trades):.1f}')
+    axes[1, 0].set_xlabel('Number of Trades')
+    axes[1, 0].set_ylabel('Frequency')
+    axes[1, 0].set_title('Number of Trades Distribution')
+    axes[1, 0].legend()
+    axes[1, 0].grid(True, alpha=0.3)
+    
+    # Summary statistics
+    axes[1, 1].axis('off')
+    stats_text = f"""
+    Summary Statistics:
+    
+    Total Simulations: {len(results_list):,}
+    Bust Rate: {bust_rate:.1%}
+    
+    Final Capital:
+    Mean: ${np.mean(final_capitals):,.0f}
+    Median: ${np.median(final_capitals):,.0f}
+    Min: ${np.min(final_capitals):,.0f}
+    Max: ${np.max(final_capitals):,.0f}
+    
+    Total Return:
+    Mean: {np.mean(total_returns):.1%}
+    Median: {np.median(total_returns):.1%}
+    Min: {np.min(total_returns):.1%}
+    Max: {np.max(total_returns):.1%}
+    
+    Trades per Simulation:
+    Mean: {np.mean(num_trades):.1f}
+    Median: {np.median(num_trades):.1f}
+    """
+    
+    axes[1, 1].text(0.1, 0.9, stats_text, transform=axes[1, 1].transAxes,
+                    fontsize=11, verticalalignment='top', fontfamily='monospace')
+    
+    plt.suptitle(title, fontsize=16, fontweight='bold')
+    plt.tight_layout()
+    plt.show()
+
+def print_simulation_summary(results_list: List[Dict[str, Any]]):
+    """
+    Print detailed summary statistics for simulation results.
+    
+    Args:
+        results_list: List of simulation result dictionaries
+    """
+    if not results_list:
+        print("No results to summarize")
+        return
+    
+    # Extract data
+    final_capitals = np.array([r['final_capital'] for r in results_list])
+    total_returns = np.array([r['total_return'] for r in results_list])
+    num_trades = np.array([r['num_trades'] for r in results_list])
+    
+    # Calculate statistics
+    bust_count = sum(1 for r in results_list if r['went_bust'])
+    bust_rate = bust_count / len(results_list)
+    
+    target_reached_count = sum(1 for r in results_list if r.get('reached_target', False))
+    target_reached_rate = target_reached_count / len(results_list)
+    
+    positive_return_count = sum(1 for r in total_returns if r > 0)
+    positive_return_rate = positive_return_count / len(results_list)
+    
+    # Check if target return was used
+    target_return = results_list[0]['parameters'].get('target_return', None)
+    
+    print("=" * 60)
+    print("SIMULATION SUMMARY")
+    print("=" * 60)
+    print(f"Total Simulations: {len(results_list):,}")
+    print(f"Went Bust: {bust_count:,} ({bust_rate:.1%})")
+    if target_return is not None:
+        print(f"Reached Target ({target_return:.1%}): {target_reached_count:,} ({target_reached_rate:.1%})")
+    print(f"Positive Returns: {positive_return_count:,} ({positive_return_rate:.1%})")
+    
+    print(f"\nFINAL CAPITAL STATISTICS:")
+    print(f"Mean: ${final_capitals.mean():,.2f}")
+    print(f"Median: ${np.median(final_capitals):,.2f}")
+    print(f"Std Dev: ${final_capitals.std():,.2f}")
+    print(f"Min: ${final_capitals.min():,.2f}")
+    print(f"Max: ${final_capitals.max():,.2f}")
+    
+    print(f"\nRETURN STATISTICS:")
+    print(f"Mean: {total_returns.mean():.1%}")
+    print(f"Median: {np.median(total_returns):.1%}")
+    print(f"Std Dev: {total_returns.std():.1%}")
+    print(f"Min: {total_returns.min():.1%}")
+    print(f"Max: {total_returns.max():.1%}")
+    
+    print(f"\nTRADE STATISTICS:")
+    print(f"Mean Trades: {num_trades.mean():.1f}")
+    print(f"Median Trades: {np.median(num_trades):.1f}")
+    print(f"Min Trades: {num_trades.min()}")
+    print(f"Max Trades: {num_trades.max()}")
+    
+    # Percentiles
+    percentiles = [5, 10, 25, 75, 90, 95]
+    print(f"\nRETURN PERCENTILES:")
+    for p in percentiles:
+        value = np.percentile(total_returns, p)
+        print(f"{p}th percentile: {value:.1%}")
+
+def run_multi_fund_simulation(df: pd.DataFrame,
+                             n_funds: int = 5,
+                             starting_capital: float = 10000,
+                             start_date: str = '2025-01-01',
+                             max_duration_days: int = 365,
+                             days_before: int = 1,
+                             min_prob_7d: float = 0.90,
+                             min_prob_current: float = 0.90,
+                             ending_factor_start: float = 0.05,
+                             ending_factor_increment: float = 0.001,
+                             skew_factor: float = 0.1,
+                             target_return: Optional[float] = None,
+                             random_seed: Optional[int] = None) -> Dict[str, Any]:
+    """
+    Run a multi-fund simulation where capital is divided into independent funds.
+    
+    Args:
+        df: Market data DataFrame
+        n_funds: Number of independent funds to create
+        starting_capital: Total initial capital (divided among funds)
+        start_date: Simulation start date
+        max_duration_days: Maximum simulation duration
+        days_before: Days before resolution to invest
+        min_prob_7d: Minimum probability at 7 days
+        min_prob_current: Minimum probability at investment day
+        ending_factor_start: Starting ending factor
+        ending_factor_increment: Daily increment to ending factor
+        skew_factor: Controls left skew in market selection
+        target_return: Target return threshold per fund (None = no threshold)
+        random_seed: Random seed for reproducibility
+    
+    Returns:
+        Dictionary containing multi-fund simulation results
+    """
+    # Set up random state
+    random_state = np.random.RandomState(random_seed)
+    
+    # Calculate capital per fund
+    capital_per_fund = starting_capital / n_funds
+    
+    # Run simulation for each fund independently
+    fund_results = []
+    all_trades = []
+    
+    for fund_id in range(n_funds):
+        # Use different seed for each fund to ensure independence
+        fund_seed = random_state.randint(0, 1000000)
+        
+        # Run single fund simulation for this fund
+        fund_result = run_single_fund_simulation(
+            df=df,
+            starting_capital=capital_per_fund,
+            start_date=start_date,
+            max_duration_days=max_duration_days,
+            days_before=days_before,
+            min_prob_7d=min_prob_7d,
+            min_prob_current=min_prob_current,
+            ending_factor_start=ending_factor_start,
+            ending_factor_increment=ending_factor_increment,
+            skew_factor=skew_factor,
+            target_return=target_return,
+            random_seed=fund_seed
+        )
+        
+        # Add fund ID to result and trades
+        fund_result['fund_id'] = fund_id
+        for trade in fund_result['trades']:
+            trade['fund_id'] = fund_id
+            all_trades.append(trade)
+        
+        fund_results.append(fund_result)
+    
+    # Calculate portfolio-level statistics
+    surviving_funds = sum(1 for fund in fund_results if not fund['went_bust'])
+    total_final_capital = sum(fund['final_capital'] for fund in fund_results)
+    total_portfolio_return = (total_final_capital - starting_capital) / starting_capital if starting_capital > 0 else 0
+    
+    # Calculate average metrics across surviving funds
+    if surviving_funds > 0:
+        avg_capital_per_surviving_fund = sum(fund['final_capital'] for fund in fund_results if not fund['went_bust']) / surviving_funds
+        avg_return_per_surviving_fund = sum(fund['total_return'] for fund in fund_results if not fund['went_bust']) / surviving_funds
+    else:
+        avg_capital_per_surviving_fund = 0
+        avg_return_per_surviving_fund = -1  # All funds went bust
+    
+    # Target achievement stats
+    funds_reached_target = sum(1 for fund in fund_results if fund.get('reached_target', False))
+    target_achievement_rate = funds_reached_target / n_funds
+    
+    # Trading activity stats
+    total_trades = len(all_trades)
+    avg_trades_per_fund = total_trades / n_funds
+    
+    # Survivorship and diversification metrics
+    survivorship_rate = surviving_funds / n_funds
+    bust_rate = 1 - survivorship_rate
+    
+    return {
+        'portfolio_final_capital': total_final_capital,
+        'portfolio_total_return': total_portfolio_return,
+        'n_funds': n_funds,
+        'surviving_funds': surviving_funds,
+        'survivorship_rate': survivorship_rate,
+        'bust_rate': bust_rate,
+        'avg_capital_per_surviving_fund': avg_capital_per_surviving_fund,
+        'avg_return_per_surviving_fund': avg_return_per_surviving_fund,
+        'funds_reached_target': funds_reached_target,
+        'target_achievement_rate': target_achievement_rate,
+        'total_trades': total_trades,
+        'avg_trades_per_fund': avg_trades_per_fund,
+        'fund_results': fund_results,
+        'all_trades': all_trades,
+        'parameters': {
+            'n_funds': n_funds,
+            'starting_capital': starting_capital,
+            'capital_per_fund': capital_per_fund,
+            'start_date': start_date,
+            'max_duration_days': max_duration_days,
+            'days_before': days_before,
+            'min_prob_7d': min_prob_7d,
+            'min_prob_current': min_prob_current,
+            'ending_factor_start': ending_factor_start,
+            'ending_factor_increment': ending_factor_increment,
+            'skew_factor': skew_factor,
+            'target_return': target_return,
+            'random_seed': random_seed
+        }
+    }
+
+def plot_multi_fund_results(results_list: List[Dict[str, Any]], title: str = "Multi-Fund Simulation Results"):
+    """
+    Plot results from multiple multi-fund simulation runs.
+    
+    Args:
+        results_list: List of multi-fund simulation result dictionaries
+        title: Plot title
+    """
+    if not results_list:
+        print("No results to plot")
+        return
+    
+    # Extract portfolio-level data
+    portfolio_final_capitals = [r['portfolio_final_capital'] for r in results_list]
+    portfolio_returns = [r['portfolio_total_return'] for r in results_list]
+    surviving_funds = [r['surviving_funds'] for r in results_list]
+    survivorship_rates = [r['survivorship_rate'] for r in results_list]
+    
+    # Create plots
+    fig, axes = plt.subplots(2, 2, figsize=(16, 12))
+    
+    # Portfolio final capital distribution
+    axes[0, 0].hist(portfolio_final_capitals, bins=30, alpha=0.7, edgecolor='black', color='steelblue')
+    axes[0, 0].axvline(np.mean(portfolio_final_capitals), color='red', linestyle='--', 
+                       label=f'Mean: ${np.mean(portfolio_final_capitals):,.0f}')
+    axes[0, 0].axvline(np.median(portfolio_final_capitals), color='green', linestyle='--',
+                       label=f'Median: ${np.median(portfolio_final_capitals):,.0f}')
+    axes[0, 0].set_xlabel('Portfolio Final Capital ($)')
+    axes[0, 0].set_ylabel('Frequency')
+    axes[0, 0].set_title('Portfolio Final Capital Distribution')
+    axes[0, 0].legend()
+    axes[0, 0].grid(True, alpha=0.3)
+    
+    # Portfolio return distribution
+    return_pct = [r * 100 for r in portfolio_returns]
+    axes[0, 1].hist(return_pct, bins=30, alpha=0.7, edgecolor='black', color='green')
+    axes[0, 1].axvline(np.mean(return_pct), color='red', linestyle='--',
+                       label=f'Mean: {np.mean(return_pct):.1f}%')
+    axes[0, 1].axvline(0, color='black', linestyle='-', alpha=0.5, label='Break-even')
+    axes[0, 1].set_xlabel('Portfolio Total Return (%)')
+    axes[0, 1].set_ylabel('Frequency')
+    axes[0, 1].set_title('Portfolio Return Distribution')
+    axes[0, 1].legend()
+    axes[0, 1].grid(True, alpha=0.3)
+    
+    # Number of surviving funds distribution
+    n_funds = results_list[0]['n_funds']
+    axes[1, 0].hist(surviving_funds, bins=range(n_funds + 2), alpha=0.7, edgecolor='black', color='orange')
+    axes[1, 0].axvline(np.mean(surviving_funds), color='red', linestyle='--',
+                       label=f'Mean: {np.mean(surviving_funds):.1f}')
+    axes[1, 0].set_xlabel('Number of Surviving Funds')
+    axes[1, 0].set_ylabel('Frequency')
+    axes[1, 0].set_title('Surviving Funds Distribution')
+    axes[1, 0].legend()
+    axes[1, 0].grid(True, alpha=0.3)
+    axes[1, 0].set_xticks(range(n_funds + 1))
+    
+    # Summary statistics
+    axes[1, 1].axis('off')
+    
+    # Calculate additional stats
+    total_bust_rate = sum(1 for r in results_list if r['surviving_funds'] == 0) / len(results_list)
+    avg_survivorship = np.mean(survivorship_rates)
+    
+    stats_text = f"""
+    Multi-Fund Summary Statistics:
+    
+    Total Simulations: {len(results_list):,}
+    Funds per Portfolio: {n_funds}
+    Total Bust Rate: {total_bust_rate:.1%}
+    
+    Portfolio Capital:
+    Mean: ${np.mean(portfolio_final_capitals):,.0f}
+    Median: ${np.median(portfolio_final_capitals):,.0f}
+    Min: ${np.min(portfolio_final_capitals):,.0f}
+    Max: ${np.max(portfolio_final_capitals):,.0f}
+    
+    Portfolio Return:
+    Mean: {np.mean(portfolio_returns):.1%}
+    Median: {np.median(portfolio_returns):.1%}
+    
+    Fund Survivorship:
+    Avg Surviving: {np.mean(surviving_funds):.1f} / {n_funds}
+    Avg Survivorship: {avg_survivorship:.1%}
+    """
+    
+    axes[1, 1].text(0.1, 0.9, stats_text, transform=axes[1, 1].transAxes,
+                    fontsize=11, verticalalignment='top', fontfamily='monospace')
+    
+    plt.suptitle(title, fontsize=16, fontweight='bold')
+    plt.tight_layout()
+    plt.show()
+
+def print_multi_fund_summary(results_list: List[Dict[str, Any]]):
+    """
+    Print detailed summary statistics for multi-fund simulation results.
+    
+    Args:
+        results_list: List of multi-fund simulation result dictionaries
+    """
+    if not results_list:
+        print("No results to summarize")
+        return
+    
+    # Extract data
+    n_funds = results_list[0]['n_funds']
+    portfolio_capitals = np.array([r['portfolio_final_capital'] for r in results_list])
+    portfolio_returns = np.array([r['portfolio_total_return'] for r in results_list])
+    surviving_funds = np.array([r['surviving_funds'] for r in results_list])
+    survivorship_rates = np.array([r['survivorship_rate'] for r in results_list])
+    
+    # Calculate portfolio-level statistics
+    total_bust_count = sum(1 for r in results_list if r['surviving_funds'] == 0)
+    total_bust_rate = total_bust_count / len(results_list)
+    
+    positive_return_count = sum(1 for r in portfolio_returns if r > 0)
+    positive_return_rate = positive_return_count / len(results_list)
+    
+    # Check if target return was used
+    target_return = results_list[0]['parameters'].get('target_return', None)
+    
+    print("=" * 80)
+    print("MULTI-FUND SIMULATION SUMMARY")
+    print("=" * 80)
+    print(f"Total Simulations: {len(results_list):,}")
+    print(f"Funds per Portfolio: {n_funds}")
+    print(f"Starting Capital per Fund: ${results_list[0]['parameters']['capital_per_fund']:,.0f}")
+    print(f"Total Starting Capital: ${results_list[0]['parameters']['starting_capital']:,.0f}")
+    
+    print(f"\nPORTFOLIO SURVIVORSHIP:")
+    print(f"Total Portfolio Bust Rate: {total_bust_rate:.1%} ({total_bust_count:,} portfolios)")
+    print(f"Average Surviving Funds: {surviving_funds.mean():.1f} / {n_funds}")
+    print(f"Average Survivorship Rate: {survivorship_rates.mean():.1%}")
+    print(f"Portfolios with All Funds Surviving: {sum(1 for s in surviving_funds if s == n_funds)} ({sum(1 for s in surviving_funds if s == n_funds)/len(results_list):.1%})")
+    
+    if target_return is not None:
+        target_achieved_portfolios = sum(1 for r in results_list if r['funds_reached_target'] > 0)
+        avg_funds_reaching_target = np.mean([r['funds_reached_target'] for r in results_list])
+        print(f"\nTARGET ACHIEVEMENT ({target_return:.1%}):")
+        print(f"Portfolios with ≥1 Fund Reaching Target: {target_achieved_portfolios:,} ({target_achieved_portfolios/len(results_list):.1%})")
+        print(f"Average Funds Reaching Target: {avg_funds_reaching_target:.1f} / {n_funds}")
+    
+    print(f"\nPORTFOLIO PERFORMANCE:")
+    print(f"Positive Returns: {positive_return_count:,} ({positive_return_rate:.1%})")
+    
+    print(f"\nPORTFOLIO CAPITAL STATISTICS:")
+    print(f"Mean: ${portfolio_capitals.mean():,.2f}")
+    print(f"Median: ${np.median(portfolio_capitals):,.2f}")
+    print(f"Std Dev: ${portfolio_capitals.std():,.2f}")
+    print(f"Min: ${portfolio_capitals.min():,.2f}")
+    print(f"Max: ${portfolio_capitals.max():,.2f}")
+    
+    print(f"\nPORTFOLIO RETURN STATISTICS:")
+    print(f"Mean: {portfolio_returns.mean():.1%}")
+    print(f"Median: {np.median(portfolio_returns):.1%}")
+    print(f"Std Dev: {portfolio_returns.std():.1%}")
+    print(f"Min: {portfolio_returns.min():.1%}")
+    print(f"Max: {portfolio_returns.max():.1%}")
+    
+    # Compare to single fund equivalent
+    print(f"\nDIVERSIFICATION ANALYSIS:")
+    single_fund_equivalent = results_list[0]['parameters']['starting_capital']
+    avg_portfolio_capital = portfolio_capitals.mean()
+    diversification_benefit = (avg_portfolio_capital - single_fund_equivalent) / single_fund_equivalent
+    print(f"Diversification Benefit: {diversification_benefit:+.1%} vs single fund baseline")
+    
+    # Risk metrics
+    portfolio_volatility = portfolio_returns.std()
+    print(f"Portfolio Return Volatility: {portfolio_volatility:.1%}")
+    
+    # Percentiles
+    percentiles = [5, 10, 25, 75, 90, 95]
+    print(f"\nPORTFOLIO RETURN PERCENTILES:")
+    for p in percentiles:
+        value = np.percentile(portfolio_returns, p)
+        print(f"{p}th percentile: {value:.1%}")

static/.gitignore

@@ -0,0 +1,4 @@
+node_modules/
+.DS_Store
+*.log
+

static/README.md

@@ -0,0 +1,49 @@
+# Safe Choices Frontend
+
+Frontend interface for the Safe Choices prediction market simulation tool.
+
+## Setup
+
+1. Navigate to the frontend directory:
+```bash
+cd frontend
+```
+
+2. Install dependencies (optional - uses npx, so no install needed):
+```bash
+npm install
+```
+
+## Running
+
+Start the development server:
+```bash
+npm run start
+```
+
+This will:
+- Start a local HTTP server on port 3000
+- Automatically open the browser to the application
+- Serve the static files with proper MIME types
+
+For development with auto-reload (no caching):
+```bash
+npm run dev
+```
+
+## Features
+
+- **Single Fund Simulation**: All capital in one fund
+- **Single Fund Threshold**: Stop at target return (Treasury rate or NASDAQ average)
+- **Multi Fund Simulation**: Diversified portfolio with multiple independent funds
+
+## Configuration
+
+All simulation parameters can be configured through the web interface:
+- Starting capital
+- Number of simulations
+- Probability thresholds
+- Market selection skew
+- Target returns (for threshold simulations)
+- Number of funds (for multi-fund simulations)
+

static/index.html

@@ -0,0 +1,283 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Safe Choices - Prediction Market Simulation</title>
+    <link rel="stylesheet" href="/static/styles.css">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/date-fns/1.30.1/date_fns.min.js"></script>
+</head>
+<body>
+    <!-- Top Navigation Bar -->
+    <header class="top-bar">
+        <div class="nav-container">
+            <div class="logo-section">
+                <img src="/static/polymarket_logo.png" alt="Safe Choices" class="logo">
+                <h1 class="app-title">Safe Choices</h1>
+                <span class="subtitle">Prediction Market Simulation</span>
+            </div>
+            <div class="nav-info">
+                <span class="dataset-info">Dataset: Polymarket 2024-2025 Markets</span>
+            </div>
+        </div>
+    </header>
+
+    <!-- Main Container -->
+    <div class="main-container">
+        <!-- Simulation Controls -->
+        <section class="controls-section">
+            <div class="controls-header">
+                <h2>Simulation Configuration</h2>
+                <p>Configure your prediction market trading simulation parameters</p>
+            </div>
+
+            <div class="controls-grid">
+                <!-- Simulation Type Selection -->
+                <div class="control-group full-width">
+                    <label class="control-label">Simulation Type</label>
+                    <div class="simulation-tabs">
+                        <button class="sim-tab active" data-sim="single" onclick="selectSimulation('single')">
+                            <div class="tab-title">Single Fund</div>
+                            <div class="tab-subtitle">All capital in one fund</div>
+                        </button>
+                        <button class="sim-tab" data-sim="threshold" onclick="selectSimulation('threshold')">
+                            <div class="tab-title">Single Fund Threshold</div>
+                            <div class="tab-subtitle">Stop at target return</div>
+                        </button>
+                        <button class="sim-tab" data-sim="multi" onclick="selectSimulation('multi')">
+                            <div class="tab-title">Multi Fund</div>
+                            <div class="tab-subtitle">Diversified portfolio</div>
+                        </button>
+                    </div>
+                </div>
+
+                <!-- Base Parameters -->
+                <div class="control-group">
+                    <label class="control-label">Starting Capital ($)</label>
+                    <input type="number" id="startingCapital" class="control-input" value="10000" min="1000" max="100000" step="1000">
+                    <div class="control-subtitle">Total initial investment amount</div>
+                </div>
+
+                <div class="control-group">
+                    <label class="control-label">Number of Simulations</label>
+                    <input type="number" id="numSimulations" class="control-input" value="100" min="10" max="100" step="10">
+                    <div class="control-subtitle">Monte Carlo simulation runs (max 100)</div>
+                </div>
+
+                <div class="control-group">
+                    <label class="control-label">Start Date</label>
+                    <input type="date" id="startDate" class="control-input" value="2025-01-01" min="2025-01-01">
+                    <div class="control-subtitle">Simulation start date (2025+ only)</div>
+                </div>
+
+                <div class="control-group">
+                    <label class="control-label">Max Duration (Days)</label>
+                    <input type="number" id="maxDuration" class="control-input" value="365" min="30" max="730" step="30">
+                    <div class="control-subtitle">Maximum simulation length</div>
+                </div>
+
+                <!-- Probability Thresholds -->
+                <div class="control-group">
+                    <label class="control-label">Min Probability 7d (%)</label>
+                    <input type="number" id="minProb7d" class="control-input" value="90" min="50" max="99" step="1">
+                    <div class="control-subtitle">Minimum market probability 7 days before</div>
+                </div>
+
+                <div class="control-group">
+                    <label class="control-label">Min Probability Current (%)</label>
+                    <input type="number" id="minProbCurrent" class="control-input" value="90" min="50" max="99" step="1">
+                    <div class="control-subtitle">Minimum probability at investment</div>
+                </div>
+
+                <div class="control-group">
+                    <label class="control-label">Days Before Resolution</label>
+                    <input type="number" id="daysBefore" class="control-input" value="1" min="1" max="7" step="1">
+                    <div class="control-subtitle">When to invest before market closes</div>
+                </div>
+
+                <div class="control-group">
+                    <label class="control-label">Market Selection Skew</label>
+                    <input type="number" id="skewFactor" class="control-input" value="0.1" min="0.01" max="1.0" step="0.01">
+                    <div class="control-subtitle">Higher values favor closer markets</div>
+                </div>
+
+                <!-- Threshold-specific controls -->
+                <div class="control-group threshold-only" style="display: none;">
+                    <label class="control-label">Target Return (%)</label>
+                    <select id="targetReturn" class="control-input">
+                        <option value="4.14">4.14% (Treasury Rate)</option>
+                        <option value="10.56">10.56% (NASDAQ Average)</option>
+                        <option value="custom">Custom</option>
+                    </select>
+                    <input type="number" id="customTarget" class="control-input" style="display: none; margin-top: 8px;" min="1" max="50" step="0.1">
+                    <div class="control-subtitle">Stop trading when target is reached</div>
+                </div>
+
+                <!-- Multi-fund specific controls -->
+                <div class="control-group multi-only" style="display: none;">
+                    <label class="control-label">Number of Funds</label>
+                    <input type="number" id="numFunds" class="control-input" value="5" min="2" max="10" step="1">
+                    <div class="control-subtitle">Split capital into N independent funds (max 10)</div>
+                </div>
+            </div>
+
+            <!-- Run Button -->
+            <div class="run-section">
+                <button class="run-button" onclick="runSimulation()" id="runBtn">
+                    <span class="run-text">Run Simulation</span>
+                    <div class="run-spinner" style="display: none;"></div>
+                </button>
+                <div class="run-info">
+                    <span id="estimatedTime">Estimated time: ~5-10 seconds</span>
+                </div>
+            </div>
+        </section>
+
+        <!-- Progress Bar -->
+        <section class="progress-section" style="display: none;">
+            <div class="progress-container">
+                <div class="progress-label">
+                    <span id="progressText">Running simulation...</span>
+                    <span id="progressPercent">0%</span>
+                </div>
+                <div class="progress-bar">
+                    <div class="progress-fill" id="progressFill"></div>
+                </div>
+            </div>
+        </section>
+
+        <!-- Results Section -->
+        <section class="results-section" id="resultsSection" style="display: none;">
+            <div class="results-header">
+                <h2>Simulation Results</h2>
+                <button class="export-button" onclick="exportResults()" id="exportBtn">Export Data</button>
+            </div>
+
+            <!-- Summary Statistics -->
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <div class="stat-header">
+                        <h3>Performance</h3>
+                    </div>
+                    <div class="stat-content">
+                        <div class="stat-item">
+                            <span class="stat-label">Average Return:</span>
+                            <span class="stat-value" id="avgReturn">--</span>
+                        </div>
+                        <div class="stat-item">
+                            <span class="stat-label">Median Return:</span>
+                            <span class="stat-value" id="medianReturn">--</span>
+                        </div>
+                        <div class="stat-item">
+                            <span class="stat-label">Success Rate:</span>
+                            <span class="stat-value" id="successRate">--</span>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="stat-card">
+                    <div class="stat-header">
+                        <h3>Risk Metrics</h3>
+                    </div>
+                    <div class="stat-content">
+                        <div class="stat-item">
+                            <span class="stat-label">Bust Rate:</span>
+                            <span class="stat-value" id="bustRate">--</span>
+                        </div>
+                        <div class="stat-item">
+                            <span class="stat-label">Volatility:</span>
+                            <span class="stat-value" id="volatility">--</span>
+                        </div>
+                        <div class="stat-item">
+                            <span class="stat-label">Max Drawdown:</span>
+                            <span class="stat-value" id="maxDrawdown">--</span>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="stat-card multi-stats" style="display: none;">
+                    <div class="stat-header">
+                        <h3>Portfolio Stats</h3>
+                    </div>
+                    <div class="stat-content">
+                        <div class="stat-item">
+                            <span class="stat-label">Avg Surviving Funds:</span>
+                            <span class="stat-value" id="avgSurvivingFunds">--</span>
+                        </div>
+                        <div class="stat-item">
+                            <span class="stat-label">Survivorship Rate:</span>
+                            <span class="stat-value" id="survivorshipRate">--</span>
+                        </div>
+                        <div class="stat-item">
+                            <span class="stat-label">Diversification Benefit:</span>
+                            <span class="stat-value" id="diversificationBenefit">--</span>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="stat-card threshold-stats" style="display: none;">
+                    <div class="stat-header">
+                        <h3>Target Achievement</h3>
+                    </div>
+                    <div class="stat-content">
+                        <div class="stat-item">
+                            <span class="stat-label">Target Reached:</span>
+                            <span class="stat-value" id="targetReached">--</span>
+                        </div>
+                        <div class="stat-item">
+                            <span class="stat-label">Avg Time to Target:</span>
+                            <span class="stat-value" id="avgTimeToTarget">--</span>
+                        </div>
+                        <div class="stat-item">
+                            <span class="stat-label">vs Never Stop:</span>
+                            <span class="stat-value" id="vsNeverStop">--</span>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Charts -->
+            <div class="charts-grid">
+                <div class="chart-card">
+                    <div class="chart-header">
+                        <h3>Return Distribution</h3>
+                    </div>
+                    <div class="chart-container">
+                        <canvas id="returnChart" width="400" height="200"></canvas>
+                    </div>
+                </div>
+
+                <div class="chart-card">
+                    <div class="chart-header">
+                        <h3>Capital Evolution</h3>
+                    </div>
+                    <div class="chart-container">
+                        <canvas id="capitalChart" width="400" height="200"></canvas>
+                    </div>
+                </div>
+
+                <div class="chart-card multi-chart" style="display: none;">
+                    <div class="chart-header">
+                        <h3>Fund Survivorship</h3>
+                    </div>
+                    <div class="chart-container">
+                        <canvas id="survivorshipChart" width="400" height="200"></canvas>
+                    </div>
+                </div>
+
+                <div class="chart-card">
+                    <div class="chart-header">
+                        <h3>Final Capital Distribution</h3>
+                    </div>
+                    <div class="chart-container">
+                        <canvas id="distributionChart" width="400" height="200"></canvas>
+                    </div>
+                </div>
+            </div>
+        </section>
+    </div>
+
+    <script src="/static/script.js"></script>
+</body>
+</html>

static/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "safe-choices-frontend",
+  "version": "1.0.0",
+  "description": "Frontend for Safe Choices prediction market simulation",
+  "main": "index.html",
+  "scripts": {
+    "start": "npx http-server . -p 3000 -o",
+    "dev": "npx http-server . -p 3000 -o -c-1"
+  },
+  "keywords": [
+    "prediction-markets",
+    "simulation",
+    "polymarket"
+  ],
+  "author": "",
+  "license": "MIT"
+}
+

static/script.js

@@ -0,0 +1,798 @@
+// Global variables
+let currentSimType = 'single';
+let simulationResults = null;
+let charts = {};
+
+// Initialize the application
+document.addEventListener('DOMContentLoaded', function() {
+    initializeDefaults();
+    setupEventListeners();
+    updateEstimatedTime();
+});
+
+// Initialize default values and constraints
+function initializeDefaults() {
+    // Set minimum start date and default to 2025-01-01
+    const startDateInput = document.getElementById('startDate');
+    const defaultDate = new Date('2025-01-01');
+    
+    startDateInput.value = defaultDate.toISOString().split('T')[0];
+    startDateInput.min = '2025-01-01';
+    
+    // Initialize target return dropdown handler
+    document.getElementById('targetReturn').addEventListener('change', function() {
+        const customInput = document.getElementById('customTarget');
+        if (this.value === 'custom') {
+            customInput.style.display = 'block';
+            customInput.value = '12.0';
+        } else {
+            customInput.style.display = 'none';
+        }
+    });
+}
+
+// Setup event listeners
+function setupEventListeners() {
+    // Input validation
+    document.getElementById('numSimulations').addEventListener('input', function() {
+        this.value = Math.min(Math.max(parseInt(this.value) || 10, 10), 100);
+        updateEstimatedTime();
+    });
+    
+    document.getElementById('numFunds').addEventListener('input', function() {
+        this.value = Math.min(Math.max(parseInt(this.value) || 2, 2), 10);
+    });
+    
+    // Update estimated time when parameters change
+    const timeInputs = ['numSimulations', 'maxDuration', 'numFunds'];
+    timeInputs.forEach(id => {
+        document.getElementById(id).addEventListener('input', updateEstimatedTime);
+    });
+    
+    // Real-time validation
+    const inputs = document.querySelectorAll('.control-input');
+    inputs.forEach(input => {
+        input.addEventListener('input', validateInputs);
+    });
+}
+
+// Select simulation type
+function selectSimulation(type) {
+    currentSimType = type;
+    
+    // Update tab appearance
+    document.querySelectorAll('.sim-tab').forEach(tab => {
+        tab.classList.remove('active');
+    });
+    document.querySelector(`[data-sim="${type}"]`).classList.add('active');
+    
+    // Show/hide conditional controls
+    document.querySelectorAll('.threshold-only').forEach(el => {
+        el.style.display = type === 'threshold' ? 'block' : 'none';
+    });
+    
+    document.querySelectorAll('.multi-only').forEach(el => {
+        el.style.display = type === 'multi' ? 'block' : 'none';
+    });
+    
+    updateEstimatedTime();
+}
+
+// Update estimated execution time
+function updateEstimatedTime() {
+    const numSims = parseInt(document.getElementById('numSimulations').value) || 100;
+    const maxDuration = parseInt(document.getElementById('maxDuration').value) || 365;
+    const numFunds = currentSimType === 'multi' ? (parseInt(document.getElementById('numFunds').value) || 5) : 1;
+    
+    // Rough estimation based on complexity
+    let baseTime = numSims * 0.05; // ~50ms per simulation
+    baseTime *= (maxDuration / 365); // Scale by duration
+    if (currentSimType === 'multi') {
+        baseTime *= Math.sqrt(numFunds); // Multi-fund overhead
+    }
+    
+    const estimatedSeconds = Math.max(2, Math.ceil(baseTime));
+    
+    let timeText = '';
+    if (estimatedSeconds < 60) {
+        timeText = `~${estimatedSeconds} seconds`;
+    } else {
+        const minutes = Math.ceil(estimatedSeconds / 60);
+        timeText = `~${minutes} minute${minutes > 1 ? 's' : ''}`;
+    }
+    
+    document.getElementById('estimatedTime').textContent = `Estimated time: ${timeText}`;
+}
+
+// Validate all inputs
+function validateInputs() {
+    const errors = [];
+    
+    // Check required fields
+    const startingCapital = parseFloat(document.getElementById('startingCapital').value);
+    if (!startingCapital || startingCapital < 1000) {
+        errors.push('Starting capital must be at least $1,000');
+    }
+    
+    const startDate = new Date(document.getElementById('startDate').value);
+    const minDate = new Date('2025-01-01');
+    if (startDate < minDate) {
+        errors.push('Start date must be 2025-01-01 or later');
+    }
+    
+    const minProb7d = parseFloat(document.getElementById('minProb7d').value);
+    const minProbCurrent = parseFloat(document.getElementById('minProbCurrent').value);
+    if (minProb7d < 50 || minProb7d > 99) {
+        errors.push('7-day probability must be between 50% and 99%');
+    }
+    if (minProbCurrent < 50 || minProbCurrent > 99) {
+        errors.push('Current probability must be between 50% and 99%');
+    }
+    
+    // Update run button state
+    const runBtn = document.getElementById('runBtn');
+    runBtn.disabled = errors.length > 0;
+    
+    return errors.length === 0;
+}
+
+// Main simulation runner
+async function runSimulation() {
+    if (!validateInputs()) return;
+    
+    // Get parameters
+    const params = getSimulationParameters();
+    
+    // Update UI for running state
+    showProgress();
+    disableControls();
+    
+    try {
+        // Call the backend API
+        const results = await callSimulationAPI(params);
+        
+        // Store results and display
+        simulationResults = results;
+        displayResults(results);
+        
+    } catch (error) {
+        console.error('Simulation error:', error);
+        alert('An error occurred during simulation: ' + (error.message || 'Unknown error'));
+    } finally {
+        hideProgress();
+        enableControls();
+    }
+}
+
+// Call the backend API for real simulations
+async function callSimulationAPI(params) {
+    const progressFill = document.getElementById('progressFill');
+    const progressPercent = document.getElementById('progressPercent');
+    const progressText = document.getElementById('progressText');
+    
+    progressText.textContent = 'Sending request to backend...';
+    progressFill.style.width = '10%';
+    progressPercent.textContent = '10%';
+    
+    // Prepare request body
+    const requestBody = {
+        simType: params.simType,
+        startingCapital: params.startingCapital,
+        numSimulations: params.numSimulations,
+        startDate: params.startDate,
+        maxDuration: params.maxDuration,
+        minProb7d: params.minProb7d,
+        minProbCurrent: params.minProbCurrent,
+        daysBefore: params.daysBefore,
+        skewFactor: params.skewFactor
+    };
+    
+    if (params.simType === 'threshold' && params.targetReturn !== undefined) {
+        requestBody.targetReturn = params.targetReturn;
+    }
+    
+    if (params.simType === 'multi' && params.numFunds !== undefined) {
+        requestBody.numFunds = params.numFunds;
+    }
+    
+    // Make API call
+    const response = await fetch('/api/simulate', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(requestBody)
+    });
+    
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ detail: response.statusText }));
+        throw new Error(errorData.detail || `HTTP ${response.status}: ${response.statusText}`);
+    }
+    
+    progressText.textContent = 'Processing results...';
+    progressFill.style.width = '90%';
+    progressPercent.textContent = '90%';
+    
+    const results = await response.json();
+    
+    progressFill.style.width = '100%';
+    progressPercent.textContent = '100%';
+    progressText.textContent = 'Complete!';
+    
+    return results;
+}
+
+// Get simulation parameters from UI
+function getSimulationParameters() {
+    const params = {
+        simType: currentSimType,
+        startingCapital: parseFloat(document.getElementById('startingCapital').value),
+        numSimulations: parseInt(document.getElementById('numSimulations').value),
+        startDate: document.getElementById('startDate').value,
+        maxDuration: parseInt(document.getElementById('maxDuration').value),
+        minProb7d: parseFloat(document.getElementById('minProb7d').value) / 100,
+        minProbCurrent: parseFloat(document.getElementById('minProbCurrent').value) / 100,
+        daysBefore: parseInt(document.getElementById('daysBefore').value),
+        skewFactor: parseFloat(document.getElementById('skewFactor').value)
+    };
+    
+    // Type-specific parameters
+    if (currentSimType === 'threshold') {
+        const targetSelect = document.getElementById('targetReturn').value;
+        if (targetSelect === 'custom') {
+            params.targetReturn = parseFloat(document.getElementById('customTarget').value) / 100;
+        } else {
+            params.targetReturn = parseFloat(targetSelect) / 100;
+        }
+    }
+    
+    if (currentSimType === 'multi') {
+        params.numFunds = parseInt(document.getElementById('numFunds').value);
+    }
+    
+    return params;
+}
+
+// Legacy function - kept for reference but not used when API is available
+async function simulateComputation(params) {
+    // This function is replaced by callSimulationAPI
+    // Kept for fallback if needed
+    return await callSimulationAPI(params);
+}
+
+// Generate a realistic simulation run
+function generateSimulationRun(params, seed) {
+    const rng = new SimpleRNG(seed + 12345);
+    
+    const run = {
+        finalCapital: 0,
+        totalReturn: 0,
+        numTrades: 0,
+        wentBust: false,
+        reachedTarget: false,
+        simulationDays: 0
+    };
+    
+    if (params.simType === 'multi') {
+        run.survivingFunds = 0;
+        run.fundResults = [];
+        
+        for (let f = 0; f < params.numFunds; f++) {
+            const fundRun = generateSingleFundRun(params, rng.next());
+            run.fundResults.push(fundRun);
+            if (!fundRun.wentBust) run.survivingFunds++;
+        }
+        
+        run.finalCapital = run.fundResults.reduce((sum, fund) => sum + fund.finalCapital, 0);
+        run.totalReturn = (run.finalCapital - params.startingCapital) / params.startingCapital;
+        run.numTrades = run.fundResults.reduce((sum, fund) => sum + fund.numTrades, 0);
+        run.wentBust = run.survivingFunds === 0;
+    } else {
+        const singleRun = generateSingleFundRun(params, seed);
+        Object.assign(run, singleRun);
+    }
+    
+    return run;
+}
+
+// Generate a single fund run with realistic market behavior
+function generateSingleFundRun(params, seed) {
+    const rng = new SimpleRNG(seed);
+    let capital = params.simType === 'multi' ? params.startingCapital / params.numFunds : params.startingCapital;
+    
+    const run = {
+        finalCapital: capital,
+        totalReturn: 0,
+        numTrades: 0,
+        wentBust: false,
+        reachedTarget: false,
+        simulationDays: 0,
+        capitalHistory: [capital]
+    };
+    
+    const maxTrades = Math.floor(params.maxDuration / 7) + rng.nextInt(5, 20);
+    let day = 0;
+    
+    for (let trade = 0; trade < maxTrades && capital > 0 && day < params.maxDuration; trade++) {
+        // Check target return for threshold simulations
+        if (params.simType === 'threshold' && params.targetReturn) {
+            const currentReturn = (capital - (params.startingCapital / (params.numFunds || 1))) / (params.startingCapital / (params.numFunds || 1));
+            if (currentReturn >= params.targetReturn) {
+                run.reachedTarget = true;
+                break;
+            }
+        }
+        
+        // Market probability based on thresholds (realistic distribution)
+        const marketProb = Math.max(params.minProbCurrent, 
+            params.minProbCurrent + rng.nextGaussian() * 0.05);
+        
+        // Win probability (slightly higher than market prob to simulate edge)
+        const winProb = Math.min(0.99, marketProb + 0.01 + rng.nextGaussian() * 0.02);
+        
+        const won = rng.nextFloat() < winProb;
+        
+        if (won) {
+            capital = capital / marketProb; // Return = 1/probability
+        } else {
+            capital = 0; // Total loss
+            run.wentBust = true;
+            break;
+        }
+        
+        run.numTrades++;
+        run.capitalHistory.push(capital);
+        
+        // Advance time (realistic trading frequency)
+        day += rng.nextInt(1, 14);
+        
+        // Ending factor check
+        const endingFactor = 0.05 + (day * 0.001);
+        if (rng.nextFloat() < endingFactor) break;
+    }
+    
+    run.finalCapital = capital;
+    run.simulationDays = day;
+    const initialCapital = params.simType === 'multi' ? params.startingCapital / params.numFunds : params.startingCapital;
+    run.totalReturn = (capital - initialCapital) / initialCapital;
+    
+    return run;
+}
+
+// Calculate summary statistics
+function calculateSummaryStats(runs, params) {
+    const returns = runs.map(r => r.totalReturn);
+    const capitals = runs.map(r => r.finalCapital);
+    const trades = runs.map(r => r.numTrades);
+    
+    const summary = {
+        avgReturn: mean(returns),
+        medianReturn: median(returns),
+        returnVolatility: standardDeviation(returns),
+        avgFinalCapital: mean(capitals),
+        medianFinalCapital: median(capitals),
+        bustRate: runs.filter(r => r.wentBust).length / runs.length,
+        positiveReturnRate: returns.filter(r => r > 0).length / returns.length,
+        avgTrades: mean(trades),
+        
+        // Percentiles
+        return5th: percentile(returns, 5),
+        return95th: percentile(returns, 95),
+        
+        // Max drawdown approximation
+        maxDrawdown: Math.abs(Math.min(...returns))
+    };
+    
+    // Type-specific stats
+    if (params.simType === 'threshold' && params.targetReturn) {
+        const reachedTarget = runs.filter(r => r.reachedTarget).length;
+        summary.targetReachedRate = reachedTarget / runs.length;
+        summary.avgTimeToTarget = mean(runs.filter(r => r.reachedTarget).map(r => r.simulationDays)) || 0;
+    }
+    
+    if (params.simType === 'multi') {
+        const survivingFunds = runs.map(r => r.survivingFunds);
+        summary.avgSurvivingFunds = mean(survivingFunds);
+        summary.survivorshipRate = mean(survivingFunds) / params.numFunds;
+        summary.portfolioBustRate = runs.filter(r => r.survivingFunds === 0).length / runs.length;
+    }
+    
+    return summary;
+}
+
+// Display results in UI
+function displayResults(results) {
+    const { summary, parameters } = results;
+    
+    // Show results section
+    document.getElementById('resultsSection').style.display = 'block';
+    document.getElementById('resultsSection').scrollIntoView({ behavior: 'smooth' });
+    
+    // Update basic statistics
+    document.getElementById('avgReturn').textContent = formatPercentage(summary.avgReturn);
+    document.getElementById('avgReturn').className = `stat-value ${getReturnClass(summary.avgReturn)}`;
+    
+    document.getElementById('medianReturn').textContent = formatPercentage(summary.medianReturn);
+    document.getElementById('medianReturn').className = `stat-value ${getReturnClass(summary.medianReturn)}`;
+    
+    document.getElementById('successRate').textContent = formatPercentage(summary.positiveReturnRate);
+    
+    document.getElementById('bustRate').textContent = formatPercentage(summary.bustRate);
+    document.getElementById('bustRate').className = `stat-value ${summary.bustRate > 0.1 ? 'negative' : 'positive'}`;
+    
+    document.getElementById('volatility').textContent = formatPercentage(summary.returnVolatility);
+    document.getElementById('maxDrawdown').textContent = formatPercentage(summary.maxDrawdown);
+    
+    // Type-specific statistics
+    if (parameters.simType === 'multi') {
+        document.querySelectorAll('.multi-stats, .multi-chart').forEach(el => {
+            el.style.display = 'block';
+        });
+        
+        document.getElementById('avgSurvivingFunds').textContent = 
+            `${summary.avgSurvivingFunds.toFixed(1)} / ${parameters.numFunds}`;
+        document.getElementById('survivorshipRate').textContent = formatPercentage(summary.survivorshipRate);
+        
+        // Simple diversification benefit calculation
+        const diversificationBenefit = summary.returnVolatility < 0.3 ? 'Positive' : 'Limited';
+        document.getElementById('diversificationBenefit').textContent = diversificationBenefit;
+    } else {
+        document.querySelectorAll('.multi-stats, .multi-chart').forEach(el => {
+            el.style.display = 'none';
+        });
+    }
+    
+    if (parameters.simType === 'threshold') {
+        document.querySelectorAll('.threshold-stats').forEach(el => {
+            el.style.display = 'block';
+        });
+        
+        document.getElementById('targetReached').textContent = formatPercentage(summary.targetReachedRate || 0);
+        document.getElementById('avgTimeToTarget').textContent = 
+            summary.avgTimeToTarget ? `${Math.round(summary.avgTimeToTarget)} days` : 'N/A';
+        document.getElementById('vsNeverStop').textContent = 
+            summary.targetReachedRate > 0.5 ? 'Better' : 'Similar';
+    } else {
+        document.querySelectorAll('.threshold-stats').forEach(el => {
+            el.style.display = 'none';
+        });
+    }
+    
+    // Generate charts
+    generateCharts(results);
+}
+
+// Generate all charts
+function generateCharts(results) {
+    const { runs, summary, parameters } = results;
+    
+    // Destroy existing charts
+    Object.values(charts).forEach(chart => {
+        if (chart) chart.destroy();
+    });
+    charts = {};
+    
+    // Return distribution histogram
+    charts.return = createReturnDistributionChart(runs);
+    
+    // Capital evolution (sample of runs)
+    charts.capital = createCapitalEvolutionChart(runs.slice(0, 10));
+    
+    // Final capital distribution
+    charts.distribution = createCapitalDistributionChart(runs);
+    
+    // Multi-fund specific chart
+    if (parameters.simType === 'multi') {
+        charts.survivorship = createSurvivorshipChart(runs, parameters.numFunds);
+    }
+}
+
+// Create return distribution chart
+function createReturnDistributionChart(runs) {
+    const ctx = document.getElementById('returnChart').getContext('2d');
+    const returns = runs.map(r => r.totalReturn * 100);
+    
+    const histogram = createHistogram(returns, 20);
+    
+    return new Chart(ctx, {
+        type: 'bar',
+        data: {
+            labels: histogram.labels,
+            datasets: [{
+                label: 'Frequency',
+                data: histogram.data,
+                backgroundColor: 'rgba(59, 130, 246, 0.7)',
+                borderColor: 'rgba(59, 130, 246, 1)',
+                borderWidth: 1
+            }]
+        },
+        options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+                legend: { display: false }
+            },
+            scales: {
+                x: {
+                    title: {
+                        display: true,
+                        text: 'Return (%)'
+                    }
+                },
+                y: {
+                    title: {
+                        display: true,
+                        text: 'Frequency'
+                    }
+                }
+            }
+        }
+    });
+}
+
+// Create capital evolution chart
+function createCapitalEvolutionChart(sampleRuns) {
+    const ctx = document.getElementById('capitalChart').getContext('2d');
+    
+    const datasets = sampleRuns.slice(0, 5).map((run, i) => ({
+        label: `Run ${i + 1}`,
+        data: run.capitalHistory || [run.finalCapital],
+        borderColor: `hsla(${i * 60}, 70%, 50%, 0.8)`,
+        backgroundColor: `hsla(${i * 60}, 70%, 50%, 0.1)`,
+        borderWidth: 2,
+        fill: false
+    }));
+    
+    return new Chart(ctx, {
+        type: 'line',
+        data: { datasets },
+        options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+                legend: { display: true }
+            },
+            scales: {
+                x: {
+                    title: {
+                        display: true,
+                        text: 'Trade Number'
+                    }
+                },
+                y: {
+                    title: {
+                        display: true,
+                        text: 'Capital ($)'
+                    }
+                }
+            }
+        }
+    });
+}
+
+// Create capital distribution chart
+function createCapitalDistributionChart(runs) {
+    const ctx = document.getElementById('distributionChart').getContext('2d');
+    const capitals = runs.map(r => r.finalCapital);
+    
+    const histogram = createHistogram(capitals, 15);
+    
+    return new Chart(ctx, {
+        type: 'bar',
+        data: {
+            labels: histogram.labels,
+            datasets: [{
+                label: 'Frequency',
+                data: histogram.data,
+                backgroundColor: 'rgba(16, 185, 129, 0.7)',
+                borderColor: 'rgba(16, 185, 129, 1)',
+                borderWidth: 1
+            }]
+        },
+        options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+                legend: { display: false }
+            },
+            scales: {
+                x: {
+                    title: {
+                        display: true,
+                        text: 'Final Capital ($)'
+                    }
+                },
+                y: {
+                    title: {
+                        display: true,
+                        text: 'Frequency'
+                    }
+                }
+            }
+        }
+    });
+}
+
+// Create survivorship chart for multi-fund
+function createSurvivorshipChart(runs, numFunds) {
+    const ctx = document.getElementById('survivorshipChart').getContext('2d');
+    const survivingCounts = runs.map(r => r.survivingFunds);
+    
+    const histogram = {};
+    for (let i = 0; i <= numFunds; i++) {
+        histogram[i] = survivingCounts.filter(c => c === i).length;
+    }
+    
+    return new Chart(ctx, {
+        type: 'bar',
+        data: {
+            labels: Object.keys(histogram),
+            datasets: [{
+                label: 'Frequency',
+                data: Object.values(histogram),
+                backgroundColor: 'rgba(245, 158, 11, 0.7)',
+                borderColor: 'rgba(245, 158, 11, 1)',
+                borderWidth: 1
+            }]
+        },
+        options: {
+            responsive: true,
+            maintainAspectRatio: false,
+            plugins: {
+                legend: { display: false }
+            },
+            scales: {
+                x: {
+                    title: {
+                        display: true,
+                        text: 'Surviving Funds'
+                    }
+                },
+                y: {
+                    title: {
+                        display: true,
+                        text: 'Frequency'
+                    }
+                }
+            }
+        }
+    });
+}
+
+// Export results
+function exportResults() {
+    if (!simulationResults) return;
+    
+    const data = {
+        timestamp: new Date().toISOString(),
+        parameters: simulationResults.parameters,
+        summary: simulationResults.summary,
+        runs: simulationResults.runs
+    };
+    
+    const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
+    const url = URL.createObjectURL(blob);
+    
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `safe_choices_simulation_${Date.now()}.json`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+}
+
+// UI control functions
+function showProgress() {
+    document.querySelector('.progress-section').style.display = 'block';
+    document.getElementById('progressFill').style.width = '0%';
+}
+
+function hideProgress() {
+    setTimeout(() => {
+        document.querySelector('.progress-section').style.display = 'none';
+    }, 500);
+}
+
+function disableControls() {
+    const runBtn = document.getElementById('runBtn');
+    runBtn.disabled = true;
+    document.querySelector('.run-text').textContent = 'Running...';
+    document.querySelector('.run-spinner').style.display = 'inline-block';
+}
+
+function enableControls() {
+    const runBtn = document.getElementById('runBtn');
+    runBtn.disabled = false;
+    document.querySelector('.run-text').textContent = 'Run Simulation';
+    document.querySelector('.run-spinner').style.display = 'none';
+}
+
+// Utility functions
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function formatPercentage(value) {
+    return `${(value * 100).toFixed(1)}%`;
+}
+
+function getReturnClass(value) {
+    if (value > 0.02) return 'positive';
+    if (value < -0.02) return 'negative';
+    return 'neutral';
+}
+
+function mean(arr) {
+    return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+
+function median(arr) {
+    const sorted = [...arr].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+
+function standardDeviation(arr) {
+    const avg = mean(arr);
+    const squareDiffs = arr.map(value => Math.pow(value - avg, 2));
+    return Math.sqrt(mean(squareDiffs));
+}
+
+function percentile(arr, p) {
+    const sorted = [...arr].sort((a, b) => a - b);
+    const index = (p / 100) * (sorted.length - 1);
+    const lower = Math.floor(index);
+    const upper = Math.ceil(index);
+    const weight = index % 1;
+    return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+}
+
+function createHistogram(data, bins) {
+    const min = Math.min(...data);
+    const max = Math.max(...data);
+    const binWidth = (max - min) / bins;
+    
+    const histogram = new Array(bins).fill(0);
+    const labels = [];
+    
+    for (let i = 0; i < bins; i++) {
+        const binStart = min + i * binWidth;
+        const binEnd = min + (i + 1) * binWidth;
+        labels.push(`${binStart.toFixed(1)}`);
+        
+        for (const value of data) {
+            if (value >= binStart && (value < binEnd || i === bins - 1)) {
+                histogram[i]++;
+            }
+        }
+    }
+    
+    return { labels, data: histogram };
+}
+
+// Simple RNG for reproducible results
+class SimpleRNG {
+    constructor(seed) {
+        this.seed = seed % 2147483647;
+        if (this.seed <= 0) this.seed += 2147483646;
+    }
+    
+    next() {
+        return this.seed = this.seed * 16807 % 2147483647;
+    }
+    
+    nextFloat() {
+        return (this.next() - 1) / 2147483646;
+    }
+    
+    nextGaussian() {
+        const u = 0.5 - this.nextFloat();
+        const v = this.nextFloat();
+        return Math.sqrt(-2.0 * Math.log(v)) * Math.cos(2.0 * Math.PI * u);
+    }
+    
+    nextInt(min, max) {
+        return Math.floor(this.nextFloat() * (max - min + 1)) + min;
+    }
+}

static/styles.css

@@ -0,0 +1,495 @@
+/* CSS Variables for Polymarket-inspired design */
+:root {
+    --polymarket-blue: #3B82F6;
+    --polymarket-blue-dark: #2563EB;
+    --polymarket-blue-light: #DBEAFE;
+    --light-gray: #F8FAFC;
+    --medium-gray: #E2E8F0;
+    --dark-gray: #64748B;
+    --text-primary: #1E293B;
+    --text-secondary: #475569;
+    --white: #FFFFFF;
+    --success: #10B981;
+    --warning: #F59E0B;
+    --error: #EF4444;
+    --shadow-sm: 0 1px 1px 0 rgba(0, 0, 0, 0.03);
+    --shadow-md: 0 1px 2px 0 rgba(0, 0, 0, 0.04);
+    --shadow-lg: 0 2px 4px 0 rgba(0, 0, 0, 0.05);
+}
+
+/* Reset and base styles */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;
+    background-color: var(--light-gray);
+    color: var(--text-primary);
+    line-height: 1.5;
+    min-height: 100vh;
+}
+
+/* Top Navigation Bar */
+.top-bar {
+    background-color: var(--white);
+    border-bottom: 1px solid var(--medium-gray);
+    box-shadow: var(--shadow-sm);
+    position: sticky;
+    top: 0;
+    z-index: 100;
+}
+
+.nav-container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 0 32px;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    height: 72px;
+}
+
+.logo-section {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.logo {
+    height: 32px;
+    width: auto;
+}
+
+.app-title {
+    font-size: 20px;
+    font-weight: 600;
+    color: var(--polymarket-blue);
+}
+
+.subtitle {
+    font-size: 14px;
+    color: var(--text-secondary);
+    font-weight: 400;
+}
+
+.nav-info {
+    display: flex;
+    align-items: center;
+}
+
+.dataset-info {
+    font-size: 14px;
+    color: var(--text-secondary);
+    background: var(--light-gray);
+    padding: 6px 12px;
+    border-radius: 20px;
+}
+
+/* Main Container */
+.main-container {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: 32px;
+    display: flex;
+    flex-direction: column;
+    gap: 32px;
+}
+
+/* Controls Section */
+.controls-section {
+    background: var(--white);
+    border-radius: 12px;
+    padding: 32px;
+    box-shadow: var(--shadow-md);
+    border: 1px solid var(--medium-gray);
+}
+
+.controls-header {
+    margin-bottom: 32px;
+}
+
+.controls-header h2 {
+    font-size: 24px;
+    font-weight: 600;
+    margin-bottom: 8px;
+    color: var(--text-primary);
+}
+
+.controls-header p {
+    font-size: 16px;
+    color: var(--text-secondary);
+}
+
+.controls-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: 24px;
+    margin-bottom: 32px;
+}
+
+.control-group {
+    display: flex;
+    flex-direction: column;
+}
+
+.control-group.full-width {
+    grid-column: 1 / -1;
+}
+
+.control-label {
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--text-primary);
+    margin-bottom: 10px;
+}
+
+.control-input {
+    padding: 12px 16px;
+    border: 1px solid var(--medium-gray);
+    border-radius: 8px;
+    font-size: 14px;
+    background: var(--white);
+    transition: all 0.2s;
+    outline: none;
+}
+
+.control-input:focus {
+    border-color: var(--polymarket-blue);
+    box-shadow: 0 0 0 3px var(--polymarket-blue-light);
+}
+
+.control-subtitle {
+    font-size: 12px;
+    color: var(--text-secondary);
+    margin-top: 6px;
+}
+
+/* Simulation Tabs */
+.simulation-tabs {
+    display: flex;
+    gap: 16px;
+    margin-top: 12px;
+}
+
+.sim-tab {
+    flex: 1;
+    padding: 20px;
+    border: 1px solid var(--medium-gray);
+    border-radius: 8px;
+    background: var(--white);
+    cursor: pointer;
+    transition: all 0.2s;
+    text-align: left;
+}
+
+.sim-tab:hover {
+    border-color: var(--polymarket-blue-light);
+    background: var(--polymarket-blue-light);
+}
+
+.sim-tab.active {
+    border-color: var(--polymarket-blue);
+    background: var(--polymarket-blue-light);
+}
+
+.tab-title {
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary);
+    margin-bottom: 4px;
+}
+
+.tab-subtitle {
+    font-size: 14px;
+    color: var(--text-secondary);
+}
+
+/* Run Section */
+.run-section {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 16px;
+    padding-top: 32px;
+    border-top: 1px solid var(--medium-gray);
+    margin-top: 8px;
+}
+
+.run-button {
+    background: var(--polymarket-blue);
+    color: var(--white);
+    border: none;
+    padding: 14px 32px;
+    border-radius: 8px;
+    font-size: 16px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: all 0.2s;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.run-button:hover:not(:disabled) {
+    background: var(--polymarket-blue-dark);
+}
+
+.run-button:disabled {
+    background: var(--dark-gray);
+    cursor: not-allowed;
+}
+
+.run-spinner {
+    width: 20px;
+    height: 20px;
+    border: 2px solid transparent;
+    border-top: 2px solid var(--white);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+.run-info {
+    font-size: 14px;
+    color: var(--text-secondary);
+}
+
+/* Progress Section */
+.progress-section {
+    background: var(--white);
+    border-radius: 12px;
+    padding: 32px;
+    box-shadow: var(--shadow-md);
+    border: 1px solid var(--medium-gray);
+}
+
+.progress-container {
+    max-width: 600px;
+    margin: 0 auto;
+}
+
+.progress-label {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 12px;
+}
+
+.progress-bar {
+    width: 100%;
+    height: 8px;
+    background: var(--medium-gray);
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.progress-fill {
+    height: 100%;
+    background: var(--polymarket-blue);
+    border-radius: 4px;
+    transition: width 0.3s ease;
+    width: 0%;
+}
+
+/* Results Section */
+.results-section {
+    display: flex;
+    flex-direction: column;
+    gap: 24px;
+}
+
+.results-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: var(--white);
+    padding: 28px 32px;
+    border-radius: 12px;
+    box-shadow: var(--shadow-md);
+    border: 1px solid var(--medium-gray);
+}
+
+.results-header h2 {
+    font-size: 24px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.export-button {
+    background: var(--white);
+    color: var(--polymarket-blue);
+    border: 1px solid var(--polymarket-blue);
+    padding: 10px 20px;
+    border-radius: 6px;
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.export-button:hover {
+    background: var(--polymarket-blue);
+    color: var(--white);
+}
+
+/* Statistics Grid */
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: 24px;
+}
+
+.stat-card {
+    background: var(--white);
+    border-radius: 12px;
+    padding: 28px;
+    box-shadow: var(--shadow-md);
+    border: 1px solid var(--medium-gray);
+}
+
+.stat-header {
+    margin-bottom: 20px;
+}
+
+.stat-header h3 {
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.stat-content {
+    display: flex;
+    flex-direction: column;
+    gap: 16px;
+}
+
+.stat-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.stat-label {
+    font-size: 14px;
+    color: var(--text-secondary);
+}
+
+.stat-value {
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.stat-value.positive {
+    color: var(--success);
+}
+
+.stat-value.negative {
+    color: var(--error);
+}
+
+.stat-value.neutral {
+    color: var(--warning);
+}
+
+/* Charts Grid */
+.charts-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(400px, 1fr));
+    gap: 24px;
+}
+
+.chart-card {
+    background: var(--white);
+    border-radius: 12px;
+    padding: 28px;
+    box-shadow: var(--shadow-md);
+    border: 1px solid var(--medium-gray);
+}
+
+.chart-header {
+    margin-bottom: 20px;
+}
+
+.chart-header h3 {
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.chart-container {
+    position: relative;
+    height: 300px;
+    width: 100%;
+    padding: 8px 0;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .nav-container {
+        padding: 0 20px;
+        height: 64px;
+    }
+    
+    .main-container {
+        padding: 20px;
+        gap: 24px;
+    }
+    
+    .controls-section {
+        padding: 24px;
+    }
+    
+    .controls-grid {
+        grid-template-columns: 1fr;
+        gap: 20px;
+    }
+    
+    .simulation-tabs {
+        flex-direction: column;
+        gap: 12px;
+    }
+    
+    .charts-grid {
+        grid-template-columns: 1fr;
+        gap: 20px;
+    }
+    
+    .chart-card,
+    .stat-card {
+        padding: 20px;
+    }
+    
+    .results-header {
+        flex-direction: column;
+        gap: 16px;
+        align-items: stretch;
+        padding: 24px;
+    }
+}
+
+/* Utility classes */
+.hidden {
+    display: none !important;
+}
+
+.loading {
+    opacity: 0.6;
+    pointer-events: none;
+}
+
+/* Conditional visibility classes */
+.single-only, .threshold-only, .multi-only {
+    transition: all 0.3s ease;
+}
+
+.multi-stats, .threshold-stats, .multi-chart {
+    transition: all 0.3s ease;
+}