ఇంప్లైడ్ వోలాటిలిటీని ఎలా లెక్కిస్తారు

Implied volatilityను ఫార్ములాతో కాదు, iteration ద్వారా లెక్కిస్తారు. Option market priceను తిరిగి volatility సంఖ్యగా మార్చే closed-form expression లేదు. అందువల్ల ఒక solver ముందుగా volatilityను అంచనా వేస్తుంది. ఆ volatilityతో Black-Scholes మోడల్ ద్వారా option ధరను లెక్కిస్తుంది. తర్వాత ఆ model priceను quoteతో పోల్చుతుంది. రెండు ధరలు penny స్థాయిలో సరిపడే వరకు ఈ ప్రక్రియను పునరావృతం చేస్తుంది.

ఇక మొత్తం పద్ధతి వివరించబడుతుంది: pricing function, standard library Pythonలో search loop, అలాగే ఒకే contractకు ఇద్దరు vendors వేర్వేరు సంఖ్యలను ఎందుకు ప్రచురిస్తారనే కారణాలు.

ఇంప్లైడ్ వోలాటిలిటీకి క్లోజ్డ్-ఫార్మ్ ఫార్ములా ఎందుకు లేదు

Black-Scholes ఒకే దిశలో పనిచేస్తుంది. దానికి స్పాట్ ధర, strike price, గడువు వరకు మిగిలిన సమయం, వడ్డీ రేటు, వోలాటిలిటీ ఇస్తే, అది సైద్ధాంతిక ధరను ఇస్తుంది. ఈ ఆరు పరిమాణాల్లో ఐదు మార్కెట్లో గమనించగలిగినవి. వోలాటిలిటీ మాత్రం కాదు. ఇప్పటి నుంచి గడువు వరకు షేరు ధర ఎంత మేర కదులుతుందనే అంచనానే ఇది.

ట్రేడర్లు ఈ సమస్యను తిరగదిద్దుతారు. ధర స్క్రీన్‌పై కనిపిస్తుంది, వోలాటిలిటీ తెలియని పరిమాణంగా ఉంటుంది. Black-Scholes ధర, ఆప్షన్ మార్కెట్ ధరకు సమానంగా వచ్చేలా ఉపయోగించే వోలాటిలిటీ ఇన్‌పుట్‌నే implied volatility అంటారు. వోలాటిలిటీ పదమైన Sigma, d1 మరియు d2 రెండింటిలోనూ normal distribution functionలోకి చేరుతుంది. దాన్ని విడిగా బయటకు తీసే బీజగణిత రూపాంతరం లేదు. అక్కడితో బీజగణితం ఆగిపోతుంది. తర్వాత సంఖ్యాత్మక శోధన ప్రారంభమవుతుంది. ఇంప్లైడ్ వోలాటిలిటీ ఏమి కొలుస్తుందిలో దీని అర్థాన్ని వివరిస్తాం; ఈ పేజీలో గణన విధానాన్ని వివరిస్తాం.

మోడల్‌లోని రెండు లక్షణాలు ఈ శోధనను సులభం చేస్తాయి. వోలాటిలిటీ పెరిగినప్పుడల్లా call ధర పెరుగుతుంది; దీనికి మినహాయింపులు ఉండవు. ఆ మార్పు కూడా సజావుగా ఉంటుంది. ఒకే దిశలో మాత్రమే పెరిగే పరిమాణాన్ని, దాని చుట్టూ ఒక పరిధిని క్రమంగా ఇరుకుగా చేయడం ద్వారా కనుగొనవచ్చు.

ప్రతి కాంట్రాక్ట్‌కు solver ఒక్కసారి నడుస్తుంది

ఫలితం ప్రతి స్టాక్‌కు ఒకటి కాదు, ప్రతి కాంట్రాక్ట్‌కు ఒక సంఖ్య. అదే స్టాక్‌కు, అదే expiry windowలో ఉన్న కాంట్రాక్ట్‌ల ఫలితాలు కూడా పరస్పరం భిన్నంగా ఉంటాయి. జూన్ 30, 2026న ట్రేడ్ అయిన, గడువు ముగియడానికి 20 నుంచి 45 రోజులు మిగిలిన ప్రతి Apple (AAPL) optionను, strikeను షేర్ ధరలోని భాగంగా తీసుకుని సమూహీకరించినప్పుడు:

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 జోన్ విలువ 35.5%గా, 0.95-1.00 జోన్ విలువ 28.1%గా, 1.10-1.20 జోన్ విలువ 27.3%గా పరిష్కరించబడింది. ఒక కంపెనీ, ఒక ట్రేడింగ్ సెషన్, 6 సమాధానాలు. ఆ వక్రరేఖలోని వంపుకు volatility skew అనే పేరు ఉంది. ఒక్కో స్టాక్‌కు ఒకే volatilityతో దాన్ని చూపడం సాధ్యం కాదు.

