Option desk

per contract  GEX = gamma x OI x 100 x S^2 x 0.01
              gamma x S x 0.01 is the delta change over a one percent move, per share;
              x S turns shares into currency;  x 100 x OI scales it to every open contract
sign          calls +, puts -   (dealers long calls and short puts against the public: the conventional
              assumption, stated on the panel because it is regularly wrong for a single name)
per strike    net_K = sum over the contracts listed at K of signed GEX
net           sum over strikes; above zero read as dampening, below zero as amplifying
walls         call wall = the strike with the largest call GEX;  put wall = the strike with the most negative put GEX
cumulative    C_K = running sum of net_K from the lowest listed strike upward, so extending the ladder
              shifts the whole profile
flip          the level where C_K crosses zero, interpolated between the two strikes that straddle it;
              with several crossings the one nearest spot is the headline and the rest are in the artifact
max pain      argmin over settlement P of  sum over K [ OI_call(K) max(P - K, 0) + OI_put(K) max(K - P, 0) ] x 100
              evaluated at each listed strike: a description of where open interest sits, not a forecast
ratios        put/call OI = sum of put OI / sum of call OI over the contracts in the profile, which are those
              carrying gamma, open interest and strike;  put/call volume = sum of put volume / sum of call volume
              over every option in the chain, a missing volume counted as zero
skipped       a contract missing gamma, open interest or strike is counted apart by cause, never treated as zero,
              and is out of the profile and the OI ratio above

at the money   the listed strike nearest spot, calls winning a tie; not an interpolated forward
wings          the call and the put whose model delta is nearest 0.25, accepted only within 0.10 of it;
               a chain that does not reach a wing reports the figure as absent rather than substituted
risk reversal  RR = sigma(put 25d) - sigma(call 25d)      positive: the downside is bid
butterfly      BF = ( sigma(put 25d) + sigma(call 25d) ) / 2 - sigma(atm)
skew slope     least-squares slope of sigma against (K / S - 1) x 100, calls only, over every call in the chain
               that carries a volatility: the whole chain, not the ladder's band
expected move  EM = S x sigma(atm) x sqrt(30 / 365)      one standard deviation over the life of the expiry
               range = [ max(S - EM, 0), S + EM ]: about 68 percent of outcomes under a lognormal
term           the same figures per expiry on file, so the slope across tenors is visible
realised       sigma(real) = sqrt( (1 / n) sum over t of r_t^2 x 252 ),  r_t = ln(S_t / S_t-1), over the simulation's
               history window of n returns: the simulation's own estimator, uncentred and divided by n, not the
               backtest's centred sample variance with n - 1
premium gap    gap = sigma(atm) - sigma(real) per expiry: a disagreement between forecast and past, not an edge

payoff         P(S_T) = sum over legs of side x qty x ( value(S_T) - premium )
               call value max(S_T - K, 0);  put value max(K - S_T, 0);  underlying S_T - entry price
               side is +1 long, -1 short; premiums are snapshot mids, so this is a shape and not a fill
breakevens     every settlement price where P(S_T) = 0, one per sign change of the piecewise-linear payoff
extremes       max gain and max loss over all S_T; "unlimited" only on the upside, where the slope beyond the
               last strike does not vanish; the downside is bounded by S_T = 0 and is evaluated there
capital        capital at risk = |max loss| for a defined-risk structure; undefined where the loss is unbounded,
               and such a structure is listed but not ranked
reward:risk    max gain / |max loss|
P(profit)      the lognormal mass of the profitable regions between breakevens, under
               ln(S_T) ~ Normal( ln(S) + (mu - sigma^2 / 2) T,  sigma^2 T ),  mu = 0,  T = days / 365
               with sigma = one at-the-money implied volatility for every strike: a model estimate, not a win rate
expected P/L   E[ P(S_T) ] under the same law, in closed form region by region, the regions cut at every strike
               and every breakeven, because P is linear in S_T between strikes and the partial expectation of a
               lognormal is analytic
shortfall      expected loss = E[ P(S_T) | P(S_T) < 0 ], the same way
ranking        expected return on risk = E[P] / capital at risk; the comparison orders on it, ties broken on P(profit)
friction       half spread = (ask - bid) / 2 per option leg;  entry = qty x half spread x 0.5
               round trip = 2 x entry + commission;  verdict ok below 10% of the net premium, thin up to 25%,
               untradeable above that, where a leg quotes wider than 40% of its own mid, or where a leg has no bid

model      Black-Scholes-Merton, European exercise, continuous carry q
           T  = calendar days to expiry / 365
           d1 = [ ln(S / K) + (r - q + sigma^2 / 2) T ] / ( sigma sqrt(T) )
           d2 = d1 - sigma sqrt(T)
           call = S exp(-qT) N(d1) - K exp(-rT) N(d2)
           put  = K exp(-rT) N(-d2) - S exp(-qT) N(-d1)
carry      r and q are read from the chain snapshot (this chain: r = 0.0400, q = 0.0000); the engine defaults are r = 0.04, q = 0
implied    sigma solves  model(S, K, T, sigma) = mid,  with mid = (bid + ask) / 2 where both sides are quoted
           and the last trade standing in for mid where a side is missing, counted apart as a last-trade mark;
           a user-supplied chain that carries its own volatility column keeps it as given and is never re-solved
           Newton-Raphson from a fixed seed, bisection on [0.001, 5] when Newton leaves the bracket
           a root is accepted only where the price is sensitive to volatility, vega > 0.0002;
           otherwise the contract keeps the provider's figure and is counted as a fallback,
           or carries no volatility at all and is skipped, never estimated
greeks     analytic, first to third order, each checked against a central finite difference
           of the price function in the test suite
           delta = dV/dS                gamma = d2V/dS2              vega  = dV/dsigma, per 1.00
           theta = dV per calendar day  rho   = dV/dr, per 1.00      lambda = delta S / V
           vanna = d2V/dS dsigma        vomma = d2V/dsigma2          charm = d delta per calendar day
           veta  = d vega per day       speed = d3V/dS3              zomma = d gamma / dsigma
           color = d gamma per day      ultima = d3V/dsigma3         dual delta = dV/dK,  dual gamma = d2V/dK2
           the four per-day figures are the change as one calendar day passes, so a negative theta is decay