Implied Volatility کیسے calculate کی جاتی ہے؟

Implied volatility کو formula سے نہیں بلکہ iteration کے ذریعے calculate کیا جاتا ہے۔ کوئی closed-form expression ایسا نہیں جو option کی market price کو واپس volatility number میں تبدیل کر سکے۔ اس لیے solver ایک volatility کا اندازہ لگاتا ہے، Black-Scholes کے ذریعے option کی price نکالتا ہے، اس model price کا quote سے موازنہ کرتا ہے، اور یہ عمل اس وقت تک دہراتا ہے جب تک دونوں قیمتیں ایک penny تک مطابقت نہ رکھیں۔ آگے پورا طریقہ دیا گیا ہے: pricing function، standard library Python میں search loop، اور وہ وجوہات جن کی بنا پر دو vendors ایک ہی contract کے لیے مختلف numbers publish کرتے ہیں۔

امplied volatility کے لیے closed-form formula کیوں موجود نہیں

Black-Scholes ایک سمت میں کام کرتا ہے۔ اسے spot price، strike price، expiry تک باقی وقت، interest rate اور volatility دیں، تو یہ ایک theoretical price نکالتا ہے۔ ان چھ میں سے پانچ quantities قابلِ مشاہدہ ہیں۔ Volatility قابلِ مشاہدہ نہیں ہوتی۔ یہ اس بارے میں ایک مفروضہ ہے کہ موجودہ وقت سے expiry تک stock کتنی دور تک حرکت کرے گا۔

Traders اس مسئلے کو الٹ دیتے ہیں۔ Price screen پر موجود ہوتی ہے، جبکہ volatility نامعلوم ہوتی ہے۔ Implied volatility وہ volatility input ہے جو Black-Scholes price کو option کی market price کے برابر کر دیتا ہے۔ Sigma، یعنی volatility term، normal distribution function کے اندر d1 اور d2 دونوں میں شامل ہوتی ہے، اور کوئی algebraic rearrangement اسے الگ نہیں کر سکتی۔ یہاں algebra رک جاتا ہے۔ اس کے بعد numerical search کام آتی ہے۔ Implied volatility کیا measure کرتی ہے میں اس کی تشریح دی گئی ہے؛ یہ صفحہ طریقۂ کار کا احاطہ کرتا ہے۔

Model کی دو خصوصیات search کو آسان بناتی ہیں۔ Volatility بڑھنے پر call کی model price ہر بار بڑھتی ہے، اور اس میں کوئی استثنا نہیں ہوتا۔ یہ تبدیلی smooth بھی رہتی ہے۔ جو quantity صرف بڑھتی ہو، اسے اس کے گرد ایک bracket کو بتدریج تنگ کر کے تلاش کیا جا سکتا ہے۔

حل ہر contract کے لیے ایک مرتبہ چلتا ہے

Output ہر contract کے لیے ایک number ہے، ہر stock کے لیے ایک نہیں۔ ایک ہی stock اور ایک ہی expiry window کے contracts بھی ایک دوسرے سے مختلف نتائج دیتے ہیں۔ 30 جون 2026 کو trade ہونے والے Apple (AAPL) کے وہ تمام options جن کی مدت ختم ہونے میں 20 سے 45 دن باقی تھے، share price کے مقابلے میں strike کے تناسب کے مطابق grouped ہیں:

WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)

Strike ladder کو اوپر سے نیچے پڑھنے پر 0.80-0.90 zone کا حل 35.5% نکلا، 0.95-1.00 zone کا 28.1%، اور 1.10-1.20 zone کا 27.3%۔ ایک company، ایک session، 6 answers۔ اس curve کے خم کا ایک نام ہے، volatility skew، اور ہر stock کے لیے ایک single volatility اسے ظاہر نہیں کر سکتی۔

وہ Black-Scholes price جس سے solver کو مطابقت پیدا کرنی ہے

S share price ہے، K strike ہے، T expiry تک سالوں میں باقی وقت ہے، r risk-free rate ہے، اور N() standard normal cumulative distribution ہے۔ اس سے مراد یہ probability ہے کہ standard normal draw کسی دیے گئے point سے نیچے آئے۔ Python میں یہ آخری حصہ math.erf کے ذریعے دستیاب ہے، اس لیے صرف interpreter کافی ہے۔

apt-get update && apt-get install -y python3

جس machine پر آپ root نہیں ہیں، وہاں دونوں commands کے آغاز میں sudo لگائیں۔ پھر اسے iv.py کے نام سے save کریں:

import math

def norm_cdf(x):
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def bs_call(S, K, T, r, sigma):
    if T <= 0.0 or sigma <= 0.0:
        return max(S - K, 0.0)
    d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
    d2 = d1 - sigma * math.sqrt(T)
    return S * norm_cdf(d1) - K * math.exp(-r * T) * norm_cdf(d2)