Solver సరిపోల్చాల్సిన Black-Scholes ధర

S అంటే షేర్ ధర, K అంటే strike ధర, T అంటే గడువు ముగిసే వరకు మిగిలిన సమయం సంవత్సరాల్లో, r అంటే risk-free rate. N() అంటే standard normal cumulative distribution. అంటే standard normal పంపిణీ నుంచి తీసుకున్న విలువ ఇచ్చిన బిందువు కంటే తక్కువగా ఉండే probability. Pythonలో ఈ చివరి భాగం math.erfలో అందుబాటులో ఉంటుంది. కాబట్టి interpreter ఒక్కటే సరిపోతుంది.

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

మీరు 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ను ఇన్‌పుట్‌గా ఇస్తే ధర లభిస్తుంది.

ఇంప్లైడ్ వోలాటిలిటీని దశలవారీగా ఎలా లెక్కించాలి

మొదట నేర్చుకోవాల్సిన పద్ధతి బైసెక్షన్. ఇది ఎప్పుడూ డైవర్జ్ కాదు. దీనికి కాల్క్యులస్ కూడా అవసరం లేదు.

1. సమాధానాన్ని సంవత్సరానికి 0.01 (1%) నుంచి 5.0 (500%) మధ్య పరిమితం చేయండి. ట్రేడ్ అయ్యే ప్రతి option ఈ పరిధిలోనే ఉంటుంది.
2. ఈ పరిధి మధ్య బిందువులో option ధరను లెక్కించండి.
3. మోడల్ ధర మార్కెట్ quote కంటే ఎక్కువగా ఉంటే, అంచనా చాలా ఎక్కువగా ఉంది. పరిధి పై పరిమితిని మధ్య బిందువుకు తగ్గించండి. మోడల్ ధర తక్కువగా ఉంటే, దిగువ పరిమితిని పైకి పెంచండి.
4. మోడల్ ధర 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కు సంవత్సరానికి ఇంప్లైడ్ వోలాటిలిటీ దాదాపు 22.6% అన్నమాట. ప్రతి దశలో పరిధి సగానికి తగ్గుతుంది. 4.99 వెడల్పు ఉన్న పరిధిని ఇరవై సార్లు సగానికి విభజిస్తే, అది 0.00001 కంటే కూడా చిన్నదవుతుంది. అందువల్ల 100 iterations పరిమితి ఎప్పుడూ అడ్డంకి కాదు.

న్యూటన్–రాఫ్సన్ ఎందుకు వేగంగా కన్వర్జ్ అవుతుంది, ఎక్కడ విఫలమవుతుంది

బైసెక్షన్ మోడల్‌లో ఇప్పటికే ఉన్న సమాచారాన్ని ఉపయోగించకుండా వదిలేస్తుంది. Vega అనేది volatilityలో ప్రతి యూనిట్ మార్పుకు option ధరలో వచ్చే మార్పు. Black-Scholes దీన్ని closed formలో ఇస్తుంది. న్యూటన్–రాఫ్సన్ దీనిని slopeగా పరిగణిస్తుంది: pricing errorను కొలిచి, దాన్ని vegaతో భాగించి, అంచనాను అంత మేర మార్చుతుంది.

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

