KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#typescript #ai-agents #developer-tools #cli #codex #claude-code #react #mcp #open-source #deepseek-harness #dsh-plugin #ai

prediction-markets

★ 14 Open GitHub ↗

Quantitative trading system for prediction markets using Bernoulli distributions, Kelly Criterion, and linear algebra. Features arbitrage detection, Monte Carlo simulation, backtesting, and interactive dashboard.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

#  Prediction Market Quantitative Trading System

A production-grade quantitative trading system for prediction markets that combines probability theory, statistical analysis, and portfolio optimization to identify trading opportunities.

## Overview

I built a complete trading system from scratch that combines probability theory, statistical analysis, and portfolio optimization to identify and capitalize on market inefficiencies. This system uses Bernoulli distributions, Kelly Criterion, and linear algebra to detect arbitrage, optimize portfolios, and backtest trading strategies in prediction markets.

## What I Built (4 Core Modules):

1. main.py - Core Trading Engine
- Market class with price validation
- Arbitrage detector using linear programming
- Binomial price model with Monte Carlo simulation
- Kelly Criterion optimizer for position sizing
- Statistical calibration analyzer

2. backtesting.py - Strategy Testing Framework
- Historical data simulator
- Trade execution engine
- Performance metrics (returns, win rate, Sharpe ratio)
- Equity curve visualization

3. visualization.py - Data Visualization Suite
- Price paths simulations
- Portfolio allocation charts
- Market calibration plots
- Performance dashboards

4. dashboard.py - Interactive Web Interface
- Stream-based UI
- Real-time arbitrage detection
- Monte Carlo price simulation
- Kelly optimization calculator
- Strategy backtesting interface

## Demonstrated Capabilities:
- Detected arbitrage opportunities with 1-3% guaranteed returns
- Backtested strategies showing 11.77% returns 
- Simulated 1000+ price scenarios using Bernoulli distributions
- Calculated optimal portfolio allocations using Kelly Criterion

## Mathematical Foundations:
- Bernoulli & Binomial Distributions - Binary outcome modeling
- Linear Algebra - Arbitrage detection and optimization
- Kelly Criterion - Portfolio optimization theory
- Monte Carlo Simulations - Risk analysis
- Statistical Hypothesis Testing - Market calibration

# Project Structure
```
prediction-market-trading/
├── main.py              # Core trading engine
├── backtesting.py       # Strategy testing framework
├── visualizations.py    # Data visualization suite
├── dashboard.py         # Interactive web interface
└── requirements.txt     # Python dependencies
```

## Quick Start

### Installation
```bash
# Clone the repository
git clone https://github.com/4Rbelaez/prediction-markets.git
cd prediction-markets

# Install dependencies
pip install -r requirements.txt
```

### Running the Dashboard
```bash
streamlit run dashboard.py
```

The dashboard will open in your browser at `http://localhost:8501`

### Running Individual Components
```bash
# Test core trading engine
python main.py

# Run backtesting framework
python backtesting.py

# Test visualizations
python visualizations.py
```

## System Components

### 1. main.py - Core Trading Engine

The foundation of the system with five key classes:

#### Market Class
Represents a binary prediction market with price validation.
```python
from main import Market

market = Market("Presidential Election", yes_price=0.52, no_price=0.45)
```

#### ArbitrageDetector
Identifies risk-free profit opportunities using linear programming.
```python
from main import ArbitrageDetector

detector = ArbitrageDetector(transaction_cost=0.02)
result = detector.detect_simple_arbitrage(market)
# Returns: {'guaranteed_return': 1.07%, 'net_cost': 0.989, ...}
```

#### BinomialPriceModel
Simulates market price evolution using Monte Carlo methods with Bernoulli random variables.
```python
from main import BinomialPriceModel

model = BinomialPriceModel(initial_price=0.5, volatility=0.15, periods=10)
paths = model.simulate_paths(n_simulations=1000)
# Generates 1000 possible price trajectories
```

#### KellyOptimizer
Calculates optimal position sizing to maximize long-term growth.
```python
from main import KellyOptimizer
import numpy as np

optimizer = KellyOptimizer(bankroll=10000)
markets = [market1, market2, market3]
true_probs = np.array([0.60, 0.55, 0.65])
allocations = optimizer.optimize_portfolio(markets, true_probs)
# Returns: {'Market_1': 2500, 'Market_2': 1500, ...}
```

#### MarketInefficiencyAnalyzer
Tests market calibration using binomial hypothesis testing.
```python
from main import MarketInefficiencyAnalyzer

analyzer = MarketInefficiencyAnalyzer()
analyzer.add_market_observation(market_price=0.70, outcome=1)
calibration = analyzer.binomial_calibration_test()
brier_score = analyzer.compute_brier_score()
```

### 2. backtesting.py - Strategy Testing Framework

Test trading strategies on historical data with comprehensive performance metrics.

#### Key Components:

- **Trade**: Dataclass representing individual trades with P&L tracking
- **HistoricalMarket**: Container for market price history and outcomes
- **HistoricalDataSimulator**: Generates synthetic market data for testing
- **Backtester**: Executes strategies and calculates performance metrics

#### Example Usage:
```python
from backtesting import Backtester, HistoricalDataSimulator, simple_kelly_strategy

# Generate test data
simulator = HistoricalDataSimulator(n_markets=20, n_periods=30)
markets = simulator.generate_market_data()

# Run backtest
backtester = Backtester(initial_bankroll=10000)
backtester.run_strategy(markets, simple_kelly_strategy, entry_time=10)

# Results: Total Return: +11.77%, Win Rate: 60%
backtester.plot_results()
```

