Options Trading Cheat Sheet: 252 Terms by Priority Level

This options trading cheat sheet covers all 252 terms you will encounter as a trader — organized by priority level so you learn in the right order, not alphabetically. Each entry includes a plain-language definition with concrete examples, plus pseudo code showing the underlying logic. If you are a developer, the pseudo code layer will make abstract options concepts click immediately — these mechanics map directly to conditionals, functions, and return values you already think in.

How to Use This Options Trading Cheat Sheet

Do not try to memorize all 252 terms at once. Work through each level in order. Move to the next level only when the current one feels automatic. This is a reference — bookmark it and return when a term appears in a broker platform, research report, or trading book.

Level 1: Foundation

These 40 terms are the minimum vocabulary for placing your first options trade. Learn them before anything else.

Option Contract A legal agreement giving the buyer the right — but not the obligation — to buy or sell 100 shares of an underlying asset at a specific price before a specific date. The seller (writer) takes on the obligation if the buyer chooses to exercise. One contract always controls 100 shares unless adjusted by a corporate action.

contract = {
    type:        CALL | PUT,
    underlying:  "AAPL",
    strike:      150.00,
    expiration:  "2026-07-18",
    multiplier:  100,         // 1 contract = 100 shares
    premium:     5.00         // cost per share
}

total_cost = contract.premium * contract.multiplier  // → $500

Call Option The right to buy 100 shares of the underlying at the strike price before expiration. You pay a premium for this right. If the stock rises above your strike, the call gains value. If it stays below your strike at expiration, the call expires worthless and you lose the premium paid.

call_payoff(stock_price, strike, premium_paid):
    intrinsic = MAX(0, stock_price - strike)
    net_profit = intrinsic - premium_paid
    RETURN net_profit * 100    // × 100 shares per contract

// Example: $150 call, stock at $165, paid $5 premium
call_payoff(165, 150, 5) → ($15 - $5) × 100 = $1,000 profit
call_payoff(145, 150, 5) → ($0  - $5) × 100 = -$500 loss (max loss)

Put Option The right to sell 100 shares of the underlying at the strike price before expiration. Puts gain value when the stock falls. A put buyer profits when the stock drops below the strike price. Often used as portfolio insurance or as a bearish directional trade.

put_payoff(stock_price, strike, premium_paid):
    intrinsic = MAX(0, strike - stock_price)
    net_profit = intrinsic - premium_paid
    RETURN net_profit * 100

// Example: $150 put, stock at $135, paid $4 premium
put_payoff(135, 150, 4) → ($15 - $4) × 100 = $1,100 profit
put_payoff(155, 150, 4) → ($0  - $4) × 100 = -$400 loss (max loss)

Underlying Asset The stock, ETF, index, or other security an option contract is based on. When you buy a call on AAPL, AAPL is the underlying. The underlying's price movement is the primary driver of the option's value.

// Option value is derived from the underlying
option_value = FUNCTION_OF(
    underlying_price,    // most important input
    strike_price,
    time_to_expiry,
    implied_volatility,
    risk_free_rate
)

// Without an underlying, option_value = UNDEFINED

Strike Price / Exercise Price The fixed price at which you can buy (call) or sell (put) the underlying. Strike price and exercise price are identical terms — exercise price is the older, formal name. The strike is set when you open the trade and never changes, even if the stock moves dramatically.

exercise_value(option_type, stock_price, strike):
    IF option_type == CALL:
        RETURN MAX(0, stock_price - strike)
    IF option_type == PUT:
        RETURN MAX(0, strike - stock_price)

// $150 strike call, stock at $160
exercise_value(CALL, 160, 150) → 10   // $10 per share intrinsic
exercise_value(CALL, 140, 150) → 0    // expires worthless

Expiration Date The last day an option can be exercised or traded. After this date, the option ceases to exist. For US equity options, expiration is typically the third Friday of the contract month (monthly) or any Friday (weekly). An option not exercised by expiration is automatically exercised if it is $0.01 or more in-the-money; otherwise it expires worthless.

is_valid(option, current_date):
    RETURN current_date <= option.expiration_date

// Days to expiration (DTE)
DTE = expiration_date - current_date  // in calendar days

// Time pressure increases as DTE → 0
time_urgency = 1 / MAX(DTE, 1)  // approaches infinity at expiry

Premium The price paid to buy an option, or received when selling one. Premium is quoted per share — multiply by 100 to get the total dollar amount for one contract. Premium has two components: intrinsic value (immediate exercise value) plus time value (remaining optionality).

premium = intrinsic_value + time_value

buyer_max_loss      = premium * 100   // 1 contract = 100 shares
seller_max_gain     = premium * 100

// Example: premium = $5.00
buyer_pays          = 5.00 * 100 = $500
seller_receives     = 5.00 * 100 = $500

Bid The highest price a buyer is currently willing to pay for an option contract. When you sell an option, you receive (at best) the bid price. Bid is always lower than the ask.

market = {
    bid: 4.90,   // you receive this when selling at market
    ask: 5.10,   // you pay this when buying at market
    mid: (4.90 + 5.10) / 2   // → $5.00
}

sell_proceeds = market.bid * 100  // → $490 per contract

Ask The lowest price a seller is willing to accept. When you buy an option, you pay the ask price (or negotiate toward the mid with a limit order). Ask is always higher than the bid.

buy_cost = market.ask * 100  // → $510 per contract

// Better approach: place a limit between bid and ask
limit_order = {
    type:   BUY,
    price:  4.95,     // between bid ($4.90) and ask ($5.10)
    status: PENDING   // fills only if ask drops to $4.95
}

Bid-Ask Spread The difference between the ask and bid price. Wide spreads mean higher transaction costs — you immediately lose the spread when entering a position. Liquid, high-volume options have tight spreads ($0.01–$0.05). Illiquid options can have spreads of $1.00 or more.

spread     = ask - bid                  // → $0.20
spread_pct = spread / mid_price * 100   // → 4% cost

round_trip_cost = spread * 100          // → $20 per contract (enter + exit)

// Rule of thumb: avoid options where spread > 10% of mid price
is_tradeable = spread_pct < 10

Volume The number of option contracts traded in a single session. High volume signals current interest and generally means tighter spreads. Volume resets to zero each day. Do not confuse with open interest — volume is today's activity, open interest is total existing positions.

daily_volume = COUNT(contracts_traded_today)

// Volume spike = unusual activity signal
is_unusual = daily_volume > (average_daily_volume * 2)

// Check volume at the specific strike — not just the underlying's total

Open Interest The total number of outstanding option contracts not yet closed or exercised. Unlike volume, open interest persists across sessions. It increases when new contracts are created and decreases when contracts are closed or exercised.

// Open interest changes:
open_interest += 1  // both buyer and seller are NEW (new contract created)
open_interest -= 1  // existing holder sells to existing short (net close)
open_interest -= 1  // option exercised

// OI stays SAME when existing holder sells to new buyer (transfer)
new_contract = buyer_is_new AND seller_is_new

Long Owning an option (you paid the premium). Long options have limited risk — max loss is the premium paid. Long calls profit from price increases. Long puts profit from price decreases.

long_position = {
    direction: BOUGHT,
    premium_paid: 5.00,
    max_loss:  premium_paid * 100,   // → $500, fixed and known
    max_gain:  UNLIMITED (long call) | (strike - premium) * 100 (long put)
}

Short / Writer Having sold an option (you received the premium). Short options have limited profit — max gain is the premium received — but potentially large or unlimited risk. Short calls on naked positions carry unlimited risk. Seller and writer are interchangeable terms.

short_position = {
    direction:        SOLD,
    premium_received: 5.00,
    max_gain:         premium_received * 100,  // → $500, fixed
    max_loss:         UNLIMITED (naked call) | (strike - premium) * 100 (put)
}

Buyer / Holder The person who paid the premium and holds the right to exercise. The buyer/holder has rights with no obligations. Buyer and holder are interchangeable — holder is more common in legal and regulatory contexts.

holder = {
    rights:      [EXERCISE, SELL_TO_CLOSE, LET_EXPIRE],
    obligations: NONE,
    capital_at_risk: premium_paid * contracts * 100
}

Exercise The act of using your option right — buying shares (call) or selling shares (put) at the strike price. Most options are never exercised; they are sold before expiration. Selling usually captures more value because it includes remaining time value, whereas exercising forfeits it.

// Should you exercise or sell the option?
exercise_value  = MAX(0, stock_price - strike)  // for call
sell_value      = option_market_price           // current premium

// Almost always: sell_value > exercise_value (time value remains)
decision = IF sell_value > exercise_value: SELL_TO_CLOSE
           ELSE: EXERCISE    // rarely better before expiry for calls

Assignment What happens to the seller when the buyer exercises. The seller is assigned and must deliver shares (short call assigned = sell 100 shares) or buy shares (short put assigned = buy 100 shares) at the strike price. Assignment can happen any time before expiration for American-style options.

on_assignment(writer_position):
    IF writer_position.type == SHORT_CALL:
        // Writer must SELL 100 shares at strike price
        sell_shares(quantity=100, price=strike)
    IF writer_position.type == SHORT_PUT:
        // Writer must BUY 100 shares at strike price
        buy_shares(quantity=100, price=strike)

// Early assignment risk is highest when the option is deep ITM
// or when a dividend is imminent (for calls)

American Style Options that can be exercised any time before expiration. Most US individual stock options and ETF options are American-style. The flexibility has value — American options are priced slightly higher than equivalent European options.

// American: exercise window is open for the full life of the contract
FOR each_day IN range(today, expiration_date):
    IF holder_chooses_to_exercise:
        execute_exercise()  // valid any day

// Early assignment risk for writers: present every single day
early_assignment_possible_any_day = TRUE

European Style Options that can only be exercised at expiration — not before. Most index options (SPX, NDX, RUT) are European-style. No early assignment risk for sellers. Cash-settled — no shares change hands, only the cash difference.

// European: exercise allowed only on expiration date
exercise_allowed(current_date, expiry_date):
    RETURN current_date == expiry_date

// Cash settlement — no share delivery
settlement_amount = MAX(0, index_value - strike) * multiplier
// SPX at 5200, $5000 strike call → (5200 - 5000) × 100 = $20,000 cash

In-the-Money (ITM) An option with intrinsic value — it would be profitable to exercise right now. For calls: stock price > strike. For puts: stock price < strike. ITM options are more expensive but move more like the underlying (higher delta).

is_ITM(option_type, stock_price, strike):
    IF option_type == CALL: RETURN stock_price > strike
    IF option_type == PUT:  RETURN stock_price < strike

// ITM amount (intrinsic value):
ITM_amount(CALL, 160, 150) → $10 in-the-money
ITM_amount(PUT,  140, 150) → $10 in-the-money

At-the-Money (ATM) Stock price equals (or is very close to) the strike price. ATM options have zero intrinsic value but maximum time value. They carry the highest gamma and are most sensitive to volatility changes.

is_ATM(stock_price, strike, tolerance=0.50):
    RETURN ABS(stock_price - strike) <= tolerance

// ATM options: intrinsic = $0, but time value is at its maximum
// Gamma is highest ATM — delta changes fastest here

Out-of-the-Money (OTM) The option has no intrinsic value — exercising right now would be unprofitable. For calls: stock price < strike. For puts: stock price > strike. OTM options are cheaper but require a larger stock move to become profitable.

is_OTM(option_type, stock_price, strike):
    IF option_type == CALL: RETURN stock_price < strike
    IF option_type == PUT:  RETURN stock_price > strike

// OTM option value is 100% time value — decays to zero if stock
// doesn't move past strike before expiry
intrinsic_value = 0
premium         = time_value_only

Intrinsic Value The immediate exercise value — how much profit you would lock in by exercising right now. Intrinsic value can never be negative. OTM options have zero intrinsic value.

intrinsic_value(option_type, stock_price, strike):
    IF option_type == CALL: RETURN MAX(0, stock_price - strike)
    IF option_type == PUT:  RETURN MAX(0, strike - stock_price)

// Option premium cannot trade below intrinsic value
// (arbitrage would instantly collapse any such mispricing)
premium >= intrinsic_value  // always true

Time Value / Extrinsic Value The portion of premium above intrinsic value. Represents the possibility that the option moves further into the money before expiration. Time value decays to zero at expiration. ATM options carry the maximum time value. Extrinsic value is a synonym — used interchangeably with time value.

