The profit diagram of an option is its profit or loss at or before expiration in dependence of the price of the underlying. Let’s assume that we know that the price of a certain asset will rise in the next months. So we buy a call option on that asset. Our profit diagram then looks like this:

This is the potential return when buying a current (June 2017) AAPL call option with 4 months expiration time. We have to pay $668 premium for that option. The current AAPL price is $144, and that’s also our strike price. The blue line is our profit or loss, dependent on the AAPL price at expiration. The option will expire out of the money when AAPL stays below $144, so we’ll then lose the premium. We’ll still lose a part of the premium if the option expires only slightly in the money. The break even point is at about $151. And if AAPL floats even higher at expiration time, we can collect huge profits of a multiple of the premium. So buying a call option means an unlimited profit chance at a limited risk. You can not lose more than the premium.

The green line in the diagram is the theoretical option value after 2 months, at half the expiration time. It is approximated with a finite difference method or calculated with the Black-Scholes formula, dependent on option type. The real option price is normally close to that theoretical value. So we can see that we could already sell the option with a profit after two months when the AAPL price is then above $148.

By the way, this option profit diagram resembles the response function of a Rectified Linear Unit in a neural network. So we can speculate that when a billion option traders permanently sell and buy large numbers of options, when the underlying price depends on option demand, and when profits are always reinvested in new options, the option market becomes a huge neural net. Some day artificial intelligence might emerge and the options start buying and selling themselves…

Option combos

Now let’s assume we know for sure that the AAPL price will move in the next time, but we do not know if it will rise or fall. For making profit in both cases, we just buy a call and a put option, both with the strike at the current price of $144:

We can see that a call and a put option with the same parameters don’t cancel out each other! The resulting profit diagram is just the sum of the profit diagrams of the single options. For both options we have to pay a $1310 total premium. If the AAPL price stays inside the $131 – $157 range, we lose. If it ends up outside this range, we win. If it ends up outside by a wide margin, we win big.

Now suppose we think an asset won’t be very volatile in the next time and its price will stay inside a range. We’ll then sell the two options instead of buying them. Selling instead of buying just turns the above profit diagram upside down. And we can already see the problem with that: The profit is now limited and the risk unlimited.

For fixing this, we need to add some more options to the combination:

For this profit diagram we’ve used 4 options. We bought one call at a strike $5 below the current price, another call at a strike $5 above the current price, and we sold short two calls with the strike at the current price. For the two long options we paid $1400 premium, and for the two short options we got $1340. This leaves us with $60 total premium cost, and a chance of up to $440 profit when the price stays inside the $140 – $148 range. This option combo, for whatever reason, got the name “Long Butterfly” by option traders.

By the way, you can see from this butterfly that you can really produce any profit diagram with a suited combination of options. The position of the butterfly peak is determined by the strike prices, its width by their distance, its height by the number of options. This way, many different butterfly peaks can be theoretically put together to a profit diagram of any shape. Unfortunately, you cannot just as freely determine its vertical position – a part of the diagram will be always below the zero line…

The code

Here’s a small C script (for Zorro) for experiments with all sorts of option combinations:

#include <contract.c>
void optionAdd(int Num,int Type,var StrikeOffs);

#define ASSET     "AAPL"
#define EXPIRY	  120	// 4 months
#define BUY	(1<<10)
#define SELL	(1<<11)

void combo() // "Butterfly"
{
	optionAdd(1,BUY|CALL,-5);  
	optionAdd(2,SELL|CALL,0);
	optionAdd(1,BUY|CALL,5);
}

//////////////////////////////////////////////////
#define POINTS 100 
var OptionGains[POINTS],OptionVals50[POINTS];
var UnderL,HistVol;

