Add house edge calculation and CUDA Monte Carlo simulation

- Add composition-dependent EV calculation for player draws and dealer outcomes
- Add HouseEdgeCalculator class for analytical house edge computation
- Add CUDA Monte Carlo simulator (~290M hands/sec on RTX 3080)
- Add blackjack payout option (3:2 vs 6:5) to web UI and strategy generation
- Add house edge display with methodology tooltip on web UI
- Remove legacy CLI (main.py) and renderers in favor of web app
- Remove tabulate dependency (no longer needed)
- Restructure .gitignore files to be local to each folder
- Update documentation for new calculation methodology

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: hankhsu1996

.gitignore

@@ -36,14 +36,6 @@ ENV/
 .coverage
 htmlcov/
 
-# Generated files
-strategy.html
-web/public/strategies/
-
-# Web app
-web/node_modules/
-web/dist/
-
 # Linting cache
 .ruff_cache/
 

CLAUDE.md

@@ -20,16 +20,6 @@ cd web && npm run dev
 
 Open http://localhost:5173/blackjack-basic-strategy/
 
-### CLI
-
-```bash
-# Text output to terminal
-uv run main.py
-
-# HTML output (color-coded)
-uv run main.py --format html
-```
-
 ## Project Structure
 
 ```
@@ -38,21 +28,24 @@ uv run main.py --format html
 │   ├── cards.py         # Card values, probabilities
 │   ├── dealer.py        # Dealer outcome distribution
 │   ├── evaluator.py     # EV calculations
+│   ├── house_edge.py    # House edge calculation
 │   ├── strategy.py      # Optimal action selection
 │   ├── tables.py        # Strategy data generation
-│   └── renderers.py     # Text/HTML renderers
+│   └── renderers.py     # Data structures
+├── cuda/                # GPU Monte Carlo simulation
+│   ├── monte_carlo.cu   # CUDA implementation
+│   └── Makefile         # Build configuration
 ├── scripts/
 │   └── generate_strategies.py  # Generate JSON for web app
-├── web/                 # Svelte + Tailwind + DaisyUI
-│   ├── src/
-│   │   ├── App.svelte
-│   │   └── lib/
-│   │       ├── components/   # UI components
-│   │       ├── stores/       # Svelte stores
-│   │       ├── types/        # TypeScript types
-│   │       └── utils/        # Color utilities
-│   └── public/strategies/    # Pre-computed JSON (generated)
-└── main.py              # CLI entry point
+└── web/                 # Svelte + Tailwind + DaisyUI
+    ├── src/
+    │   ├── App.svelte
+    │   └── lib/
+    │       ├── components/   # UI components
+    │       ├── stores/       # Svelte stores
+    │       ├── types/        # TypeScript types
+    │       └── utils/        # Color utilities
+    └── public/strategies/    # Pre-computed JSON (generated)
 ```
 
 ## Development
@@ -61,7 +54,6 @@ uv run main.py --format html
 
 ```bash
 uv sync                      # Install dependencies
-uv run main.py               # Run CLI
 uv run ruff check .          # Lint
 uv run ruff format .         # Format
 ```
