ET News & Sponsor Info
General Topics
Markets
Technical Topics
Brokerage Firms
Tools of the Trade
Trading for a Living
Community Lounge
Site Support

# Formula to gauge success probability?

Discussion in 'Options' started by afx111, Feb 2, 2011.

1. ### afx111

Hi guys, is there a formula to determine the probability that an option trade's success?

For instance, whats the probability that an option would expire worthless in say 2 weeks? if its 10% away from strike price?

Should i perform like a simple probability distribution of returns on the underlying?

Or can i just look at the delta as a reasonable of success probability?

-- thanks!

3. ### Kevin Schmit

Probability of success is not the same as probablility of
finishing in the money. "Success" for a long OTM call held
to expiration, for example, might be defined as the call
expiring ITM by an amount greater than you paid for it.

Assuming BSM log-normality, probability of a call finishing
ITM is N(d2). Probability of success is N(d2) computed with
your strike (K) increased by the amount you paid for the option.

For the example of a 10d call, delta is not a bad approximation.
Delta is N(d1), which will always be slightly less than N(d2),
just as probability of success is always less (for a long option)
than probability of finishing ITM.

5. ### afx111

Thanks alot for the info guys! really useful stuff!

6. ### stevegee58

The ThinkOrSwim platform has very nice built-in calculators for probability of expiring in the money and probability of touching a strike price.

You can add these as columns in a custom view of any option chain and display them in real time.

7. ### nazzdack

Which of those formulas is always best?

8. ### GTG

I translated these C# function from some excel vba code someone posted on EliteTrade several years ago. You could probably find the original VBA functions for excel with a search:

Code:
```using System;

namespace Trader.OptionPricing
{
/// <summary>
///  m drift
/// s standard deviation
/// t time
/// H up barrier
/// L down barrier
/// K1,K2 barriers
/// ST starting price

/// ProbPTBB probability at time t the price is below the barrier
/// ProbPTUB probability at time t the price is above the barrier
/// ProbMaxPTUB probability at any time until t max price is crossing above the up barrier
/// ProbMaxPTBB probability at any time until t max price is below the barrier
/// ProbMinPTBB probability at any time until t min price is crossing bellow the down barrier
/// ProbMinPTUB probability at any time until t min price is above the down barrier
/// ProbFPBBMaxPTUB probability final price is below K1 and max price is crossing above the up barrier
/// ProbFPUBMinPTBB probability final price is above K2 and min price is crossing below the down barrier
/// </summary>
///
public class PriceProb
{
/// <summary>
///  ProbPTBB probability at time t the price is below the barrier
/// </summary>
/// <param name="m">drift</param>
/// <param name="s">standard deviation</param>
/// <param name="t">time</param>
/// <param name="H">up barrier</param>
/// <param name="ST">starting price</param>
/// <returns>the probability</returns>
public static double ProbPTBB(double m, double s, double t, double H, double ST)
{
double MM = m - s*s/2;

double ptbb = snorm( ( Math.Log(H/ST) - MM*t ) / ( s*Math.Sqrt(t) ) );

return ptbb;
}

/// <summary>
/// ProbPTUB probability at time t the price is above the barrier
/// </summary>
/// <param name="m">drift</param>
/// <param name="s">standard deviation</param>
/// <param name="t">time</param>
/// <param name="L">lower barrier</param>
/// <param name="ST">starting price</param>
/// <returns>the probability</returns>
public static double ProbPTUB(double m, double s, double t, double L, double ST)
{
double MM = m - s*s/2;

double ptub = 1 - snorm( (Math.Log(L/ST) - MM*t) / (s*Math.Sqrt(t) ) );

return ptub;
}

/// <summary>
/// ProbMaxPTUB probability at any time until t max price is crossing above the up barrier
/// </summary>
/// <param name="m">drift</param>
/// <param name="m">drift</param>
/// <param name="s">standard deviation</param>
/// <param name="t">time</param>
/// <param name="H">up barrier</param>
/// <param name="ST">starting price</param>
/// <returns>the probability</returns>
public static double ProbMaxPTUB(double m, double s, double t, double H, double ST)
{
double MM = m - s*s/2;

// ((H/ST)^(2*MM/s^2)) = Math.Pow( (H/ST), (2*MM/(s*s)) )
double maxptub  =snorm(  ( -Math.Log(H/ST) + MM*t) / ( s*Math.Sqrt(t) ) )+Math.Pow( (H/ST), (2*MM/(s*s)) ) * snorm( ( -Math.Log(H/ST) - MM*t ) / ( s*Math.Sqrt(t) ) );

return maxptub;
}

/// <summary>
/// ProbMaxPTBB probability at any time until t max price is below the barrier
/// </summary>
/// <param name="m">drift</param>
/// <param name="s">standard deviation</param>
/// <param name="t">time</param>
/// <param name="H">up barrier</param>
/// <param name="ST">starting price</param>
/// <returns>the probability</returns>
public static double ProbMaxPTBB(double m, double s, double t, double H, double ST)
{
double MM = m - s*s/2;

double maxptbb = 1 - ( snorm( ( -Math.Log(H/ST) + MM*t) / ( s*Math.Sqrt(t) ) ) + Math.Pow( (H/ST), (2*MM/(s*s)) ) * snorm( (- Math.Log(H/ST) - MM*t) / (s*Math.Sqrt(t) ) ) );

return maxptbb;
}

/// <summary>
/// ProbMinPTBB probability at any time until t min price is crossing bellow the down barrier
/// </summary>
/// <param name="m">drift</param>
/// <param name="s">standard deviation</param>
/// <param name="t">time</param>
/// <param name="L">down barrier</param>
/// <param name="ST">starting price</param>
/// <returns>the probability</returns>
public static double ProbMinPTBB(double m, double s, double t, double L, double ST)
{
double MM = m - s*s/2;

// ((L/ST)^(2*MM/s^2)) = Math.Pow( (L/ST), (2*MM/(s*s)) )
double minptbb = snorm( (Math.Log(L/ST) - MM*t) / (s*Math.Sqrt(t) ) ) + Math.Pow( (L/ST), (2*MM/(s*s)) ) * snorm( ( Math.Log(L/ST) + MM*t ) / (s*Math.Sqrt(t) ) );

return minptbb;
}

/// <summary>
/// ProbMinPTUB probability at any time until t min price is above the down barrier
/// </summary>
/// <param name="m">drift</param>
/// <param name="s">standard deviation</param>
/// <param name="t">time</param>
/// <param name="L">down barrier</param>
/// <param name="ST">starting price</param>
/// <returns>the probability</returns>
public static double ProbMinPTUB(double m, double s, double t, double L, double ST)
{
double MM = m - s*s/2;

// ((L/ST)^(2*MM/s^2)) = Math.Pow( (L/ST), (2*MM/(s*s)) )
double minptub = 1 - ( snorm( ( Math.Log(L/ST) - MM*t ) / ( s*Math.Sqrt(t) ) ) + Math.Pow( (L/ST), (2*MM/(s*s)) ) * snorm( (Math.Log(L/ST)+MM*t) / (s*Math.Sqrt(t) ) ) );

return minptub;
}

/// <summary>
/// ProbFPBBMaxPTUB probability final price is below K1 and max price is crossing above the up barrier
/// </summary>
/// <param name="m">drift</param>
/// <param name="m">drift</param>
/// <param name="s">standard deviation</param>
/// <param name="t">time</param>
/// <param name="H">up barrier</param>
/// <param name="K1">barrier</param>
/// <param name="ST">starting price</param>
/// <returns>the probability</returns>
public static double ProbFPBBMaxPTUB(double m, double s, double t, double H, double K1, double ST)
{
double MM = m - s*s/2;

// ((H/ST)^(2*MM/s^2)) = Math.Pow( (H/ST), (2*MM/(s*s)) )
double fppbmaxptub = Math.Pow( (H/ST), (2*MM/(s*s)) ) * snorm( (Math.Log(K1/ST) - 2*Math.Log(H/ST) - MM*t) / (s*Math.Sqrt(t) ) );

return fppbmaxptub;
}

/// <summary>
/// ProbFPUBMinPTBB probability final price is above K2 and min price is crossing below the down barrier
/// </summary>
/// <param name="m">drift</param>
/// <param name="m">drift</param>
/// <param name="s">standard deviation</param>
/// <param name="t">time</param>
/// <param name="L">down barrier</param>
/// <param name="K2">barrier</param>
/// <param name="ST">starting price</param>
/// <returns>the probability</returns>
public static double ProbFPUBMinPTBB(double m, double s, double t, double L, double K2, double ST)
{
double MM = m - s*s/2;

// ((L/ST)^(2*MM/s^2)) = Math.Pow( (L/ST), (2*MM/(s*s)) )
double fpubminptbb = Math.Pow( (L/ST), (2*MM/(s*s)) )*snorm((-Math.Log(K2/ST)+2*Math.Log(L/ST)+MM*t)/(s*Math.Sqrt(t)));

return fpubminptbb;
}

static double snorm(double sigma)
{
double z = 0.3989423*Math.Exp(-sigma*sigma*0.5);
double y = 1.0 / (1.0 + 0.2316419*Math.Abs(sigma));
double ysquared = y*y;
double ycubed = ysquared*y;
double yfourth = ycubed*y;
double yfifth = yfourth*y;
double x = 1.0 - z*(1.330274*yfifth - 1.821256*yfourth + 1.781478*ycubed - 0.356538*ysquared + 0.3193815*y);

if (sigma >= 0.0)
{
return x;
}

if (sigma < 0.0)
{
return 1.0 - x;
}

throw new Exception("Sigma was NaN!");
}

//		static double snorm(double z)
//		{
//			double a1 = 0.31938153;
//			double a2 = -0.356563782;
//			double a3 = 1.781477937;
//			double a4 = -1.821255978;
//			double a5 = 1.330274429;
//
//			double w;
//			if (0 > z)
//			{
//				w = -1;
//			}
//			else
//			{
//				w = 1;
//			}
//
//			double k = 1 / (1 + 0.2316419 * w * z);
//
//			double sn = 0.5 + w * (0.5 - 1 / Math.Sqrt(2 * Math.PI) * Exp(-z ^ 2 / 2) * (a1 * k + a2 * k ^ 2 + a3 * k ^ 3 + a4 * k ^ 4 + a5 * k ^ 5));
//
//			return sn;
//		}
}
}

```

9. ### Martinghoul

Duuuude, every single one of them is golden and will make you a bazillionaire instantly.

10. ### Wayne Gibbous

Probability of success trading options?

Just multiply by 0.000000001...

#10     Feb 4, 2011
ET IS FREE BECAUSE OF THE FINANCIAL SUPPORT FROM THESE COMPANIES:
 AMP Global Clearing Futures and FX Trading Earn2Trade Trading Education and Funding Challenge efutures Futures & Options Trading GFF Brokers Low-Cost Futures Brokerage IC Markets True ECN for FX and CFDs Jigsaw Trading Advanced Trading Tools KJ Trading Systems Trader Education Services Lightspeed Equities & Options Trading MetaTrader 5 Institutional Multi-Asset Platform MotiveWave Full-Featured Trading Software NinjaTrader Trading Software & Brokerage Optimus Futures Futures Trading Platforms and Order Routing Option Workshop Option Analysis Software Rithmic Futures Trade Execution Platform SpreadProfessor Spread Trading Instruction TD Ameritrade Introducing 24 hour trading, 5 days a week TopstepTrader We Fund Traders TradersStudio System Development Platform Trading Technologies Trading Software Provider Tradovate Commision-Free Futures Trading