### 3. visualizations.py - Data Visualization Suite

Professional visualizations for all trading components using Matplotlib and Seaborn.

#### MarketVisualizer Methods:

- **plot_price_paths()**: Monte Carlo price simulations with confidence bands
- **plot_kelly_allocations()**: Portfolio allocation bar and pie charts
- **plot_calibration()**: Market calibration accuracy analysis
- **plot_arbitrage_opportunities()**: Visual comparison of arbitrage returns

#### Example:
```python
from visualizations import MarketVisualizer
import matplotlib.pyplot as plt

# Visualize price simulations
fig = MarketVisualizer.plot_price_paths(paths, title="Price Evolution")
plt.savefig('price_simulation.png')

# Visualize Kelly allocations
fig = MarketVisualizer.plot_kelly_allocations(allocations, bankroll=10000)
plt.show()
```

### 4. dashboard.py - Interactive Web Interface

Streamlit-based web application with five interactive pages:

#### Pages:

1. **Home**: System overview and component descriptions
2. **Arbitrage Detector**: Real-time arbitrage opportunity detection
3. **Price Simulator**: Interactive Monte Carlo price simulation
4. **Kelly Optimizer**: Portfolio allocation calculator
5. **Backtesting**: Strategy testing with configurable parameters

#### Features:

- Real-time parameter adjustment with sliders
- Interactive visualizations
- Export functionality for charts
- Comprehensive results display

## Mathematical Foundations

### Bernoulli & Binomial Distributions
- **Bernoulli Random Variable**: Models binary market outcomes (win=1, lose=0)
- **Binomial Distribution**: Sum of multiple Bernoulli trials, used for:
  - Price path simulation (each time step is a coin flip)
  - Statistical hypothesis testing for market calibration

### Kelly Criterion
Optimal bet sizing formula to maximize long-term growth:
```
f* = (p × b - q) / b

where:
  f* = optimal fraction of bankroll to bet
  p = true probability of winning
  q = 1 - p
  b = net odds received
```

### Linear Programming
Used in arbitrage detection to solve:
```
minimize: cost = Σ(price_i × position_i)
subject to: guaranteed payout = 1
```

### Monte Carlo Simulation
Generates thousands of possible price scenarios to:
- Estimate probability distributions
- Calculate value-at-risk (VaR)
- Assess strategy robustness

## Sample Results

### Arbitrage Detection
```
Market: Presidential Election
YES Price: $0.52, NO Price: $0.45
Total Cost: $0.97
Net Cost (with 2% fees): $0.989
Guaranteed Return: 1.07%
```

### Backtesting Performance
```
Initial Bankroll: $10,000
Final Bankroll: $11,177
Total Return: +11.77%
Number of Trades: 5
Win Rate: 60%
Average Win: $726
Average Loss: $500
```

### Price Simulation (1000 paths, 10 periods)
```
Initial Price: 0.500
Mean Final Price: 0.530
Standard Deviation: 0.237
95% Confidence Interval: [0.157, 0.990]
```

## Tech Stack

- **Python 3.8+**: Core programming language
- **NumPy**: Numerical computing and array operations
- **SciPy**: Statistical functions and optimization
- **Pandas**: Data manipulation and analysis
- **Matplotlib**: Static visualizations
- **Seaborn**: Statistical data visualization
- **Streamlit**: Interactive web dashboard

## Key Concepts Demonstrated

### Quantitative Finance
- Arbitrage detection and exploitation
- Portfolio optimization theory
- Risk management and position sizing
- Strategy backtesting methodology

### Probability & Statistics
- Random variable modeling (Bernoulli/Binomial)
- Monte Carlo simulation techniques
- Hypothesis testing (binomial tests)
- Calibration analysis

### Software Engineering
- Object-oriented design with classes
- Modular architecture for extensibility
- Type hints for code clarity
- Comprehensive documentation

### Data Science
- Statistical analysis and visualization
- Performance metrics calculation
- Interactive dashboard development
- Data-driven decision making

## Future Enhancements

- [ ] Real API integration (Polymarket, Kalshi, PredictIt)
- [ ] Machine learning models for probability estimation
- [ ] Multi-market arbitrage detection (triangular arbitrage)
- [ ] Real-time monitoring with alerts (email/SMS)
- [ ] Advanced risk management (stop-loss, position limits)
- [ ] Cloud deployment (AWS/GCP) for 24/7 operation
- [ ] Historical data scraping and storage
- [ ] Advanced portfolio optimization (mean-variance)

## References

- Kelly, J. L. (1956). "A New Interpretation of Information Rate"
- Hull, J. C. "Options, Futures, and Other Derivatives"
- Prediction Market Research - George Mason University
- Binomial Options Pricing Model
- Monte Carlo Methods in Finance

## License

MIT License - See LICENSE file for details

## Contributing

Contributions welcome! Please open an issue or submit a pull request.

## 📧 Contact

Your Name - [LinkedIn](https://www.linkedin.com/in/andrew-arbelaez-bab191193/) - arbelaezandrew@gmail.com

Project Link: [https://github.com/4Rbelaez/prediction-markets](https://github.com/4Rbelaez/prediction-markets)
```

prediction-markets

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README