hypercall_margin/

lib.rs

//! Pure margin computation for the Hypercall options + perps platform.
//!
//! This crate contains all margin math with **zero IO dependencies** -- no database,
//! no network, no async runtime. It is the correctness kernel for margin calculations.
//!
//! # Margin Modes
//!
//! Hypercall supports two margin modes:
//!
//! - **Standard** (Deribit-style): linear per-position margin. Long options are fully paid
//!   (zero margin), short options use `max(15% * spot - OTM, 10% * spot)` for IM.
//!   See [`standard::StandardMarginService`].
//!
//! - **Portfolio** (SPAN-style): scenario-based margin. The portfolio is stressed across
//!   17 scenarios (13 core + 4 tail) combining spot and vol shocks. Scanning risk is the
//!   worst-case weighted loss, plus contingency add-ons for short gamma near expiry.
//!   See [`portfolio::span::compute_span_margin_at`].
//!
//! # Architecture
//!
//! ```text
//! hypercall-types  (WalletAddress, shared primitives)
//!       ^
//! hypercall-margin (this crate: types + pure math)
//!       ^
//! hypercall        (engine: IO, vol oracle, async wiring)
//! ```
//!
//! The engine populates market state (spot prices, implied vols) and calls into this
//! crate for the actual margin computation. This crate never fetches data itself.
//!
//! # Example
//!
//! ```
//! use hypercall_margin::standard::{StandardMarginService, StandardAccount};
//! use rust_decimal_macros::dec;
//!
//! let service = StandardMarginService::new();
//! let account = StandardAccount::new("wallet".to_string(), dec!(10000));
//! let result = service.compute_margin(&account);
//! assert!(result.can_increase_risk());
//! ```

pub mod black_76;
pub mod black_scholes;
pub mod constants;
pub mod error;
pub mod margin_mode {
    pub use hypercall_types::margin_mode::*;
}
pub mod portfolio;
pub mod standard;
pub mod types;

pub use constants::MM_TO_IM_RATIO;
pub use error::MarginError;
pub use margin_mode::MarginMode;
pub use types::{Account, MarginDetails, OptionType, Scenario, ScenarioType};

pub use portfolio::{
    account_cash_decimal, classify_liquidity_gap, compute_extended_risk_grid_from_snapshot,
    compute_risk_grid_from_snapshot, compute_span_margin_at, empty_portfolio_margin_details,
    generate_scenarios, has_portfolio_positions, market_state_from_snapshot, pool_capacity_usdc,
    pool_target_usdc, pool_utilization, short_option_oi_usdc, snapshot_from_account,
    utilization_apr, validate_pool_config, ContingencyMargin, ExtendedRiskGrid, InstrumentRiskRow,
    PmAccountSettlementFacts, PmFixtureOptionKey, PmFixturePosition, PmLiquidityClassification,
    PmMarketMarks, PmSettlementFixture, PmSettlementModelError, PmSettlementObligation,
    PmSettlementPoolConfig, PmSettlementPoolSnapshot, PortfolioMarginConfig,
    PortfolioMarginContingencyConfig, PortfolioMarginGridConfig, PortfolioMarginMarketState,
    PortfolioMarginOptionExposure, PortfolioMarginOptionKey, PortfolioMarginOptionMarketState,
    PortfolioMarginPerpExposure, PortfolioMarginScenario, PortfolioMarginSnapshot,
    PortfolioMarginSymbolOverride, PortfolioMarginUnderlyingMarketState,
    PortfolioMarginUnderlyingSnapshot, ScenarioPnl, SnapshotComponentKind,
};

pub use standard::{
    OptionPosition, PerpPosition, PositionMarginContribution, StandardAccount,
    StandardMarginParams, StandardMarginResult, StandardMarginService,
};

#[cfg(test)]
mod proptest_properties {
    use super::standard::types::{OptionPosition, PerpPosition, StandardAccount};
    use super::standard::StandardMarginService;
    use proptest::prelude::*;
    use rust_decimal::Decimal;
    use rust_decimal_macros::dec;

    fn arb_decimal_positive(max: f64) -> impl Strategy<Value = Decimal> {
        (1u64..=(max as u64 * 100)).prop_map(|v| Decimal::new(v as i64, 2))
    }

    fn arb_decimal_nonzero(max: f64) -> impl Strategy<Value = Decimal> {
        prop_oneof![
            (1u64..=(max as u64 * 100)).prop_map(|v| Decimal::new(v as i64, 2)),
            (1u64..=(max as u64 * 100)).prop_map(|v| Decimal::new(-(v as i64), 2)),
        ]
    }

    // ===== Property 1: Standard margin non-negativity =====

    proptest! {
        #[test]
        fn standard_margin_is_non_negative(
            spot in arb_decimal_positive(100000.0),
            size in arb_decimal_nonzero(100.0),
            strike in arb_decimal_positive(200000.0),
            balance in arb_decimal_positive(1000000.0),
        ) {
            let service = StandardMarginService::new();
            let mut account = StandardAccount::new("prop".to_string(), balance);
            account.option_positions.push(OptionPosition {
                symbol: "TEST-C".to_string(),
                underlying: "TEST".to_string(),
                expiry_ts: 0,
                strike,
                is_call: true,
                size,
                mark_price: spot / dec!(10),
                entry_price: spot / dec!(10),
                spot_price: spot,
            });

            let result = service.compute_margin(&account);
            prop_assert!(result.position_im >= dec!(0), "position_im was {}", result.position_im);
            prop_assert!(result.position_mm >= dec!(0), "position_mm was {}", result.position_mm);
        }

    // ===== Property 2: Adding position never decreases margin =====

        #[test]
        fn adding_position_never_decreases_margin(
            spot in arb_decimal_positive(100000.0),
            size1 in arb_decimal_nonzero(50.0),
            size2 in arb_decimal_nonzero(50.0),
            strike1 in arb_decimal_positive(200000.0),
            strike2 in arb_decimal_positive(200000.0),
        ) {
            let service = StandardMarginService::new();

            let mut account1 = StandardAccount::new("prop".to_string(), dec!(1000000));
            account1.option_positions.push(OptionPosition {
                symbol: "A-C".to_string(),
                underlying: "A".to_string(),
                expiry_ts: 0,
                strike: strike1,
                is_call: true,
                size: size1,
                mark_price: spot / dec!(10),
                entry_price: spot / dec!(10),
                spot_price: spot,
            });

            let mut account2 = account1.clone();
            account2.option_positions.push(OptionPosition {
                symbol: "B-C".to_string(),
                underlying: "B".to_string(),
                expiry_ts: 0,
                strike: strike2,
                is_call: true,
                size: size2,
                mark_price: spot / dec!(10),
                entry_price: spot / dec!(10),
                spot_price: spot,
            });

            let result1 = service.compute_margin(&account1);
            let result2 = service.compute_margin(&account2);

            prop_assert!(
                result2.position_im >= result1.position_im,
                "Adding position decreased IM: {} -> {}",
                result1.position_im,
                result2.position_im
            );
        }

    // ===== Property 3: Perp margin scales linearly =====

        #[test]
        fn perp_margin_scales_linearly_with_size(
            spot in arb_decimal_positive(100000.0),
            size in arb_decimal_nonzero(100.0),
        ) {
            let service = StandardMarginService::new();

            let mut account1 = StandardAccount::new("prop".to_string(), dec!(1000000));
            account1.perp_positions.push(PerpPosition {
                symbol: "TEST-PERP".to_string(),
                underlying: "TEST".to_string(),
                size,
                mark_price: spot,
                entry_price: spot,
            });

            let mut account2 = StandardAccount::new("prop".to_string(), dec!(1000000));
            account2.perp_positions.push(PerpPosition {
                symbol: "TEST-PERP".to_string(),
                underlying: "TEST".to_string(),
                size: size * dec!(2),
                mark_price: spot,
                entry_price: spot,
            });

            let result1 = service.compute_margin(&account1);
            let result2 = service.compute_margin(&account2);

            prop_assert_eq!(result2.position_im, result1.position_im * dec!(2));
        }
    }
}