یہی مکمل forward model ہے۔ اسے volatility دیں، اور یہ price واپس دے گا۔

Implied volatility کیسے calculate کی جاتی ہے، مرحلہ وار

Bisection وہ method ہے جسے پہلے سیکھنا چاہیے۔ یہ کبھی diverge نہیں ہوتا اور اس کے لیے calculus کی ضرورت نہیں ہوتی۔

1. جواب کو 0.01 (سالانہ 1%) اور 5.0 (500%) کے درمیان bracket کریں۔ ہر traded option اس range کے اندر ہوتا ہے۔
2. Bracket کے midpoint پر option کی price calculate کریں۔
3. اگر model price، market quote سے زیادہ ہو تو اندازہ بہت زیادہ تھا: bracket کی اوپری حد کو midpoint تک نیچے لے آئیں۔ اگر model price کم ہو تو نچلی حد کو midpoint تک اوپر لے آئیں۔
4. اس وقت رک جائیں جب model price، quote سے ایک cent کے اندر آ جائے۔

def implied_vol(price, S, K, T, r, lo=0.01, hi=5.0, tol=0.01):
    for _ in range(100):
        mid = 0.5 * (lo + hi)
        diff = bs_call(S, K, T, r, mid) - price
        if abs(diff) < tol:
            return mid
        if diff > 0.0:
            hi = mid
        else:
            lo = mid
    return 0.5 * (lo + hi)

# $100 stock, $100 strike, three months, 4% rates, $5.00 on the screen
print(round(implied_vol(5.00, 100.0, 100.0, 0.25, 0.04), 4))

python3 iv.py چلائیں۔ یہ تقریباً 0.226 دکھاتا ہے، یعنی اس فرضی quote کے لیے implied volatility سالانہ تقریباً 22.6% ہے۔ ہر iteration میں bracket نصف رہ جاتا ہے۔ 4.99 چوڑے range کو بیس مرتبہ نصف کرنے کے بعد یہ 0.00001 سے بھی کم رہ جاتا ہے، اس لیے 100 iterations کی حد کبھی پوری نہیں ہوتی۔

Newton-Raphson تیزی سے کیوں converge کرتا ہے، اور کہاں ناکام ہو جاتا ہے

Bisection اس معلومات کو نظرانداز کر دیتا ہے جو model پہلے ہی فراہم کر رہا ہوتا ہے۔ Vega volatility میں فی یونٹ تبدیلی کے مقابلے میں option کی price میں تبدیلی ہے، اور Black-Scholes اسے closed form میں فراہم کرتا ہے۔ Newton-Raphson اسے slope کے طور پر استعمال کرتا ہے: pricing error ناپیں، اسے vega سے divide کریں، اور guess کو اتنی مقدار سے آگے بڑھا دیں۔

def bs_vega(S, K, T, r, sigma):
    d1 = (math.log(S / K) + (r + 0.5 * sigma * sigma) * T) / (sigma * math.sqrt(T))
    return S * math.sqrt(T) * math.exp(-0.5 * d1 * d1) / math.sqrt(2.0 * math.pi)

def implied_vol_newton(price, S, K, T, r, sigma=0.5):
    for _ in range(20):
        v = bs_vega(S, K, T, r, sigma)
        if v < 1e-8:
            return None          # no slope left, hand the job back to bisection
        step = (bs_call(S, K, T, r, sigma) - price) / v
        sigma -= step
        if sigma <= 0.0:
            return None          # the step overshot into nonsense
        if abs(step) < 1e-6:
            return sigma
    return None

At-the-money کے قریب یہ عمل bisection کے درجن بھر passes کے مقابلے میں تین یا چار passes میں مکمل ہو جاتا ہے۔ ناکامی کا مسئلہ denominator میں ہوتا ہے: جب strike، share price سے دور ہوتا جاتا ہے تو vega کم ہوتی جاتی ہے۔ یہی AAPL contracts، ہر zone کی average vega کو at-the-money reading کے فیصد کے طور پر دکھاتے ہوئے:

WITH toFloat64(strike_price) / toFloat64(underlying_close) AS moneyness,
     (
         SELECT avg(toFloat64(vega))
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND days_to_expiry BETWEEN 20 AND 45
           AND iv_converged = 1
           AND volume > 0
           AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.025
     ) AS atm_vega
SELECT multiIf(moneyness < 0.90, '0.80-0.90',
               moneyness < 0.95, '0.90-0.95',
               moneyness < 1.00, '0.95-1.00',
               moneyness < 1.05, '1.00-1.05',
               moneyness < 1.10, '1.05-1.10',
                                 '1.10-1.20') AS strike_vs_spot,
       round(100 * avg(toFloat64(vega)) / atm_vega, 1) AS vega_pct_of_atm,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = toDate('2026-06-30')
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND moneyness BETWEEN 0.80 AND 1.20
GROUP BY strike_vs_spot
ORDER BY min(moneyness)

