@ebowwa/quant-rust 0.1.0

package/src/prediction/lmsr.rs

@@ -0,0 +1,194 @@
+//! # LMSR (Logarithmic Market Scoring Rule)
+//!
+//! Calculations for LMSR-based prediction markets (used by Gnosis, Hanson, etc.)
+
+use crate::prediction::Outcome;
+
+/// State of an LMSR market
+#[derive(Debug, Clone, Copy)]
+pub struct LMSRState {
+    /// YES shares outstanding
+    pub yes_shares: f64,
+    /// NO shares outstanding
+    pub no_shares: f64,
+    /// Liquidity parameter (b)
+    pub b: f64,
+}
+
+impl LMSRState {
+    /// Create a new LMSR state
+    pub fn new(yes_shares: f64, no_shares: f64, b: f64) -> Self {
+        Self {
+            yes_shares,
+            no_shares,
+            b,
+        }
+    }
+}
+
+/// Calculate price in LMSR market.
+///
+/// Price = e^(q_i / b) / sum(e^(q_j / b))
+///
+/// # Arguments
+/// * `state` - Current LMSR state
+/// * `outcome` - Which outcome to price
+///
+/// # Returns
+/// Price as probability (0-1)
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::lmsr::{LMSRState, lmsr_price};
+/// use quant_rust::prediction::Outcome;
+/// let state = LMSRState::new(0.0, 0.0, 100.0);
+/// let price = lmsr_price(&state, Outcome::Yes);
+/// assert!((price - 0.5).abs() < 1e-10); // Equal shares = 50/50
+/// ```
+pub fn lmsr_price(state: &LMSRState, outcome: Outcome) -> f64 {
+    let LMSRState { yes_shares, no_shares, b } = *state;
+
+    if b <= 0.0 {
+        return 0.0;
+    }
+
+    let exp_yes = (yes_shares / b).exp();
+    let exp_no = (no_shares / b).exp();
+    let sum = exp_yes + exp_no;
+
+    if sum == 0.0 {
+        return 0.5;
+    }
+
+    match outcome {
+        Outcome::Yes => exp_yes / sum,
+        Outcome::No => exp_no / sum,
+    }
+}
+
+/// Calculate cost to buy shares in LMSR.
+///
+/// Cost = b * ln(sum(e^(q_i + delta_i) / b)) - b * ln(sum(e^(q_i) / b))
+///
+/// # Arguments
+/// * `state` - Current LMSR state
+/// * `outcome` - Which outcome to buy
+/// * `shares` - Number of shares to buy
+///
+/// # Returns
+/// Cost in quote currency
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::lmsr::{LMSRState, lmsr_buy_cost};
+/// use quant_rust::prediction::Outcome;
+/// let state = LMSRState::new(0.0, 0.0, 100.0);
+/// let cost = lmsr_buy_cost(&state, Outcome::Yes, 50.0);
+/// assert!(cost > 0.0);
+/// ```
+pub fn lmsr_buy_cost(state: &LMSRState, outcome: Outcome, shares: f64) -> f64 {
+    let LMSRState { yes_shares, no_shares, b } = *state;
+
+    if b <= 0.0 {
+        return 0.0;
+    }
+
+    // Before cost: b * ln(e^(yes/b) + e^(no/b))
+    let before = b * ((yes_shares / b).exp() + (no_shares / b).exp()).ln();
+
+    // After cost depends on which outcome we're buying
+    let after = match outcome {
+        Outcome::Yes => {
+            b * (((yes_shares + shares) / b).exp() + (no_shares / b).exp()).ln()
+        }
+        Outcome::No => {
+            b * ((yes_shares / b).exp() + ((no_shares + shares) / b).exp()).ln()
+        }
+    };
+
+    after - before
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_lmsr_price_equal() {
+        // Equal shares should give 50/50
+        let state = LMSRState::new(0.0, 0.0, 100.0);
+        let yes_price = lmsr_price(&state, Outcome::Yes);
+        let no_price = lmsr_price(&state, Outcome::No);
+        assert!((yes_price - 0.5).abs() < 1e-10);
+        assert!((no_price - 0.5).abs() < 1e-10);
+        assert!((yes_price + no_price - 1.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_lmsr_price_more_yes() {
+        // More YES shares should increase YES price
+        let state = LMSRState::new(100.0, 0.0, 100.0);
+        let yes_price = lmsr_price(&state, Outcome::Yes);
+        assert!(yes_price > 0.5);
+    }
+
+    #[test]
+    fn test_lmsr_price_more_no() {
+        // More NO shares should increase NO price
+        let state = LMSRState::new(0.0, 100.0, 100.0);
+        let yes_price = lmsr_price(&state, Outcome::Yes);
+        assert!(yes_price < 0.5);
+    }
+
+    #[test]
+    fn test_lmsr_buy_cost_positive() {
+        let state = LMSRState::new(0.0, 0.0, 100.0);
+        let cost = lmsr_buy_cost(&state, Outcome::Yes, 50.0);
+        assert!(cost > 0.0);
+    }
+
+    #[test]
+    fn test_lmsr_buy_cost_increases_with_shares() {
+        let state = LMSRState::new(0.0, 0.0, 100.0);
+        let cost_small = lmsr_buy_cost(&state, Outcome::Yes, 10.0);
+        let cost_large = lmsr_buy_cost(&state, Outcome::Yes, 50.0);
+        assert!(cost_large > cost_small);
+    }
+
+    #[test]
+    fn test_lmsr_buy_cost_symmetry() {
+        let state = LMSRState::new(0.0, 0.0, 100.0);
+        let cost_yes = lmsr_buy_cost(&state, Outcome::Yes, 50.0);
+        let cost_no = lmsr_buy_cost(&state, Outcome::No, 50.0);
+        // Should cost the same to buy either outcome from equal starting point
+        assert!((cost_yes - cost_no).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_lmsr_buy_cost_zero_shares() {
+        let state = LMSRState::new(0.0, 0.0, 100.0);
+        let cost = lmsr_buy_cost(&state, Outcome::Yes, 0.0);
+        assert!((cost - 0.0).abs() < 1e-10);
+    }
+
+    #[test]
+    fn test_lmsr_liquidity_parameter_effect() {
+        // Higher b = more liquidity = prices move less
+        let state_low = LMSRState::new(100.0, 0.0, 50.0);
+        let state_high = LMSRState::new(100.0, 0.0, 200.0);
+
+        let price_low = lmsr_price(&state_low, Outcome::Yes);
+        let price_high = lmsr_price(&state_high, Outcome::Yes);
+
+        // With same shares but higher b, price should be closer to 0.5
+        assert!(price_high < price_low);
+    }
+
+    #[test]
+    fn test_lmsr_prices_sum_to_one() {
+        let state = LMSRState::new(123.0, 456.0, 100.0);
+        let yes_price = lmsr_price(&state, Outcome::Yes);
+        let no_price = lmsr_price(&state, Outcome::No);
+        assert!((yes_price + no_price - 1.0).abs() < 1e-10);
+    }
+}

package/src/prediction/mod.rs

@@ -0,0 +1,59 @@
+//! # Prediction Market Tools
+//!
+//! Tools for binary outcome prediction markets (Polymarket, Manifold, Kalshi, etc.)
+//!
+//! ## Modules
+//!
+//! - [`odds`] - Probability and odds conversions
+//! - [`kelly`] - Kelly criterion position sizing
+//! - [`amm`] - Constant product AMM calculations
+//! - [`lmsr`] - Logarithmic Market Scoring Rule
+//! - [`arbitrage`] - Arbitrage detection
+//! - [`calibration`] - Forecast calibration and scoring
+//! - [`risk`] - Position risk metrics
+//! - [`pnl`] - PnL and payout calculations
+
+pub mod amm;
+pub mod arbitrage;
+pub mod calibration;
+pub mod kelly;
+pub mod lmsr;
+pub mod odds;
+pub mod pnl;
+pub mod risk;
+
+// Re-exports for convenience
+pub use amm::{
+    amm_buy_cost, amm_impermanent_loss, amm_price_after_buy, amm_price_impact, amm_shares_received,
+    AMMState, PriceImpactResult,
+};
+pub use arbitrage::{
+    detect_arbitrage, find_cross_market_arbitrage, ArbitrageOpportunity, CrossMarketArbitrage,
+    MarketPrice,
+};
+pub use calibration::{
+    brier_score, calculate_calibration, log_loss, CalibrationBucket, CalibrationResult, Prediction,
+};
+pub use kelly::{fractional_kelly, kelly_criterion, kelly_multiple, BetOpportunity, KellyResult};
+pub use lmsr::{lmsr_buy_cost, lmsr_price, LMSRState};
+pub use odds::{
+    american_odds_to_prob, decimal_odds_to_prob, price_to_implied_prob, prob_to_american_odds,
+    prob_to_decimal_odds, prob_to_fair_price,
+};
+pub use pnl::{
+    calculate_payout, calculate_pnl, calculate_unrealized_pnl, time_weighted_return,
+    ClosedPosition,
+};
+pub use risk::{
+    break_even_prob, calculate_edge, calculate_prediction_risk, has_positive_ev,
+    PredictionRiskMetrics,
+};
+
+use serde::{Deserialize, Serialize};
+
+/// Outcome type for prediction markets
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Outcome {
+    Yes,
+    No,
+}

package/src/prediction/odds.rs

@@ -0,0 +1,229 @@
+//! # Odds and Probability Conversions
+//!
+//! Convert between probability, decimal odds, and American odds formats.
+
+use std::f64::INFINITY;
+use std::f64::NEG_INFINITY;
+
+/// Convert probability (0-1) to decimal odds.
+///
+/// # Arguments
+/// * `prob` - Probability value (0-1)
+///
+/// # Returns
+/// Decimal odds (1 / prob), or infinity if prob is 0 or negative
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::odds::prob_to_decimal_odds;
+/// let odds = prob_to_decimal_odds(0.25);
+/// assert_eq!(odds, 4.0);
+/// ```
+pub fn prob_to_decimal_odds(prob: f64) -> f64 {
+    if prob <= 0.0 {
+        return INFINITY;
+    }
+    1.0 / prob
+}
+
+/// Convert probability (0-1) to American odds.
+///
+/// # Arguments
+/// * `prob` - Probability value (0-1)
+///
+/// # Returns
+/// American odds:
+/// - Positive (>100): underdog, profit on $100 bet
+/// - Negative (<-100): favorite, amount to bet to win $100
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::odds::prob_to_american_odds;
+/// let odds = prob_to_american_odds(0.25);
+/// assert_eq!(odds, 300); // +300 underdog
+///
+/// let odds = prob_to_american_odds(0.75);
+/// assert_eq!(odds, -300); // -300 favorite
+/// ```
+pub fn prob_to_american_odds(prob: f64) -> f64 {
+    if prob <= 0.0 {
+        return INFINITY;
+    }
+    if prob >= 1.0 {
+        return NEG_INFINITY;
+    }
+
+    if prob > 0.5 {
+        // Favorite: negative odds
+        -((prob / (1.0 - prob)) * 100.0).round()
+    } else {
+        // Underdog: positive odds
+        (((1.0 - prob) / prob) * 100.0).round()
+    }
+}
+
+/// Convert decimal odds to probability.
+///
+/// # Arguments
+/// * `odds` - Decimal odds (must be >= 1)
+///
+/// # Returns
+/// Implied probability (1 / odds), or 1.0 if odds <= 1
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::odds::decimal_odds_to_prob;
+/// let prob = decimal_odds_to_prob(4.0);
+/// assert_eq!(prob, 0.25);
+/// ```
+pub fn decimal_odds_to_prob(odds: f64) -> f64 {
+    if odds <= 1.0 {
+        return 1.0;
+    }
+    1.0 / odds
+}
+
+/// Convert American odds to probability.
+///
+/// # Arguments
+/// * `odds` - American odds (positive or negative)
+///
+/// # Returns
+/// Implied probability
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::odds::american_odds_to_prob;
+/// let prob = american_odds_to_prob(300.0);
+/// assert_eq!(prob, 0.25);
+///
+/// let prob = american_odds_to_prob(-300.0);
+/// assert_eq!(prob, 0.75);
+/// ```
+pub fn american_odds_to_prob(odds: f64) -> f64 {
+    if odds > 0.0 {
+        // Underdog: prob = 100 / (odds + 100)
+        100.0 / (odds + 100.0)
+    } else {
+        // Favorite: prob = |odds| / (|odds| + 100)
+        odds.abs() / (odds.abs() + 100.0)
+    }
+}
+
+/// Convert price (0-1) to implied probability, accounting for fees.
+///
+/// # Arguments
+/// * `price` - Market price (0-1)
+/// * `fee_bps` - Optional fee in basis points (e.g., 100 = 1%)
+///
+/// # Returns
+/// Implied probability including fee impact
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::odds::price_to_implied_prob;
+/// let prob = price_to_implied_prob(0.50, Some(100.0)); // 1% fee
+/// assert!((prob - 0.505).abs() < 0.001);
+/// ```
+pub fn price_to_implied_prob(price: f64, fee_bps: Option<f64>) -> f64 {
+    if price <= 0.0 {
+        return 0.0;
+    }
+    if price >= 1.0 {
+        return 1.0;
+    }
+
+    let fee = fee_bps.unwrap_or(0.0);
+    price * (1.0 + fee / 10000.0)
+}
+
+/// Convert probability to fair price, accounting for fees.
+///
+/// # Arguments
+/// * `prob` - Probability value (0-1)
+/// * `fee_bps` - Optional fee in basis points (e.g., 100 = 1%)
+///
+/// # Returns
+/// Fair price after accounting for fees
+///
+/// # Example
+/// ```
+/// use quant_rust::prediction::odds::prob_to_fair_price;
+/// let price = prob_to_fair_price(0.50, Some(100.0)); // 1% fee
+/// assert!((price - 0.495).abs() < 0.001);
+/// ```
+pub fn prob_to_fair_price(prob: f64, fee_bps: Option<f64>) -> f64 {
+    if prob <= 0.0 {
+        return 0.0;
+    }
+    if prob >= 1.0 {
+        return 1.0;
+    }
+
+    let fee = fee_bps.unwrap_or(0.0);
+    prob / (1.0 + fee / 10000.0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_prob_to_decimal_odds() {
+        assert_eq!(prob_to_decimal_odds(0.25), 4.0);
+        assert_eq!(prob_to_decimal_odds(0.5), 2.0);
+        assert_eq!(prob_to_decimal_odds(1.0), 1.0);
+        assert!(prob_to_decimal_odds(0.0).is_infinite());
+        assert!(prob_to_decimal_odds(-0.1).is_infinite());
+    }
+
+    #[test]
+    fn test_prob_to_american_odds() {
+        assert_eq!(prob_to_american_odds(0.25), 300.0); // +300 underdog
+        assert_eq!(prob_to_american_odds(0.75), -300.0); // -300 favorite
+        assert_eq!(prob_to_american_odds(0.5), 100.0); // Even money
+        assert!(prob_to_american_odds(0.0).is_infinite());
+    }
+
+    #[test]
+    fn test_decimal_odds_to_prob() {
+        assert_eq!(decimal_odds_to_prob(4.0), 0.25);
+        assert_eq!(decimal_odds_to_prob(2.0), 0.5);
+        assert_eq!(decimal_odds_to_prob(1.0), 1.0);
+    }
+
+    #[test]
+    fn test_american_odds_to_prob() {
+        assert_eq!(american_odds_to_prob(300.0), 0.25);
+        assert_eq!(american_odds_to_prob(-300.0), 0.75);
+        assert_eq!(american_odds_to_prob(100.0), 0.5);
+    }
+
+    #[test]
+    fn test_price_to_implied_prob() {
+        assert_eq!(price_to_implied_prob(0.5, None), 0.5);
+        assert_eq!(price_to_implied_prob(0.5, Some(0.0)), 0.5);
+        assert!((price_to_implied_prob(0.5, Some(100.0)) - 0.505).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_prob_to_fair_price() {
+        assert_eq!(prob_to_fair_price(0.5, None), 0.5);
+        assert_eq!(prob_to_fair_price(0.5, Some(0.0)), 0.5);
+        assert!((prob_to_fair_price(0.5, Some(100.0)) - 0.49505).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_round_trip_conversion() {
+        // Decimal odds round trip
+        let prob = 0.4;
+        let odds = prob_to_decimal_odds(prob);
+        let back = decimal_odds_to_prob(odds);
+        assert!((prob - back).abs() < 1e-10);
+
+        // American odds round trip
+        let odds = prob_to_american_odds(prob);
+        let back = american_odds_to_prob(odds);
+        assert!((prob - back).abs() < 0.01); // Allow rounding error
+    }
+}