keeks 0.2.0__tar.gz → 0.3.0__tar.gz

keeks-0.3.0/CHANGELOG.md

@@ -0,0 +1,50 @@
+v0.3.0
+======
+
+**New Features:**
+ * Added MertonShare strategy based on Merton's portfolio problem with CRRA utility
+ * MertonShare supports configurable risk aversion parameter (gamma)
+ * Added CRRA utility functions to keeks.utils: `crra_utility()`, `expected_utility()`, `find_indifference_price()`
+ * Added `calculate_max_entry_price()` method to ALL 9 strategies:
+   - **Utility-based**: KellyCriterion, MertonShare, OptimalF use CRRA utility
+   - **Kelly variants**: FractionalKelly, DrawdownAdjustedKelly scale Kelly's price
+   - **Rule-based**: FixedFraction, CPPI, Dynamic apply mechanical rules
+   - **Risk-neutral**: NaiveStrategy pays expected value
+ * Added St. Petersburg paradox example demonstrating all 9 strategies
+ * Updated strategy comparison example to include MertonShare with different risk aversion levels
+ * Added comprehensive tests for MertonShare strategy (16 test cases)
+ * Added comprehensive tests for utility functions (18 test cases)
+ * Added comprehensive tests for strategy entry price methods (17 test cases)
+ * Updated documentation to include MertonShare, utility functions, and entry price methods
+ * Example outputs now include both CSV and PNG visualizations
+
+**Critical Bug Fixes:**
+ * Fixed bankruptcy protection - bankrolls can no longer go negative
+ * Fixed transaction cost bug in simulators - costs now correctly increase losses instead of decreasing them
+ * Fixed transaction costs being charged on zero bets - costs only apply when actually betting
+ * Fixed CPPI hardcoded 1% edge threshold - now works with realistic 0.5-2% edges
+ * Added bankruptcy checks to all simulators - simulations now stop when bankroll is depleted
+ * Fixed drawdown check ordering - bankruptcy is now checked before drawdown limits
+ * Fixed ruin rate detection in examples - now properly detects early termination
+ * Added 9 comprehensive bankruptcy protection tests
+ * Updated example parameters to realistic professional bettor scenario (52% win, 0.95x payoff, 0.4% edge)
+
+v0.2.0
+======
+
+ * no longer allowing negative bets
+
+v0.1.0
+======
+
+ * modernizing, added new methods, examples fixes
+
+v0.0.2
+======
+
+ * adding CI, docs, and testing
+
+v0.0.1
+======
+
+ * first release

keeks-0.3.0/CLAUDE.md