Wings میں sensitivity کا صرف ایک حصہ رہ جاتا ہے: 33.1% at-the-money vega، 0.80-0.90 zone میں، اور 31.6%، 1.10-1.20 zone میں۔ اتنی چھوٹی رقم سے pricing error کو divide کرنے پر step بہت بڑا بن جاتا ہے۔ اس سے guess صفر سے نیچے جا سکتا ہے، جہاں model کے پاس مزید کوئی نتیجہ دینے کے لیے کچھ نہیں رہتا۔ Production solvers دونوں طریقوں کو یکجا کرتے ہیں: پہلے bracketing کی جاتی ہے، پھر Newton سے نتیجے کو polish کیا جاتا ہے۔ Vega میں اسی Greek کی وضاحت ہے۔

دو ذرائع مختلف implied volatility کیوں رپورٹ کرتے ہیں

Model عوامی ہے اور arithmetic طے شدہ ہے، اس لیے اختلاف inputs میں پیدا ہوتا ہے۔

• Mid بمقابلہ last۔ Solver کو ایک price درکار ہوتی ہے۔ اگر کسی contract کی bid $2.00 اور offer $2.20 ہو تو midpoint $2.10 بنتا ہے، جبکہ last print شاید نوے منٹ پہلے $2.02 ہو۔ ایسے contract میں price کے دس cents، volatility کے ایک point سے زیادہ اہم ہو سکتے ہیں۔
• Dividends اور carry۔ اوپر دیا گیا function ایسے stock پر European call کی pricing کرتا ہے جو کوئی dividend ادا نہیں کرتا۔ Expiry سے پہلے dividend forward price کم کر دیتا ہے، جبکہ ہر desk اپنی adjustment اور اپنی rate استعمال کرتا ہے۔
• American early exercise۔ US single-stock options کسی بھی دن exercise کیے جا سکتے ہیں، اور اس حق کی اپنی value ہوتی ہے جس کے لیے European formula میں کوئی جگہ نہیں۔ اسے نظرانداز کرنے والا solver فرق کو volatility میں منتقل کر دیتا ہے۔ Binomial trees exercise کے حق کی براہِ راست pricing کرتے ہیں۔
• Stale quotes۔ کوئی strike منگل کو آخری بار trade ہوا ہو، پھر بھی اس کا quote دکھائی دیتا رہتا ہے، اور solver اسے موصول ہونے والی چیز کو درست سمجھ کر استعمال کرتا ہے۔

Convergence سے آخری دو مسائل نمایاں ہو جاتے ہیں۔ ذیل کا panel 30 جون 2026 کو آٹھ معروف ناموں کے لیے 20 سے 45 دن باقی رہنے والے traded contracts شمار کرتا ہے، اور at the money volatility کے ساتھ ان contracts کا حصہ بھی رپورٹ کرتا ہے جن میں solve converged ہوا:

WITH abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) AS distance_from_spot
SELECT underlying_symbol AS symbol,
       round(100 * avgIf(toFloat64(implied_volatility), iv_converged = 1 AND distance_from_spot < 0.05), 1) AS atm_iv_pct,
       round(100 * countIf(iv_converged = 1) / count(), 1) AS solved_pct,
       count() AS contract_count
FROM global_markets.options_greeks
WHERE date = toDate('2026-06-30')
  AND underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'AMZN', 'TSLA', 'SPY', 'KO', 'JNJ')
  AND days_to_expiry BETWEEN 20 AND 45
  AND volume > 0
GROUP BY symbol
HAVING countIf(iv_converged = 1 AND distance_from_spot < 0.05) > 0
ORDER BY atm_iv_pct DESC

TSLA نے 8 ناموں میں سب سے زیادہ at the money reading، یعنی 47.7%، دکھائی؛ نچلے مقام پر موجود SPY کی reading 14.4% تھی۔ TSLA chain میں traded contracts کے 97.8% سے converged answer حاصل ہوا۔ باقی contracts ایسے strikes ہیں جہاں solver کو دی گئی price کسی بھی volatility سے reproduce نہیں ہو سکتی، یا quote intrinsic value سے کم ہے، یا market crossed ہے۔ ایسی reading کو high سمجھا جائے یا نہیں، یہ الگ سوال ہے: کیا 30% IV زیادہ ہے اس موضوع کا جائزہ لیتا ہے، جبکہ expected move اسے dollar range میں تبدیل کرتا ہے۔

وہی contract، ہر session میں دوبارہ حل شدہ