time_value = premium - intrinsic_value
// Identical formula for extrinsic_value

// Time value erodes daily (non-linear — faster near expiry)
time_value_remaining(DTE, original_DTE, initial_tv):
    fraction = SQRT(DTE / original_DTE)
    RETURN initial_tv * fraction

// At expiration: time_value = 0, always
time_value(DTE=0) → 0

Moneyness The relationship between the current stock price and the strike price — describes how far ITM, ATM, or OTM an option is. Expressed as a distance in dollars or as a percentage. Determines the delta range and how the option behaves.

moneyness(option_type, stock_price, strike):
    diff = stock_price - strike

    IF option_type == CALL:
        IF diff > 0:  RETURN "ITM", depth=diff
        IF diff == 0: RETURN "ATM"
        IF diff < 0:  RETURN "OTM", depth=ABS(diff)

    IF option_type == PUT:
        IF diff < 0:  RETURN "ITM", depth=ABS(diff)
        IF diff == 0: RETURN "ATM"
        IF diff > 0:  RETURN "OTM", depth=diff

// Percentage OTM (normalizes across different stock prices):
pct_OTM = ABS(stock_price - strike) / stock_price * 100

Covered Call Owning 100 shares and simultaneously selling a call against them. The short call is covered by the shares — if assigned, you deliver shares you already own. Generates income in neutral-to-slightly-bullish markets but caps your upside at the strike price.

covered_call = {
    long_shares:       100,
    short_call_strike: above current stock_price,  // OTM call
    premium_received:  call_premium * 100
}

// Payoff at expiration:
IF stock_price <= short_strike:
    profit = premium_received + (stock_price - entry_price) * 100
IF stock_price > short_strike:
    profit = premium_received + (short_strike - entry_price) * 100  // capped
    // Shares called away — you miss upside above the strike

Protective Put Owning 100 shares and buying a put as downside insurance. If the stock falls below the put strike, the put gains value and offsets share losses. The cost of the put is the insurance premium.

protective_put = {
    long_shares: 100,
    long_put:    strike below current stock_price,
    premium_paid: put_premium * 100
}

// Max loss is now defined (without put: unlimited downside)
max_loss = (entry_price - put_strike + premium_paid) * 100

// Stock can fall to zero — loss is capped regardless

Cash-Secured Put Selling a put while holding enough cash to buy 100 shares at the strike price if assigned. Lower risk than a naked put because you have the capital ready. Used to generate income or acquire stock at a lower price.

cash_secured_put = {
    short_put:     strike below current stock_price,
    cash_reserved: strike * 100    // must hold as collateral
}

max_gain = premium_received * 100
max_loss = (strike - premium_received) * 100  // if stock goes to $0

// Effective purchase price if assigned:
net_cost_basis = strike - premium_received

Naked Call Selling a call without owning the underlying shares. If assigned, you must buy shares at market price and sell at strike — a potentially catastrophic loss if the stock has surged. Requires substantial margin and carries unlimited risk.

naked_call = {
    short_call:   strike above stock_price,
    shares_owned: 0   // "naked" — no hedge
}

max_gain = premium_received * 100
max_loss = UNLIMITED  // stock can rise to any price

// Loss if assigned: stock at $300, $200 strike call, $5 premium received
loss = (stock_price - strike - premium_received) * 100
     = (300 - 200 - 5) × 100 = -$9,500

Naked Put Selling a put without cash reserved to buy shares if assigned. Risk is large — the stock could go to zero. Requires margin. Sometimes used aggressively by traders who want the stock but with no capital set aside.

naked_put = {
    short_put:    strike below current stock_price,
    cash_reserved: 0   // "naked" — no collateral
}

max_gain = premium_received * 100
max_loss = (strike - premium_received) * 100

// Example: $150 put, $5 premium, stock collapses to $0
max_loss = (150 - 5) × 100 = -$14,500

Breakeven Point The stock price at expiration where the position makes exactly zero profit or loss. For long calls: strike + premium paid. For long puts: strike minus premium paid.

breakeven(option_type, strike, premium):
    IF option_type == CALL: RETURN strike + premium
    IF option_type == PUT:  RETURN strike - premium

// $150 call, $5 premium:
breakeven(CALL, 150, 5) → $155   // must close above $155 to profit

// $150 put, $4 premium:
breakeven(PUT, 150, 4) → $146    // must close below $146 to profit

Max Profit The maximum possible gain on a position. For long calls: unlimited (stock can rise infinitely). For long puts: strike minus premium paid (stock can only reach zero). For short options: the premium received.

max_profit(position_type, strike, premium):
    IF position_type == LONG_CALL:  RETURN UNLIMITED
    IF position_type == LONG_PUT:   RETURN (strike - premium) * 100
    IF position_type == SHORT_CALL: RETURN premium * 100
    IF position_type == SHORT_PUT:  RETURN premium * 100

// Long put example: $150 put, $4 premium
max_profit = (150 - 4) × 100 = $14,600  // if stock goes to $0

Max Loss The maximum possible loss on a position. For long options: the premium paid. For naked short calls: unlimited. For short puts: strike minus premium (if stock goes to zero).

max_loss(position_type, strike, premium):
    IF position_type == LONG_CALL:    RETURN premium * 100
    IF position_type == LONG_PUT:     RETURN premium * 100
    IF position_type == SHORT_CALL:   RETURN UNLIMITED
    IF position_type == SHORT_PUT:    RETURN (strike - premium) * 100
    IF position_type == COVERED_CALL: RETURN (entry_price - premium) * 100

// Always calculate max loss before entering any trade
risk_acceptable = max_loss <= account_risk_per_trade_limit

Net Debit When you pay more in premium than you receive — you are a net buyer of options. Debit strategies need the stock to move in your favor to profit. Maximum loss equals the net premium paid.

net_debit = premium_paid - premium_received

IF net_debit > 0:
    max_loss = net_debit * 100
    requires_stock_to_move = TRUE

// Example: buy $5 call, sell $2 call = $3 net debit per share
net_debit = 5.00 - 2.00 = 3.00   // pay $300 per spread

Net Credit When you receive more in premium than you pay — you are a net seller of options. Credit strategies profit when the stock stays within a range and time passes. Maximum gain equals the net premium received.

net_credit = premium_received - premium_paid

IF net_credit > 0:
    max_gain = net_credit * 100
    profit_if_stock_stays_in_range = TRUE

// Example: sell $4 put, buy $2 put = $2 net credit
net_credit = 4.00 - 2.00 = 2.00   // receive $200 per spread
max_gain   = 2.00 * 100 = $200

Level 2: Core Mechanics

How options actually work day-to-day — orders, settlement, expiration cycles, and position management.

Time Decay / Theta Decay The daily erosion of an option's time value as expiration approaches. Time decay accelerates in the final 30 days. Sellers benefit from time decay every day the position is open; buyers fight it. The rate of daily decay is measured by the Greek theta.

// Daily time value loss
daily_pnl_from_theta = theta * contracts * 100

// Decay is non-linear — accelerates near expiry (square root of time)
// At DTE = 45: slow decay
// At DTE = 7: rapid decay
// At DTE = 0: all remaining time value → 0

FOR each_day IN range(DTE, 0):
    time_value -= theta_for_that_DTE
    theta_for_that_DTE *= 1.05  // accelerates each day

Early Exercise Exercising an American-style option before expiration. Rarely optimal for calls — you sacrifice remaining time value. May be rational for deep ITM puts, or for calls just before the ex-dividend date of a dividend-paying stock (to capture the dividend by owning shares).

should_early_exercise_call(option, stock):
    upcoming_dividend  = stock.next_dividend
    time_value_left    = option.premium - option.intrinsic_value

    IF upcoming_dividend > time_value_left:
        RETURN TRUE   // rational: capture dividend by owning shares
    RETURN FALSE      // almost always false for calls

// For puts: early exercise rational when deep ITM
// (interest earned on sale proceeds > remaining time value)

Dividend Risk The risk that a short call gets exercised early before the ex-dividend date. The call holder exercises early to own shares on the ex-date and collect the dividend. Sellers of calls on dividend-paying stocks face this risk.

dividend_risk(short_call, stock):
    days_to_ex_div  = stock.ex_dividend_date - today
    call_time_value = short_call.premium - short_call.intrinsic_value

    IF days_to_ex_div <= 2 AND stock.dividend > call_time_value:
        early_assignment_likely = TRUE

// Protection: close or roll short calls before the ex-dividend date

Pin Risk The uncertainty near expiration when the stock price is very close to a short option's strike. You do not know whether you will be assigned — if the stock closes exactly at the strike, assignment is essentially random.

is_pinning(stock_price, strike, DTE):
    RETURN DTE <= 1 AND ABS(stock_price - strike) < 0.50

// Problem: you may or may not have 100 shares Monday morning
// Depending on whether the holder exercised after Friday's close
// Solution: close positions before 3pm on expiration day

Assignment Risk The ongoing risk that a short option gets exercised by the holder, forcing you to buy or sell shares. American-style options can be assigned any time. Risk is highest for ITM short options and near dividend dates.

assignment_risk_score(short_option, stock):
    score = 0
    IF short_option.is_ITM:              score += 3
    IF stock.dividend_imminent:           score += 3
    IF short_option.DTE <= 5:            score += 2
    IF short_option.time_value < 0.10:   score += 2
    RETURN score

// High score → consider closing or rolling the position

Roll / Roll Up / Roll Down / Roll Out Rolling closes an existing position and simultaneously opens a new one with adjusted parameters. Roll Up: move the strike higher. Roll Down: move the strike lower. Roll Out: extend to a later expiration. These are often combined — Roll Up and Out means higher strike plus later expiry.

roll(position, new_strike, new_expiry):
    close_order = BUY_TO_CLOSE(position)
    open_order  = SELL_TO_OPEN(new_strike, new_expiry)

    net_result  = open_order.premium - close_order.cost
    IF net_result < 0: paying_debit_to_roll    // bad — avoid if possible
    IF net_result > 0: receiving_credit_to_roll // preferred

roll_up(position, delta_strike):    new_strike = position.strike + delta_strike
roll_down(position, delta_strike):  new_strike = position.strike - delta_strike
roll_out(position, weeks):          new_expiry = position.expiry + weeks

Calendar Roll Rolling from one expiration to a later one at the same strike. Common when managing a short option that has decayed significantly — you roll out to the next cycle to collect more premium without changing the directional stance.

calendar_roll(short_position, weeks_out):
    close(short_position)
    new_expiry = short_position.expiry + weeks_out
    open_short(strike=short_position.strike, expiry=new_expiry)

    // Should generate a net credit (later expiry = more time value = more premium)
    net_result = new_premium - close_cost
    ASSERT net_result > 0  // if not, do not roll — take the loss

Adjustments Changes made to option contracts by the OCC when a corporate action occurs — stock splits, mergers, spin-offs, or special dividends. After adjustment, the contract may cover a different number of shares, a different deliverable, or a different strike price. Always verify adjusted contracts before trading.

// 2:1 stock split adjustment:
original_contract = { strike: 200, multiplier: 100 }
adjusted_contract = { strike: 100, multiplier: 200 }
// Total contract value preserved: 200 × 100 = 100 × 200

// Merger (cash + stock deal):
adjusted_deliverable = {
    cash:   merger_cash_per_share * 100,
    shares: new_company_shares_per_original_share * 100
}

Contract Multiplier The number of shares one option contract controls. Standard US equity options: 100 shares. Mini options: 10 shares. Index options (SPX, NDX): cash-settled with a dollar multiplier of $100 per index point. Always confirm the multiplier before calculating position size.

contract_dollar_value = option_premium * multiplier

// Equity option (standard):
equity_value = option_premium * 100

// SPX index option: not 100 shares — cash settled
spx_value = option_premium * 100  // $100 per point

// Mini option:
mini_value = option_premium * 10

Deliverable What is exchanged when an option is exercised. Standard: 100 shares of the underlying. After corporate actions, the deliverable may change. Index options are cash-settled — no shares change hands, only the cash difference is transferred.

deliver_on_exercise(option):
    IF option.settlement == CASH:
        RETURN MAX(0, settlement_value - strike) * multiplier  // cash only

    IF option.settlement == PHYSICAL:
        RETURN 100_shares_of_underlying

    IF option.settlement == ADJUSTED:
        RETURN adjusted_deliverable   // post-corporate action terms