// ===== Properties 4-7: SPAN / PM / Black-Scholes =====

#[cfg(test)]
mod span_proptest_properties {
    use super::portfolio::config::*;
    use super::portfolio::contingency::calculate_contingency_margin_at;
    use super::portfolio::evaluator::calculate_scanning_risk;
    use super::portfolio::snapshot::*;
    use super::types::OptionType;
    use hypercall_types::wallet_address::test_wallet;
    use proptest::prelude::*;
    use rust_decimal::Decimal;
    use rust_decimal_macros::dec;
    use std::collections::HashMap;

    const FIXED_NOW_TS: i64 = 1_700_000_000;
    const FAR_EXPIRY_TS: i64 = FIXED_NOW_TS + 90 * 24 * 3600;

    fn test_pm_config() -> PortfolioMarginConfig {
        PortfolioMarginConfig {
            base_grid: PortfolioMarginGridConfig {
                scenarios: PortfolioMarginScenario::finalized_default_grid(),
                base_volatility: 0.8,
                base_skew: 0.0,
                base_excess_kurtosis: 0.0,
                delta_threshold: 0.0001,
                strike_match_tolerance: 0.01,
                expiry_match_tolerance_years: 0.001,
            },
            symbol_overrides: Vec::new(),
            contingency: PortfolioMarginContingencyConfig::finalized_default(),
            risk_free_rate: 0.05,
        }
    }