Implied volatility میں کچھ بھی محفوظ نہیں ہوتا۔ اسے screen پر موجود price کی بنیاد پر دوبارہ calculate کیا جاتا ہے۔ ذیل میں AAPL کا سب سے زیادہ traded contract دیا گیا ہے، جس کی expiry July 17, 2026 ہے۔ اسے June 1 سے expiry تک follow کیا گیا۔ Strike price تبدیل نہیں ہوئی اور expiry بھی تبدیل نہیں ہوئی:

WITH (
         SELECT ticker
         FROM global_markets.options_greeks
         WHERE underlying_symbol = 'AAPL'
           AND date = toDate('2026-06-30')
           AND expiration_date = toDate('2026-07-17')
           AND iv_converged = 1
           AND volume > 0
         ORDER BY volume DESC
         LIMIT 1
     ) AS pinned_contract
SELECT date,
       round(100 * avg(toFloat64(implied_volatility)), 1) AS implied_vol_pct,
       round(avg(days_to_expiry)) AS days_to_expiry
FROM global_markets.options_greeks
WHERE ticker = pinned_contract
  AND date BETWEEN toDate('2026-06-01') AND toDate('2026-07-17')
  AND iv_converged = 1
  AND volume > 0
GROUP BY date
ORDER BY date

29 sessions کے دوران solved reading 25.1% پر کھلی۔ اس وقت 46 دن باقی تھے۔ یہ reading 26.6% پر ختم ہوئی، جبکہ 4 دن باقی تھے۔ اس line پر ہر point، اسی session کے quote پر اوپر بیان کردہ loop کے ایک run کی نمائندگی کرتا ہے۔ ہماری ہر ticker کے لیے pages یہی solve شائع کرتی ہیں: AAPL implied volatility پوری chain پر روزانہ یہ calculation چلاتا ہے، اس لیے قاری اس page پر موجود code کے ذریعے وہاں دی گئی ہر figure reproduce کر سکتا ہے۔

Implied volatility کا حساب: عام سوالات

کیا implied volatility کے لیے کوئی formula موجود ہے؟

نہیں۔ Black-Scholes volatility کو price سے map کرتا ہے، لیکن اس mapping کا کوئی elementary inverse نہیں، کیونکہ sigma normal distribution کے اندر دو مرتبہ ظاہر ہوتا ہے۔ آپ یہاں یا کہیں بھی جو implied volatility number دیکھتے ہیں، وہ iterative solver سے حاصل ہوتا ہے۔

یہ calculation کتنی iterations لیتی ہے؟

ہر bisection pass bracket کو نصف کر دیتا ہے۔ چنانچہ 0.01 سے 5.0 کی range بیس passes میں 0.00001 سے کم رہ جاتی ہے، جبکہ quote کو قریب ترین cent سے match کرنے کے لیے عموماً تقریباً ایک درجن passes کافی ہوتے ہیں۔ Newton-Raphson near-the-money options میں تین یا چار passes میں نتیجے تک پہنچ جاتا ہے، لیکن جہاں vega کم ہو وہاں اس کے steps غیر مستحکم ہو سکتے ہیں۔

میرے broker اور data vendor کی implied volatility مختلف کیوں دکھائی دیتی ہے؟

انہوں نے solver میں مختلف inputs استعمال کیے۔ عام فرق mid quote اور last trade کے درمیان، rate اور dividend assumption میں، اور اس بات میں ہوتا ہے کہ model American early exercise کو بالکل handle کرتا ہے یا نہیں۔ کسی thin strike میں صرف stale quote ہی جواب کو کئی points تک بدل سکتی ہے۔

کیا ایک ہی strike پر calls اور puts کی implied volatility یکساں ہوتی ہے؟

نظری طور پر ہاں۔ put-call parity انہیں مشترکہ strike اور expiry پر ایک دوسرے سے جوڑتی ہے۔ عملی طور پر دونوں quotes الگ الگ مقرر ہوتے ہیں، اس لیے solved numbers میں معمولی فرق آ سکتا ہے۔ یہی ایک اور وجہ ہے کہ پوری option chain کی averages مختلف vendors میں مختلف رہتی ہیں۔

کیا میں market data کے بغیر implied volatility calculate کر سکتا ہوں؟

ہاں، hypothetical quote کے لیے۔ اوپر دیا گیا code price، strike، spot، time to expiry اور rate لیتا ہے، جو سب ہاتھ سے درج کیے جاتے ہیں۔ کسی live vendor number سے match کرنا زیادہ مشکل مرحلہ ہے، کیونکہ اس کے لیے وہی inputs درکار ہوتے ہیں جو vendor نے استعمال کیے ہوں۔

یہاں موجود ہر panel اپنے پیچھے کا SQL محفوظ رکھتا ہے۔ کسی ایک کو کھولیں، پھر Strasmore terminal پر live chain کے خلاف یہی solve چلائیں۔