Cash Settlement Settlement where no shares change hands — only the cash difference is paid. Common for index options (SPX, NDX, RUT). Eliminates the need to buy or deliver 100 shares on exercise.

// SPX call cash settlement:
cash_payout(index_close, strike, multiplier=100):
    RETURN MAX(0, index_close - strike) * multiplier

// Example: SPX closes at 5,220, $5,000 strike call
cash_payout(5220, 5000, 100) → $22,000 received
// No shares involved — pure cash transfer

Physical Delivery Settlement where actual shares change hands. Most equity and ETF options settle this way. Call exercised: buyer pays strike × 100 and receives 100 shares. Put exercised: buyer delivers 100 shares and receives strike × 100.

physical_delivery_call(strike):
    buyer_pays      = strike * 100
    buyer_receives  = 100_shares
    seller_receives = strike * 100
    seller_delivers = 100_shares

physical_delivery_put(strike):
    buyer_delivers  = 100_shares
    buyer_receives  = strike * 100
    seller_receives = 100_shares
    seller_pays     = strike * 100

Exercise by Exception / Auto Exercise The OCC's rule that automatically exercises any option $0.01 or more in-the-money at expiration unless the holder instructs otherwise. You do not need to call your broker — ITM options exercise automatically. OTM options expire worthless automatically.

auto_exercise(option, settlement_price):
    intrinsic = exercise_value(option.type, settlement_price, option.strike)

    IF intrinsic >= 0.01:
        EXERCISE(option)         // automatic unless holder opts out
    ELSE:
        EXPIRE_WORTHLESS(option)

// Risk for short writers: late stock movement (4pm–5:30pm)
// can push OTM options ITM, triggering unexpected assignment

OCC (Options Clearing Corporation) The central counterparty and guarantor for all US-listed options trades. The OCC stands between every buyer and seller — if your counterparty defaults, the OCC fulfills the obligation. Requires margin from all members to cover potential defaults.

// OCC is counterparty to both sides of every trade
buyer → OCC → seller    // OCC sits in the middle

IF seller_defaults:
    OCC.fulfill_obligation(buyer)   // buyer is always protected
    OCC.pursue(defaulted_seller)

// OCC margin requirements backstop the entire system
member_margin = position_based_risk_model(all_positions)

Clearing House The institution that processes, confirms, and guarantees trades. OCC is the clearing house for all US-listed options. Brokers are clearing members. The clearing house requires margin deposits to cover potential losses.

clearing_process(trade):
    clearing_house.confirm(buyer, seller, terms)
    clearing_house.collect_margin(seller)    // performance bond
    clearing_house.issue_confirmation()
    clearing_house.monitor_daily_pnl()

    IF member_margin_below_threshold:
        clearing_house.issue_margin_call(member)

Margin Requirement The minimum capital your broker requires you to hold when writing (selling) options. Protects against potential losses on short positions. Calculated on position risk, not just premium received. Naked options require more margin than defined-risk spreads.

// Simplified margin for a naked short put (Reg T):
margin(short_put, stock_price, strike, premium):
    option_A = (0.20 * stock_price * 100) - OTM_amount + (premium * 100)
    option_B = (0.10 * strike * 100) + (premium * 100)
    RETURN MAX(option_A, option_B)

// Margin ties up capital — directly reduces available buying power
buying_power_effect = margin_requirement

Buying Power The amount of capital available in your account to open new positions. Selling options reduces buying power by the margin requirement. Buying options reduces buying power by the premium paid.

available_buying_power = account_value - SUM(all_margin_requirements)

// Defined-risk spread:
buying_power_reduction = max_loss_of_spread * 100   // clean, known amount

// Naked option:
buying_power_reduction = margin_requirement  // much larger, varies with stock price

// Always verify buying power effect before entering a position

Limit Order An order to buy or sell only at a specified price or better. For options, always use limit orders — market orders on illiquid options fill at terrible prices due to wide bid-ask spreads.

limit_order = {
    type:   BUY | SELL,
    price:  your_specified_price,
    action: FILL only if:
            BUY  → market_price <= specified_price
            SELL → market_price >= specified_price
}

// Best practice: start at the mid price
initial_price = (bid + ask) / 2
// Move toward ask (buying) or bid (selling) if not filling

Market Order An order to buy or sell immediately at the best available price. Never use market orders on options — you guarantee the worst possible fill price and maximize slippage, especially on illiquid contracts.

market_order = { action: FILL_IMMEDIATELY at whatever_price }

// Danger example:
bid = 4.00, ask = 5.50
market_buy_fill  = 5.50    // you pay the full ask
immediate_loss   = (5.50 - 4.00) * 100 = $150 per contract vs. the mid

Stop Order / Stop-Limit Order Stop order: converts to a market order when price reaches a trigger level. Dangerous for options — the triggered market order may fill at a terrible price. Stop-limit order: converts to a limit order at the trigger — safer, but may not fill if the market gaps past your limit.

stop_order = {
    trigger:  specified_price,
    action:   WHEN triggered → send MARKET_ORDER   // dangerous
}

stop_limit_order = {
    trigger:      specified_price,
    limit_price:  max_acceptable_fill_price,
    action:       WHEN triggered → send LIMIT_ORDER(limit_price)  // safer
}

// Risk: stop-limit may not execute if market gaps past limit_price

Good-Til-Canceled (GTC) / Day Order GTC: order stays active until you cancel it or the broker's maximum duration (often 60–90 days). Day order: expires at the end of the current trading session. Day orders are safer — you review and re-enter each session with fresh market awareness.

GTC_order = { duration: UNTIL_CANCELED | broker_max_days }
day_order  = { duration: CURRENT_SESSION_ONLY, auto_expire: market_close }

// GTC risk: market conditions change, old order fills unexpectedly
// Best practice: prefer day orders; use GTC only with careful monitoring

All-or-None Order (AON) An order that must fill entirely or not at all. Critical for multi-leg option spreads — a partial fill (only one leg fills) leaves you with an unhedged, unintended position. Not all brokers support AON on options.

all_or_none = {
    quantity: N_contracts,
    rule:     FILL_ALL or FILL_NONE
}

// Danger: bull call spread — only long call fills
partial_fill_risk = long_leg_only_filled AND short_leg_did_not_fill
// Result: naked long call — much more expensive than intended spread

Expiration Cycle The schedule of available expiration dates for a given underlying. Standard monthly: third Friday of each month. Highly liquid underlyings (SPY, QQQ, AAPL) also have weekly expirations every Friday and sometimes daily (0DTE) options.

// Standard monthly expirations:
monthly = [third_Friday_of(each_month)]

// Weekly additions (for liquid underlyings):
weekly = [every_Friday]

// Available DTE when entering a trade:
dte_options = [0, 1, 2, 3, 4, 7, 14, 21, 28, 35, 45, 60...]

Weekly / Monthly / Quarterly Options Weekly options expire every Friday and have higher gamma and theta than monthly options at the same strike. Monthly options expire the third Friday of each month — the most liquid series, used for most income strategies. Quarterly options expire at end of each calendar quarter, used primarily by institutions.

weekly  = { DTE: 1-7,   gamma: HIGH,   theta: HIGH,   premium: LOW   }
monthly = { DTE: 21-35, gamma: MEDIUM, theta: MEDIUM, premium: MEDIUM }
quarterly = { DTE: 60-90, gamma: LOW,  theta: LOW,    premium: HIGH  }

// Sweet spot for premium sellers: 30-45 DTE (monthly)
// Theta starts accelerating meaningfully, still enough premium to collect
optimal_entry_DTE = 30 to 45

LEAPs (Long-term Equity Anticipation Securities) Options with expiration dates more than one year away. Time decay is slow — useful for buyers. Often used as stock substitutes (deep ITM LEAPs with ~0.80 delta behave like owning shares at a fraction of the capital required).

is_LEAP(option): RETURN option.DTE > 365

// LEAP as stock substitute:
deep_ITM_LEAP = { delta: ~0.80, strike: far_below_stock_price }
// Behaves like 80 shares for a fraction of the cost of 100 shares

capital_LEAP  = LEAP_premium * 100     // example: $30 × 100 = $3,000
capital_stock = stock_price * 100      // example: $150 × 100 = $15,000

// Time decay on LEAP is very slow vs. monthly options

Front Month / Back Month Front month: the nearest expiration contract — most liquid, fastest time decay, tightest bid-ask spread. Back month: any expiration further out. Back month decays slower and is used in calendar spreads paired with a short front-month position.

front_month = MIN(all_available_expirations)   // nearest date
back_month  = second_nearest OR further

// Calendar spread logic:
short_front_month + long_back_month = calendar_spread
// Profit: front month decays faster than back month

Option Chain The full matrix of all available options for a given underlying — all calls and puts at every strike across all expiration dates. The option chain is your primary trading interface.

option_chain = {
    underlying:  "AAPL",
    expirations: [date1, date2, date3, ...],
    strikes:     [100, 105, 110, ..., 250],

    // Each cell: expiration × strike
    contract = {
        call: { bid, ask, delta, gamma, theta, vega, IV, OI, volume },
        put:  { bid, ask, delta, gamma, theta, vega, IV, OI, volume }
    }
}

Series / Class of Options A series is all options of the same type (call or put) on the same underlying with the same expiration date — e.g., the June 2026 AAPL calls. A class is all options on a specific underlying across all types, strikes, and expirations — e.g., all AAPL options.

series = {
    underlying: "AAPL", type: CALL, expiry: "2026-06-20",
    strikes:    [all available strikes for this date]
}

class = {
    underlying: "AAPL",
    series:     [all_series_across_all_expiries_and_types]
}
// series is a subset of class

Leg One component of a multi-option strategy. A straddle has two legs (a call + a put). An iron condor has four legs. Managing legs individually vs. as a spread affects execution quality and commission costs — always try to execute multi-leg strategies as a single combo order.

iron_condor_legs = [
    { action: SELL_PUT,  strike: lower_put  },    // leg 1
    { action: BUY_PUT,   strike: lowest     },    // leg 2
    { action: SELL_CALL, strike: upper_call },    // leg 3
    { action: BUY_CALL,  strike: highest    }     // leg 4
]

Multi-Leg Order / Combo Order Submitting multiple option legs as a single order. Prevents partial fills that leave you with an unintended position. Brokers route combo orders to special handling so all legs fill together.

combo_order = {
    legs:      [leg1, leg2, leg3, leg4],
    fill_rule: ALL_OR_NONE,
    net_price: target_credit_or_debit
}

// Risk of legging in separately:
IF leg1_fills AND leg2_does_not_fill:
    position = UNHEDGED  // dangerous — correct immediately

Synthetic Long / Synthetic Short Replicating the payoff of owning or shorting shares using options only. Synthetic long: buy a call + sell a put at the same strike. Synthetic short: buy a put + sell a call at the same strike. Useful when you want stock-like exposure without buying the shares.

synthetic_long(strike, expiry):
    buy_call(strike, expiry)    // unlimited upside
    sell_put(strike, expiry)    // obligated to buy if stock falls
    // Behaves identically to owning 100 shares from the strike price

synthetic_short(strike, expiry):
    buy_put(strike, expiry)     // profit if stock falls
    sell_call(strike, expiry)   // obligated to sell if stock rises
    // Behaves identically to being short 100 shares from strike

Level 3: The Greeks

Sensitivity measures — how option prices respond to changes in underlying price, time, and volatility. Master these to truly understand your position risk.

Delta How much an option's price changes for every $1 move in the underlying. Also approximates the probability that the option expires in-the-money. Calls: positive delta (0 to 1.0). Puts: negative delta (−1.0 to 0).

delta = change_in_option_price / change_in_underlying_price
// Call delta: 0.0 → 1.0 | Put delta: -1.0 → 0.0

// P&L from a $1 move:
pnl_per_dollar_move = delta * contracts * 100

// Probability approximation:
prob_ITM_at_expiry ≈ ABS(delta)   // 0.30 delta → ~30% chance ITM

// 2 contracts, delta 0.60, stock up $1:
pnl = 0.60 * 2 * 100 = $120 gain

Gamma The rate of change of delta per $1 move in the underlying. Always positive for long options, always negative for short options. High gamma means delta changes rapidly — the position accelerates as the stock moves. Gamma is highest ATM and near expiration.

gamma = change_in_delta / change_in_underlying_price

// Update delta after a price move:
new_delta = old_delta + (gamma * price_change)

// Example: call, delta 0.50, gamma 0.05, stock moves up $2:
new_delta = 0.50 + (0.05 * 2) = 0.60