@@ -0,0 +1,202 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Keeks is a Python library for optimal bankroll allocation and betting strategies, focusing on the Kelly Criterion and its variants. The library provides tools for:
+- Bankroll management with risk protection
+- Mathematical betting strategies (Kelly, Fractional Kelly, etc.)
+- Simulation of betting scenarios with different probability distributions
+
+## Development Commands
+
+This project uses `uv` as the package manager. All commands are available via the Makefile.
+
+### Setup
+```bash
+make setup         # Install uv and create virtual environment
+make install-dev   # Install package with development dependencies
+```
+
+### Testing
+```bash
+make test          # Run pytest
+make test-cov      # Run tests with coverage report
+make test-all      # Run tests on all Python versions using tox
+
+# Run a single test file
+uv run pytest tests/test_kelly_criterion.py
+
+# Run a specific test
+uv run pytest tests/test_kelly_criterion.py::test_basic_functionality
+
+# Custom pytest arguments
+make test PYTEST_ARGS="tests/test_bankroll.py -v"
+```
+
+### Code Quality
+```bash
+make lint          # Run ruff checks
+make lint-fix      # Auto-fix linting issues (includes unsafe fixes)
+make format        # Format code with ruff
+```
+
+### Documentation
+```bash
+make docs          # Build Sphinx documentation and open in Chrome
+```
+
+### Other
+```bash
+make build         # Build package distributions
+make clean         # Clean build artifacts
+make examples      # Run example scripts (st_petersburg_comparison.py)
+```
+
+## Architecture
+
+### Four-Component Design
+
+The library follows a four-component architecture:
+
+1. **BankRoll** (`keeks/bankroll.py`): Central state manager
+   - Tracks total funds and bettable funds (via `percent_bettable`)
+   - Maintains transaction history
+   - Enforces risk limits via `max_draw_down` parameter
+   - Raises `RuinError` when drawdown limit exceeded
+   - Key methods: `deposit()`, `withdraw()`, `bet()`, `add_funds()`, `remove_funds()`
+
+2. **Strategies** (`keeks/binary_strategies/`): Decision engines
+   - All inherit from `BaseStrategy` abstract class
+   - Must implement `evaluate(probability, current_bankroll)` returning bet fraction
+   - Strategy constructors take: `payoff`, `loss`, `transaction_cost`
+   - Available strategies: `KellyCriterion`, `FractionalKellyCriterion`, `DrawdownAdjustedKelly`, `OptimalF`, `FixedFractionStrategy`, `CPPIStrategy`, `DynamicBankrollManagement`, `MertonShare`, `NaiveStrategy`
+
+3. **Simulators** (`keeks/simulators/`): Test harnesses
+   - `RepeatedBinarySimulator`: Fixed probability across all trials
+   - `RandomBinarySimulator`: Normally distributed probabilities
+   - `RandomUncertainBinarySimulator`: Adds uncertainty to outcomes
+   - All simulators have `evaluate_strategy(strategy, bankroll)` method that runs trials and updates bankroll in-place
+
+4. **Utility Functions** (`keeks/utils.py`): Decision theory tools
+   - `crra_utility(wealth, risk_aversion)`: Calculate CRRA utility values
+   - `expected_utility(outcomes, probabilities, current_wealth, entry_price, risk_aversion)`: Calculate expected utility of a gamble
+   - `find_indifference_price(outcomes, probabilities, current_wealth, risk_aversion)`: Find maximum price willing to pay for a gamble
+   - Used for one-time decision problems (e.g., St. Petersburg paradox) vs. repeated betting strategies
+
+### Key Design Patterns
+
+- **Strategy Pattern**: Betting strategies are interchangeable implementations of `BaseStrategy`
+- **State Management**: `BankRoll` maintains all financial state; strategies are stateless (except for state-dependent variants)
+- **In-Place Updates**: Simulators modify the `BankRoll` object directly rather than returning new values
+- **Safety-First**: Strategies use `get_max_safe_bet()` to prevent negative bankroll scenarios
+
+### Important Constraints
+
+- **No negative bets**: All strategies validated in `BaseStrategy.__init__()` to ensure `payoff > 0`, `loss >= 0`, `transaction_cost >= 0`
+- **Drawdown protection**: `BankRoll.max_draw_down` enforces maximum loss per transaction; raises `RuinError` when violated
+- **Test isolation**: NEVER add test-specific handling or special case logic in library code (see python_standards.mdc)
+
+## Code Standards
+
+### Python Style
+- Line length: 88 characters (ruff/Black default)
+- Use snake_case for functions/variables, CamelCase for classes
+- Type hints preferred for public APIs
+- Docstrings: NumPy/Google style with parameters, returns, and examples
+
+### Testing Standards
+- Tests in `tests/` directory, named `test_*.py`
+- Use `pytest.approx()` for floating-point comparisons
+- Random seed (`random.seed(42)`) for reproducible simulations
+- Target 80%+ code coverage
+- Run specific tests: `uv run pytest tests/test_file.py::test_name`
+
+### Import Organization
+1. Standard library (random, abc)
+2. Third-party (numpy, matplotlib, pandas, pytest)
+3. Local imports (keeks modules)
+
+## Common Patterns
+
+### Testing a Strategy
+```python
+# Pattern used throughout tests
+bankroll = BankRoll(initial_funds=1000, percent_bettable=0.5, max_draw_down=0.3)
+strategy = KellyCriterion(payoff=1.0, loss=1.0, transaction_cost=0.01)
+simulator = RepeatedBinarySimulator(
+    payoff=1.0, loss=1.0, transaction_costs=0.01,
+    probability=0.55, trials=1000
+)
+simulator.evaluate_strategy(strategy, bankroll)
+```
+
+### Strategy Implementation
+```python
+class CustomStrategy(BaseStrategy):
+    def evaluate(self, probability: float, current_bankroll: float) -> float:
+        # Calculate bet fraction (0.0 to 1.0)
+        fraction = ...  # your logic
+        # Always respect safety limits
+        return min(fraction, self.get_max_safe_bet(current_bankroll))
+```
+
+### Using MertonShare Strategy
+```python
+# MertonShare uses CRRA utility (Constant Relative Risk Aversion)
+# Formula: f* = μ / (γ × σ²) where:
+#   μ = expected return
+#   γ = risk aversion coefficient (1=aggressive, 2=moderate, 5=conservative)
+#   σ² = variance of returns
+
+from keeks.binary_strategies.simple import MertonShare
+
+# Moderate risk aversion (γ=2.0 is empirically common)
+strategy = MertonShare(
+    payoff=1.0,
+    loss=1.0,
+    transaction_cost=0.01,
+    risk_aversion=2.0,  # Higher values = more conservative
+    min_probability=0.5,
+    max_fraction=1.0
+)
+
+# MertonShare is typically more conservative than Kelly Criterion
+# Useful for risk-averse investors or when parameter uncertainty is high
+```
+
+### Using Utility Functions for One-Time Decisions
+```python
+# For one-time gamble decisions (not repeated betting)
+from keeks.utils import find_indifference_price
+
+# St. Petersburg paradox example: what would you pay to play?
+# Generate outcomes and probabilities for St. Petersburg game
+outcomes = [2**n for n in range(1, 31)]  # Payouts: $2, $4, $8, ..., $2^30
+probabilities = [(0.5)**n for n in range(1, 31)]  # Probs: 0.5, 0.25, 0.125, ...
+
+max_price = find_indifference_price(
+    outcomes=outcomes,
+    probabilities=probabilities,
+    current_wealth=10000,
+    risk_aversion=2.0,  # Moderate risk aversion
+    tolerance=0.01
+)
+
+print(f"Maximum willing to pay: ${max_price:.2f}")
+# Output: Maximum willing to pay: $12.80
+
+# For comparison, Kelly bettor (γ=1.0) would pay ~$14.24
+# Conservative bettor (γ=5.0) would pay ~$11.26
+```
+
+## Project-Specific Notes
+
+- **Version**: Managed in `pyproject.toml` (currently 0.3.0)
+- **Python Support**: 3.8, 3.9, 3.10, 3.11
+- **Documentation site**: [keeks.mcginniscommawill.com](https://keeks.mcginniscommawill.com)
+- **Educational focus**: Library includes disclaimer about educational use only
+- **Examples**:
+  - `strategy_comparison.py`: Compares all strategies with favorable odds
+  - `st_petersburg_paradox.py`: True St. Petersburg paradox - shows rational payment amounts

{keeks-0.2.0 → keeks-0.3.0}/Makefile

@@ -91,6 +91,6 @@ test-all:
 
 # Run example scripts
 examples:
-	uv run python examples/st_petersburg_comparison.py
+	uv run python examples/strategy_comparison.py
 
 all: clean test docs 

{keeks-0.2.0 → keeks-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keeks
-Version: 0.2.0
+Version: 0.3.0
 Summary: A python library for bankroll allocation strategies
 Project-URL: Homepage, https://github.com/wdm0006/keeks
 Project-URL: Bug Tracker, https://github.com/wdm0006/keeks/issues
@@ -168,11 +168,40 @@ Keeks implements several betting strategies:
    dynamic = DynamicBankrollManagement(base_fraction=0.1, payoff=1.0, loss=1.0, window_size=10)
    ```
 
-8. **Naive Strategy**: A simple strategy that bets the full amount when expected value is positive
+8. **Merton Share (CRRA Utility)**: Based on Merton's portfolio problem with constant relative risk aversion
+   ```python
+   from keeks.binary_strategies.simple import MertonShare
+   merton = MertonShare(payoff=1.0, loss=1.0, transaction_cost=0.01, risk_aversion=2.0)
+   ```
+
+9. **Naive Strategy**: A simple strategy that bets the full amount when expected value is positive
    ```python
    naive = NaiveStrategy(payoff=1.0, loss=1.0, transaction_cost=0.01)
    ```
 
+### Utility Functions
+
+For one-time decision problems (e.g., "What should I pay for this opportunity?"), keeks provides CRRA utility functions:
+
+```python
+from keeks.utils import find_indifference_price
+
+# Calculate maximum price you'd pay for a gamble
+# Example: St. Petersburg paradox
+outcomes = [2**n for n in range(1, 31)]
+probabilities = [(0.5)**n for n in range(1, 31)]
+
+max_price = find_indifference_price(
+    outcomes=outcomes,
+    probabilities=probabilities,
+    current_wealth=10000,
+    risk_aversion=2.0  # 1.0=Kelly, 2.0=moderate, 5.0=conservative
+)
+# Returns: ~$12.80 despite infinite expected value!
+```
+
+See [examples/st_petersburg_paradox.py](examples/st_petersburg_paradox.py) for a complete demonstration.
+
 ### Simulators
 
 Test your strategies with different simulators:

{keeks-0.2.0 → keeks-0.3.0}/README.md

@@ -133,11 +133,40 @@ Keeks implements several betting strategies:
    dynamic = DynamicBankrollManagement(base_fraction=0.1, payoff=1.0, loss=1.0, window_size=10)
    ```
 
-8. **Naive Strategy**: A simple strategy that bets the full amount when expected value is positive
+8. **Merton Share (CRRA Utility)**: Based on Merton's portfolio problem with constant relative risk aversion
+   ```python
+   from keeks.binary_strategies.simple import MertonShare
+   merton = MertonShare(payoff=1.0, loss=1.0, transaction_cost=0.01, risk_aversion=2.0)
+   ```
+
+9. **Naive Strategy**: A simple strategy that bets the full amount when expected value is positive
    ```python
    naive = NaiveStrategy(payoff=1.0, loss=1.0, transaction_cost=0.01)
    ```
 
+### Utility Functions
+
+For one-time decision problems (e.g., "What should I pay for this opportunity?"), keeks provides CRRA utility functions:
+
+```python
+from keeks.utils import find_indifference_price
+
+# Calculate maximum price you'd pay for a gamble
+# Example: St. Petersburg paradox
+outcomes = [2**n for n in range(1, 31)]
+probabilities = [(0.5)**n for n in range(1, 31)]
+
+max_price = find_indifference_price(
+    outcomes=outcomes,
+    probabilities=probabilities,
+    current_wealth=10000,
+    risk_aversion=2.0  # 1.0=Kelly, 2.0=moderate, 5.0=conservative
+)
+# Returns: ~$12.80 despite infinite expected value!
+```
+
+See [examples/st_petersburg_paradox.py](examples/st_petersburg_paradox.py) for a complete demonstration.
+
 ### Simulators
 
 Test your strategies with different simulators:

{keeks-0.2.0 → keeks-0.3.0}/docs/source/binary_strategies.rst

@@ -75,3 +75,11 @@ OptimalF
     :members:
     :undoc-members:
     :show-inheritance:
+
+Merton Share
+------------
+
+.. autoclass:: keeks.binary_strategies.simple.MertonShare
+    :members:
+    :undoc-members:
+    :show-inheritance:

keeks-0.3.0/examples/output/st_petersburg_paradox.csv

@@ -0,0 +1,5 @@
+Bankroll,Kelly ($),Kelly (%),Half Kelly ($),Half Kelly (%),Drawdown Kelly ($),Drawdown Kelly (%),Optimal F ($),Optimal F (%),Merton (γ=2.0) ($),Merton (γ=2.0) (%),Merton (γ=5.0) ($),Merton (γ=5.0) (%),Naive ($),Naive (%),Fixed 5% ($),Fixed 5% (%),Dynamic 10% ($),Dynamic 10% (%)
+$1,$0.50,49.609%,$0.25,24.805%,$0.20,19.844%,$0.50,49.609%,$0.50,49.609%,$0.50,49.609%,$1.00,100.000%,$0.05,5.000%,$0.10,10.000%
+$10,$4.97,49.658%,$2.48,24.829%,$1.99,19.863%,$4.97,49.658%,$3.96,39.600%,$3.10,31.006%,$10.00,100.000%,$0.50,5.000%,$1.00,10.000%
+$100,$7.79,7.791%,$3.90,3.896%,$3.12,3.116%,$7.79,7.791%,$6.49,6.491%,$5.20,5.197%,$100.00,100.000%,$5.00,5.000%,$10.00,10.000%
+"$1,000",$10.95,1.095%,$5.48,0.548%,$4.38,0.438%,$10.95,1.095%,$9.55,0.955%,$8.06,0.806%,$1000.00,100.000%,$50.00,5.000%,$100.00,10.000%

keeks-0.3.0/examples/output/strategy_comparison.csv

@@ -0,0 +1,14 @@
+Strategy,Mean,Median,Min,Max,Std Dev,Ruin Rate
+Merton (γ=1.0),$1301.11,$1255.87,$623.56,$3112.29,$379.23,0.0%
+Kelly Criterion,$1316.52,$1250.61,$539.09,$3052.69,$397.43,0.0%
+Naive Strategy,$1272.19,$1215.58,$566.97,$2641.01,$351.19,0.0%
+Optimal F,$1279.55,$1215.03,$393.22,$2839.17,$415.17,0.0%
+Merton (γ=2.0),$1102.08,$1095.51,$757.45,$1739.15,$154.93,0.0%
+Half Kelly,$1102.39,$1080.04,$721.58,$1767.90,$165.63,0.0%
+Drawdown Kelly,$1065.94,$1064.01,$722.03,$1578.80,$126.19,0.0%
+Quarter Kelly,$1022.51,$1015.90,$787.98,$1276.53,$78.62,0.0%
+Merton (γ=5.0),$1012.83,$1010.68,$869.55,$1243.26,$60.75,0.0%
+CPPI,$961.07,$960.53,$928.36,$996.13,$12.10,0.0%
+Fixed 5%,$13028.93,$72.95,$0.00,$1087677.26,$80321.85,33.0%
+Dynamic,$1875.02,$13.62,$0.00,$145023.91,$9762.06,41.2%
+Fixed 10%,$98.25,$0.00,$0.00,$48451.32,$2164.67,98.8%

keeks-0.3.0/examples/st_petersburg_paradox.py

@@ -0,0 +1,244 @@
+"""
+True St. Petersburg Paradox: What Would You Pay to Play?
+
+The St. Petersburg paradox is a probability theory paradox:
+- Flip a fair coin repeatedly until it comes up tails
+- Payout is $2^n where n is the number of flips
+- Expected value is infinite: E[X] = Σ(1/2^n × 2^n) = Σ(1) = ∞
+
+The paradox: Despite infinite expected value, no rational person would pay much to play.
+
+This example calculates the maximum entry price different betting strategies would pay
+to play one round of the St. Petersburg game at various wealth levels.
+"""
+
+import os
+
+import matplotlib
+matplotlib.use("Agg")  # Use non-interactive backend
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+from keeks.binary_strategies import KellyCriterion
+from keeks.binary_strategies.kelly import DrawdownAdjustedKelly, FractionalKellyCriterion
+from keeks.binary_strategies.simple import (
+    CPPIStrategy,
+    DynamicBankrollManagement,
+    FixedFractionStrategy,
+    MertonShare,
+    NaiveStrategy,
+    OptimalF,
+)
+
+
+def get_st_petersburg_outcomes(max_flips=30):
+    """
+    Generate outcomes and probabilities for St. Petersburg game.
+
+    Parameters
+    ----------
+    max_flips : int
+        Maximum coin flips to consider (practical cap for infinite series)
+        Note: Limited to ~1000 due to float64 overflow at 2^1024
+
+    Returns
+    -------
+    tuple
+        (outcomes, probabilities) arrays
+    """
+    import numpy as np
+
+    outcomes = []
+    probabilities = []
+
+    for n in range(1, max_flips + 1):
+        prob = (0.5) ** n  # Probability of exactly n flips
+        payout = 2.0 ** n    # Payout is 2^n (use 2.0 to keep as float)
+        outcomes.append(payout)
+        probabilities.append(prob)
+
+    return np.array(outcomes, dtype=float), np.array(probabilities, dtype=float)
+
+
+def main():
+    """Calculate maximum payment for St. Petersburg game across different scenarios."""
+
+    print("=" * 80)
+    print("ST. PETERSBURG PARADOX: WHAT WOULD YOU PAY TO PLAY?")
+    print("=" * 80)
+    print()
+    print("The Game:")
+    print("  - Flip a fair coin repeatedly until tails")
+    print("  - Payout is $2^n where n is the number of flips")
+    print("  - Expected value is INFINITE")
+    print()
+    print("The Question:")
+    print("  Given your wealth, what's the maximum you'd rationally pay to play once?")
+    print()
+    print("=" * 80)
+    print()
+
+    # Different bankroll levels to test
+    bankrolls = [1, 10, 100, 1_000]
+
+    # Create strategy instances - all 9 strategies!
+    strategies = {
+        # Utility-based strategies
+        "Kelly": KellyCriterion(
+            payoff=1.0, loss=1.0, transaction_cost=0.0
+        ),
+        "Half Kelly": FractionalKellyCriterion(
+            payoff=1.0, loss=1.0, transaction_cost=0.0, fraction=0.5
+        ),
+        "Drawdown Kelly": DrawdownAdjustedKelly(
+            payoff=1.0, loss=1.0, transaction_cost=0.0, max_acceptable_drawdown=0.2
+        ),
+        "Optimal F": OptimalF(
+            payoff=1.0, loss=1.0, transaction_cost=0.0, win_rate=0.55
+        ),
+        "Merton (γ=2.0)": MertonShare(
+            payoff=1.0, loss=1.0, transaction_cost=0.0, risk_aversion=2.0
+        ),
+        "Merton (γ=5.0)": MertonShare(
+            payoff=1.0, loss=1.0, transaction_cost=0.0, risk_aversion=5.0
+        ),
+        # Rule-based strategies
+        "Naive": NaiveStrategy(
+            payoff=1.0, loss=1.0, transaction_cost=0.0
+        ),
+        "Fixed 5%": FixedFractionStrategy(
+            payoff=1.0, loss=1.0, transaction_cost=0.0, fraction=0.05
+        ),
+        "Dynamic 10%": DynamicBankrollManagement(
+            payoff=1.0, loss=1.0, transaction_cost=0.0, base_fraction=0.1, window_size=10
+        ),
+    }
+
+    # Get St. Petersburg outcomes
+    # Using 1,000 flips gives EV = $1,000, approaching the infinite EV of the true paradox
+    # Each flip contributes exactly $1 to expected value: (1/2^n) × 2^n = 1
+    # True paradox has infinite flips → infinite EV, but we cap at 1000 due to float64 limits
+    outcomes, probabilities = get_st_petersburg_outcomes(max_flips=1_000)
+
+    print("Calculating optimal entry prices for each strategy...")
+    print()
+
+    # Calculate results
+    all_results = []
+
+    for bankroll in bankrolls:
+        row = {"Bankroll": f"${bankroll:,}"}
+
+        for strategy_name, strategy in strategies.items():
+            # Use the strategy's calculate_max_entry_price method
+            max_price = strategy.calculate_max_entry_price(
+                outcomes=outcomes,
+                probabilities=probabilities,
+                current_wealth=bankroll
+            )
+            row[f"{strategy_name}"] = max_price
+            row[f"{strategy_name} (%BR)"] = (max_price / bankroll) * 100
+
+        all_results.append(row)
+
+    # Create DataFrame
+    df_results = pd.DataFrame(all_results)
+
+    # Display price table
+    print("\nMAXIMUM ENTRY PRICE BY STRATEGY AND WEALTH LEVEL:")
+    print("=" * 80)
+    print()
+
+    # Create price-only table for display
+    price_cols = ["Bankroll"] + list(strategies.keys())
+    df_prices = df_results[price_cols].copy()
+
+    # Format prices as currency
+    for col in strategies.keys():
+        df_prices[col] = df_results[col].apply(lambda x: f"${x:.2f}")
+
+    print(df_prices.to_string(index=False))
+
+    # Create visualization
+    print("Creating visualization...")
+
+    # Single chart: Entry price by strategy by bankroll
+    fig, ax = plt.subplots(figsize=(16, 10))
+
+    # Prepare data for plotting
+    bankroll_labels = [f"${b:,}" for b in bankrolls]
+    x = np.arange(len(bankroll_labels))
+    n_strategies = len(strategies)
+    width = 0.08  # Width of bars
+
+    # Define colors for different strategy types
+    colors = {
+        'Kelly': '#1f77b4',
+        'Half Kelly': '#aec7e8',
+        'Drawdown Kelly': '#7fbfe8',
+        'Optimal F': '#4a90c4',
+        'Merton (γ=2.0)': '#ff7f0e',
+        'Merton (γ=5.0)': '#ffbb78',
+        'Naive': '#2ca02c',
+        'Fixed 5%': '#d62728',
+        'Dynamic 10%': '#9467bd',
+    }
+
+    # Plot bars for each strategy
+    for i, strategy_name in enumerate(strategies.keys()):
+        prices = [all_results[j][strategy_name] for j in range(len(bankrolls))]
+        offset = (i - n_strategies / 2 + 0.5) * width
+        ax.bar(x + offset, prices, width, label=strategy_name,
+               color=colors.get(strategy_name, f'C{i}'))
+
+    ax.set_xlabel('Bankroll Level', fontsize=12, fontweight='bold')
+    ax.set_ylabel('Maximum Entry Price ($, log scale)', fontsize=12, fontweight='bold')
+    ax.set_title('St. Petersburg Paradox: Maximum Entry Price by Strategy\n' +
+                 '(Despite Infinite Expected Value, Agents Pay Finite Amounts)',
+                 fontsize=14, fontweight='bold', pad=20)
+    ax.set_xticks(x)
+    ax.set_xticklabels(bankroll_labels, rotation=0)
+    ax.set_yscale('log')
+    ax.legend(loc='upper left', fontsize=9, ncol=2)
+    ax.grid(axis='y', alpha=0.3, linestyle='--', which='both')
+
+    # Add annotation
+    ax.text(0.98, 0.02,
+            'Utility-based strategies (Kelly, Merton, Optimal F) analyze risk\n' +
+            'Rule-based strategies (Fixed, Dynamic) apply mechanical rules\n' +
+            'Naive pays expected value ($1,000 for 1k flips), capped at wealth',
+            transform=ax.transAxes, fontsize=9,
+            verticalalignment='bottom', horizontalalignment='right',
+            bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.3))
+
+    plt.tight_layout()
+
+    # Create output directory
+    output_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "output")
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Save figure
+    fig_path = os.path.join(output_dir, "st_petersburg_paradox.png")
+    plt.savefig(fig_path, dpi=300, bbox_inches='tight')
+    print(f"\n✓ Chart saved to: {fig_path}")
+
+    # Save CSV with better formatting
+    csv_data = []
+    for result in all_results:
+        row = {"Bankroll": result["Bankroll"]}
+        for strategy_name in strategies.keys():
+            row[f"{strategy_name} ($)"] = f"${result[strategy_name]:.2f}"
+            row[f"{strategy_name} (%)"] = f"{result[f'{strategy_name} (%BR)']:.3f}%"
+        csv_data.append(row)
+
+    df_csv = pd.DataFrame(csv_data)
+    csv_path = os.path.join(output_dir, "st_petersburg_paradox.csv")
+    df_csv.to_csv(csv_path, index=False)
+    print(f"✓ Data saved to: {csv_path}")
+
+
+
+if __name__ == "__main__":
+    main()