void optionPlot(int Num,CONTRACT* C,var Premium,var RangeMin,var RangeMax) 
{
	PlotScale = 10;
	var Step = (RangeMax-RangeMin)/POINTS;
	Step = round(Step+0.5,1); // round up
	RangeMin = round(RangeMin,1);

	int i;
	for(i=0; i<POINTS; i++)
	{
		if(Num == 0) {
			OptionGains[i] = OptionVals50[i] = 0;
		} else {
			var Price = RangeMin + i*Step;
			if(Price > RangeMax) break;
			var Gain = 0;
			var Strike = C->fStrike; 
			var Val50 = contractVal(C,Price,HistVol,0,0);
			switch(C->Type&(BUY|SELL|CALL|PUT)) {
				case BUY|CALL: 
					if(Price > Strike) Gain = Price - Strike;
					Gain -= Premium;
					Val50 -= Premium;
					break;
				case BUY|PUT: 
					if(Price < Strike) Gain = Strike - Price;
					Gain -= Premium;
					Val50 -= Premium;
					break;
				case SELL|CALL: 
					if(Price > Strike) Gain = Strike - Price;
					Gain += Premium;
					Val50 = Premium - Val50;
					break;
				case SELL|PUT: 
					if(Price < Strike) Gain = Price - Strike;
					Gain += Premium;
					Val50 = Premium - Val50;
					break;
			}
			OptionGains[i] += Multiplier*Num*Gain;
			OptionVals50[i] += Multiplier*Num*Val50;
			plotBar("Zero",i,0,0,LINE,BLACK);
			plotBar("ValueAt50%",i,Price,OptionVals50[i],LINE|LBL2,GREEN);
			plotBar("ValueAtExpiry",i,Price,OptionGains[i],LINE|LBL2,BLUE);
		}
	}
}

void optionAdd(int Num,int Type,var StrikeOffs)
{
	CONTRACT C;
	C.Type = Type;
	C.Expiry = EXPIRY;
	C.fStrike = round(UnderL+StrikeOffs,1);
	var Premium = contractVal(&C,UnderL,HistVol,0,0);
	C.Expiry = EXPIRY*0.5; // for the value at 50% expiration 
	optionPlot(Num,&C,Premium,0.8*UnderL,1.2*UnderL);
}

void run() 
{
	BarPeriod = 1440;
	StartDate = NOW;
	set(PRELOAD);
	if(is(INITRUN)) {
		initRQL();
		assetAdd(ASSET);
		assetHistory(ASSET,FROM_GOOGLE);
		asset(ASSET);
	}
	vars Close = series(priceClose());
	HistVol = Volatility(Close,20);
	UnderL = Close[0];
	Multiplier = 100;

	if(!is(LOOKBACK)) 
	{
		optionAdd(0,0,0); // reset the graphs
		combo();
		quit("Ok!");
	}
}

This script plots the above diagrams. The core of the script is the combo() function at the begin. It contains one or several optionAdd calls that get as parameters the number of options, the type (BUY, SELL, CALL, PUT, EUROPEAN, BINARY), and the strike difference to the current price. In the example above you can see the combination for the long butterfly. The asset and expiration can be set up in the #define lines above. The script downloads the current asset prices from Google and calculates the volatility that is needed for getting the options values and premiums. For running it you need Zorro, R, and the RQuantLib package from https://cran.r-project.org/bin/windows/contrib/3.3/RQuantLib_0.4.2.zip.

Some more examples of popular option combos:

// Call Spread
void combo()
{
	optionAdd(1, BUY|CALL, -5);
	optionAdd(1, SELL|CALL, 5);
}

// Put Spread
void combo()
{
	optionAdd(1, BUY|PUT, 5);
	optionAdd(1, SELL|PUT, -5);
}

Call or Put Spreads limit our risk as well as our profit to a fixed amount. The steepness of the center slope can be controlled with the strike difference. We can see from the diagrams that Spreads are (almost) equivalent to binary options – but with a much better payout factor. The diagrams are not completely symmetrical, and the Call Spread above has $514 potential profit and $486 potential loss – equivalent to a binary option with 105% payout. If the asset has the same likeliness of going up and going down, a Call Spread gives us a statistical advantage similar to the seller’s advantage of single options. With a Put Spread it’s the other way around.