    fn make_option_snapshot(
        spot: f64,
        strike: f64,
        quantity: f64,
        iv: f64,
    ) -> (PortfolioMarginSnapshot, PortfolioMarginMarketState) {
        let spot_dec = Decimal::from_f64_retain(spot).unwrap();
        let strike_dec = Decimal::from_f64_retain(strike).unwrap();
        let quantity_dec = Decimal::from_f64_retain(quantity).unwrap();

        let key = PortfolioMarginOptionKey {
            underlying: "BTC".to_string(),
            option_type: OptionType::Call,
            strike: strike_dec,
            expiry_ts: FAR_EXPIRY_TS,
        };

        let snapshot = PortfolioMarginSnapshot {
            wallet: test_wallet(200),
            cash_balance: dec!(100000),
            underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: spot_dec,
                executed_options: vec![PortfolioMarginOptionExposure {
                    key: key.clone(),
                    expiry_years: dec!(0.25),
                    quantity: quantity_dec,
                    entry_price: dec!(0),
                    source: SnapshotComponentKind::ExecutedPositions,
                }],
                hypothetical_open_order_options: Vec::new(),
                executed_perps: Vec::new(),
                hypothetical_open_order_perps: Vec::new(),
            }],
        };

        let market_state = PortfolioMarginMarketState {
            config: test_pm_config(),
            underlyings: HashMap::from([(
                "BTC".to_string(),
                PortfolioMarginUnderlyingMarketState {
                    spot_price: spot,
                    option_inputs: HashMap::from([(
                        key,
                        PortfolioMarginOptionMarketState {
                            implied_volatility: iv,
                        },
                    )]),
                    funding: None,
                },
            )]),
        };

        (snapshot, market_state)
    }

    fn make_perp_snapshot(
        spot: f64,
        quantity: f64,
    ) -> (PortfolioMarginSnapshot, PortfolioMarginMarketState) {
        let spot_dec = Decimal::from_f64_retain(spot).unwrap();
        let quantity_dec = Decimal::from_f64_retain(quantity).unwrap();

        let snapshot = PortfolioMarginSnapshot {
            wallet: test_wallet(201),
            cash_balance: dec!(100000),
            underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                underlying: "BTC".to_string(),
                spot_price: spot_dec,
                executed_options: Vec::new(),
                hypothetical_open_order_options: Vec::new(),
                executed_perps: vec![PortfolioMarginPerpExposure {
                    underlying: "BTC".to_string(),
                    quantity: quantity_dec,
                    entry_price: Some(spot_dec),
                    unrealized_pnl: dec!(0),
                }],
                hypothetical_open_order_perps: Vec::new(),
            }],
        };

        let market_state = PortfolioMarginMarketState {
            config: test_pm_config(),
            underlyings: HashMap::from([(
                "BTC".to_string(),
                PortfolioMarginUnderlyingMarketState {
                    spot_price: spot,
                    option_inputs: HashMap::new(),
                    funding: None,
                },
            )]),
        };

        (snapshot, market_state)
    }

    proptest! {
        #![proptest_config(ProptestConfig::with_cases(256))]

    // ===== Property 4: Scanning risk non-negativity =====

        #[test]
        fn scanning_risk_is_non_negative_for_options(
            spot in 10.0f64..200000.0,
            strike_ratio in 0.5f64..2.0,
            quantity in -10.0f64..10.0,
            iv in 0.1f64..3.0,
        ) {
            prop_assume!(quantity.abs() > 0.001);
            let strike = spot * strike_ratio;
            let (snapshot, market_state) = make_option_snapshot(spot, strike, quantity, iv);
            let scenarios = super::generate_scenarios(&market_state);

            let scanning_risk = calculate_scanning_risk(&snapshot, &market_state, &scenarios)
                .expect("scanning risk should compute");

            prop_assert!(
                scanning_risk >= 0.0,
                "scanning_risk was {} for spot={} strike={} qty={} iv={}",
                scanning_risk, spot, strike, quantity, iv
            );
        }

        #[test]
        fn scanning_risk_is_non_negative_for_perps(
            spot in 10.0f64..200000.0,
            quantity in -100.0f64..100.0,
        ) {
            prop_assume!(quantity.abs() > 0.001);
            let (snapshot, market_state) = make_perp_snapshot(spot, quantity);
            let scenarios = super::generate_scenarios(&market_state);

            let scanning_risk = calculate_scanning_risk(&snapshot, &market_state, &scenarios)
                .expect("scanning risk should compute");

            prop_assert!(
                scanning_risk >= 0.0,
                "scanning_risk was {} for spot={} qty={}",
                scanning_risk, spot, quantity
            );
        }

    // ===== Property 5: Hedging reduces scanning risk =====

        #[test]
        fn hedge_reduces_or_maintains_scanning_risk(
            spot in 100.0f64..100000.0,
            short_qty in 1.0f64..10.0,
            hedge_ratio in 0.1f64..1.0,
            iv in 0.3f64..2.0,
        ) {
            let strike = spot * 1.05;
            let (naked_snapshot, market_state) = make_option_snapshot(spot, strike, -short_qty, iv);
            let scenarios = super::generate_scenarios(&market_state);

            let naked_risk = calculate_scanning_risk(&naked_snapshot, &market_state, &scenarios)
                .expect("naked risk should compute");

            let spot_dec = Decimal::from_f64_retain(spot).unwrap();
            let strike_dec = Decimal::from_f64_retain(strike).unwrap();
            let short_qty_dec = Decimal::from_f64_retain(-short_qty).unwrap();
            let hedge_qty_dec = Decimal::from_f64_retain(short_qty * hedge_ratio).unwrap();

            let short_key = PortfolioMarginOptionKey {
                underlying: "BTC".to_string(),
                option_type: OptionType::Call,
                strike: strike_dec,
                expiry_ts: FAR_EXPIRY_TS,
            };
            let hedge_strike = strike * 1.1;
            let hedge_strike_dec = Decimal::from_f64_retain(hedge_strike).unwrap();
            let hedge_key = PortfolioMarginOptionKey {
                underlying: "BTC".to_string(),
                option_type: OptionType::Call,
                strike: hedge_strike_dec,
                expiry_ts: FAR_EXPIRY_TS,
            };

            let hedged_snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(202),
                cash_balance: dec!(100000),
                underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                    underlying: "BTC".to_string(),
                    spot_price: spot_dec,
                    executed_options: vec![
                        PortfolioMarginOptionExposure {
                            key: short_key.clone(),
                            expiry_years: dec!(0.25),
                            quantity: short_qty_dec,
                            entry_price: dec!(0),
                            source: SnapshotComponentKind::ExecutedPositions,
                        },
                        PortfolioMarginOptionExposure {
                            key: hedge_key.clone(),
                            expiry_years: dec!(0.25),
                            quantity: hedge_qty_dec,
                            entry_price: dec!(0),
                            source: SnapshotComponentKind::ExecutedPositions,
                        },
                    ],
                    hypothetical_open_order_options: Vec::new(),
                    executed_perps: Vec::new(),
                    hypothetical_open_order_perps: Vec::new(),
                }],
            };

            let hedged_market_state = PortfolioMarginMarketState {
                config: test_pm_config(),
                underlyings: HashMap::from([(
                    "BTC".to_string(),
                    PortfolioMarginUnderlyingMarketState {
                        spot_price: spot,
                        option_inputs: HashMap::from([
                            (short_key, PortfolioMarginOptionMarketState { implied_volatility: iv }),
                            (hedge_key, PortfolioMarginOptionMarketState { implied_volatility: iv }),
                        ]),
                        funding: None,
                    },
                )]),
            };

            let hedged_risk = calculate_scanning_risk(&hedged_snapshot, &hedged_market_state, &scenarios)
                .expect("hedged risk should compute");

            prop_assert!(
                hedged_risk <= naked_risk + 1e-6,
                "hedge increased risk: naked={} hedged={} (spot={} qty={} hedge_ratio={})",
                naked_risk, hedged_risk, spot, short_qty, hedge_ratio
            );
        }

    // ===== Property 6: Contingency non-negativity =====

        #[test]
        fn contingency_margins_are_non_negative(
            spot in 10.0f64..200000.0,
            quantity in -50.0f64..50.0,
            near_expiry in prop::bool::ANY,
        ) {
            let spot_dec = Decimal::from_f64_retain(spot).unwrap();
            let quantity_dec = Decimal::from_f64_retain(quantity).unwrap();
            let expiry_ts = if near_expiry {
                FIXED_NOW_TS + 12 * 3600
            } else {
                FAR_EXPIRY_TS
            };

            let snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(203),
                cash_balance: dec!(100000),
                underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                    underlying: "BTC".to_string(),
                    spot_price: spot_dec,
                    executed_options: vec![PortfolioMarginOptionExposure {
                        key: PortfolioMarginOptionKey {
                            underlying: "BTC".to_string(),
                            option_type: OptionType::Call,
                            strike: spot_dec,
                            expiry_ts,
                        },
                        expiry_years: dec!(0.01),
                        quantity: quantity_dec,
                        entry_price: dec!(0),
                        source: SnapshotComponentKind::ExecutedPositions,
                    }],
                    hypothetical_open_order_options: Vec::new(),
                    executed_perps: Vec::new(),
                    hypothetical_open_order_perps: Vec::new(),
                }],
            };

            let config = test_pm_config();
            let contingency = calculate_contingency_margin_at(&snapshot, &config, FIXED_NOW_TS)
                .expect("contingency should compute");

            prop_assert!(
                contingency.option_floor >= 0.0,
                "option_floor was {} for spot={} qty={}",
                contingency.option_floor, spot, quantity
            );
            prop_assert!(
                contingency.gamma_overlay >= 0.0,
                "gamma_overlay was {} for spot={} qty={}",
                contingency.gamma_overlay, spot, quantity
            );
        }

    // ===== Property 7: IM >= MM always =====

        #[test]
        fn im_always_gte_mm(
            spot in 100.0f64..100000.0,
            quantity in -10.0f64..10.0,
            iv in 0.1f64..3.0,
        ) {
            prop_assume!(quantity.abs() > 0.001);
            let strike = spot * 1.1;
            let (snapshot, market_state) = make_option_snapshot(spot, strike, quantity, iv);

            let result = super::compute_span_margin_at(&snapshot, &market_state, FIXED_NOW_TS)
                .expect("span margin should compute");

            prop_assert!(
                result.initial_margin_required >= result.maintenance_margin_required,
                "IM ({}) < MM ({}) for spot={} qty={} iv={}",
                result.initial_margin_required, result.maintenance_margin_required,
                spot, quantity, iv
            );
        }

    // ===== Property 8: PM floor property =====

        #[test]
        fn pm_never_drops_below_contingency_floor(
            spot in 100.0f64..100000.0,
            quantity in -10.0f64..-0.01,
            iv in 0.1f64..3.0,
        ) {
            let strike = spot;
            let (snapshot, market_state) = make_option_snapshot(spot, strike, quantity, iv);

            let result = super::compute_span_margin_at(&snapshot, &market_state, FIXED_NOW_TS)
                .expect("span margin should compute");

            let im_f64 = result.initial_margin_required.to_string().parse::<f64>().unwrap();
            let floor_f64 = result.option_floor.to_string().parse::<f64>().unwrap();

            prop_assert!(
                im_f64 >= floor_f64 - 1e-6,
                "IM ({}) dropped below option floor ({}) for spot={} qty={} iv={}",
                im_f64, floor_f64, spot, quantity, iv
            );
        }
    }
}