షేరు ధరకు సమీపంలో ఉన్న contractsకు ఇది బైసెక్షన్‌లోని పన్నెండు దశలతో పోలిస్తే మూడు లేదా నాలుగు దశల్లో ఫలితాన్ని ఇస్తుంది. విఫలమయ్యే కారణం denominatorలో ఉంటుంది: strike price షేరు ధరకు దూరంగా వెళ్లే కొద్దీ vega తగ్గుతుంది. అదే AAPL contractsకు, ప్రతి zoneలోని సగటు 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ను భాగిస్తే చాలా పెద్ద step వస్తుంది. దాంతో అంచనా సున్నా కంటే దిగువకు వెళ్లవచ్చు. అక్కడ మోడల్‌కు చెప్పడానికి ఏమీ మిగలదు. Production solvers ఈ రెండు పద్ధతులను కలిపి ఉపయోగిస్తాయి. ముందుగా rangeను bracket చేసి, తర్వాత న్యూటన్‌తో తుది సర్దుబాటు చేస్తాయి. Vegaలో ఈ Greek గురించి వివరించాం.

రెండు వనరులు వేర్వేరు implied volatilityని ఎందుకు నివేదిస్తాయి

మోడల్ పబ్లిక్‌గా అందుబాటులో ఉంది. లెక్కలు కూడా ఖరారయ్యాయి. కాబట్టి తేడా inputsలోనే ఉంటుంది.

• Mid వర్సెస్ last. Solverకు ఒకే ధర అవసరం. ఒక contractకు bid $2.00, offer $2.20గా ఉంటే midpoint $2.10 అవుతుంది. కానీ last print తొంభై నిమిషాల క్రితం నమోదైన $2.02 అయి ఉండవచ్చు. ఇలాంటి contractలో volatilityలోని ఒక point కంటే ధరలోని పది సెంట్లు ఎక్కువ ప్రభావం చూపుతాయి.
• డివిడెండ్లు, carry. పై ఫంక్షన్ ఎలాంటి డివిడెండ్ చెల్లించని షేరుపై European callకు ధరను లెక్కిస్తుంది. expiryకి ముందు డివిడెండ్ చెల్లిస్తే forward price తగ్గుతుంది. ప్రతి desk తన సొంత adjustment, rateను ఉపయోగిస్తుంది.
• American early exercise. US single-stock optionsను ఏ రోజైనా exercise చేయవచ్చు. ఈ హక్కుకు విలువ ఉంటుంది. కానీ European formulaలో దాన్ని చేర్చే అవకాశం లేదు. దాన్ని పట్టించుకోని solver ఆ తేడాను volatilityలోకి నెట్టేస్తుంది. Binomial trees exercise హక్కుకు నేరుగా ధరను నిర్ణయిస్తాయి.
• Stale quotes. మంగళవారం last trade జరిగిన strikeకు ఇప్పటికీ quote కనిపించవచ్చు. Solverకు అందినదే నిజమని అది పరిగణిస్తుంది.

Convergence వల్ల చివరి రెండు కారణాలు స్పష్టంగా కనిపిస్తాయి. కింది panel జూన్ 30, 2026న విస్తృతంగా ట్రేడ్ అయ్యే ఎనిమిది పేర్లను తీసుకుని, expiryకి 20 నుంచి 45 రోజులు మిగిలిన traded contractsను లెక్కిస్తుంది. అలాగే at the money volatility, solve converged అయిన contracts శాతాన్ని రెండింటినీ చూపిస్తుంది:

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 లభించింది. మిగిలినవి solverకు ఇచ్చిన ధరను ఏ volatilityతోనూ పునరుత్పత్తి చేయలేని strikes. వీటిలో intrinsic value కంటే తక్కువ quote లేదా crossed market ఉండవచ్చు. ఇలాంటి సంఖ్య ఎక్కువగా ఉందా అనేది వేరే ప్రశ్న: 30% IV ఎక్కువేనా దీనిని వివరిస్తుంది. అంచనా కదలిక దాన్ని డాలర్ పరిధిగా మారుస్తుంది.

అదే కాంట్రాక్ట్, ప్రతి ట్రేడింగ్ సెషన్‌లో మళ్లీ లెక్కింపు