// High gamma = accelerating position — good for longs, dangerous for short gamma

Theta The daily dollar amount an option loses to time decay. Expressed as a negative number per share for long options (you lose value each day). Positive for short options (you gain value each day). Theta accelerates as DTE decreases.

// Daily P&L from time decay (per share):
theta_per_share    = theta  // e.g., -0.05 per day for long
theta_per_contract = theta * 100  // → -$5 per contract per day

// Position total:
position_theta_pnl = SUM(theta_i * contracts_i * 100 FOR each leg)

// Long option: theta = negative (daily loss)
// Short option: theta = positive (daily gain)

Vega How much an option's price changes for each 1 percentage point change in implied volatility. Long options: positive vega (gain when IV rises). Short options: negative vega (lose when IV rises).

vega = change_in_option_price / change_in_IV_percentage_point

// Example: vega = 0.20, IV rises 1pp:
option_gain = 0.20 * 1 = $0.20 per share → $20 per contract

// IV crush at earnings: IV drops 25pp
option_loss = vega * (-25) * contracts * 100
// Even a correct directional move can be swamped by the vega loss

Rho How much an option's price changes for each 1% change in the risk-free interest rate. Positive for calls (higher rates benefit calls); negative for puts. Generally the smallest Greek in practice — most relevant for LEAPs or during aggressive Fed rate cycles.

rho = change_in_option_price / change_in_interest_rate_pct

// Practical impact for short-dated options: minimal
// Impact grows with DTE — rho matters most for LEAPs
// Fed raises rates 1% → call prices rise slightly, put prices fall slightly

Delta Neutral A position where total portfolio delta is approximately zero — neither profits nor loses from small stock price moves. Allows isolating theta or vega exposure without directional risk.

portfolio_delta = SUM(delta_i * contracts_i * 100 FOR all positions)

is_delta_neutral = ABS(portfolio_delta) < threshold  // e.g., < ±10

// Neutralize with shares:
IF portfolio_delta > 0: sell_shares(portfolio_delta)   // reduce long delta
IF portfolio_delta < 0: buy_shares(ABS(portfolio_delta)) // reduce short delta

Position Delta / Position Gamma / Position Theta / Position Vega / Position Rho Aggregate Greek values across all legs of a multi-leg position or portfolio. Each position Greek sums up that individual Greek across all contracts. Used to understand total risk exposure at a glance.

// General formula for any Greek G:
position_G = SUM(G_i * contracts_i * 100 FOR each leg i)

// Iron condor example:
position_delta = (put_spread_delta + call_spread_delta) * 100 * contracts
// Should be near zero for a balanced iron condor
// position_theta: positive (collecting decay)
// position_vega:  negative (hurt by IV rise)

Greeks Sensitivity The general concept that all Greeks change as market conditions change — delta changes (gamma), vega changes (vomma), theta changes (color). A position that looks acceptable today may have very different Greek exposure next week with a different stock price or IV level.

// Greeks are dynamic — recalculate after any significant market move
recalculate_greeks(position, new_price, new_IV, new_DTE):
    new_delta = black_scholes_delta(new_price, new_IV, new_DTE)
    new_gamma = black_scholes_gamma(new_price, new_IV, new_DTE)
    new_theta = black_scholes_theta(new_price, new_IV, new_DTE)
    new_vega  = black_scholes_vega(new_price, new_IV, new_DTE)
    RETURN updated_greeks

Gamma Scalping A hedging technique for long gamma positions. As the stock moves up, delta rises — sell shares to neutralize. As the stock moves down, delta falls — buy shares to neutralize. The net effect captures the gamma: buying low and selling high as the stock oscillates.

// Gamma scalping loop
target_delta = 0  // keep position delta neutral

WHILE position_is_open:
    current_delta = recalculate_delta(current_price)

    IF current_delta > target_delta + threshold:
        sell_shares(current_delta - target_delta)  // trim rising delta
    IF current_delta < target_delta - threshold:
        buy_shares(target_delta - current_delta)   // add to falling delta

// Profit source: realized volatility of the stock must exceed IV paid
// Requires stock to oscillate substantially — not profitable in drift

Charm Second-order Greek — the rate of change of delta over time (how much delta shifts per day, holding price constant). ITM options drift toward delta 1.0 as expiry nears; OTM options drift toward delta 0.0. Important near expiration.

charm = change_in_delta / change_in_time  // per day

// Delta changes daily even with no price movement
new_delta = old_delta + (charm * days_passed)

// Example near expiration: ATM call delta can move from 0.50 → 0.85
// in the final week even if stock barely moves

Vanna The rate of change of delta with respect to implied volatility — and equivalently, the rate of change of vega with respect to the underlying price. Relevant when you expect both price and volatility to move simultaneously (common in selloffs).

vanna = change_in_delta / change_in_IV
      = change_in_vega  / change_in_underlying_price

// In a market selloff: stock falls AND IV rises simultaneously
// Vanna effect: put delta becomes more negative faster than gamma alone predicts
// Position can accelerate unexpectedly — important for hedging books

Vomma / Volga The rate of change of vega with respect to implied volatility — how much your vega exposure itself changes as IV moves. High vomma means the position is highly sensitive to large IV moves (vol-of-vol risk). Relevant for positions on volatility products.

vomma = change_in_vega / change_in_IV

// High vomma: gains accelerate when IV spikes far above current levels
// Short vomma: profits in stable IV, bleeds badly in IV explosions

// Particularly relevant for:
// - VIX options
// - Short straddles near earnings (short vomma exposure)

Speed Third-order Greek — the rate of change of gamma with respect to the underlying price. Tells you how quickly gamma itself accelerates as the stock moves. Most relevant for 0DTE (same-day expiry) ATM options where gamma can explode rapidly.

speed = change_in_gamma / change_in_underlying_price

// High speed: gamma grows quickly as stock moves through strike
// Matters most for: very short-dated ATM options
// 0DTE positions near the strike can become extremely nonlinear
new_gamma = current_gamma + (speed * price_change)

Zomma The rate of change of gamma with respect to implied volatility. Tells you how gamma will shift when IV changes. In high-IV environments, gamma behaves differently than in calm markets — compounding risk for short gamma/short vega positions.

zomma = change_in_gamma / change_in_IV

// When IV spikes, ATM gamma often increases
// This compounds risk: short gamma AND short vega positions
// both hurt simultaneously — the losses are correlated, not independent

Color The rate of change of gamma with respect to time — how gamma evolves as days pass. Near expiration, ATM gamma grows rapidly. Color tells you how fast that gamma growth is accelerating day by day.

color = change_in_gamma / change_in_time  // per day

// Gamma grows faster as DTE → 0 for ATM options
projected_gamma_tomorrow = current_gamma + (color * 1)

// Color becomes critical in the final 5 DTE for ATM short positions
// Gamma risk can double in a single day late in the option's life

Ultima Fourth-order Greek — the rate of change of vomma with respect to implied volatility. Deeply theoretical for most traders. Relevant only for complex volatility book management at institutional level.

ultima = change_in_vomma / change_in_IV
// How the vol-of-vol sensitivity itself changes with IV

// Practical use: volatility hedge funds, exotic options desks
// Retail traders: awareness only — not actionable in most strategies

Lambda The percentage change in option price for a 1% change in the underlying price. Also called elasticity or leverage ratio. Measures how much "bang for the buck" you get compared to owning the stock.

lambda = delta * (stock_price / option_price)

// Example: delta 0.50, stock $100, option price $5
lambda = 0.50 * (100 / 5) = 10x leverage

// Interpretation: 1% stock move → approximately 10% option value change
// Shows the leverage embedded in options — both amplifies gains AND losses

Dual Delta / Dual Gamma Sensitivities of the option price with respect to the strike price (not the stock price). Used in exotic options pricing and for analyzing the effect of changing strikes. Less common in standard options trading.

// Standard delta: sensitivity to underlying price change
delta = dOption/dS  // d(option price) / d(stock price)

// Dual delta: sensitivity to strike price change
dual_delta = dOption/dK  // d(option price) / d(strike)

// For a call: dual_delta is negative (higher strike = lower call value)
// Used in: barrier options, exotic pricing, strike sensitivity analysis

Vega Exposure The total dollar sensitivity of a position to a 1 percentage point change in IV across all legs. Position vega quantifies how much money you make or lose when volatility moves.

// Position vega (aggregate)
position_vega = SUM(vega_i * contracts_i * 100 FOR each leg)

// Example: position_vega = -$500
// IV rises 1pp → position loses $500
// IV falls 1pp → position gains $500

// Short options strategies have negative position vega
// Long options strategies have positive position vega

Theta/Gamma Ratio A measure of the trade-off between time decay collected (theta) and gamma risk accepted. A high theta/gamma ratio means you collect a lot of theta for each unit of gamma risk — a desirable property for short premium strategies.

theta_gamma_ratio = position_theta / position_gamma

// Higher ratio: more theta collected per unit of gamma risk
// Low ratio: high gamma risk for little theta collected

// Compare across different strikes and DTE to optimize entry
optimal_entry = MAX(theta_gamma_ratio) given acceptable_gamma_risk

Beta Weighted Delta Converting all position deltas to a common benchmark (typically SPY or SPX) to measure total market exposure across a mixed portfolio. Allows apples-to-apples comparison of directional risk.

beta_weighted_delta(stock, delta, contracts):
    beta = correlation_to_SPY(stock)  // e.g., AAPL beta ≈ 1.2
    spy_equivalent = delta * beta * contracts * 100
    RETURN spy_equivalent

// Portfolio total market exposure:
total_BWD = SUM(beta_weighted_delta(s, d, c) FOR all positions)
// total_BWD = +500 means you behave like long 500 shares of SPY

Delta Hedge / Vega Hedge Delta hedge: neutralizing directional risk by taking an offsetting position in the underlying shares. Vega hedge: neutralizing IV sensitivity by adding positions that offset your vega exposure, often using VIX options or opposing options positions.

delta_hedge(option_position):
    position_delta = option_position.delta * contracts * 100
    IF position_delta > 0: sell_shares(position_delta)
    IF position_delta < 0: buy_shares(ABS(position_delta))
    // Requires rebalancing as delta drifts

vega_hedge(portfolio):
    portfolio_vega = SUM(vega_i * contracts_i * 100)
    IF portfolio_vega < 0:  // vulnerable to IV spike
        buy_calls OR buy_VIX_calls  // add positive vega

Dynamic Hedging / Static Hedging Dynamic hedging continuously adjusts the delta hedge as the underlying price moves — required for delta-neutral books. Transaction costs must balance against hedge accuracy. Static hedging applies one hedge at entry and holds it unchanged until close or expiration — simpler but leaves residual risk as positions drift.

// Dynamic: continuous rebalancing
dynamic_hedge_loop:
    WHILE position_is_open:
        IF ABS(portfolio_delta) > rebalance_threshold:
            execute_delta_hedge()
        WAIT(rebalance_interval)

// Static: one-time hedge
static_hedge:
    open_position(main_trade)
    add_hedge(offsetting_contract)
    // No further adjustment until close or expiry

Decay Curve The non-linear path of time value erosion over an option's life. Decay is slow when the option has many weeks remaining, then accelerates sharply in the final 30 days — forming a hockey stick shape. Sellers enter at 30–45 DTE to capture the steepening portion of the curve.

// Time value remaining approximation (square root of time)
time_value_remaining(DTE, original_DTE, initial_tv):
    fraction = SQRT(DTE / original_DTE)
    RETURN initial_tv * fraction

// Example: 45 DTE option, initial time value $5.00
tv_at_30DTE = 5.00 * SQRT(30/45) = $4.08
tv_at_7DTE  = 5.00 * SQRT(7/45)  = $1.98
tv_at_1DTE  = 5.00 * SQRT(1/45)  = $0.75
// The final week erodes much faster in dollar terms

Overnight Theta / Weekend Decay Option contracts price in time decay for all calendar days, not just trading days. Saturday and Sunday count as time passage even though markets are closed. Short options benefit from collecting three days of theta over a weekend without market exposure.

// Theta is per calendar day, not per trading day
weekly_theta_trading = theta * 5   // Mon–Fri positions
weekly_theta_calendar = theta * 7  // includes weekend

// Weekend strategy: enter short positions Thursday → collect weekend theta
// Risk: cannot exit if news breaks over the weekend
weekend_theta_gain = theta * 2  // Saturday + Sunday