// ===== Property 9-10: Black-Scholes bounds =====

#[cfg(test)]
mod bs_proptest_properties {
    use super::black_scholes::{black_scholes, black_scholes_with_moments};
    use super::types::OptionType;
    use proptest::prelude::*;

    proptest! {
        #![proptest_config(ProptestConfig::with_cases(1024))]

    // ===== Property 9: Call price in [0, spot] =====

        #[test]
        fn call_price_bounded_by_spot(
            spot in 1.0f64..200000.0,
            strike in 1.0f64..400000.0,
            time in 0.001f64..5.0,
            vol in 0.01f64..5.0,
            rate in 0.0f64..0.2,
        ) {
            let price = black_scholes(&OptionType::Call, spot, strike, time, rate, vol);

            prop_assert!(
                price >= -1e-10,
                "call price {} < 0 for spot={} strike={} t={} vol={} r={}",
                price, spot, strike, time, vol, rate
            );
            prop_assert!(
                price <= spot + 1e-10,
                "call price {} > spot {} for strike={} t={} vol={} r={}",
                price, spot, strike, time, vol, rate
            );
        }

    // ===== Property 10: Put price in [0, strike * exp(-rT)] =====

        #[test]
        fn put_price_bounded_by_discounted_strike(
            spot in 1.0f64..200000.0,
            strike in 1.0f64..400000.0,
            time in 0.001f64..5.0,
            vol in 0.01f64..5.0,
            rate in 0.0f64..0.2,
        ) {
            let price = black_scholes(&OptionType::Put, spot, strike, time, rate, vol);
            let upper = strike * (-rate * time).exp();

            prop_assert!(
                price >= -1e-10,
                "put price {} < 0 for spot={} strike={} t={} vol={} r={}",
                price, spot, strike, time, vol, rate
            );
            prop_assert!(
                price <= upper + 1e-10,
                "put price {} > discounted strike {} for spot={} strike={} t={} vol={} r={}",
                price, upper, spot, strike, time, vol, rate
            );
        }

    // ===== Edgeworth-adjusted BS respects no-arbitrage bounds =====
    //
    // The Edgeworth expansion can produce raw prices outside [0, spot] or
    // [0, K*exp(-rT)] for large moment adjustments. We clamp in the pricing
    // function to enforce no-arbitrage bounds. This test covers the full
    // parameter space to verify the clamp works.

        #[test]
        fn moment_adjusted_call_bounded(
            spot in 1.0f64..100000.0,
            strike in 1.0f64..200000.0,
            time in 0.001f64..2.0,
            vol in 0.1f64..3.0,
            skew in -1.0f64..1.0,
            kurtosis in -1.0f64..3.0,
        ) {
            let price = black_scholes_with_moments(
                &OptionType::Call, spot, strike, time, 0.05, vol, skew, kurtosis,
            );

            prop_assert!(
                price >= 0.0,
                "moment-adjusted call {} < 0 for spot={} strike={} skew={} kurt={}",
                price, spot, strike, skew, kurtosis
            );
            prop_assert!(
                price <= spot,
                "moment-adjusted call {} > spot {} for strike={} skew={} kurt={}",
                price, spot, strike, skew, kurtosis
            );
        }

        #[test]
        fn moment_adjusted_put_bounded(
            spot in 1.0f64..100000.0,
            strike in 1.0f64..200000.0,
            time in 0.001f64..2.0,
            vol in 0.1f64..3.0,
            skew in -1.0f64..1.0,
            kurtosis in -1.0f64..3.0,
        ) {
            let price = black_scholes_with_moments(
                &OptionType::Put, spot, strike, time, 0.05, vol, skew, kurtosis,
            );
            let upper = strike * (-0.05f64 * time).exp();

            prop_assert!(
                price >= 0.0,
                "moment-adjusted put {} < 0 for spot={} strike={} skew={} kurt={}",
                price, spot, strike, skew, kurtosis
            );
            prop_assert!(
                price <= upper,
                "moment-adjusted put {} > discounted strike {} for spot={} strike={} skew={} kurt={}",
                price, upper, spot, strike, skew, kurtosis
            );
        }
    }
}

// ===== Property 11: Equity additivity =====

#[cfg(test)]
mod equity_proptest_properties {
    use super::portfolio::config::*;
    use super::portfolio::equity::{calculate_net_option_upnl, calculate_net_perp_upnl};
    use super::portfolio::snapshot::*;
    use super::types::OptionType;
    use hypercall_types::wallet_address::test_wallet;
    use proptest::prelude::*;
    use rust_decimal::Decimal;
    use rust_decimal_macros::dec;
    use std::collections::HashMap;

