Introduction

Suppose a bank sells you the right to buy a share of stock for $100 in three months. The bank has just taken on risk: if the stock shoots to $130 the bank must sell it to you at a steep loss. How do professional traders manage that exposure without simply holding every share they might ever owe?

The answer is dynamic hedging — adjusting a portfolio of shares and cash continuously so that small moves in the stock price cancel out. The tool that tells you how much to hold is called delta (Δ\Delta), the first of the Greeks: a family of partial derivatives that dissect an option's price into its moving parts.

  • Delta (Δ\Delta) — how much the option price changes per $1 move in the underlying.
  • Gamma (Γ\Gamma) — how fast delta itself changes; the curvature of the option's value.
  • Vega (V\mathcal{V}) — sensitivity to implied volatility; the risk that the market's fear gauge swings.

Understanding the Greeks is not just finance trivia. It is the same mathematical structure that appears whenever you must control a continuously evolving system — from robotics to control theory to Monte Carlo methods.

Try It: Delta-Hedge in Real Time

The simulator below prices a European call option using the Black-Scholes formula and computes its Greeks. Drag the stock price slider to simulate the underlying drifting through the day.

<!-- Option Greeks & Delta-Hedging demo -->
<div class="controls">
  <label>Stock price $ <span id="s-val">100.00</span></label>
  <input type="range" id="s-slider" min="60" max="140" step="0.5" value="100">
  <label>Implied vol <span id="vol-val">20</span>%</label>
  <input type="range" id="vol-slider" min="5" max="80" step="1" value="20">
  <label>Days to expiry <span id="t-val">30</span></label>
  <input type="range" id="t-slider" min="1" max="90" step="1" value="30">
</div>
<table id="greeks-table">
  <thead>
    <tr>
      <th>Greek</th>
      <th>Value</th>
      <th>Meaning</th>
    </tr>
  </thead>
  <tbody>
    <tr><td>Price (C)</td><td id="c-price">—</td><td id="c-price-desc">—</td></tr>
    <tr><td>Delta (Δ)</td><td id="c-delta">—</td><td id="c-delta-desc">—</td></tr>
    <tr><td>Gamma (Γ)</td><td id="c-gamma">—</td><td id="c-gamma-desc">—</td></tr>
    <tr><td>Vega (𝒱)</td><td id="c-vega">—</td><td id="c-vega-desc">—</td></tr>
  </tbody>
</table>
<div class="hedge-row">
  <span>Current hedge:</span>
  <span id="hedge-shares">—</span>
  <span>shares held</span>
</div>
<div class="status" id="status"></div>
<div class="btns">
  <button id="btn-rebalance" type="button">Re-hedge now</button>
  <button id="btn-reset" type="button" class="ghost">Reset</button>
</div>

