Option Strategies

Follow these steps to implement the put butterfly strategy:

1. In the Initialize method, set the start date, end date, cash, and Option universe.

private Symbol _symbol;

public override void Initialize()
{
    SetStartDate(2017, 2, 1);
    SetEndDate(2017, 3, 5);
    SetCash(500000);

    var option = AddOption("GOOG", Resolution.Minute);
    _symbol = option.Symbol;
    option.SetFilter(universe => universe.IncludeWeeklys()
                                            .Strikes(-15, 15)
                                            .Expiration(TimeSpan.FromDays(0), TimeSpan.FromDays(31)));
}

def Initialize(self) -> None:
    self.SetStartDate(2017, 2, 1)
    self.SetEndDate(2017, 3, 5)
    self.SetCash(500000)

    option = self.AddOption("GOOG", Resolution.Minute)
    self.symbol = option.Symbol
    option.SetFilter(self.UniverseFunc)

def UniverseFunc(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
    return universe.IncludeWeeklys().Strikes(-15, 15).Expiration(timedelta(0), timedelta(31))

2. In the OnData method, select strikes and expiration date of the contracts in the strategy legs.

public override void OnData(Slice slice)
{
    if (Portfolio.Invested) return;

    // Get the OptionChain
    var chain = slice.OptionChains.get(_symbol, null);
    if (chain == null || chain.Count() == 0) return;

    // Select an expiry date
    var expiry = chain.OrderByDescending(x => x.Expiry).First().Expiry;
    
    // Select the put contracts that expire on the selected date
    var puts = chain.Where(x => x.Expiry == expiry && x.Right == OptionRight.Put);
    if (puts.Count() == 0) return;

    // Sort the put contracts by their strike prices
    var putStrikes = puts.Select(x => x.Strike).OrderBy(x => x);

    // Get the ATM strike price
    var atmStrike = puts.OrderBy(x => Math.Abs(x.Strike - chain.Underlying.Price)).First().Strike;

    // Get the distance between lowest strike price and ATM strike, and highest strike price and ATM strike 
    // Get the lower value as the spread distance as equidistance is needed for both sides
    var spread = Math.Min(Math.Abs(putStrikes.First() - atmStrike), Math.Abs(putStrikes.Last() - atmStrike));

    // Select the strike prices of the strategy legs
    var itmStrike = atmStrike + spread;
    var otmStrike = atmStrike - spread;

def OnData(self, slice: Slice) -> None:
    if self.Portfolio.Invested: return

    # Get the OptionChain
    chain = slice.OptionChains.get(self.symbol, None)
    if not chain: return

    # Select an expiry date
    expiry = sorted(chain, key = lambda x: x.Expiry, reverse=True)[0].Expiry
    
    # Select the put contracts that expire on the selected date
    puts = [i for i in chain if i.Expiry == expiry and i.Right == OptionRight.Put]
    if len(puts) == 0: return

    # Sort the put contracts by their strike prices
    put_strikes = sorted([x.Strike for x in puts])

    # Get the ATM strike price
    atm_strike = sorted(puts, key=lambda x: abs(x.Strike - chain.Underlying.Price))[0].Strike

    # Get the distance between lowest strike price and ATM strike, and highest strike price and ATM strike. 
    # Get the lower value as the spread distance as equidistance is needed for both sides
    spread = min(abs(put_strikes[0] - atm_strike), abs(put_strikes[-1] - atm_strike))

    # Select the strike prices of the strategy legs
    itm_strike = atm_strike + spread
    otm_strike = atm_strike - spread

3. In the OnData method, call the OptionStrategies.PutButterfly method and then submit the order.

var optionStrategy = OptionStrategies.PutButterfly(_symbol, itmStrike, atmStrike, otmStrike, expiry);
Buy(optionStrategy, 1);    // if long put butterfly
Sell(optionStrategy, 1);   // if short put butterfly

option_strategy = OptionStrategies.PutButterfly(self.symbol, itm_strike, atm_strike, otm_strike, expiry)
self.Buy(option_strategy, 1)    # if long put butterfly
self.Sell(option_strategy, 1)   # if short put butterfly

Option strategies synchronously execute by default. To asynchronously execute Option strategies, set the asynchronous argument to Falsefalse. You can also provide a tag and order properties to the Buy and Sell methods.

Buy(optionStrategy, quantity, asynchronous, tag, orderProperties);
Sell(optionStrategy, quantity, asynchronous, tag, orderProperties);

self.Buy(option_strategy, quantity, asynchronous, tag, order_properties)
self.Sell(option_strategy, quantity, asynchronous, tag, order_properties)

The put butterfly can be long or short.

Long Put Butterfly

The long put butterfly is a limited-reward-limited-risk strategy. The payoff is

$$ \begin{array}{rcll} P^{OTM}_T & = & (K^{OTM} - S_T)^{+}\\ P^{ITM}_T & = & (K^{ITM} - S_T)^{+}\\ P^{ATM}_T & = & (K^{ATM} - S_T)^{+}\\ P_T & = & (P^{OTM}_T + P^{ITM}_T - 2\times P^{ATM}_T + 2\times P^{ATM}_0 - P^{ITM}_0 - P^{OTM}_0)\times m - fee \end{array} $$ $$ \begin{array}{rcll} \textrm{where} & P^{OTM}_T & = & \textrm{OTM put value at time T}\\ & P^{ITM}_T & = & \textrm{ITM put value at time T}\\ & P^{ATM}_T & = & \textrm{ATM put value at time T}\\ & S_T & = & \textrm{Underlying asset price at time T}\\ & K^{OTM} & = & \textrm{OTM put strike price}\\ & K^{ITM} & = & \textrm{ITM put strike price}\\ & K^{ATM} & = & \textrm{ATM put strike price}\\ & P_T & = & \textrm{Payout total at time T}\\ & P^{ITM}_0 & = & \textrm{ITM put value at position opening (debit paid)}\\ & P^{OTM}_0 & = & \textrm{OTM put value at position opening (debit paid)}\\ & P^{ATM}_0 & = & \textrm{ATM put value at position opening (credit received)}\\ & m & = & \textrm{Contract multiplier}\\ & T & = & \textrm{Time of expiration} \end{array} $$

The following chart shows the payoff at expiration:

The maximum profit is $K^{ATM} - K^{OTM} + 2\times P^{ATM}_0 - P^{ITM}_0 - P^{OTM}_0$. It occurs when the underlying price is the same at expiration as it was when you open the trade. In this case, the payout of the combined bull put and bear put spreads are at their maximum.

The maximum loss is the net debit paid, $2\times P^{ATM}_0 - P^{ITM}_0 - P^{OTM}_0$. It occurs when the underlying price is below the ITM strike price or above the OTM strike price at expiration.

If the Option is American Option, there is risk of early assignment on the sold contracts.

Short Put Butterfly

The short put butterfly is a limited-reward-limited-risk strategy. The payoff is

$$ \begin{array}{rcll} P^{OTM}_T & = & (K^{OTM} - S_T)^{+}\\ P^{ITM}_T & = & (K^{ITM} - S_T)^{+}\\ P^{ATM}_T & = & (K^{ATM} - S_T)^{+}\\ P_T & = & (2\times P^{ATM}_T - P^{OTM}_T - P^{ITM}_T - 2\times P^{ATM}_0 + P^{ITM}_0 + P^{OTM}_0)\times m - fee \end{array} $$ $$ \begin{array}{rcll} \textrm{where} & P^{OTM}_T & = & \textrm{OTM put value at time T}\\ & P^{ITM}_T & = & \textrm{ITM put value at time T}\\ & P^{ATM}_T & = & \textrm{ATM put value at time T}\\ & S_T & = & \textrm{Underlying asset price at time T}\\ & K^{OTM} & = & \textrm{OTM put strike price}\\ & K^{ITM} & = & \textrm{ITM put strike price}\\ & K^{ATM} & = & \textrm{ATM put strike price}\\ & P_T & = & \textrm{Payout total at time T}\\ & P^{ITM}_0 & = & \textrm{ITM put value at position opening (credit received)}\\ & P^{OTM}_0 & = & \textrm{OTM put value at position opening (credit received)}\\ & P^{ATM}_0 & = & \textrm{ATM put value at position opening (debit paid)}\\ & m & = & \textrm{Contract multiplier}\\ & T & = & \textrm{Time of expiration} \end{array} $$

The following chart shows the payoff at expiration:

The maximum profit is the net credit received, $P^{ITM}_0 + P^{OTM}_0 - 2\times P^{ATM}_0$. It occurs when the underlying price is below the ITM strike or above the OTM strike at expiration.

The maximum loss is $K^{ATM} - K^{OTM} - 2\times P^{ATM}_0 + P^{ITM}_0 + P^{OTM}_0$. It occurs when the underlying price at expiration is at the same price as when you opened the trade.

If the Option is American Option, there is risk of early assignment on the sold contracts.

The following table shows the price details of the assets in the long put butterfly algorithm:

Asset	Price ($)	Strike ($)
ITM put	37.80	832.50
ATM put	14.70	800.00
OTM put	5.70	767.50
Underlying Equity at expiration	829.08	-

Therefore, the payoff is

$$ \begin{array}{rcll} P^{OTM}_T & = & (K^{OTM} - S_T)^{+}\\ & = & (829.08-832.50)^{+}\\ & = & 0\\ P^{ITM}_T & = & (K^{ITM} - S_T)^{+}\\ & = & (829.08-767.50)^{+}\\ & = & 61.58\\ P^{ATM}_T & = & (K^{ATM} - S_T)^{+}\\ & = & (829.08-800.00)^{+}\\ & = & 29.08\\ P_T & = & (P^{OTM}_T + P^{ITM}_T - 2\times P^{ATM}_T + 2\times P^{ATM}_0 - P^{ITM}_0 - P^{OTM}_0)\times m - fee\\ & = & (61.58+0-29.08\times2-5.70-37.80+14.70\times2)\times100-1.00\times4\\ & = & -1072 \end{array} $$

So, the strategy losses $1,072.

The following algorithm implements a long put butterfly Option strategy: