By Matt Connor
Collar Option Greeks as the Stock Moves
A collar's option greeks flip sign as the stock moves. See net delta, gamma, theta and vega priced at five spots, from below the put to above the call.
A collar's option greeks change sign as the stock moves. The three legs never change, 100 shares of stock, one long put below the market and one short call above it, yet the same position reads long gamma near the put strike and short gamma near the call strike, and its theta switches from an expense to an income somewhere in between. The panels below price one collar at five stock prices and show every greek at each of them.
The collar we are pricing, leg by leg
The model panels on this page all price one hypothetical position:
- 100 shares of a stock trading near $100
- long one put struck at $90
- short one call struck at $110
- both option legs 30 calendar days from expiry
- both priced at a flat 25% implied volatility, a 4% risk free rate and no dividend
One contract covers 100 shares, so each option leg carries a multiplier of 100. Every figure below is a position greek rather than a per share greek: net delta in share equivalents, net gamma in share equivalents gained or lost per $1 move, net theta in dollars per calendar day, net vega in dollars per one point of implied volatility. The values are Black-Scholes outputs computed inside each panel's SQL from those round inputs, so they are reproducible and never depend on a live quote. If the structure itself is new to you, start with how a collar is built and the covered call versus collar comparison.
How a collar's delta changes with the stock price
The stock contributes a flat 100 share equivalents at any price. The long put contributes a negative delta that deepens toward -100 as the stock falls under its strike. The short call contributes a negative delta that deepens toward -100 as the stock climbs over its own. Add the three and you have the position's exposure at that moment.
The exact SQL behind every number
SELECT
spot_price,
stock_delta,
long_put_delta,
short_call_delta,
net_delta
FROM
(
WITH
100.0 AS shares,
100.0 AS contract_multiplier,
90.0 AS put_strike,
110.0 AS call_strike,
0.25 AS vol,
0.04 AS rate,
30.0 / 365.0 AS years
SELECT
spot,
concat('$', toString(toUInt16(spot))) AS spot_price,
(log(spot / put_strike) + (rate + 0.5 * vol * vol) * years) / (vol * sqrt(years)) AS d1_put,
(log(spot / call_strike) + (rate + 0.5 * vol * vol) * years) / (vol * sqrt(years)) AS d1_call,
0.5 * (1 + erf(d1_put / sqrt(2))) AS nd1_put,
0.5 * (1 + erf(d1_call / sqrt(2))) AS nd1_call,
toInt32(shares) AS stock_delta,
round(contract_multiplier * (nd1_put - 1), 1) AS long_put_delta,
round(-contract_multiplier * nd1_call, 1) AS short_call_delta,
round(shares + contract_multiplier * (nd1_put - 1) - contract_multiplier * nd1_call, 1) AS net_delta
FROM
(
SELECT arrayJoin([85.0, 90.0, 100.0, 110.0, 118.0]) AS spot
)
)
ORDER BY spotNet delta traces a hump, not a line. At $85, under the put strike, the put alone carries -76.3 share equivalents and the position nets 23.7: most of the downside has already been handed off. Midway between the strikes at $100 both options sit out of the money and net delta reaches 83.4, the closest this position comes to simply owning shares. Above the call strike at $118 the short call carries -85.6 and the net lands at 14.4. A collar is at its most stock-like in the middle of its range and at its most hedged at either end. Anyone measuring exposure across a whole account meets the same arithmetic in beta weighted portfolio delta.
Collar option greeks at five stock prices
Delta describes the exposure right now. Gamma, theta and vega describe how that exposure behaves as the stock moves, as the clock runs and as implied volatility changes. In a collar each of them carries a different sign at different prices.
The exact SQL behind every number
SELECT
spot_price,
net_gamma,
net_theta,
net_vega
FROM
(
WITH
100.0 AS contract_multiplier,
90.0 AS put_strike,
110.0 AS call_strike,
0.25 AS vol,
0.04 AS rate,
30.0 / 365.0 AS years
SELECT
spot,
concat('$', toString(toUInt16(spot))) AS spot_price,
(log(spot / put_strike) + (rate + 0.5 * vol * vol) * years) / (vol * sqrt(years)) AS d1_put,
(log(spot / call_strike) + (rate + 0.5 * vol * vol) * years) / (vol * sqrt(years)) AS d1_call,
d1_put - vol * sqrt(years) AS d2_put,
d1_call - vol * sqrt(years) AS d2_call,
exp(-0.5 * d1_put * d1_put) / sqrt(2 * pi()) AS pdf_put,
exp(-0.5 * d1_call * d1_call) / sqrt(2 * pi()) AS pdf_call,
0.5 * (1 + erf(-d2_put / sqrt(2))) AS nd2_put_below,
0.5 * (1 + erf( d2_call / sqrt(2))) AS nd2_call_above,
pdf_put / (spot * vol * sqrt(years)) AS gamma_put,
pdf_call / (spot * vol * sqrt(years)) AS gamma_call,
(-(spot * pdf_put * vol) / (2 * sqrt(years)) + rate * put_strike * exp(-rate * years) * nd2_put_below) / 365 AS theta_put_day,
(-(spot * pdf_call * vol) / (2 * sqrt(years)) - rate * call_strike * exp(-rate * years) * nd2_call_above) / 365 AS theta_call_day,
spot * pdf_put * sqrt(years) / 100 AS vega_put_point,
spot * pdf_call * sqrt(years) / 100 AS vega_call_point,
round(contract_multiplier * (gamma_put - gamma_call), 2) AS net_gamma,
round(contract_multiplier * (theta_put_day - theta_call_day), 2) AS net_theta,
round(contract_multiplier * (vega_put_point - vega_call_point), 2) AS net_vega
FROM
(
SELECT arrayJoin([85.0, 90.0, 100.0, 110.0, 118.0]) AS spot
)
)
ORDER BY spotNear the put strike at $90 the long put dominates the position: net gamma 6.01, net vega 10 per volatility point, net theta -3.68 per day. That is a long options profile. The position picks up delta on a rally, sheds it on a decline, gains value when implied volatility rises, and pays a daily rent for holding that shape.
Near the call strike at $110 every sign reverses: gamma -4.96, vega -12.34, theta 5.75 a day. Same three legs, opposite behaviour. The position now sheds delta on a rally, gains value when implied volatility falls, and collects the daily rent instead of paying it.
Between the strikes at $100 all three readings sit close to zero: gamma -0.88, vega -1.82 and theta 0.94 a day. With both options out of the money, a collar in the middle of its range is a stock position wearing two very quiet options.
Why the same collar pays theta at one price and collects it at another
Theta is the model's estimate of what one day's passage removes from an option's price with everything else held fixed. It works on extrinsic value, the part of an option's price above its intrinsic value, and extrinsic value concentrates in whichever leg sits nearest the money. At the put strike the long put holds most of the position's extrinsic value, and decay on a long option is an expense. At the call strike the short call holds it, and decay on a short option is income. Gamma and vega concentrate in that same near-the-money leg, which is why all three flip together rather than one at a time. The single leg mechanics are covered in option theta and option vega.
This is what a position greeks screen is showing when a collar pays theta one week and collects it the next with no trade in between. The legs did not change. The stock moved across the range, and the clock advanced.
What the final weeks do to the same collar
Where the stock sits is only half the story. Gamma also concentrates as expiry approaches, and pricing the identical collar at three tenors makes that visible.
The exact SQL behind every number
SELECT
spot_price,
round(maxIf(net_gamma, days_out = 90), 2) AS gamma_90d,
round(maxIf(net_gamma, days_out = 30), 2) AS gamma_30d,
round(maxIf(net_gamma, days_out = 7), 2) AS gamma_7d
FROM
(
WITH
100.0 AS contract_multiplier,
90.0 AS put_strike,
110.0 AS call_strike,
0.25 AS vol,
0.04 AS rate
SELECT
spot,
days_out,
concat('$', toString(toUInt16(spot))) AS spot_price,
days_out / 365.0 AS years,
(log(spot / put_strike) + (rate + 0.5 * vol * vol) * years) / (vol * sqrt(years)) AS d1_put,
(log(spot / call_strike) + (rate + 0.5 * vol * vol) * years) / (vol * sqrt(years)) AS d1_call,
exp(-0.5 * d1_put * d1_put) / sqrt(2 * pi()) AS pdf_put,
exp(-0.5 * d1_call * d1_call) / sqrt(2 * pi()) AS pdf_call,
contract_multiplier * (pdf_put - pdf_call) / (spot * vol * sqrt(years)) AS net_gamma
FROM
(
SELECT
spot,
arrayJoin([7, 30, 90]) AS days_out
FROM
(
SELECT arrayJoin([85.0, 90.0, 100.0, 110.0, 118.0]) AS spot
)
)
)
GROUP BY spot, spot_price
ORDER BY spotAt the put strike the reading runs 2.33 at 90 days, 6.01 at 30 days and 12.79 in the final week. At the call strike the same compression runs the other way and reaches -10.47 at 7 days. Away from the strikes the effect inverts: at $85, five dollars under the put, the seven day reading of 3.7 comes in under the 5.05 that same price shows a month out, since five dollars is a long way to travel in a week.
That is the mechanical backdrop to rolling a collar. Moving a strike to a later expiry, or further from the stock, trades a concentrated greek profile for a diffuse one: an option the stock is pinned against in expiry week carries many times the gamma, vega and theta of an option months away. The same effect across every greek is laid out in how option greeks change over time.
Where the flat volatility assumption stops
The model above prices both legs at the same 25%. Live option markets quote a different implied volatility at every strike. The panel below takes one liquid name, AAPL, averages implied volatility across three months of contracts with 20 to 45 days to expiry, and groups them by how far each strike sat from that day's closing price, downside puts on one side and upside calls on the other.
The exact SQL behind every number
SELECT
concat(toString(distance_pct), '% out') AS strike_distance,
round(100 * avgIf(implied_volatility, below_spot AND put_leg), 1) AS downside_put_iv_pct,
round(100 * avgIf(implied_volatility, above_spot AND call_leg), 1) AS upside_call_iv_pct,
round(100 * (avgIf(implied_volatility, below_spot AND put_leg)
- avgIf(implied_volatility, above_spot AND call_leg)), 1) AS put_minus_call_pts
FROM
(
SELECT
implied_volatility,
round(abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) * 100 / 2.5) * 2.5 AS distance_pct,
toFloat64(strike_price) < toFloat64(underlying_close) AS below_spot,
toFloat64(strike_price) > toFloat64(underlying_close) AS above_spot,
delta < 0 AS put_leg,
delta > 0 AS call_leg
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
AND date >= '2026-05-01'
AND date < '2026-08-01'
AND iv_converged = 1
AND volume > 0
AND days_to_expiry BETWEEN 20 AND 45
AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) BETWEEN 0.015 AND 0.16
)
GROUP BY distance_pct
HAVING countIf(below_spot AND put_leg) > 50
AND countIf(above_spot AND call_leg) > 50
ORDER BY distance_pctAt 2.5% out the downside puts averaged 26.1% against 26% for the equally distant upside calls. At 15% out the downside puts averaged 34.5% against 26.7%, a gap of 7.8 volatility points. A collar buys its put from the steeper side of that curve and sells its call into the flatter one, so the vega on a live surface will not match a flat-volatility model exactly. The shape itself is covered in what implied volatility is and tracked for this name in AAPL implied volatility.
Model assumptions and data notes
- Black-Scholes on a non-dividend-paying stock, European exercise, a flat 25% implied volatility on both legs, a 4% risk free rate and a 30 out of 365 year fraction. The full formula sits in each panel's SQL.
- Theta is the annual figure divided by 365 for one calendar day. Vega is scaled to one point of implied volatility. Both are multiplied by 100 for the contract size.
- Listed US equity options are American style and can be exercised early, most often around a dividend. That behaviour sits outside this model, and each leg of a real collar carries its own implied volatility.
- The AAPL panel reads contracts with converged implied volatility and non-zero volume, 20 to 45 days to expiry, dated 1 May 2026 through 31 July 2026, bucketed in 2.5% steps by the distance between the strike and the same day's closing price.
FAQ
Does a collar have positive or negative theta?
Both, at different stock prices. Priced 30 days out, the example collar shows -3.68 dollars a day with the stock at the put strike and 5.75 dollars a day at the call strike. The sign belongs to the price, not to the structure.
Is a collar long or short gamma?
Near the put strike it is long gamma, near the call strike it is short gamma, and between the two it is close to flat. The worked example prints 6.01 at the put strike and -4.96 at the call strike. The single leg version is in what option gamma is.
Why do my collar's greeks look different from last week?
Nothing in the position has to change for the numbers to change. Distance from each strike and days left to expiry are both inputs to every greek, and both move on their own.
Does a zero cost collar have zero greeks?
No. Zero cost describes the premium on day one: the call sold pays for the put bought. The position still carries the delta, gamma, theta and vega shown above, and each keeps moving with the stock.
Why is a collar's delta highest between the strikes?
Both options are out of the money there, leaving the 100 shares as almost the whole exposure. The example nets 83.4 share equivalents at $100 against 23.7 at $85, where the put has taken over most of the downside.
Every panel here ships with the SQL underneath it, Black-Scholes arithmetic included, so any figure can be checked line by line. To price the same three legs against other strikes, dates and volatilities, ask for it in plain English on the Strasmore terminal.