@@ -81,7 +73,21 @@ npm run build                # Production build
 uv run python -m scripts.generate_strategies
 ```
 
-Generates 96 JSON files (6 deck options × 2⁴ boolean options) to `web/public/strategies/`.
+Generates strategy JSON files for all rule combinations to `web/public/strategies/`.
+
+### CUDA Monte Carlo (Optional)
+
+For verifying house edge calculations with high precision:
+
+```bash
+cd cuda
+make                    # Build (requires NVIDIA GPU + CUDA toolkit)
+make test               # Quick test: 1B hands
+make run                # Standard: 10B hands (~±0.002%)
+make precision          # High precision: 40B hands (~±0.001%)
+```
+
+See `cuda/README.md` for setup instructions.
 
 ## Configuration Options
 
@@ -115,17 +121,9 @@ GameConfig → EVCalculator → BasicStrategy → StrategyTables → JSON/Render
 - **GameConfig**: Immutable dataclass holding all rule parameters
 - **DealerProbabilities**: Calculates P(dealer final total | upcard)
 - **EVCalculator**: Core EV calculations using (total, soft_aces) state
+- **HouseEdgeCalculator**: Computes house edge for a given configuration
 - **BasicStrategy**: Determines optimal action by comparing EVs
 - **StrategyTables**: Generates strategy data (`StrategyData`)
-- **TextRenderer**: Renders tables as ASCII text (tabulate)
-- **HTMLRenderer**: Renders tables as color-coded HTML
-
-### Renderer Pattern
-
-The renderer architecture separates data from presentation:
-- `StrategyData` / `TableData`: Format-agnostic data structures
-- `Renderer` Protocol: Any class with `render(StrategyData) -> str`
-- Easy to add new formats (PDF, Image) by implementing the protocol
 
 ### State Representation
 

cuda/.gitignore

@@ -0,0 +1,2 @@
+# Compiled binary
+monte_carlo

cuda/Makefile

@@ -0,0 +1,33 @@
+# CUDA Monte Carlo Makefile
+
+NVCC = /usr/local/cuda/bin/nvcc
+NVCC_FLAGS = -O3
+
+# RTX 3080 = sm_86, RTX 3070 = sm_86, RTX 2080 = sm_75
+ARCH = -arch=sm_86
+
+TARGET = monte_carlo
+SRC = monte_carlo.cu cJSON.c
+STRATEGY = ../web/public/strategies/6-h17-das-rsa-peek-32.json
+
+.PHONY: all clean run test precision
+
+all: $(TARGET)
+
+$(TARGET): monte_carlo.cu cJSON.c cJSON.h
+	$(NVCC) $(NVCC_FLAGS) $(ARCH) -o $@ monte_carlo.cu cJSON.c
+
+clean:
+	rm -f $(TARGET)
+
+# Quick test: 1 billion hands
+test: $(TARGET)
+	./$(TARGET) $(STRATEGY) 1
+
+# Standard run: 10 billion hands
+run: $(TARGET)
+	./$(TARGET) $(STRATEGY) 10
+
+# High precision: 40 billion hands (~±0.001% accuracy)
+precision: $(TARGET)
+	./$(TARGET) $(STRATEGY) 40

cuda/README.md

@@ -0,0 +1,119 @@
+# CUDA Monte Carlo Blackjack Simulator
+
+High-performance GPU-accelerated Monte Carlo simulation for calculating blackjack house edge.
+
+## Features
+
+- Loads strategy and rules from JSON file
+- Finite deck simulation with proper shoe and reshuffling
+- ~290 million hands/second on RTX 3080
+
+## Prerequisites (WSL2 Ubuntu)
+
+### 1. Windows NVIDIA Driver
+
+Your Windows NVIDIA driver must be version 470.76+ (you likely already have this with an RTX 3080).
+
+Check in Windows:
+
+```
+nvidia-smi
+```
+
+### 2. Install CUDA Toolkit in WSL
+
+```bash
+# Add NVIDIA package repository
+wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-keyring_1.1-1_all.deb
+sudo dpkg -i cuda-keyring_1.1-1_all.deb
+sudo apt-get update
+
+# Install CUDA toolkit (compiler and libraries)
+sudo apt-get install -y cuda-toolkit-12-4
+
+# Add to PATH (add to ~/.bashrc for persistence)
+export PATH=/usr/local/cuda/bin:$PATH
+```
+
+### 3. Verify Installation
+
+```bash
+nvcc --version
+nvidia-smi
+```
+
+## Building
+
+```bash
+cd cuda
+make
+```
+
+## Usage
+
+```bash
+# Quick test: 1 billion hands (~±0.005% precision)
+make test
+
+# Standard run: 10 billion hands (~±0.002% precision)
+make run
+
+# High precision: 40 billion hands (~±0.001% precision)
+make precision
+```
+
+Or run directly with a strategy file:
+
+```bash
+./monte_carlo ../web/public/strategies/6-h17-das-rsa-peek-32.json 10
+```
+
+## Expected Output
+
+```
+Loading strategy from: ../web/public/strategies/6-h17-das-rsa-peek-32.json
+Config: Decks=6, H17=Yes, Peek=Yes, BJ=1.50
+
+=== CUDA Monte Carlo Blackjack Simulator ===
+Target: 10 billion hands
+Threads: 8704
+
+Running simulation...
+
+=== Results ===
+Hands: 10.00 billion
+House edge: 0.6971% +/- 0.0022%
+95% CI: [0.6949%, 0.6994%]
+Time: 34.69 seconds
+Speed: 288.28 million hands/sec
+```
+
+## Precision vs Hands
+
+Standard error scales as 1/√n:
+
+| Hands | Standard Error | 95% CI  | Time (RTX 3080) |
+| ----- | -------------- | ------- | --------------- |
+| 1B    | ±0.006%        | ±0.012% | ~4s             |
+| 10B   | ±0.002%        | ±0.004% | ~35s            |
+| 40B   | ±0.001%        | ±0.002% | ~140s           |
+
+## Troubleshooting
+
+### "CUDA driver version is insufficient"
+
+Update your Windows NVIDIA driver to the latest version.
+
+### "no CUDA-capable device is detected"
+
+1. Make sure you're on WSL2 (not WSL1): `wsl --status`
+2. Update WSL: `wsl --update`
+3. Restart WSL: `wsl --shutdown` then reopen
+
+## Technical Details
+
+- Each CUDA thread maintains its own shoe
+- Fisher-Yates shuffle for true random shoe
+- Reshuffles at 75% penetration
+- One split allowed, split aces get one card only
+- Dealer peeks for blackjack (configurable via JSON)