/* base reset */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; font-size: 14px; }
.controls { display: grid; grid-template-columns: auto 1fr; gap: 4px 10px; align-items: center; margin-bottom: .8rem; }
.controls label { white-space: nowrap; font-weight: 600; font-size: .85rem; }
input[type=range] { width: 100%; }
table { width: 100%; border-collapse: collapse; margin-bottom: .7rem; }
th { background: #1d3557; color: #fff; padding: 5px 8px; text-align: left; font-size: .82rem; }
td { padding: 4px 8px; border-bottom: 1px solid #dee2e6; font-size: .85rem; }
td:first-child { font-weight: 700; font-family: ui-monospace, monospace; }
tr:nth-child(even) td { background: #f4f7fa; }
.hedge-row { font-size: .9rem; margin-bottom: .5rem; }
.hedge-row span:nth-child(2) { font-weight: 700; font-size: 1rem; margin: 0 .3rem; color: #1d3557; }
.status { font-size: .9rem; font-weight: 600; min-height: 1.4em; margin-bottom: .4rem; }
.status.gain { color: #0a7d33; }
.status.loss { color: #c92f3c; }
.status.neutral { color: #555; }
.btns { display: flex; gap: .5rem; }
button { font: 600 13px system-ui; padding: .4rem .85rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Black-Scholes European call pricer + Greeks calculator.
// Model: log-normal stock, constant vol & rate, no dividends.

// Abramowitz & Stegun approximation for the standard normal CDF.
function normCDF(x) {
  const t = 1 / (1 + 0.2316419 * Math.abs(x));
  const poly = t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
  const pdf = Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
  const result = 1 - pdf * poly;
  return x >= 0 ? result : 1 - result;
}

// Standard normal PDF.
function normPDF(x) { return Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI); }

// Compute price, delta, gamma and vega for a European call.
// Inputs: S=stock price, K=strike, r=risk-free rate, T=time(years), sig=volatility
function bsGreeks(S, K, r, T, sig) {
  if (T <= 0) {
    const intrinsic = Math.max(S - K, 0);
    return { price: intrinsic, delta: S > K ? 1 : 0, gamma: 0, vega: 0, d1: 0, d2: 0 };
  }
  const sqrtT = Math.sqrt(T);
  const d1 = (Math.log(S / K) + (r + 0.5 * sig * sig) * T) / (sig * sqrtT);
  const d2 = d1 - sig * sqrtT;
  const price = S * normCDF(d1) - K * Math.exp(-r * T) * normCDF(d2);
  const delta = normCDF(d1);
  const gamma = normPDF(d1) / (S * sig * sqrtT);
  const vega = S * normPDF(d1) * sqrtT / 100; // per 1% move in vol
  return { price, delta, gamma, vega, d1, d2 };
}

// Fixed parameters: strike = $100, risk-free rate = 5%
const K = 100, r = 0.05;

// Hedge state: prevS = last rebalanced stock price, hedgeShares = current hedge ratio
let prevS = null, prevDelta = null, hedgeShares = null, hedgeValue = null, pnl = 0;

const slider = document.getElementById('s-slider');
const volSlider = document.getElementById('vol-slider');
const tSlider = document.getElementById('t-slider');
const sValEl = document.getElementById('s-val');
const volValEl = document.getElementById('vol-val');
const tValEl = document.getElementById('t-val');

function getParams() {
  return {
    S: parseFloat(slider.value),
    sig: parseFloat(volSlider.value) / 100,
    T: parseInt(tSlider.value) / 365
  };
}

function update() {
  const { S, sig, T } = getParams();
  sValEl.textContent = S.toFixed(2);
  volValEl.textContent = (sig * 100).toFixed(0);
  tValEl.textContent = Math.round(T * 365);
  const g = bsGreeks(S, K, r, T, sig);

  document.getElementById('c-price').textContent = '


Watch what happens: as the stock moves, delta changes (gamma is at work), and the hedge — the number of shares you must hold to stay neutral — must be rebalanced. The P&L column shows how much you gain or lose between rebalances; without hedging, every tick is an unmanaged exposure.

 + g.price.toFixed(3);
  document.getElementById('c-delta').textContent = g.delta.toFixed(4);
  document.getElementById('c-gamma').textContent = g.gamma.toFixed(5);
  document.getElementById('c-vega').textContent = '


Watch what happens: as the stock moves, delta changes (gamma is at work), and the hedge — the number of shares you must hold to stay neutral — must be rebalanced. The P&L column shows how much you gain or lose between rebalances; without hedging, every tick is an unmanaged exposure.

 + g.vega.toFixed(4);

  document.getElementById('c-price-desc').textContent = i18nFmt('Fair value of the call with strike $%K%', { K: K });
  document.getElementById('c-delta-desc').textContent = i18nFmt('Hold %shares% shares to be neutral right now', { shares: g.delta.toFixed(2) });
  document.getElementById('c-gamma-desc').textContent = i18nFmt('Delta drifts by %gamma% per $1 move', { gamma: g.gamma.toFixed(5) });
  document.getElementById('c-vega-desc').textContent = i18nFmt('Cost per 1% change in implied vol', {});

  // Show currently held shares if hedged, else show current delta as suggestion
  if (hedgeShares !== null) {
    document.getElementById('hedge-shares').textContent = hedgeShares.toFixed(4);
  } else {
    document.getElementById('hedge-shares').textContent = g.delta.toFixed(4);
  }

  // Compute net P&L since last rebalance: option gain + hedge gain
  const statusEl = document.getElementById('status');
  if (hedgeShares !== null && prevS !== null && S !== prevS) {
    const optionPnL = g.price - bsGreeks(prevS, K, r, T, sig).price;
    const hedgePnL = hedgeShares * (S - prevS);
    const netPnL = optionPnL + hedgePnL;
    const sign = netPnL >= 0 ? '+' : '';
    statusEl.textContent = i18nFmt('Net P&L since last rebalance: %net%', { net: sign + netPnL.toFixed(4) });
    statusEl.className = 'status ' + (Math.abs(netPnL) < 0.005 ? 'neutral' : netPnL > 0 ? 'gain' : 'loss');
  } else if (hedgeShares === null) {
    statusEl.textContent = 'Press Re-hedge to lock a hedge, then move the price.';
    statusEl.className = 'status neutral';
  }
}

function rebalance() {
  const { S, sig, T } = getParams();
  const g = bsGreeks(S, K, r, T, sig);
  prevS = S;
  prevDelta = g.delta;
  hedgeShares = g.delta;
  document.getElementById('hedge-shares').textContent = hedgeShares.toFixed(4);
  const statusEl = document.getElementById('status');
  statusEl.textContent = i18nFmt('Hedged at delta = %delta%. Now move the stock price.', { delta: g.delta.toFixed(4) });
  statusEl.className = 'status neutral';
}

function reset() {
  prevS = null; prevDelta = null; hedgeShares = null; hedgeValue = null; pnl = 0;
  slider.value = 100; volSlider.value = 20; tSlider.value = 30;
  document.getElementById('status').textContent = '';
  document.getElementById('status').className = 'status';
  update();
}

slider.addEventListener('input', update);
volSlider.addEventListener('input', update);
tSlider.addEventListener('input', update);
document.getElementById('btn-rebalance').addEventListener('click', rebalance);
document.getElementById('btn-reset').addEventListener('click', reset);
update();
Result
Console

Watch what happens: as the stock moves, delta changes (gamma is at work), and the hedge — the number of shares you must hold to stay neutral — must be rebalanced. The P&L column shows how much you gain or lose between rebalances; without hedging, every tick is an unmanaged exposure.

The Math Behind the Greeks

The Black-Scholes formula gives the price CC of a European call option:

C=S⋅N(d1)−Ke−rTN(d2)C = S \cdot N(d_1) - K e^{-rT} N(d_2)

where SS is the stock price, KK the strike, rr the risk-free rate, TT the time to expiry, N(⋅)N(\cdot) the standard normal CDF, and:

d1=ln⁡(S/K)+(r+σ2/2)TσT,d2=d1−σTd_1 = \frac{\ln(S/K) + (r + \sigma^2/2)T}{\sigma\sqrt{T}}, \quad d_2 = d_1 - \sigma\sqrt{T}

The Greeks are partial derivatives of CC:

  • Delta: Δ=∂C/∂S=N(d1)\Delta = \partial C / \partial S = N(d_1). Always between 0 and 1 for a call; it is literally the hedge ratio — hold Δ\Delta shares per option sold to be instantaneously neutral.
  • Gamma: Γ=∂2C/∂S2=N′(d1)/(SσT)\Gamma = \partial^2 C / \partial S^2 = N'(d_1) / (S \sigma \sqrt{T}). Gamma is the cost of hedging: a large gamma means delta shifts rapidly, forcing expensive, frequent rebalancing.
  • Vega: V=∂C/∂σ=SN′(d1)T\mathcal{V} = \partial C / \partial \sigma = S N'(d_1) \sqrt{T}. Volatility is never truly constant; vega measures how badly a mis-estimate of σ\sigma will hurt you.

Why dynamic hedging works — and why it costs money. A delta-hedged portfolio is instantaneously risk-free, but gamma keeps breaking the hedge as the stock drifts. The trader must rebalance continuously (in practice, at discrete intervals), and each rebalance has a cost. The Black-Scholes equation is essentially the statement that those rebalancing costs exactly equal the option's fair value — a remarkable self-consistency.

Status: the Black-Scholes model was published in 1973 by Fischer Black and Myron Scholes (with key contributions by Robert Merton). Scholes and Merton received the Nobel Prize in Economics in 1997. Black had died in 1995 and so could not share it.

Where It Matters

The Greek framework is far broader than stock options:

  • Equity and FX derivatives desks: every major bank runs real-time Greek dashboards. Aggregated delta, gamma and vega across thousands of positions tell the risk manager exactly where the book is exposed.
  • Interest-rate derivatives: the analogues of delta and gamma for bond options are DV01 (dollar value of a basis point) and convexity — the same mathematical structure, different underlying variable.
  • Volatility trading: traders buy or sell options specifically to be long or short gamma or vega, making pure bets on how much the market will move, not in which direction.
  • Machine learning and control theory: the gradient of a loss function with respect to model weights is the ML equivalent of delta; second-order methods exploit gamma-like curvature. See also Monte Carlo methods for how simulation plugs into the same framework.
  • Regulatory capital: Basel III requires banks to compute sensitivities (Greeks) for every derivative position when calculating how much capital to hold against market risk.

The key insight is always the same: when a value depends smoothly on inputs, its partial derivatives let you hedge, optimize and control it — whether the "value" is an option price, a neural-network loss, or the attitude of a drone.

Conclusion

Options look like a simple bet — will this stock rise above $100 by Friday? — but managing the risk of selling one is an ongoing, continuous problem. The Greeks transform that problem into something tractable: delta tells you the hedge ratio right now, gamma tells you how fast you need to adjust it, and vega reminds you that your volatility estimate might be wrong.

Dynamic delta-hedging turns an option — in theory — into a sequence of risk-free rebalances whose total cost equals exactly the fair price of the contract. In practice, discrete rebalancing, transaction costs and model error mean the hedge leaks, and gamma and vega are the measure of that leak.

The mathematics behind the Greeks is the same calculus of continuous sensitivity that shows up in Monte Carlo methods and throughout quantitative science: wherever a quantity depends smoothly on its inputs, its partial derivatives are the steering wheel.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/option-greeks-hedging/Content licensed under CC BY-NC 4.0.