Gamma Trap A situation where large open interest at a specific strike forces market makers to continuously delta-hedge, creating a self-reinforcing price feedback loop. When market makers are short gamma (negative gamma exposure), their hedging amplifies moves — pushing the stock further in the direction it is already moving.

// Negative gamma environment: market makers short gamma
IF market_maker_is_short_gamma AND stock_rises:
    market_maker.buy_shares_to_delta_hedge()
    buying_pressure → stock_rises_further
    more_calls_go_ITM → more_delta_hedge_buying_needed
    // Feedback loop — self-reinforcing until vol collapses or stock reverses

// Positive gamma (MMs long gamma) = stabilizing force
// Negative gamma (MMs short gamma) = destabilizing force

Level 4: Volatility Mastery

The most important pricing driver in options. Mastering volatility separates consistent traders from lucky ones.

Implied Volatility (IV) The volatility value reverse-engineered from current option prices — what the market is pricing in as future movement. IV is not a historical fact; it is solved for using Black-Scholes given the observed market price. High IV means expensive options. Low IV means cheap options.

// IV is solved for, not directly observed
IV = SOLVE(v) WHERE:
    black_scholes(stock_price, strike, DTE, rate, v) == market_price

// Daily expected move approximation:
daily_move = stock_price * (IV / SQRT(252))
// IV 40%, stock $100 → ±$2.52/day expected move

// Annual 1-standard-deviation range:
annual_move = stock_price * IV
// IV 40%, stock $100 → expected within $60–$140 (68% probability)

Historical Volatility (HV) / Realized Volatility The actual volatility that occurred over a past period — calculated from the standard deviation of daily log returns, annualized. Realized volatility is a synonym used after the period has passed. Compare HV to IV to assess whether options are expensive or cheap relative to actual movement.

// 20-day historical volatility:
HV_20 = STDDEV(daily_log_returns[last_20_days]) * SQRT(252)

daily_log_return(day) = LOG(close[day] / close[day-1])

// Vol premium: IV - HV
IF IV > HV: options_relatively_expensive  // selling premium may be favorable
IF IV < HV: options_relatively_cheap      // buying premium may be favorable

// Historically: vol_premium = IV - HV ≈ +2% to +5% (IV consistently > HV)
// This persistent premium is the statistical edge for premium sellers

IV Rank (IVR) / Implied Volatility Rank Where current IV sits relative to its 52-week high and low. IVR of 80 means current IV is 80% of the way from the 52-week low to the 52-week high. High IVR → favorable to sell premium. Low IVR → selling is unattractive.

IV_rank = (current_IV - IV_52wk_low) / (IV_52wk_high - IV_52wk_low) * 100

// Example: 52wk range 20%–80%, current IV = 65%
IV_rank = (65 - 20) / (80 - 20) * 100 = 75

// Trading signals:
IF IV_rank > 50: premium_selling_favorable   = TRUE
IF IV_rank < 20: premium_selling_unfavorable = TRUE

IV Percentile / Implied Volatility Percentile The percentage of past trading days (over 252 days) where IV was below the current level. Different from IV Rank — percentile counts individual daily observations, not just high/low extremes. More robust to outlier spikes that distort the 52-week range.

days_below_current_IV = COUNT(d IN last_252_days WHERE IV[d] < current_IV)
IV_percentile         = days_below_current_IV / 252 * 100

// Example: current IV higher than 180 of past 252 days
IV_percentile = 180 / 252 * 100 = 71.4%

// Prefer IV_percentile over IV_rank when the stock has had a major vol spike
// that distorts the 52-week high/low range

IV Crush The rapid collapse in implied volatility immediately after a major known event (earnings, FDA decision, FOMC). IV spikes before the event as uncertainty peaks, then crashes once the event is resolved. Buyers of pre-event options often lose value even when the stock moves in the correct direction.

IV_before_earnings = 65%
IV_after_earnings  = 30%
IV_drop            = -35pp  // the "crush"

// Option loss from IV crush:
vega_loss = vega * (-35) * contracts * 100

// Option gain from correct directional move (+5%):
delta_gain = delta * (stock_price * 0.05) * contracts * 100

// Net result: often negative even with the right direction
total_pnl = delta_gain + vega_loss   // frequently delta_gain < ABS(vega_loss)

Volatility Skew The difference in implied volatility across strikes at the same expiration. OTM puts typically have higher IV than equidistant OTM calls on equity underlyings — fear is asymmetric, crashes are sharper than rallies. Skew measures this asymmetry.

// Measure skew: 25-delta put IV minus 25-delta call IV
skew = IV(put_25_delta) - IV(call_25_delta)

// Typical equity: skew is negative (puts more expensive than calls)
// Normal: skew = 3%–8%
// Elevated: skew > 10% (hedging demand for crash protection surging)

// Trading skew:
risk_reversal = buy_call(25_delta) + sell_put(25_delta)
// Pays to trade if you think skew will normalize (puts become cheaper)

Volatility Smile When both OTM calls and OTM puts have higher IV than ATM options, creating a U-shape ("smile") when IV is plotted against strikes. Common in currency and commodity markets. Equity options more typically show a "smirk" (only puts are elevated, not calls).

// Smile: U-shaped IV across strikes (currency, commodities)
strikes = [80,  90,  100, 110, 120]  // ATM = 100
IV_smile = [35%, 28%, 22%, 28%, 35%]  // symmetric U-shape

// Smirk (equity typical): left-skewed, puts elevated only
IV_smirk = [40%, 32%, 22%, 18%, 15%]  // put side elevated, call side flat/declining

Volatility Term Structure How implied volatility varies across expiration dates. In calm markets: IV increases with time (contango — normal). In fear events: near-term IV spikes above long-dated IV (backwardation). The shape of the term structure tells you where the market fears volatility will occur.

term_structure = {
    "7 DTE":   IV_weekly,
    "30 DTE":  IV_monthly,
    "90 DTE":  IV_quarterly,
    "365 DTE": IV_LEAP
}

// Normal (contango): IV grows with time
is_contango      = IV_weekly < IV_monthly < IV_quarterly

// Fear (backwardation): near-term more expensive
is_backwardation = IV_weekly > IV_monthly > IV_quarterly

Volatility Cone A visualization showing realized volatility at multiple lookback periods across historical percentile bands. Forms a cone shape — wide at long lookbacks (more variation), narrow at short lookbacks. Helps identify when current IV is historically extreme.

// Build vol cone: HV at multiple lookbacks, across percentile bands
vol_cone = {
    lookback_10:  { p10: X, median: Y, p90: Z },
    lookback_20:  { p10: X, median: Y, p90: Z },
    lookback_60:  { p10: X, median: Y, p90: Z },
    lookback_252: { p10: X, median: Y, p90: Z }
}

// Signal:
IF current_IV > vol_cone.lookback_30.p90: IV_historically_extreme = TRUE
IF current_IV < vol_cone.lookback_30.p10: IV_historically_cheap   = TRUE

Forward Volatility The implied volatility for a future period, extracted from two options with different expirations. Tells you what volatility the market prices between two future dates — useful for isolating event vol or trading the term structure.

// Extract forward vol between T_short and T_long using variance additivity
var_total   = IV_long^2  * T_long
var_near    = IV_short^2 * T_short
var_forward = var_total - var_near
T_forward   = T_long - T_short

forward_vol = SQRT(var_forward / T_forward)
// Used for: calendar spread pricing, event volatility extraction

Spot Volatility The implied volatility for the nearest available expiration — the "right now" IV reading. Contrasted with forward volatility or longer-dated IV. Spot vol spikes dramatically during fear events.

spot_vol = IV[shortest_expiry]  // nearest expiration

// Spot vol vs. forward vol relationship:
IF spot_vol > forward_vol: backwardation  // near-term fear spike
IF spot_vol < forward_vol: contango       // calm now, uncertainty ahead

Contango Term structure condition where longer-dated IV is higher than shorter-dated IV — the normal state in calm markets. Long VIX products lose value in contango due to futures roll-down. Benefits sellers of long-dated options relative to short-dated.

is_contango = IV[long_expiry] > IV[short_expiry]  // TRUE in normal markets

// VIX futures contango cost (roll-down):
// Front month VIX future decays toward spot VIX as expiry approaches
// Holding long VIX futures = paying the roll cost continuously
expected_annual_vxu_decay ≈ -50% to -70% in sustained contango

Backwardation Term structure condition where near-term IV is higher than longer-dated IV. Occurs during fear events — investors scramble for near-term protection. Backwardation is temporary and typically reverts to contango once the fear event resolves.

is_backwardation = IV[short_expiry] > IV[long_expiry]  // fear signal

// Trading backwardation:
sell_near_term_expensive_IV + buy_longer_term_cheaper_IV
// Calendar spread benefits from backwardation normalizing back to contango

// Historical pattern: backwardation lasts days to weeks, not months

Max Pain Theory The theory that options market makers nudge the underlying toward the strike price with the maximum total option pain — where the most premium expires worthless. Not consistently reliable as a trading signal but widely monitored near expiration.

// Find max pain: the stock price that minimizes total ITM option value
max_pain_strike = MINIMIZE(total_option_value(P))

// For each candidate stock price P:
total_value(P) = SUM(call_pain(K, P) + put_pain(K, P) FOR all strikes K)
call_pain(K, P) = MAX(0, P - K) * OI_calls[K] * 100
put_pain(K, P)  = MAX(0, K - P) * OI_puts[K]  * 100

// Max pain = the P that minimizes total_value(P)

Option Pain / Open Interest Analysis Studying the distribution of open interest across strikes to identify key price levels, potential support/resistance zones, and likely pinning behavior near expiration.

// Find highest OI strikes — potential pin levels
OI_by_strike = { K: OI_calls[K] + OI_puts[K] FOR each K }
pin_level     = argmax(OI_by_strike)  // strike with most total OI

// Put/call OI ratio: sentiment indicator
PC_OI_ratio = SUM(OI_puts) / SUM(OI_calls)
// ratio > 1.2: bearish positioning
// ratio < 0.6: bullish/complacent positioning

Unusual Options Activity (UOA) When volume dramatically exceeds normal levels at specific strikes — often signaling institutional positioning, event hedging, or informed trading. Requires context: is it a hedge, a directional bet, or a spread?

is_unusual(option, avg_daily_volume):
    volume_ratio = option.volume / avg_daily_volume

    IF volume_ratio > 5 AND option_OI_is_new:
        flag = "Possibly informed or institutional"
    IF volume_ratio > 10:
        flag = "Highly unusual — investigate"

// Additional bullish signals:
// - Buyer hitting the ask (aggressive, paying up)
// - Near-term OTM calls (short-term directional bet)
// - Concentrated at single strike (not a hedge spread)

Volatility Products (VIX Options, OVX, VVIX, VXN, RVX, TYVIX/MOVE) Financial instruments designed to trade volatility directly. Each measures implied volatility in a different market — VIX (S&P 500), OVX (crude oil), VXN (Nasdaq-100), RVX (Russell 2000), MOVE/TYVIX (Treasury bonds), VVIX (volatility of VIX itself).

// VIX: 30-day implied vol of S&P 500 options
VIX = annualized_IV_SPX_30day

// OVX: crude oil volatility (USO options)
OVX = annualized_IV_USO_30day

// VXN: Nasdaq-100 volatility (QQQ options)
VXN = annualized_IV_QQQ_30day  // typically VXN > VIX (tech = more volatile)

// VVIX: volatility of VIX — vol-of-vol
VVIX = annualized_IV_VIX_options

// MOVE: Treasury bond volatility
MOVE = annualized_IV_treasury_options

// Divergence signals:
IF MOVE > 120 AND VIX < 15:
    rate_stress_not_yet_in_equities = TRUE  // watch for contagion

Gamma Squeeze / Short Squeeze via Options Gamma squeeze: a rapid price move caused by market makers forced to buy the underlying as OTM calls go in-the-money — a self-reinforcing feedback loop. Short squeeze via options: when a heavily shorted stock with large call OI experiences both short covering and market maker delta hedging simultaneously.

// Gamma squeeze mechanics
WHILE aggressive_call_buying_continues:
    new_calls_bought += N
    MM_delta_exposure += gamma * N
    shares_MM_must_buy += delta_hedge_quantity
    buying_pressure   → stock_rises
    stock_rises       → more_calls_ITM
    more_calls_ITM    → more_delta_hedging_needed
    // Self-reinforcing until vol collapses or buyers exhausted

// Double squeeze: gamma + short covering simultaneously
combined_buying = delta_hedge_buying + short_seller_covering
// Amplified price move beyond either mechanism alone

Event-Driven Trading / Earnings Play Trading options around known future events — earnings, FDA decisions, FOMC meetings. These create predictable IV spikes before the event and IV crush after. Buyers profit if the actual move exceeds the implied move; sellers profit if the move is smaller than implied.

// Calculate implied move at earnings:
implied_move = (ATM_call_premium + ATM_put_premium) / stock_price * 100

// Example: $100 stock, ATM straddle costs $8
implied_move = 8 / 100 * 100 = 8%  // market implies ±8% move

// Buyer edge: actual move > implied move
// Seller edge: actual move < implied move AND IV crushes
historical_implied_vs_actual = track over many events → find bias

Level 5: Strategies & Spreads

Multi-leg options strategies. Know max profit, max loss, and breakeven before entering any position.

Vertical Spread Buying and selling options of the same type (both calls or both puts) at different strikes but the same expiration. Reduces cost vs. a naked long option but caps profit potential. The foundation of most defined-risk options trading.

vertical_spread(type, long_strike, short_strike, expiry):
    buy_option(type, long_strike,  expiry)
    sell_option(type, short_strike, expiry)

    net_cost   = long_premium - short_premium
    width      = ABS(long_strike - short_strike)
    max_profit = width * 100 - net_cost   // for debit spreads
    max_loss   = net_cost                  // for debit spreads

Bull Call Spread Buy a call at a lower strike, sell a call at a higher strike (same expiry). Net debit. Profits if the stock rises above the lower strike before expiration. Cheaper than a naked long call; profit is capped at the higher strike.

bull_call_spread(low, high, expiry):
    buy_call(low, expiry)    // pay premium_low
    sell_call(high, expiry)  // receive premium_high

    net_debit  = premium_low - premium_high
    max_profit = (high - low) * 100 - net_debit
    max_loss   = net_debit
    breakeven  = low + net_debit

// Example: buy $150 call ($5), sell $160 call ($2) = $3 net debit
// max_profit = $700 | max_loss = $300 | breakeven = $153

Bear Call Spread Sell a call at a lower strike, buy a call at a higher strike (same expiry). Net credit. Profits if the stock stays below the lower (short) strike. Bearish to neutral strategy.

bear_call_spread(low, high, expiry):
    sell_call(low, expiry)   // receive premium
    buy_call(high, expiry)   // pay for protection

    net_credit = premium_received - premium_paid
    max_gain   = net_credit
    max_loss   = (high - low) * 100 - net_credit
    breakeven  = low + net_credit

Bull Put Spread Sell a put at a higher strike, buy a put at a lower strike (same expiry). Net credit. Profits if the stock stays above the higher (sold) strike. Bullish to neutral strategy — equivalent to a bull call spread in risk profile.

bull_put_spread(low, high, expiry):
    sell_put(high, expiry)   // higher strike = more premium
    buy_put(low, expiry)     // protection below

    net_credit = premium_received - premium_paid
    max_gain   = net_credit
    max_loss   = (high - low) * 100 - net_credit
    breakeven  = high - net_credit

Bear Put Spread Buy a put at a higher strike, sell a put at a lower strike (same expiry). Net debit. Profits if the stock falls below the higher (bought) strike before expiration.

bear_put_spread(low, high, expiry):
    buy_put(high, expiry)    // more expensive, closer to money
    sell_put(low, expiry)    // cheaper, reduces net cost

    net_debit  = premium_paid - premium_received
    max_profit = (high - low) * 100 - net_debit
    max_loss   = net_debit
    breakeven  = high - net_debit

Credit Spread / Debit Spread Credit spread: net premium received — you are a net seller. Profit from theta and range-bound stock. Debit spread: net premium paid — you are a net buyer. Profit from directional move. Same structural risk profile can be expressed as either a credit or debit spread using put-call parity.

classify_spread(premium_received, premium_paid):
    net = premium_received - premium_paid
    IF net > 0: RETURN CREDIT_SPREAD   // collect to enter
    IF net < 0: RETURN DEBIT_SPREAD    // pay to enter

// Credit spreads: profit from time + staying in range
// Debit spreads: need the stock to move in your favor

Iron Condor Selling an OTM put spread and an OTM call spread simultaneously on the same underlying and expiration. Four legs total. Profits when the stock stays between the two short strikes. Maximum profit is the net credit received.

iron_condor(low_put, mid_put, mid_call, high_call, expiry):
    buy_put(low_put, expiry)
    sell_put(mid_put, expiry)    // short put spread
    sell_call(mid_call, expiry)  // short call spread
    buy_call(high_call, expiry)

    net_credit  = total_received - total_paid
    max_gain    = net_credit
    max_loss    = MAX(put_spread_width, call_spread_width) * 100 - net_credit
    profit_zone = stock_between(mid_put, mid_call)

// Example: $130/$140 put spread + $160/$170 call spread = $3.00 credit
// max_gain = $300, max_loss = $700, profit if stock stays $140–$160

Iron Butterfly Like an iron condor but both short strikes are at the same ATM strike. Creates a tighter profit zone but higher credit received. Maximum profit when stock is exactly at the short strike at expiration.

iron_butterfly(low_put, ATM, high_call, expiry):
    buy_put(low_put, expiry)
    sell_put(ATM, expiry)
    sell_call(ATM, expiry)    // same strike as short put
    buy_call(high_call, expiry)

    net_credit  = short_straddle_credit - long_wing_cost
    max_gain    = net_credit  // stock exactly at ATM at expiry
    max_loss    = wing_width * 100 - net_credit

// Higher credit than iron condor, but much narrower profit window

Long Straddle Buying a call and a put at the same strike and expiration. Profits from large moves in either direction. Expensive — you pay for two options. Requires the stock to move more than the combined premium paid.

long_straddle(strike, expiry):
    buy_call(strike, expiry)   // premium_c
    buy_put(strike, expiry)    // premium_p

    total_cost      = (premium_c + premium_p) * 100
    max_loss        = total_cost  // stock stays exactly at strike
    upper_breakeven = strike + (premium_c + premium_p)
    lower_breakeven = strike - (premium_c + premium_p)
    max_gain        = UNLIMITED (up) | (lower_breakeven * 100) (down)

Short Straddle Selling a call and a put at the same strike and expiration. Maximum profit when stock stays exactly at the strike. Unlimited risk on the call side; large risk if the stock collapses. High-income, high-risk strategy.

short_straddle(strike, expiry):
    sell_call(strike, expiry)
    sell_put(strike, expiry)

    max_gain        = (premium_c + premium_p) * 100
    max_loss        = UNLIMITED (upside) | large (downside)
    upper_breakeven = strike + (premium_c + premium_p)
    lower_breakeven = strike - (premium_c + premium_p)
    // Profit zone is the narrow band between the two breakevens

Long Strangle Buying an OTM call and an OTM put at different strikes (same expiry). Cheaper than a straddle because both options are OTM at entry. Requires a larger move to profit.

long_strangle(put_strike, call_strike, expiry):
    buy_put(put_strike, expiry)     // OTM put — below current price
    buy_call(call_strike, expiry)   // OTM call — above current price

    total_cost      = (put_premium + call_premium) * 100
    upper_breakeven = call_strike + (put_premium + call_premium)
    lower_breakeven = put_strike  - (put_premium + call_premium)
    max_loss        = total_cost  // stock ends between put and call strike

Short Strangle Selling an OTM call and OTM put at different strikes. Wider profit zone than a short straddle. Still carries unlimited risk on the call side. High probability of profit in range-bound, low-volatility environments.

short_strangle(put_strike, call_strike, expiry):
    sell_put(put_strike, expiry)
    sell_call(call_strike, expiry)

    max_gain        = total_premium_received * 100
    profit_zone     = stock_between(put_strike, call_strike)  // wider than straddle
    max_loss        = UNLIMITED (above call) | large (below put)
    // Key advantage vs. short straddle: much wider range to stay profitable

Butterfly Spread Three strikes, wing ratio 1:2:1. Buy one option at the lower strike, sell two at the middle strike, buy one at the upper strike. Tent-shaped payoff — maximum profit if stock lands exactly at the middle strike at expiration.

butterfly_spread(low, mid, high, type, expiry):
    buy_option(type, low, expiry)    // × 1
    sell_option(type, mid, expiry)   // × 2  (the "body")
    buy_option(type, high, expiry)   // × 1

    net_debit  = (2 × mid_premium) - low_premium - high_premium  // usually small debit
    max_profit = (mid - low) * 100 - net_debit
    max_loss   = net_debit
    peak_at    = mid  // stock must expire exactly at middle strike

Condor Spread Four strikes, ratio 1:1:1:1. Buy far OTM, sell near OTM, sell near OTM (opposite side), buy far OTM. Flatter profit zone than a butterfly — profits over a range rather than a single point. All calls or all puts (unlike iron condor which mixes puts and calls).

condor_spread(a, b, c, d, type, expiry):
    // a < b < c < d, all same type
    buy_option(type, a, expiry)   // lowest
    sell_option(type, b, expiry)
    sell_option(type, c, expiry)
    buy_option(type, d, expiry)   // highest

    profit_zone = stock_between(b, c)  // the flat profit range
    max_profit  = net_credit from b and c sales - cost of wing options

Calendar Spread (Horizontal Spread) Buy a longer-dated option, sell the same strike with a shorter expiration. Profits from the front month decaying faster than the back month. Low directional risk; profits when stock stays near the strike and IV remains stable or rises.

calendar_spread(strike, near_expiry, far_expiry):
    sell_option(strike, near_expiry)  // shorter — decays faster
    buy_option(strike, far_expiry)    // longer — retains more value

    net_debit   = far_premium - near_premium
    max_gain    = when stock near strike at near_expiry
    max_loss    = net_debit (both options go far OTM or deep ITM)

// Profit from: front month theta > back month theta
// Risk: large price move hurts calendar — both legs lose value

Diagonal Spread Buy an option at one strike and expiration, sell an option at a different strike and earlier expiration. Combines time decay capture (calendar) with directional bias (vertical). Common structure for the Poor Man's Covered Call.

diagonal_spread(long_strike, short_strike, near_expiry, far_expiry):
    buy_option(long_strike,  far_expiry)    // longer-dated, deeper ITM
    sell_option(short_strike, near_expiry)  // shorter-dated, further OTM

    // Near expiry decays faster — collect premium each cycle
    // Roll the short option monthly as it expires

Poor Man's Covered Call (PMCC) Buy a deep ITM LEAP call as a stock substitute, then sell short-dated OTM calls against it each month. Replicates a covered call at a fraction of the capital cost — no need to own 100 shares.

PMCC(underlying, LEAP_strike, short_strike, near_expiry, LEAP_expiry):
    buy_LEAP_call(LEAP_strike, LEAP_expiry)    // ~0.80 delta, acts like stock
    sell_call(short_strike, near_expiry)        // monthly income

    capital_required = LEAP_premium * 100       // vs. 100 shares × stock_price
    monthly_income   = short_call_premium * 100
    risk             = LEAP value erodes if stock falls sharply or IV drops

Collar Long 100 shares + long put + short call. The put protects downside; the short call finances the put cost. Creates a bounded payoff — profit capped at call strike, loss capped at put strike.

collar(entry_price, put_strike, call_strike, expiry):
    own_shares(100)
    buy_put(put_strike, expiry)    // downside protection
    sell_call(call_strike, expiry) // finances the put

    max_gain = (call_strike - entry_price) * 100 + net_credit
    max_loss = (entry_price - put_strike)  * 100 - net_credit

Zero-Cost Collar A collar where the call premium exactly offsets the put cost — you pay nothing for the downside protection. Common for executives hedging large stock positions. Tradeoff: you give up all upside above the call strike.

zero_cost_collar(entry_price, put_strike, call_strike, expiry):
    put_cost    = get_put_premium(put_strike, expiry)
    call_credit = get_call_premium(call_strike, expiry)

    // Adjust strikes until put_cost ≈ call_credit
    WHILE ABS(put_cost - call_credit) > 0.05:
        adjust_call_strike_until_balanced()

    net_cost = 0  // free downside protection, capped upside

Risk Reversal Buy an OTM call, sell an OTM put (same expiry). Bullish position that mimics owning stock but at lower cost. Can often be done for a credit when put skew is elevated — selling expensive puts funds the call purchase.

