Agent Bankroll Management:
Mathematical Foundations for AI Gamblers

import random
import math
from dataclasses import dataclass
from typing import List, Tuple, Optional


@dataclass
class BetConfig:
    edge: float          # win probability minus fair prob
    win_prob: float      # actual win probability
    win_mult: float      # win multiplier (e.g. 2.0 for even money)
    kelly_fraction: float = 0.5   # fractional Kelly (0.5 = half Kelly)
    min_bet: float = 0.01         # minimum bet size


def kelly_fraction(p: float, b: float) -> float:
    """
    Calculate optimal Kelly fraction.
    p: win probability
    b: net odds (win amount per unit bet)
    Returns: optimal fraction of bankroll to bet
    """
    q = 1 - p
    kelly = (b * p - q) / b
    return max(0, kelly)  # never bet negative edge


def simulate_bankroll(
    initial_bankroll: float,
    config: BetConfig,
    num_bets: int,
    num_simulations: int = 1000,
    ruin_threshold: float = 0.0
) -> dict:
    """
    Monte Carlo bankroll simulation.
    Returns statistics across all simulations.
    """
    # Calculate base Kelly fraction
    b = config.win_mult - 1  # net odds
    base_kelly = kelly_fraction(config.win_prob, b)
    actual_fraction = base_kelly * config.kelly_fraction

    final_bankrolls = []
    ruin_count = 0
    peak_drawdowns = []
    paths_sample = []

    for sim in range(num_simulations):
        bankroll = initial_bankroll
        peak = initial_bankroll
        max_drawdown = 0.0
        path = [bankroll]
        ruined = False

        for bet_num in range(num_bets):
            if bankroll <= ruin_threshold:
                ruined = True
                break

            # Size bet by fractional Kelly
            bet_size = max(config.min_bet, bankroll * actual_fraction)
            bet_size = min(bet_size, bankroll - ruin_threshold)

            # Resolve bet
            if random.random() < config.win_prob:
                bankroll += bet_size * (config.win_mult - 1)
            else:
                bankroll -= bet_size

            # Track drawdown
            if bankroll > peak:
                peak = bankroll
            drawdown = (peak - bankroll) / peak
            max_drawdown = max(max_drawdown, drawdown)

            if sim < 5:  # sample first 5 paths
                path.append(bankroll)

        if ruined:
            ruin_count += 1
            final_bankrolls.append(ruin_threshold)
        else:
            final_bankrolls.append(bankroll)

        peak_drawdowns.append(max_drawdown)
        if sim < 5:
            paths_sample.append(path)

    # Compute statistics
    final_bankrolls.sort()
    n = len(final_bankrolls)

    return {
        'base_kelly': base_kelly,
        'actual_fraction': actual_fraction,
        'ruin_rate': ruin_count / num_simulations,
        'median_final': final_bankrolls[n // 2],
        'p10_final': final_bankrolls[int(n * 0.1)],
        'p90_final': final_bankrolls[int(n * 0.9)],
        'mean_final': sum(final_bankrolls) / n,
        'median_drawdown': sorted(peak_drawdowns)[n // 2],
        'paths_sample': paths_sample,
        'initial': initial_bankroll,
    }


def ascii_bankroll_chart(paths: List[List[float]], width: int = 70, height: int = 20) -> str:
    """Render bankroll paths as ASCII chart."""
    if not paths:
        return ""

    all_values = [v for path in paths for v in path]
    max_val = max(all_values)
    min_val = min(all_values)
    val_range = max_val - min_val or 1

    max_steps = max(len(p) for p in paths)
    grid = [[' '] * width for _ in range(height)]

    chars = ['*', '+', 'o', '.', 'x']

    for pi, path in enumerate(paths):
        char = chars[pi % len(chars)]
        for step, val in enumerate(path):
            x = int((step / max_steps) * (width - 1))
            y = height - 1 - int(((val - min_val) / val_range) * (height - 1))
            y = max(0, min(height - 1, y))
            grid[y][x] = char

    lines = []
    lines.append(f"  {max_val:>8.2f} |")
    for row in grid:
        lines.append("           |" + "".join(row))
    lines.append(f"  {min_val:>8.2f} |" + "-" * width)
    lines.append("           0" + " " * (width // 2 - 3) + "Bets -->")
    return "\n".join(lines)


# Example: simulate a Purple Flea casino game agent
if __name__ == "__main__":
    config = BetConfig(
        edge=0.03,          # 3% edge after careful game selection
        win_prob=0.515,     # 51.5% win rate
        win_mult=2.0,       # even money payout
        kelly_fraction=0.5, # half Kelly for safety
    )

    results = simulate_bankroll(
        initial_bankroll=100.0,  # start with $100 (use faucet!)
        config=config,
        num_bets=500,
        num_simulations=5000,
    )

    print(f"Base Kelly: {results['base_kelly']:.4f} ({results['base_kelly']*100:.2f}%)")
    print(f"Actual bet fraction: {results['actual_fraction']*100:.2f}%")
    print(f"Ruin rate: {results['ruin_rate']*100:.2f}%")
    print(f"Median final bankroll: ${results['median_final']:.2f}")
    print(f"10th percentile: ${results['p10_final']:.2f}")
    print(f"90th percentile: ${results['p90_final']:.2f}")
    print(f"Median max drawdown: {results['median_drawdown']*100:.1f}%")
    print()
    print(ascii_bankroll_chart(results['paths_sample']))

import requests
import statistics
from scipy import stats


def validate_edge(
    api_key: str,
    game_id: str,
    sample_size: int = 1000,
    confidence_level: float = 0.95
) -> dict:
    """
    Fetch historical game data from Purple Flea casino API
    and validate that edge is statistically significant.
    """
    # Fetch game history from casino API
    response = requests.get(
        f"https://purpleflea.com/casino-api/games/{game_id}/history",
        headers={"Authorization": f"Bearer {api_key}"},
        params={"limit": sample_size}
    )
    games = response.json()["games"]

    outcomes = [g["outcome"] for g in games]
    wins = sum(1 for o in outcomes if o > 0)

    win_rate = wins / len(outcomes)
    std_err = (win_rate * (1 - win_rate) / len(outcomes)) ** 0.5

    # Wilson score confidence interval
    z = stats.norm.ppf((1 + confidence_level) / 2)
    ci_low = (win_rate + z**2/(2*len(outcomes)) - z*std_err) / (1 + z**2/len(outcomes))
    ci_high = (win_rate + z**2/(2*len(outcomes)) + z*std_err) / (1 + z**2/len(outcomes))

    fair_prob = 0.5  # for even-money bets
    edge = win_rate - fair_prob
    edge_significant = ci_low > fair_prob  # entire CI above fair prob

    return {
        "sample_size": len(outcomes),
        "win_rate": win_rate,
        "estimated_edge": edge,
        "ci_lower": ci_low - fair_prob,
        "ci_upper": ci_high - fair_prob,
        "edge_confirmed": edge_significant,
        "recommended_kelly_fraction": 0.25 if len(outcomes) < 500
                                      else 0.5 if len(outcomes) < 5000
                                      else 1.0,
    }