Quest 12

Simulate a long call strategy over 30 days

Write a Python simulator: buy a 7-DTE ATM call on momentum, hold for 5 days or until +50%/−50%. How does it perform?

Lesson

A minimal options simulator

We'll use a toy option pricer (Black-Scholes-ish) where:

Delta ≈ (spot − strike) / strike_range or fixed 0.5 for ATM
Theta ≈ −premium / days_to_expiry (linear decay approximation — real theta is non-linear)
Option premium ≈ max(intrinsic, extrinsic_value)

Not accurate enough for real trading, but captures the SHAPE of option P&L:

Theta eats extrinsic daily
Spot moves drive intrinsic
Premium floor is intrinsic value

Strategy to simulate

1. Every day, check momentum: today's close > 5-day moving average 2. If momentum + no open position → buy a 7-DTE ATM call for ~$3.00 3. Each day, compute P&L = (intrinsic_today − intrinsic_yesterday) + theta 4. Exit if: P&L >= 50% of cost OR P&L <= −50% OR DTE == 1

Your task

Fill in the theta decay and the entry condition. The framework runs your code.

pythonEdit below, click Run tests

bars = load_dataset("BTC_DAILY_2024")
closes = [b["close"] for b in bars]

# Toy option pricer — approximation only
def option_premium(spot, strike, dte_days, base_iv=0.5):
    intrinsic = max(0, spot - strike)  # long call
    # Extrinsic = rough function of DTE × IV × sqrt-ish
    extrinsic = spot * base_iv * (dte_days / 365) ** 0.5
    return intrinsic + extrinsic

def sma(values, period):
    if len(values) < period: return None
    return sum(values[-period:]) / period

# Simulate
starting_cash = 1000
cash = starting_cash
position = None  # dict with entry_spot, strike, entry_premium, entry_day, dte
trades = []

for day, close in enumerate(closes):
    ma = sma(closes[:day + 1], 5)
    if ma is None:
        continue

if position is None:
        # TODO: buy if close > ma (momentum)
        if close > ma:
            # Buy ATM call: strike = close, DTE = 7
            strike = close
            premium = option_premium(close, strike, 7)
            if cash >= premium * 100:
                position = {
                    "entry_spot": close, "strike": strike, "entry_premium": premium,
                    "entry_day": day, "expiry_day": day + 7,
                }
                cash -= premium * 100
    else:
        dte = position["expiry_day"] - day
        if dte <= 0:
            # At expiry, intrinsic only
            exit_premium = max(0, close - position["strike"])
        else:
            exit_premium = option_premium(close, position["strike"], dte)
        pnl_pct = (exit_premium - position["entry_premium"]) / position["entry_premium"] if position["entry_premium"] > 0 else 0
        # TODO: exit if pnl_pct >= 0.5 OR pnl_pct <= -0.5 OR dte <= 1
        should_exit = False
        if pnl_pct >= 0.5 or pnl_pct <= -0.5 or dte <= 1:
            should_exit = True
        if should_exit:
            cash += exit_premium * 100
            trades.append({"pnl_pct": pnl_pct, "dte_at_exit": dte})
            position = None

final_equity = cash + (0 if position is None else option_premium(closes[-1], position["strike"], max(0, position["expiry_day"] - len(closes) + 1)) * 100)
wins = sum(1 for t in trades if t["pnl_pct"] > 0)
losses = len(trades) - wins
print(f"trades: {len(trades)} wins: {wins} losses: {losses}")
print(f"starting: ${starting_cash}, ending: ${final_equity:.2f}, PnL: {((final_equity - starting_cash) / starting_cash) * 100:.1f}%")

Algorithmic Trading