risk_reversal(put_strike, call_strike, expiry):
    buy_call(call_strike, expiry)
    sell_put(put_strike, expiry)

    net = put_premium - call_premium
    IF net > 0: position_entered_for_credit  // put > call due to skew
    IF net < 0: position_entered_for_debit

    // Behaves like long stock between put_strike and call_strike

Fence A three-leg position: long stock + long put + short call. Functionally identical to a collar. The term "fence" is common in commodity and agricultural markets; "collar" is more common in equity markets.

// Fence = Collar (different terminology, same structure)
fence(long_shares, long_put, short_call, expiry):
    // Same as collar — long stock protected by put, income from call
    max_gain = (call_strike - entry_price) * 100 + net_credit
    max_loss = (entry_price - put_strike)  * 100 - net_credit

Box Spread A fully hedged four-leg position combining a bull call spread and a bear put spread at the same strikes. Guaranteed payoff at expiration equals the spread width. Used by sophisticated traders as a borrowing instrument at near-risk-free rates.

box_spread(low, high, expiry):
    buy_call(low, expiry)
    sell_call(high, expiry)
    buy_put(high, expiry)
    sell_put(low, expiry)

    // Guaranteed at expiration (regardless of stock price):
    guaranteed_value = (high - low) * 100

    // Present value (what you pay today):
    PV = guaranteed_value / (1 + risk_free_rate * T)

    // Net cost = PV → profit at expiry = guaranteed - PV (the "interest")

Jelly Roll A calendar spread combining two opposite synthetics across two expiration dates. Profits from the difference in interest rates and dividends between expiration dates. Primarily an institutional arbitrage trade.

jelly_roll(strike, near_expiry, far_expiry):
    // Near term: synthetic long (buy call + sell put)
    buy_call(strike, near_expiry)
    sell_put(strike, near_expiry)

    // Far term: synthetic short (sell call + buy put)
    sell_call(strike, far_expiry)
    buy_put(strike, far_expiry)

    // Profit = difference in cost of carry between the two dates
    // Affected by: interest rates, dividends, and time

Conversion / Reversal Risk-free arbitrage using stock, call, and put at the same strike. Conversion: long stock + long put + short call (locked profit when options mispriced above parity). Reversal: short stock + short put + long call (opposite mispricing). Exploits put-call parity violations.

// Put-call parity: C - P = S - PV(K)
// Conversion: C - P > S - PV(K) → sell the spread
conversion:
    buy_stock()
    buy_put(strike, expiry)
    sell_call(strike, expiry)
    profit = locked_in_from_mispricing  // risk-free

// Reversal: C - P < S - PV(K) → buy the spread
reversal:
    sell_stock_short()
    sell_put(strike, expiry)
    buy_call(strike, expiry)

Wheel Strategy A systematic income approach cycling through two phases. Phase 1: sell cash-secured puts until assigned — collect premium. Phase 2: sell covered calls on assigned shares until called away — collect more premium. Repeat indefinitely. Works best on stocks you are willing to own.

wheel(target_stock, put_strike, call_strike):
    // Phase 1: sell puts
    WHILE NOT assigned:
        sell_cash_secured_put(put_strike)  // collect premium
        IF assigned: receive_shares(at=put_strike)

    // Phase 2: sell covered calls
    WHILE holding_shares:
        sell_covered_call(call_strike)  // collect premium
        IF called_away: deliver_shares(at=call_strike)

    // Restart Phase 1
    effective_cost_basis = put_strike - SUM(all_premiums_collected)
    total_income         = SUM(all_premiums)

Covered Strangle Own 100 shares, sell an OTM call, AND sell an OTM put. Double income compared to a covered call but with added downside risk from the short put (which is not covered by the shares).

covered_strangle(shares, put_strike, call_strike, expiry):
    own_shares(100)
    sell_call(call_strike, expiry)   // income: upside capped
    sell_put(put_strike, expiry)     // additional income + downside risk

    total_income     = (call_premium + put_premium) * 100
    additional_risk  = put_strike * 100  // must buy more shares if put assigned

Ratio Spread / Back Spread Ratio spread: buy fewer options at one strike, sell more at another. Creates directional bias but with naked exposure on the extra short contracts. Back spread (reverse ratio): sell fewer, buy more — net long options. Profits from a large move or rising IV.

// Ratio spread (1:2 call ratio)
ratio_spread(low, high, expiry):
    buy_call(low, expiry)    // × 1
    sell_call(high, expiry)  // × 2  (extra short contract = unlimited risk above high)
    max_loss = UNLIMITED above the short strike

// Back spread (2:1 call back spread)
call_back_spread(low, high, expiry):
    sell_call(low, expiry)   // × 1
    buy_call(high, expiry)   // × 2  (net long options)
    max_loss = between the two strikes at expiration

Jade Lizard Sell an OTM put + sell an OTM call spread (bear call spread). Structured so the total credit exceeds the call spread width — eliminating upside risk. Only downside risk remains on the put side.

jade_lizard(put_strike, call_strike1, call_strike2, expiry):
    sell_put(put_strike, expiry)
    sell_call(call_strike1, expiry)
    buy_call(call_strike2, expiry)

    total_credit = put_premium + (call1_premium - call2_premium)

    // Key condition for no upside risk:
    ASSERT total_credit >= (call_strike2 - call_strike1)
    // If met: loss above call_strike2 is offset by the credit received

    max_loss = (put_strike - total_credit) * 100  // downside only

Broken Wing Butterfly A butterfly spread where one wing is wider than the other — creating a position that can be entered for a small credit instead of a debit. Risk exists on the wider wing side. Common variation: skip a strike on the downside wing (put broken wing butterfly).

broken_wing_butterfly(a, b, c, type, expiry):
    // a < b, c - b > b - a  (wider upper wing)
    buy_option(type, a, expiry)
    sell_option(type, b, expiry)  // × 2
    buy_option(type, c, expiry)

    // If wider upper wing → receive credit, risk is on the upside
    // Put BWB (wider lower wing) → receive credit, risk is on the downside
    max_gain = at strike b | OR = net_credit (if stock moves to wide side)

Arbitrage Risk-free profit from exploiting price discrepancies between related instruments. In options: put-call parity violations, box spread mispricings, or cross-market pricing differences. Rare in modern markets — algorithmic traders close mispricings within milliseconds.

arbitrage_exists(option_market):
    parity_value = call_price - put_price - stock_price + PV(strike)

    IF ABS(parity_value) > transaction_costs:
        RETURN TRUE  // arbitrage exists — execute immediately
    RETURN FALSE     // efficiently priced

// Retail reality: algorithms eliminate arb opportunities in < 1ms
// Retail traders cannot exploit standard arbitrage opportunities

Merger Arbitrage with Options Using options to trade the probability of an announced deal closing or failing. Buy target stock calls if confident the deal closes (target will trade to deal price). Buy target puts if you believe the deal will break.

merger_arb_options(target, deal_price, deal_break_price):
    // Deal closure bet:
    buy_call(target, strike_below_deal_price)
    // Profit if target trades up to deal price

    // Deal failure bet:
    buy_put(target, strike_above_current_price)
    // Profit if target collapses to pre-deal levels on failure

    // Risk: binary event — deal closes or breaks
    deal_close_probability = implied_from_current_spread_vs_deal_price

Diagonal Calendar Spread A combination of a diagonal spread and a calendar spread — different strikes and different expirations. More directionally flexible than a standard calendar. Allows adjusting the trade's bias while still capturing time decay.

diagonal_calendar(long_strike, short_strike, near_expiry, far_expiry):
    buy_option(long_strike,  far_expiry)    // longer-dated anchor
    sell_option(short_strike, near_expiry)  // shorter-dated monthly income

    // Directional bias from strike difference
    // Time decay from expiry difference
    // Roll the short leg monthly — keep the long leg as the anchor

Synthetic Arbitrage / Put-Call Parity Arbitrage / Relative Value Trade Trading the spread between two theoretically equivalent instruments. Synthetic arbitrage exploits mispricing between synthetic positions and their real equivalents. Relative value trade pairs two related options (e.g., same underlying, different strikes or dates) to exploit a discrepancy in relative pricing.

// Put-call parity arb: if C - P ≠ S - PV(K)
parity_arb = C - P - S + PV(K)
IF parity_arb > transaction_cost: execute_conversion()
IF parity_arb < -transaction_cost: execute_reversal()

// Relative value trade:
IF IV_call_strike_A > IV_call_strike_B by more_than_historical_avg:
    sell_call_A + buy_call_B  // bet on skew mean reversion

Level 6: Advanced & Niche

Professional-level concepts used by institutional traders, volatility desks, and options specialists.

Black-Scholes Model The foundational mathematical formula for pricing European options (Black and Scholes, 1973). Takes five inputs — stock price, strike, time, risk-free rate, volatility — and outputs a theoretical option price. All five standard Greeks are derived from this model as partial derivatives.

black_scholes_call(S, K, T, r, sigma):
    d1 = (LOG(S/K) + (r + sigma^2 / 2) * T) / (sigma * SQRT(T))
    d2 = d1 - sigma * SQRT(T)
    call_price = S * N(d1) - K * EXP(-r * T) * N(d2)
    RETURN call_price
    // N() = cumulative standard normal distribution

// Put price via put-call parity:
put_price = call_price - S + K * EXP(-r * T)

Put-Call Parity The mathematical relationship linking call price, put price, stock price, and present value of the strike. Any violation is an arbitrage opportunity. All options pricing theory is built on this foundation.

// Put-call parity:
// C - P = S - PV(K)
// C - P = S - K × EXP(-r × T)

verify_parity(C, P, S, K, r, T):
    lhs = C - P
    rhs = S - K * EXP(-r * T)

    IF ABS(lhs - rhs) > transaction_costs:
        RETURN "Arbitrage: execute conversion or reversal"
    RETURN "Fairly priced"

Binary Options Options that pay a fixed amount if a condition is met at expiration, or zero if not. A binary call pays $100 if the stock is above the strike; $0 otherwise. Exchange-traded binaries (CBOE) are legitimate; unregulated retail binary options products are frequently fraudulent.

binary_call_payoff(stock_price, strike, fixed_payout=100):
    IF stock_price > strike: RETURN fixed_payout
    ELSE:                    RETURN 0

// Pricing approximation:
// A standard option's delta ≈ probability of expiring ITM
// Binary call price ≈ delta × payout (under risk-neutral measure)
binary_call_price ≈ N(d2) * fixed_payout * EXP(-r * T)

Asian Options Exotic options where the payoff is based on the average price of the underlying over a period, not the final price. Reduces manipulation risk near expiration. Common in commodity and FX markets. Cheaper than standard options because averaging smooths volatility.

asian_call_payoff(price_series, strike):
    average_price = MEAN(price_series)   // average over the option's life
    RETURN MAX(0, average_price - strike) * multiplier

// vs. standard call:
standard_call = MAX(0, final_price - strike) * multiplier

// Asian options cost less:
asian_premium < standard_premium  // averaging reduces effective volatility

Barrier Options Exotic options that activate (knock-in) or deactivate (knock-out) when the underlying crosses a price barrier. Cheaper than standard options. Knock-out: option disappears if the stock reaches the barrier — you lose all value. Knock-in: option only becomes active once the stock reaches the barrier.

knock_out_call(stock_price, strike, barrier, expiry):
    IF stock_price_touched_barrier_during_life:
        RETURN 0   // knocked out — worthless regardless of final price
    ELSE:
        RETURN MAX(0, stock_price - strike) * multiplier  // standard payoff

knock_in_call(stock_price, strike, barrier, expiry):
    IF barrier_touched_during_life:
        RETURN MAX(0, stock_price - strike) * multiplier
    ELSE:
        RETURN 0   // never activated

Lookback Options Exotic options where the payoff is based on the maximum (call) or minimum (put) price reached during the option's entire life. Always exercise at the theoretically best price. Very expensive — significantly more than equivalent standard options.

lookback_call_payoff(price_series):
    max_price = MAX(price_series)  // highest price during life
    min_price = MIN(price_series)
    RETURN max_price - min_price   // fixed-strike variant: max - K

// Key: lookback always selects the best possible exercise point
// This guarantee makes it much more expensive than standard option
lookback_premium >> standard_premium