Implied volatilityకు సంబంధించిన ఏ విలువా నిల్వ చేయబడదు. స్క్రీన్‌పై కనిపిస్తున్న ధర ఆధారంగా అది మళ్లీ లెక్కించబడుతుంది. జూలై 17, 2026న ముగియనున్న, అత్యధికంగా ట్రేడ్ అయిన AAPL కాంట్రాక్ట్‌ను జూన్ 1 నుంచి expiry వరకు కింద అనుసరించాం. strike మారలేదు, 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 సెషన్లలో, లెక్కించిన విలువ 25.1% వద్ద ప్రారంభమైంది. అప్పుడు గడువు వరకు 46 రోజులు మిగిలి ఉన్నాయి. చివరికి అది 26.6% వద్ద ముగిసింది. అప్పుడు 4 రోజులు మిగిలి ఉన్నాయి. ఆ రేఖలోని ప్రతి బిందువు, ఆయా సెషన్‌ quoteపై పై loopను ఒకసారి అమలు చేసి పొందిన ఫలితం. మా ప్రతి ticker పేజీలో ఇదే లెక్కింపు అందుబాటులో ఉంటుంది: AAPL implied volatility మొత్తం options chainపై ప్రతిరోజూ దీన్ని అమలు చేస్తుంది. అందువల్ల ఈ పేజీలోని codeతో అక్కడి ఏ విలువనైనా పాఠకుడు పునరుత్పత్తి చేయవచ్చు.

Implied volatility లెక్కింపు గురించి తరచుగా అడిగే ప్రశ్నలు

Implied volatilityకు ఏదైనా ఫార్ములా ఉందా?

లేదు. Black-Scholes volatilityని ధరగా మారుస్తుంది. ఆ mappingకు elementary inverse ఉండదు, ఎందుకంటే sigma normal distributionలో రెండుసార్లు కనిపిస్తుంది. మీరు ఇక్కడ లేదా మరెక్కడైనా చూసే ప్రతి implied volatility సంఖ్య iterative solver ద్వారా లెక్కించబడుతుంది.

ఈ లెక్కింపుకు ఎన్ని iterations పడతాయి?

ప్రతి bisection passలో bracket సగానికి తగ్గుతుంది. అందువల్ల 0.01 నుంచి 5.0 వరకు ఉన్న range ఇరవై passesలో 0.00001 కంటే దిగువకు తగ్గుతుంది. Quoteను సమీప centకు సరిపోల్చడానికి సాధారణంగా దాదాపు పన్నెండు passes పడతాయి. Vega తక్కువగా ఉన్న చోట steps సరిగ్గా పనిచేయకపోవచ్చు. ఆ ప్రమాదం ఉన్నా, near-the-money optionsలో Newton-Raphson సాధారణంగా మూడు లేదా నాలుగు iterationsలో సమాధానానికి చేరుతుంది.

నా broker మరియు data vendor వేర్వేరు implied volatilityలను ఎందుకు చూపిస్తున్నాయి?

వారు solverలో వేర్వేరు inputs ఉపయోగించారు. సాధారణ తేడాలు mid quoteకు బదులుగా last tradeను ఉపయోగించడం, వడ్డీ రేటు మరియు డివిడెండ్ అంచనా, అలాగే model American early exerciseను పరిగణనలోకి తీసుకుంటుందా లేదా అన్నవి. తక్కువగా ట్రేడ్ అయ్యే strikeలో stale quote ఒక్కటే సమాధానాన్ని కొన్ని పాయింట్ల మేర మార్చగలదు.

ఒకే strike వద్ద calls మరియు putsకు ఒకే implied volatility ఉంటుందా?

సిద్ధాంతపరంగా అవును. ఒకే strike మరియు expiry వద్ద put-call parity రెండింటినీ అనుసంధానిస్తుంది. ఆచరణలో రెండు quotes స్వతంత్రంగా నిర్ణయించబడతాయి. అందువల్ల solve చేసిన సంఖ్యల్లో స్వల్ప తేడా ఉంటుంది. Chain మొత్తం సగటులు vendors మధ్య మారడానికి ఇదీ ఒక కారణం.

Market data లేకుండా implied volatilityను లెక్కించవచ్చా?

అవును, ఒక hypothetical quote కోసం లెక్కించవచ్చు. పై codeలో price, strike, spot, expiry వరకు ఉన్న సమయం, rate వంటి విలువలను చేతితో నమోదు చేయవచ్చు. Live vendor సంఖ్యతో సరిపోల్చడం కష్టమైన భాగం. దానికి vendor ఉపయోగించిన inputsనే ఉపయోగించాలి.

ఇక్కడి ప్రతి panel దాని వెనుక ఉన్న SQLను నిల్వ చేస్తుంది. ఒక panelను తెరిచి, Strasmore terminalలో live chainపై అదే solveను అమలు చేయండి.