    const FIXED_NOW_TS: i64 = 1_700_000_000;
    const FAR_EXPIRY_TS: i64 = FIXED_NOW_TS + 90 * 24 * 3600;

    fn test_pm_config() -> PortfolioMarginConfig {
        PortfolioMarginConfig {
            base_grid: PortfolioMarginGridConfig {
                scenarios: PortfolioMarginScenario::finalized_default_grid(),
                base_volatility: 0.8,
                base_skew: 0.0,
                base_excess_kurtosis: 0.0,
                delta_threshold: 0.0001,
                strike_match_tolerance: 0.01,
                expiry_match_tolerance_years: 0.001,
            },
            symbol_overrides: Vec::new(),
            contingency: PortfolioMarginContingencyConfig::finalized_default(),
            risk_free_rate: 0.05,
        }
    }

    proptest! {
        #![proptest_config(ProptestConfig::with_cases(256))]

        #[test]
        fn equity_equals_cash_plus_option_upnl_plus_perp_upnl(
            cash in 1000.0f64..1000000.0,
            spot in 100.0f64..100000.0,
            opt_quantity in -10.0f64..10.0,
            perp_quantity in -10.0f64..10.0,
            iv in 0.3f64..2.0,
        ) {
            prop_assume!(opt_quantity.abs() > 0.001);

            let spot_dec = Decimal::from_f64_retain(spot).unwrap();
            let cash_dec = Decimal::from_f64_retain(cash).unwrap();
            let opt_qty_dec = Decimal::from_f64_retain(opt_quantity).unwrap();
            let perp_qty_dec = Decimal::from_f64_retain(perp_quantity).unwrap();

            let strike = spot * 1.1;
            let strike_dec = Decimal::from_f64_retain(strike).unwrap();

            let key = PortfolioMarginOptionKey {
                underlying: "BTC".to_string(),
                option_type: OptionType::Call,
                strike: strike_dec,
                expiry_ts: FAR_EXPIRY_TS,
            };

            let snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(204),
                cash_balance: cash_dec,
                underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                    underlying: "BTC".to_string(),
                    spot_price: spot_dec,
                    executed_options: vec![PortfolioMarginOptionExposure {
                        key: key.clone(),
                        expiry_years: dec!(0.25),
                        quantity: opt_qty_dec,
                        entry_price: dec!(100),
                        source: SnapshotComponentKind::ExecutedPositions,
                    }],
                    hypothetical_open_order_options: Vec::new(),
                    executed_perps: vec![PortfolioMarginPerpExposure {
                        underlying: "BTC".to_string(),
                        quantity: perp_qty_dec,
                        entry_price: Some(spot_dec),
                        unrealized_pnl: dec!(0),
                    }],
                    hypothetical_open_order_perps: Vec::new(),
                }],
            };

            let market_state = PortfolioMarginMarketState {
                config: test_pm_config(),
                underlyings: HashMap::from([(
                    "BTC".to_string(),
                    PortfolioMarginUnderlyingMarketState {
                        spot_price: spot,
                        option_inputs: HashMap::from([(
                            key,
                            PortfolioMarginOptionMarketState { implied_volatility: iv },
                        )]),
                        funding: None,
                    },
                )]),
            };

            let result = super::compute_span_margin_at(&snapshot, &market_state, FIXED_NOW_TS)
                .expect("span margin should compute");

            let option_upnl = calculate_net_option_upnl(&snapshot, &market_state)
                .expect("option upnl should compute");
            let perp_upnl = calculate_net_perp_upnl(&snapshot, &market_state)
                .expect("perp upnl should compute");

            let expected_equity = cash + option_upnl + perp_upnl;
            let actual_equity: f64 = result.equity.to_string().parse().unwrap();

            prop_assert!(
                (actual_equity - expected_equity).abs() < 1e-4,
                "equity mismatch: actual={} expected=cash({})+opt_upnl({})+perp_upnl({})={}",
                actual_equity, cash, option_upnl, perp_upnl, expected_equity
            );
        }
    }
}

// ===== Properties 12-18: SPAN structural invariants =====

#[cfg(test)]
mod span_structural_properties {
    use super::black_scholes::black_scholes_with_moments;
    use super::portfolio::config::*;
    use super::portfolio::contingency::calculate_contingency_margin_at;
    use super::portfolio::evaluator::{calculate_scanning_risk, calculate_scenario_pnl};
    use super::portfolio::snapshot::*;
    use super::types::OptionType;
    use hypercall_types::wallet_address::test_wallet;
    use proptest::prelude::*;
    use rust_decimal::Decimal;
    use rust_decimal_macros::dec;
    use std::collections::HashMap;

    const FIXED_NOW_TS: i64 = 1_700_000_000;
    const FAR_EXPIRY_TS: i64 = FIXED_NOW_TS + 90 * 24 * 3600;

    fn test_pm_config() -> PortfolioMarginConfig {
        PortfolioMarginConfig {
            base_grid: PortfolioMarginGridConfig {
                scenarios: PortfolioMarginScenario::finalized_default_grid(),
                base_volatility: 0.8,
                base_skew: 0.0,
                base_excess_kurtosis: 0.0,
                delta_threshold: 0.0001,
                strike_match_tolerance: 0.01,
                expiry_match_tolerance_years: 0.001,
            },
            symbol_overrides: Vec::new(),
            contingency: PortfolioMarginContingencyConfig::finalized_default(),
            risk_free_rate: 0.05,
        }
    }

    fn make_option_key(
        underlying: &str,
        option_type: OptionType,
        strike: Decimal,
    ) -> PortfolioMarginOptionKey {
        PortfolioMarginOptionKey {
            underlying: underlying.to_string(),
            option_type,
            strike,
            expiry_ts: FAR_EXPIRY_TS,
        }
    }