OVX CBOE Crude Oil Volatility Index — the "VIX for oil." Measures 30-day implied volatility of USO options. High OVX signals expected large oil price movement. Useful context when trading energy sector options or commodity-linked equities.

OVX = annualized_IV_USO_30day_ATM_options

// Correlation signal:
IF OVX_spikes AND energy_stock_IV_stable:
    energy_stocks_may_be_mispriced = TRUE
    // Oil vol rising but stock IV hasn't caught up yet

// OVX levels (approximate):
// < 25:  calm oil market
// 25-40: normal range
// > 50:  high fear in energy markets

VVIX The volatility of VIX — measures implied volatility of VIX options. Tells you how much VIX itself is expected to move. High VVIX means the market expects large VIX swings — elevated tail risk, potentially ahead of a vol event.

VVIX = implied_vol_of_VIX_options

// High VVIX + low VIX = calm now, but large vol spike expected
IF VVIX > 120 AND VIX < 15:
    tail_risk = ELEVATED  // market buying VIX protection quietly

// VVIX sometimes leads VIX spikes by days to weeks
// Use as early warning indicator for volatility events

VXN CBOE Nasdaq-100 Volatility Index — the VIX equivalent for the QQQ/Nasdaq-100. Tech stocks typically carry higher volatility than the broad S&P 500. VXN normally trades 5–8 points above VIX. Large divergence signals unusual relative risk in tech vs. broad market.

VXN = annualized_IV_NDX_30day_options

// VXN - VIX spread (normal: +5 to +8 points)
vxn_vix_spread = VXN - VIX

IF vxn_vix_spread > 15: tech_fear_elevated   = TRUE
IF vxn_vix_spread < 2:  tech_unusually_calm  = TRUE  // possible complacency

RVX CBOE Russell 2000 Volatility Index — measures small-cap implied volatility. Small caps are inherently riskier than large caps, so RVX typically trades above VIX. A dramatic spike in RVX relative to VIX signals small-cap specific stress (often credit or liquidity related).

RVX = annualized_IV_RUT_30day_options

// Small cap risk premium:
small_cap_premium = RVX - VIX

// RVX > VIX: always true in normal markets
// If spread widens dramatically: small cap stress, credit risk rising
// Watch for: RVX spike + VIX stable = small cap isolated selloff

TYVIX / MOVE Index Measures Treasury bond implied volatility — the bond market's fear gauge. High MOVE means large rate moves expected. A sustained divergence between VIX (equity calm) and MOVE (rate stress) often signals macro instability that eventually reaches equities.

MOVE = implied_vol_of_treasury_options  // ICE BofA MOVE Index

// MOVE levels (approximate):
// < 80:  calm rates environment
// 80-120: normal rate uncertainty
// > 120:  high rate volatility (Fed uncertainty, banking stress)

// Divergence signal:
IF MOVE > 130 AND VIX < 15:
    macro_risk_building = TRUE  // rates market sees stress before equities
    // Historically, equity vol follows rate vol with a lag of 2-6 weeks

Liquidity Risk / Counterparty Risk / Model Risk Three distinct risk categories beyond market risk. Liquidity risk: cannot exit a position at a fair price due to wide spreads or no buyers. Counterparty risk: eliminated for exchange-listed options via the OCC guarantee. Model risk: the model used to price options (Black-Scholes) may not reflect real-world behavior, especially for exotic options.

liquidity_risk(option):
    spread_pct = (ask - bid) / mid * 100
    IF spread_pct > 15 OR volume < 10: RETURN HIGH_LIQUIDITY_RISK

counterparty_risk:
    // Exchange-listed options: OCC guarantees all contracts = ZERO

model_risk(option_type):
    IF option_type IN [EXOTIC, BARRIER, LOOKBACK]: RETURN HIGH_MODEL_RISK
    // Black-Scholes assumes log-normal returns — real markets have fat tails
    // Model can misprice tail events significantly

Probability of Profit (PoP) The estimated likelihood a trade closes profitably. Approximated from option deltas and breakeven levels. Higher PoP trades typically have worse reward-to-risk — the market prices probability efficiently, so you rarely get high PoP AND high reward.

// Short OTM option PoP:
PoP_short_put = 1 - ABS(put_delta)
// 0.30 delta put → ~70% PoP

// Spread PoP — use breakeven vs. current price + IV:
PoP_spread = probability_stock_stays_above(breakeven, current_IV, DTE)

// Reality check: high PoP ≠ high expected value
// The market is aware of the probability — price reflects it

Expected Value (EV) / Edge Expected value is the probability-weighted average outcome — positive EV trades are worth taking systematically. Edge is the systematic advantage above breakeven EV that a strategy generates over many trades. Options sellers exploit the persistent vol premium (IV historically exceeds realized vol).

// Expected value of a short put:
EV = (PoP * max_gain) - ((1 - PoP) * avg_loss)

// Example: 70% PoP, $300 gain, average loss $700:
EV = (0.70 * 300) - (0.30 * 700) = 210 - 210 = 0  // breakeven

// Real edge comes from vol premium (IV consistently > HV):
edge_per_trade = IV_at_entry - realized_vol_at_expiry  // in volatility points
// Positive historically → premium sellers have a systematic edge

// Net edge after costs:
net_edge = gross_edge - commissions - slippage
ASSERT net_edge > 0  // if not, strategy is not viable

Dark Pool / Block Trade / Sweep Order Dark pools: private trading venues for large institutional orders — executed away from public exchanges to avoid market impact. Block trade: a large off-exchange negotiated transaction. Sweep order: an aggressive large order hitting all available contracts at multiple strikes simultaneously — signals urgency and directional conviction.

// Sweep detection signals:
sweep_detected(order):
    RETURN (
        order.size > 1000_contracts AND
        order.filled_across_multiple_exchanges AND
        order.price == ask  // buyer paying up — will not wait
    )

// Sweep is more bullish than a patient limit order at the mid
// Interpretation: buyer expects imminent move, cannot wait for better fill

dark_pool_signal = sudden_large_OI_increase WITHOUT corresponding_public_volume

Flash Crash An extreme intraday market move (usually downward) that reverses quickly — often caused by algorithmic feedback loops, forced liquidation, or cascade stops. Options can trade at extreme prices during a flash crash. Short gamma positions can sustain catastrophic losses in seconds.

// Flash crash risk for short gamma positions:
flash_crash_scenario:
    time = 5_minutes
    market_drop = -8%
    stock_goes_ITM = short_options_deep_ITM
    gamma_loss = gamma * price_move^2  // loss accelerates non-linearly

    // P&L in 5 minutes:
    delta_loss = delta * (-8%) * position_size
    gamma_loss = 0.5 * gamma * (price_move)^2  // second-order loss
    total_loss = delta_loss + gamma_loss  // can be catastrophic

// Protection: defined-risk spreads cap max loss regardless

Tender Offer Play / Special Dividend Risk / Corporate Action Options Options adjustments triggered by corporate events. Tender offer: a company offers to buy shares at a premium — puts become near-worthless, calls may gain. Special dividend: stock drops on ex-date, calls lose value, puts gain. Spin-off: options may deliver new company shares as part of the adjusted deliverable.

// Tender offer effect on options:
tender_offer_premium = 20%_above_current_price

// All OTM calls suddenly ITM:
call_value_change = MAX(0, tender_price - strike) - original_call_price

// Special dividend: stock drops by dividend_amount on ex-date
stock_adjustment = -dividend_amount
call_new_value = calculate_call(stock_price - dividend_amount, strike, DTE, IV)
// OCC adjusts strike or multiplier for special dividends above threshold

Ex-Dividend / Reverse Split / Spin-Off Adjustment OCC adjusts option contracts to preserve fair value after corporate actions. After a 2:1 stock split: strike halved, multiplier doubled. After a reverse split: opposite. Spin-off: options may deliver a package of original shares + new company shares. Adjusted contracts often become illiquid.

// 2:1 stock split adjustment:
pre_split  = { strike: 200, multiplier: 100, total_value: 200 * 100 = 20000 }
post_split = { strike: 100, multiplier: 200, total_value: 100 * 200 = 20000 }  // same

// Spin-off: deliverable becomes a package
spin_off_deliverable = {
    original_shares:  100,
    new_co_shares:    spin_ratio * 100  // e.g., 0.5 new shares per original
}

// Adjusted contracts: verify terms before trading — OCC publishes all adjustments

Rights Offering / Warrant / Convertible Bond Optionality Rights: short-term options issued by the company to existing shareholders to buy new shares at a discount — not exchange-traded options. Warrants: long-term options issued by the company (often with bonds) — traded, but subject to dilution. Convertible bond optionality: the embedded right to convert a bond into equity at a fixed price.

// Warrant value approximation:
warrant_value ≈ MAX(0, stock_price - exercise_price)  // basic intrinsic

// Dilution when warrants exercised:
new_shares_issued   = warrants_exercised
total_shares_after  = original_shares + new_shares_issued
dilution_pct        = new_shares_issued / total_shares_after * 100

// Convertible bond: embedded call option on the stock
// Bond holder can convert bonds → shares at the conversion price
conversion_value = bonds_held * (stock_price / conversion_price) * face_value

Employee Stock Option (ESO) Options granted to employees as compensation — not exchange-traded. Cannot be sold or transferred. Vest over 3–4 years. Subject to blackout periods around earnings. Taxed as ordinary income (not capital gains) when exercised. Must be managed separately from standard options strategy.

ESO = {
    grant_date:     date_of_grant,
    total_options:  N,
    exercise_price: stock_price_at_grant,   // fixed — never changes
    vesting: {
        cliff:   25% after 1 year,
        monthly: 75% over 36 months after cliff
    },
    expiry: 10_years_from_grant
}

vested_options(date):
    IF date < cliff_date: RETURN 0
    cliff_vested   = total_options * 0.25
    monthly_vested = (date - cliff_date).months * (total_options * 0.75 / 36)
    RETURN cliff_vested + monthly_vested

Index Option Options on a broad market index (SPX, NDX, RUT, DJIA). European-style, cash-settled. No shares change hands on exercise. In the US, index options receive favorable tax treatment under Section 1256: 60% long-term / 40% short-term capital gains regardless of holding period.

// SPX call cash settlement:
spx_settlement = MAX(0, SPX_VRO - strike) * 100
// VRO = special opening settlement value, not closing price

// Tax treatment (US Section 1256 contracts):
IF contract_is_1256:
    long_term_pct  = 60%
    short_term_pct = 40%
    // Annual mark-to-market — taxed each year regardless of open position

Futures Option Options on futures contracts — crude oil, gold, corn, Treasury bonds, currencies. Underlying is a futures contract, not a stock. Usually American-style; exercise delivers a long or short futures position. Subject to CFTC regulation. Margin requirements differ from equity options.

futures_option_exercise(option_type, strike, futures_price):
    // Exercise delivers a futures position, not shares
    IF option_type == CALL:
        buyer_receives = LONG_futures_at_strike_price
    IF option_type == PUT:
        buyer_receives = SHORT_futures_at_strike_price

// Margin: futures options use SPAN margining (risk-based)
// vs. Reg T for equity options (percentage of notional)
margin = SPAN(position_delta, gamma, vega, DTE)

Currency Option / Interest Rate Option Currency options: right to buy or sell a foreign currency at a fixed exchange rate before expiration. Used by corporations to hedge FX exposure and by traders to speculate on rate moves. Interest rate options (caps, floors, swaptions): options on interest rates used by banks and corporations to manage rate risk.

// EUR/USD call: right to buy EUR at strike USD price
fx_call_payoff(EUR_USD_rate, strike, notional_EUR):
    IF EUR_USD_rate > strike:
        RETURN (EUR_USD_rate - strike) * notional_EUR
    RETURN 0

// Interest rate cap: protects floating-rate borrower
cap_payoff(actual_rate, cap_rate, notional, period):
    IF actual_rate > cap_rate:
        RETURN (actual_rate - cap_rate) * notional * period
    RETURN 0  // no payment if rate stays below cap

Where to Go From Here

This options trading cheat sheet is a reference, not a reading assignment. Use it to look up terms as you encounter them in real trading — return when a term appears in your broker platform, a research report, or a risk report you cannot fully parse.

The pseudo code for each term is a tool. When a concept feels abstract, run through the logic manually with real numbers from an actual position. Options mechanics are exact — they follow the logic precisely every time.

Return to Level 5 and 6 when a specific strategy or risk event sends you looking for terminology. Those sections are designed for targeted lookup, not sequential reading.