The green line shows us whether it makes sense to sell the combo prematurely. Suppose we learned that the new iPhone tends to sudden explosions, and opened an AAPL Put Spread. When the AAPL price goes down and falls below $120 after 2 months, it makes no sense to wait until expiration, since the green line at 120 has almost the same value than the blue line. Only problem is that selling reduces our profit by the bid/ask spread and commission. An option expiration has no bid/ask spread and, if out of the money, also no commission.

Some more combos:

// Strangle
void combo()
{
	optionAdd(1, BUY|CALL, 5);
	optionAdd(1, BUY|PUT, -5);
}

// Condor
void combo()
{
	optionAdd(1, BUY|CALL, -10);
	optionAdd(1, SELL|CALL, -5);
	optionAdd(1, SELL|CALL, 5);
	optionAdd(1, BUY|CALL, 10);
}

Combos that involve both selling and buying options – such as Spreads, Condors, or Butterflys – are especially attractive. Their investment is only the difference of the premiums, and the broker’s margin requirement is also accordingly smaller due to the limited risk. This allows trading with small capital and high leverage.

Get rich quick

Here’s my today’s get-rich-quick tip, this time for brokers. The problem with options is that you often need to wait weeks, months, or years until they finally expire and you can book your profit. Dear brokers, how about opening a market for short-term options? Options that expire at the end of each trading day, with strike prices in steps of cents, not dollars? Those options would be a very interesting instrument especially for short-term algorithmic trading. They would become very popular and produce a lot of commissions. Of course, 10% of those commissions are mine. I just patented this concept. Contact me for license conditions.

Conclusion

• Options can be clever combined for reducing the investment, limiting the risk, increasing the leverage, and generating profit diagrams of any shape.
• Depending on premiums, profit diagrams are often not perfectly symmetrical. This results in a statistial advantage (or disadvantage) of option combos with nondirectional assets.

I’ve included the OptionsCurve script in the 2017 script repository. Since price data download from Google rather than Yahoo was only recently implemented, you’ll need Zorro 1.59 or above. You’ll also need R and the RQuantLib package. In the final article of this series we’ll test a real options trading strategy.

Options Trading, Part 3

Binary options, in their most common form, are very different to real options. They are a bet that the price of an asset will rise or fall within a given time frame. If you win the bet, the broker pays your stake multiplied with a win payout factor in the 75%..95% range. If you lose, you pay the stake minus a possible loss payout. You’re trading not against the market, but against the broker. The broker needs you to lose, otherwise they would not make any profit. Even if they really pay out your wins, and even if they do not manipulate the price curve, they can still control your profit with their payout factors. So it seems that even if you had a winning system, the broker would just reduce the payout for making sure that you lose in the long run.

However this conclusion is a fallacy. It can in fact be of advantage for the broker to offer a payout that allows you to win, as long as most other traders still lose. A broker has not the freedom of arbitrarily reducing the payout. He’s competing with other brokers. But why would you want to trade binary options anyway, when you also can trade serious instruments instead? If you wanted a binary outcome, you can also achieve this by opening a Put or Call Spread with real options – and this with a serious broker, much higher payout factors (even > 100% in some cases) and the possibility to sell the options prematurely.

But aside from tax advantages in some countries, there is one single compelling reason that might make a binary options trading experiment worthwhile. Profit and trading cost of a binary option are independent of the time frame. So you can trade on very short time frames, which would be difficult, if not impossible with real options or other financial instruments. You can find a discussion of this problem in the Scalping article.

Binary scalping math

The required minimum win rate for binary trading can be calculated from the broker’s win and loss payout:

[pmath size=16]W~=~ {1-Pl}/{1+Pw-Pl}[/pmath]

W = required win rate for break even
Pl = Loss payout
Pw = Win payout

With 85% win payout and no loss payout, you need a win rate of

[pmath size=16]W ~=~ 1/{1.85} ~=~ 54%[/pmath]

54% win rate seem to be manageable on short time frames. The transaction costs of a non-binary, conventional broker would require a much higher win rate, as in the following graph from the Scalping article:

You had to win almost 80% of five-minutes trades – impossible for a trading system under normal conditions unless you enforce that win rate with some tricks, which however won’t help getting in the profit zone.

So, smaller trading costs on low time frames are the obvious benefit of trading binary options. With all the side benefits of low time frames, such as more data for backtests, and shorter drawdown periods in live trading. But how can we take advantage of that? There are three problems to solve.

Three steps to potential binary profit

1. Find a strategy with a win rate that is better than the W determined with the above payout formula. But be aware that prices on small time frames are strongly feed dependent. Normally you won’t know your binary broker’s price source (if he has any at all). For being on the safe side, test with different historical price data from different serious brokers (f.i. Oanda or FXCM) and stay some percent points above the minimum W.
    
2. Find a way to trade automated. Binary brokers often do not want you to do that. Consequently most do not offer a platform or API for automated trading. But they all have a web interface. So you need either a software tool (such as Zorro) that can send key strokes and mouse clicks to a website, or some other means to get your trades to the broker.
     
3. Find a broker that’s halfway honest. At least one that allows you to really collect your gains. All binary brokers make it easy to deposit, but some follow the philosophy: “If you gave it to me, it’s mine.” Make test withdrawals before you deposit large amounts. Keep the account balance small. Check the broker’s opportunity to manipulate the price curve: the more customers they have and the more bets they handle, the more difficult is it to manipulate without attracting unwanted attention. Retrieve as many information as possible about your broker: Where are they really located? For some reason, fraudsters seem to be concentrated in Tel Aviv. Check what customers say about that broker – but be aware: positive statements on trader forums are often planted by the broker himself.

All those issues make trading binary options sort of “messy”. However it’s the messy methods that sometimes offer the best opportunities. Ed Thorp made his first millions not with ‘serious trading’, but with a Blackjack strategy and with a method to estimate the value of warrants, both also considered messy and hard to calculate at that time.

Step 1: The system

A price curve is no random walk. At least not all of the time. Long time frames are often dominated by trend, short time frames by mean reversion. When transaction costs do not matter, it’s not very hard to find a system with > 54% win rate on 5-minutes bars. Here’s a simple example that exploits the mean reversion tendency of short time frames (script for Zorro):

var objective()
{
	return ((var)(NumWinLong+NumWinShort))/(NumLossLong+NumLossShort);
}


function run()
{
	BarPeriod = 5;
	LookBack = 100;
	NumWFOCycles = 20;
	NumCores = -1;
	
	set(BINARY);
	WinPayout = 85;
	LossPayout = 0;

	set(PARAMETERS);
	int TimePeriod = optimize(20,10,100);
	var Threshold = 0.01*(HH(TimePeriod)-LL(TimePeriod));

	if(NumOpenLong+NumOpenShort == 0) 
	{
		LifeTime = 1;
		if(HH(TimePeriod) - priceClose() < Threshold)
			enterShort();
		else if(priceClose() - LL(TimePeriod) < Threshold)
			enterLong();
	}
}

In the C code above we defined an individual objective() function that optimizes the system for binary trading. It measures the system performance as the number of winning trades divided by the number of losing trades. Otherwise the optimizer would hunt for the most robust profit factor, which makes no sense for binary trading.

The setup establishes a 5 minutes bar period, which is the time frame of our bets. We use 20 WFO cycles and let the optimizer use all CPU cores but one. This way the training run takes about 5-10 minutes for 5 years data. The BINARY flag activates binary trades, and we’re simulating a broker with 85% win payout and no loss payout.

We have a mean reverting system that trades whenever the current price is closer than a threshold – here, 1% of recent volatility – to its previous High or Low. The time period for determining the High and Low is the only system parameter that we optimize. You could improve the system in many ways, for instance by optimizing also the threshold, by modifying the objective() function so that it prefers systems with more trades, and by applying a filter that prevents trading in non mean-reverting market regimes. Since we bet on the price in 5 minutes, we’ve set the LifeTime of a trade to one bar. Here’s the equity curve from a 5 years walk forward test with EUR/USD:

The system has about 56% win rate and a notable, although not spectacular positive return. Which is not achieved by the crude mean reversion mechanism, but mostly by amplifying the small entry-exit price differences through binary trading, even though the payout is only 85%. You won’t get a similar result with conventional trades. The same system not trading binary options, but leveraged forex positions produces a very different equity curve (for testing, comment out the BINARY flag and the Payout settings in the code):

With the same trades we have now only 40% win rate and an overall loss, since all the trade profit is eaten up by spread and commission. 

Step 2: Automatizing

How do you let your script automatically enter a bet at the right moment? This is a technical issue unrelated to trading, but it comes up whenever you have a broker with a web based platform and no proper connection for automatizing. Here’s a code snippet for detecting the positions of [Buy] and [Sell] buttons on a website, and automated clicking them:

void main()
{
	int BuyX,BuyY,SellX,SellY; // button coordinates

// open the browser	
	printf("\nOpening the broker's website...");
	exec("http://financial-hacker.com/shark.htm",0,1);

// get the position of the Buy button
	printf("\nRight click on [Buy]!");
	while(wait(50)) {
		int button = mouse(&BuyX,&BuyY,window(""));
		if(button & 2) break;
	}
// wait until right mouse key released	
	while(wait(50)) {
		int x,y,button = mouse(&x,&y,0);
		if(!(button & 2)) break;	
	}

// get the position of the Sell button	
	printf("\nRight click on [Sell]!");
	while(wait(50)) {
		int button = mouse(&SellX,&SellY,window(""));
		if(button & 2) break;
	}
// wait until right mouse key released	
	while(wait(50)) {
		int x,y,button = mouse(&x,&y,0);
		if(!(button & 2)) break;	
	}

// send mouse clicks to Buy and Sell	
	printf("\nI will now click on [Buy]!");
	keys("[click %d,%d]",BuyX,BuyY);
	printf("\nI will now click on [Sell]!");
	keys("[click %d,%d]",SellX,SellY);
	printf("\nDone!");
}

Start the script, and wait until the broker’s website pops up in your browser. Then follow the instructions in Zorro’s message window. Manoever the mouse onto the “Buy” button and hit the right mouse key. Then do the same with the “Sell” button. The script will store the button positions and then use the keys function to send test clicks to both positions of the active window. For testing purposes I’ve imitated a typical binary broker’s trading platform.

You now only need to glue together your trading script with the button clicking script, and adapt the latter to the website of your broker. This is left as an exercise to the reader. And better use improved versions – the scripts here are kept simple for demonstration purposes. As long as the script trades, make sure that the browser window stays in the foreground, or else it can not click on the buttons. For the position size, either enter a fixed size for all positions, or let your script click into the size field and send key strokes to set individual sizes.

Step 3: The broker

Of course I don’t want to recommend a particular binary options broker. In the end, they’re all crooks – but some are crookier than others. Finding a suited broker is, also, left as an exercise to the reader. Binary broker comparison websites are often – surprise, surprise – installed and paid by binary brokers. US citizens are normally not allowed to trade binary options with brokers that are not regulated in the US. Some brokers will accept your deposit nevertheless, but use that as pretext to refuse payout. If you’re a citizen of Israel, you might not be accepted by many binary brokers since they’re not allowed to fraud compatriots. 

Conclusion

It’s often the “messy” and despised trade instruments that can still provide opportunities when they are correctly understood. I’ve uploaded the two scripts to the 2016 repository. You’ll need Zorro 1.52 or above for running them. When you now make huge profits with binary options, don’t forget where the money comes from: Not from the broker, but from his less fortunate customers that maybe just haven’t read the right blog.

Addendum: From all articles on this blog, this one attracted by far the most spam comments. From them it appears that a new lucrative business has established in the orbit of binary brokers: recovery fraud. As soon as you’ve lost your money, you’ll receive offers by “hackers” or “law firms” to recover it, for a fee of course. Where did they get your email from? Naturally from the very broker that bagged your money…