    proptest! {
        #![proptest_config(ProptestConfig::with_cases(256))]

    // ===== Property 12: Put-call parity under scenarios =====
    // For each scenario: call_pnl - put_pnl ~= perp_pnl (at same strike/expiry).
    // This verifies the BS repricing is internally consistent across option types.

        #[test]
        fn put_call_parity_under_scenarios(
            spot in 100.0f64..50000.0,
            strike_ratio in 0.8f64..1.2,
            iv in 0.3f64..1.5,
        ) {
            let strike = spot * strike_ratio;
            let spot_dec = Decimal::from_f64_retain(spot).unwrap();
            let strike_dec = Decimal::from_f64_retain(strike).unwrap();

            let call_key = make_option_key("BTC", OptionType::Call, strike_dec);
            let put_key = make_option_key("BTC", OptionType::Put, strike_dec);

            let call_snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(210),
                cash_balance: dec!(0),
                underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                    underlying: "BTC".to_string(),
                    spot_price: spot_dec,
                    executed_options: vec![PortfolioMarginOptionExposure {
                        key: call_key.clone(),
                        expiry_years: dec!(0.25),
                        quantity: dec!(1),
                        entry_price: dec!(0),
                        source: SnapshotComponentKind::ExecutedPositions,
                    }],
                    hypothetical_open_order_options: Vec::new(),
                    executed_perps: Vec::new(),
                    hypothetical_open_order_perps: Vec::new(),
                }],
            };

            let put_snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(211),
                cash_balance: dec!(0),
                underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                    underlying: "BTC".to_string(),
                    spot_price: spot_dec,
                    executed_options: vec![PortfolioMarginOptionExposure {
                        key: put_key.clone(),
                        expiry_years: dec!(0.25),
                        quantity: dec!(-1),
                        entry_price: dec!(0),
                        source: SnapshotComponentKind::ExecutedPositions,
                    }],
                    hypothetical_open_order_options: Vec::new(),
                    executed_perps: Vec::new(),
                    hypothetical_open_order_perps: Vec::new(),
                }],
            };

            let perp_snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(212),
                cash_balance: dec!(0),
                underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                    underlying: "BTC".to_string(),
                    spot_price: spot_dec,
                    executed_options: Vec::new(),
                    hypothetical_open_order_options: Vec::new(),
                    executed_perps: vec![PortfolioMarginPerpExposure {
                        underlying: "BTC".to_string(),
                        quantity: dec!(1),
                        entry_price: None,
                        unrealized_pnl: dec!(0),
                    }],
                    hypothetical_open_order_perps: Vec::new(),
                }],
            };

            let market_state = PortfolioMarginMarketState {
                config: test_pm_config(),
                underlyings: HashMap::from([(
                    "BTC".to_string(),
                    PortfolioMarginUnderlyingMarketState {
                        spot_price: spot,
                        option_inputs: HashMap::from([
                            (call_key, PortfolioMarginOptionMarketState { implied_volatility: iv }),
                            (put_key, PortfolioMarginOptionMarketState { implied_volatility: iv }),
                        ]),
                        funding: None,
                    },
                )]),
            };

            // Test on a pure spot-only scenario (no vol shock) where parity is exact
            let scenario = PortfolioMarginScenario {
                id: "parity".to_string(),
                spot_shock_pct: 0.10,
                vol_shock_pct: 0.0,
                pnl_weight: 1.0,
                is_tail: false,
            };

            let call_pnl = calculate_scenario_pnl(&call_snapshot, &market_state, &scenario)
                .expect("call pnl");
            let put_pnl = calculate_scenario_pnl(&put_snapshot, &market_state, &scenario)
                .expect("put pnl");
            let perp_pnl = calculate_scenario_pnl(&perp_snapshot, &market_state, &scenario)
                .expect("perp pnl");

            // long call + short put = synthetic long ~= perp for spot-only shock
            let synthetic_pnl = call_pnl + put_pnl;
            let tolerance = spot * 0.02; // 2% of spot for time value / rate effects
            prop_assert!(
                (synthetic_pnl - perp_pnl).abs() < tolerance,
                "put-call parity violated: call_pnl={} + put_pnl(short)={} = {} vs perp_pnl={} (spot={} strike={})",
                call_pnl, put_pnl, synthetic_pnl, perp_pnl, spot, strike
            );
        }

    // ===== Property 13: Cross-underlying independence =====
    // margin(BTC + ETH) == margin(BTC) + margin(ETH) -- no cross-netting.

        #[test]
        fn cross_underlying_margin_is_additive(
            btc_spot in 10000.0f64..100000.0,
            eth_spot in 1000.0f64..10000.0,
            btc_qty in -5.0f64..5.0,
            eth_qty in -5.0f64..5.0,
            iv in 0.3f64..1.5,
        ) {
            prop_assume!(btc_qty.abs() > 0.01 && eth_qty.abs() > 0.01);

            let btc_spot_dec = Decimal::from_f64_retain(btc_spot).unwrap();
            let eth_spot_dec = Decimal::from_f64_retain(eth_spot).unwrap();
            let btc_strike_dec = Decimal::from_f64_retain(btc_spot * 1.1).unwrap();
            let eth_strike_dec = Decimal::from_f64_retain(eth_spot * 1.1).unwrap();
            let btc_qty_dec = Decimal::from_f64_retain(btc_qty).unwrap();
            let eth_qty_dec = Decimal::from_f64_retain(eth_qty).unwrap();

            let btc_key = make_option_key("BTC", OptionType::Call, btc_strike_dec);
            let eth_key = make_option_key("ETH", OptionType::Call, eth_strike_dec);

            // Combined portfolio
            let combined = PortfolioMarginSnapshot {
                wallet: test_wallet(220),
                cash_balance: dec!(0),
                underlyings: vec![
                    PortfolioMarginUnderlyingSnapshot {
                        underlying: "BTC".to_string(),
                        spot_price: btc_spot_dec,
                        executed_options: vec![PortfolioMarginOptionExposure {
                            key: btc_key.clone(), expiry_years: dec!(0.25),
                            quantity: btc_qty_dec, entry_price: dec!(0),
                            source: SnapshotComponentKind::ExecutedPositions,
                        }],
                        hypothetical_open_order_options: Vec::new(),
                        executed_perps: Vec::new(),
                        hypothetical_open_order_perps: Vec::new(),
                    },
                    PortfolioMarginUnderlyingSnapshot {
                        underlying: "ETH".to_string(),
                        spot_price: eth_spot_dec,
                        executed_options: vec![PortfolioMarginOptionExposure {
                            key: eth_key.clone(), expiry_years: dec!(0.25),
                            quantity: eth_qty_dec, entry_price: dec!(0),
                            source: SnapshotComponentKind::ExecutedPositions,
                        }],
                        hypothetical_open_order_options: Vec::new(),
                        executed_perps: Vec::new(),
                        hypothetical_open_order_perps: Vec::new(),
                    },
                ],
            };

            // BTC only
            let btc_only = PortfolioMarginSnapshot {
                wallet: test_wallet(221),
                cash_balance: dec!(0),
                underlyings: vec![combined.underlyings[0].clone()],
            };

            // ETH only
            let eth_only = PortfolioMarginSnapshot {
                wallet: test_wallet(222),
                cash_balance: dec!(0),
                underlyings: vec![combined.underlyings[1].clone()],
            };

            let combined_ms = PortfolioMarginMarketState {
                config: test_pm_config(),
                underlyings: HashMap::from([
                    ("BTC".to_string(), PortfolioMarginUnderlyingMarketState {
                        spot_price: btc_spot,
                        option_inputs: HashMap::from([(btc_key.clone(), PortfolioMarginOptionMarketState { implied_volatility: iv })]),
                        funding: None,
                    }),
                    ("ETH".to_string(), PortfolioMarginUnderlyingMarketState {
                        spot_price: eth_spot,
                        option_inputs: HashMap::from([(eth_key.clone(), PortfolioMarginOptionMarketState { implied_volatility: iv })]),
                        funding: None,
                    }),
                ]),
            };

            let btc_ms = PortfolioMarginMarketState {
                config: test_pm_config(),
                underlyings: HashMap::from([
                    ("BTC".to_string(), PortfolioMarginUnderlyingMarketState {
                        spot_price: btc_spot,
                        option_inputs: HashMap::from([(btc_key, PortfolioMarginOptionMarketState { implied_volatility: iv })]),
                        funding: None,
                    }),
                ]),
            };

            let eth_ms = PortfolioMarginMarketState {
                config: test_pm_config(),
                underlyings: HashMap::from([
                    ("ETH".to_string(), PortfolioMarginUnderlyingMarketState {
                        spot_price: eth_spot,
                        option_inputs: HashMap::from([(eth_key, PortfolioMarginOptionMarketState { implied_volatility: iv })]),
                        funding: None,
                    }),
                ]),
            };

            let scenarios = super::generate_scenarios(&combined_ms);

            let combined_risk = calculate_scanning_risk(&combined, &combined_ms, &scenarios).unwrap();
            let btc_risk = calculate_scanning_risk(&btc_only, &btc_ms, &scenarios).unwrap();
            let eth_risk = calculate_scanning_risk(&eth_only, &eth_ms, &scenarios).unwrap();

            // Scanning risk picks the worst scenario globally, so combined can be
            // <= sum (the worst scenario for BTC may not be worst for ETH).
            // But combined should never EXCEED the sum -- that would mean cross-netting
            // is somehow amplifying risk.
            prop_assert!(
                combined_risk <= btc_risk + eth_risk + 1e-6,
                "cross-underlying amplification: combined={} > btc({}) + eth({}) = {}",
                combined_risk, btc_risk, eth_risk, btc_risk + eth_risk
            );
        }

    // ===== Property 14: Open order toggle correctness =====
    // Disabling open order contingency should never increase margin.

        #[test]
        fn disabling_open_order_contingency_never_increases_margin(
            spot in 100.0f64..100000.0,
            quantity in -10.0f64..-0.01,
            near_expiry in prop::bool::ANY,
        ) {
            let spot_dec = Decimal::from_f64_retain(spot).unwrap();
            let qty_dec = Decimal::from_f64_retain(quantity).unwrap();
            let expiry_ts = if near_expiry { FIXED_NOW_TS + 12 * 3600 } else { FAR_EXPIRY_TS };

            let snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(230),
                cash_balance: dec!(100000),
                underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                    underlying: "BTC".to_string(),
                    spot_price: spot_dec,
                    executed_options: Vec::new(),
                    hypothetical_open_order_options: vec![PortfolioMarginOptionExposure {
                        key: PortfolioMarginOptionKey {
                            underlying: "BTC".to_string(),
                            option_type: OptionType::Call,
                            strike: spot_dec,
                            expiry_ts,
                        },
                        expiry_years: dec!(0.01),
                        quantity: qty_dec,
                        entry_price: dec!(0),
                        source: SnapshotComponentKind::OpenOrders,
                    }],
                    executed_perps: Vec::new(),
                    hypothetical_open_order_perps: Vec::new(),
                }],
            };

            let enabled_config = test_pm_config();
            let mut disabled_config = test_pm_config();
            disabled_config.contingency.apply_floor_to_open_orders = false;
            disabled_config.contingency.apply_gamma_to_open_orders = false;

            let enabled = calculate_contingency_margin_at(&snapshot, &enabled_config, FIXED_NOW_TS).unwrap();
            let disabled = calculate_contingency_margin_at(&snapshot, &disabled_config, FIXED_NOW_TS).unwrap();

            prop_assert!(
                disabled.option_floor <= enabled.option_floor + 1e-10,
                "disabling floor toggle increased floor: disabled={} > enabled={}",
                disabled.option_floor, enabled.option_floor
            );
            prop_assert!(
                disabled.gamma_overlay <= enabled.gamma_overlay + 1e-10,
                "disabling gamma toggle increased gamma: disabled={} > enabled={}",
                disabled.gamma_overlay, enabled.gamma_overlay
            );
        }

    // ===== Property 15: Idempotency =====
    // Same input produces identical output across two calls.

        #[test]
        fn span_margin_is_idempotent(
            spot in 100.0f64..100000.0,
            quantity in -10.0f64..10.0,
            iv in 0.3f64..2.0,
        ) {
            prop_assume!(quantity.abs() > 0.001);

            let spot_dec = Decimal::from_f64_retain(spot).unwrap();
            let strike_dec = Decimal::from_f64_retain(spot * 1.1).unwrap();
            let qty_dec = Decimal::from_f64_retain(quantity).unwrap();
            let key = make_option_key("BTC", OptionType::Call, strike_dec);

            let snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(240),
                cash_balance: dec!(50000),
                underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                    underlying: "BTC".to_string(),
                    spot_price: spot_dec,
                    executed_options: vec![PortfolioMarginOptionExposure {
                        key: key.clone(), expiry_years: dec!(0.25),
                        quantity: qty_dec, entry_price: dec!(100),
                        source: SnapshotComponentKind::ExecutedPositions,
                    }],
                    hypothetical_open_order_options: Vec::new(),
                    executed_perps: Vec::new(),
                    hypothetical_open_order_perps: Vec::new(),
                }],
            };

            let market_state = PortfolioMarginMarketState {
                config: test_pm_config(),
                underlyings: HashMap::from([(
                    "BTC".to_string(),
                    PortfolioMarginUnderlyingMarketState {
                        spot_price: spot,
                        option_inputs: HashMap::from([(key, PortfolioMarginOptionMarketState { implied_volatility: iv })]),
                        funding: None,
                    },
                )]),
            };

            let r1 = super::compute_span_margin_at(&snapshot, &market_state, FIXED_NOW_TS).unwrap();
            let r2 = super::compute_span_margin_at(&snapshot, &market_state, FIXED_NOW_TS).unwrap();

            prop_assert_eq!(r1.scanning_risk, r2.scanning_risk, "scanning_risk differs between calls");
            prop_assert_eq!(r1.option_floor, r2.option_floor, "option_floor differs between calls");
            prop_assert_eq!(r1.gamma_overlay, r2.gamma_overlay, "gamma_overlay differs between calls");
            prop_assert_eq!(r1.equity, r2.equity, "equity differs between calls");
            prop_assert_eq!(r1.initial_margin_required, r2.initial_margin_required, "IM differs between calls");
            prop_assert_eq!(r1.maintenance_margin_required, r2.maintenance_margin_required, "MM differs between calls");
        }

    // ===== Property 16: Empty portfolio produces zero margin =====

        #[test]
        fn empty_portfolio_zero_margin(
            cash in 0.0f64..1000000.0,
        ) {
            let cash_dec = Decimal::from_f64_retain(cash).unwrap();
            let snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(250),
                cash_balance: cash_dec,
                underlyings: Vec::new(),
            };

            let market_state = PortfolioMarginMarketState {
                config: test_pm_config(),
                underlyings: HashMap::new(),
            };

            let scenarios = super::generate_scenarios(&market_state);
            let scanning_risk = calculate_scanning_risk(&snapshot, &market_state, &scenarios).unwrap();
            let contingency = calculate_contingency_margin_at(&snapshot, &market_state.config, FIXED_NOW_TS).unwrap();

            prop_assert_eq!(scanning_risk, 0.0, "empty portfolio has non-zero scanning risk");
            prop_assert_eq!(contingency.option_floor, 0.0, "empty portfolio has non-zero floor");
            prop_assert_eq!(contingency.gamma_overlay, 0.0, "empty portfolio has non-zero gamma");
        }

    // ===== Property 17: Standard vs PM directional consistency for naked short =====
    // For a single naked short option with no hedges, PM scanning risk should
    // not be dramatically lower than standard margin IM. We check PM >= 20% of
    // standard IM -- a very loose bound that catches gross miscalculations.

        #[test]
        fn pm_not_dramatically_below_standard_for_naked_short(
            spot in 1000.0f64..100000.0,
            strike_ratio in 0.9f64..1.1,
            iv in 0.3f64..1.5,
        ) {
            let strike = spot * strike_ratio;
            let spot_dec = Decimal::from_f64_retain(spot).unwrap();
            let strike_dec = Decimal::from_f64_retain(strike).unwrap();
            let key = make_option_key("BTC", OptionType::Call, strike_dec);

            // Standard margin for 1 short call
            let std_service = super::StandardMarginService::new();
            let mut std_account = super::StandardAccount::new("test".to_string(), dec!(1000000));
            std_account.option_positions.push(super::OptionPosition {
                symbol: "BTC-C".to_string(),
                underlying: "BTC".to_string(),
                expiry_ts: FAR_EXPIRY_TS,
                strike: strike_dec,
                is_call: true,
                size: dec!(-1),
                mark_price: dec!(0),
                entry_price: dec!(0),
                spot_price: spot_dec,
            });
            let std_result = std_service.compute_margin(&std_account);
            let std_im: f64 = std_result.position_im.to_string().parse().unwrap();

            // PM scanning risk for same position
            let snapshot = PortfolioMarginSnapshot {
                wallet: test_wallet(250),
                cash_balance: dec!(1000000),
                underlyings: vec![PortfolioMarginUnderlyingSnapshot {
                    underlying: "BTC".to_string(),
                    spot_price: spot_dec,
                    executed_options: vec![PortfolioMarginOptionExposure {
                        key: key.clone(), expiry_years: dec!(0.25),
                        quantity: dec!(-1), entry_price: dec!(0),
                        source: SnapshotComponentKind::ExecutedPositions,
                    }],
                    hypothetical_open_order_options: Vec::new(),
                    executed_perps: Vec::new(),
                    hypothetical_open_order_perps: Vec::new(),
                }],
            };

            let market_state = PortfolioMarginMarketState {
                config: test_pm_config(),
                underlyings: HashMap::from([(
                    "BTC".to_string(),
                    PortfolioMarginUnderlyingMarketState {
                        spot_price: spot,
                        option_inputs: HashMap::from([(key, PortfolioMarginOptionMarketState { implied_volatility: iv })]),
                        funding: None,
                    },
                )]),
            };

            let pm_result = super::compute_span_margin_at(&snapshot, &market_state, FIXED_NOW_TS).unwrap();
            let pm_im: f64 = pm_result.initial_margin_required.to_string().parse().unwrap();

            // PM can legitimately be lower (scenario-based vs flat %), but shouldn't
            // be dramatically lower. 20% floor is very loose.
            prop_assert!(
                pm_im >= std_im * 0.20 - 1.0,
                "PM margin ({}) is <20% of standard margin ({}) for naked short at spot={} strike={}",
                pm_im, std_im, spot, strike
            );
        }

    // ===== Property 18: BS put-call parity (vanilla, exact) =====
    // C - P = S - K*exp(-rT), verifying the pricing kernel itself.

        #[test]
        fn bs_put_call_parity_exact(
            spot in 10.0f64..100000.0,
            strike in 10.0f64..200000.0,
            time in 0.01f64..3.0,
            vol in 0.05f64..3.0,
            rate in 0.0f64..0.15,
        ) {
            let call = black_scholes_with_moments(
                &OptionType::Call, spot, strike, time, rate, vol, 0.0, 0.0,
            );
            let put = black_scholes_with_moments(
                &OptionType::Put, spot, strike, time, rate, vol, 0.0, 0.0,
            );
            let forward = spot - strike * (-rate * time).exp();

            let diff = (call - put) - forward;
            let tolerance = spot * 1e-10;
            prop_assert!(
                diff.abs() < tolerance,
                "put-call parity violated: C({}) - P({}) = {} but S - K*exp(-rT) = {} (diff={})",
                call, put, call - put, forward, diff
            );
        }
    }
}