Option Strategies

Follow these steps to implement the protective collar strategy:

1. In the Initializeinitialize method, set the start date, set the end date, subscribe to the underlying Equity, and create an Option universe.

private Symbol _symbol;

public override void Initialize()
{
    SetStartDate(2017, 4, 1);
    SetEndDate(2017, 4, 30);
    SetCash(100000);

    UniverseSettings.Asynchronous = true;
    var option = AddOption("GOOG", Resolution.Minute);
    _symbol = option.Symbol;
    option.SetFilter(universe => universe.IncludeWeeklys().ProtectiveCollar(30, -1, -10));
}

def initialize(self) -> None:
    self.set_start_date(2017, 4, 1)
    self.set_end_date(2017, 4, 30)
    self.set_cash(100000)

    self.universe_settings.asynchronous = True
    option = self.add_option("GOOG", Resolution.MINUTE)
    self._symbol = option.symbol
    option.set_filter(lambda universe: universe.include_weeklys().protective_collar(30, -1, -10))

The ProtectiveCollarprotective_collar filter narrows the universe down to just the two contracts you need to form a protective collar.

2. In the OnDataon_data method, select the Option contracts.

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

    // Get the OptionChain
    if (!slice.OptionChains.TryGetValue(_symbol, out var chain)) return;

    // Select an expiry date
    var expiry = chain.Max(x => x.Expiry);

    // Select the call and put contracts that expire on the selected date
    var calls = chain.Where(x => x.Expiry == expiry && x.Right == OptionRight.Call);
    var puts = chain.Where(x => x.Expiry == expiry && x.Right == OptionRight.Put);
    if (calls.Count() == 0 || puts.Count() == 0) return;

    // Select the OTM contracts
    var call = calls.OrderBy(x => x.Strike).Last();
    var put = puts.OrderBy(x => x.Strike).First();

def on_data(self, slice: Slice) -> None:
    if self.portfolio.invested:
        return

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

    # Select an expiry date
    expiry = max([x.expiry for x in chain])

    # Select the call and put contracts that expire on the selected date
    calls = [x for x in chain if x.right == OptionRight.CALL and x.expiry == expiry]
    puts = [x for x in chain if x.right == OptionRight.PUT and x.expiry == expiry]
    if not calls or not puts:
        return

    # Select the OTM contracts
    call = sorted(calls, key = lambda x: x.strike)[-1]
    put = sorted(puts, key = lambda x: x.strike)[0]

3. In the OnDataon_data method, select the contracts and place the orders.

Approach A: Call the OptionStrategies.ProtectiveCollarOptionStrategies.protective_collar method with the details of each leg and then pass the result to the Buybuy method.

var protectiveCollar = OptionStrategies.ProtectiveCollar(_symbol, call.Strike, put.Strike, expiry);
Buy(protectiveCollar, 1);

protective_collar = OptionStrategies.protective_collar(self._symbol, call.strike, put.strike, expiry)
self.buy(protective_collar, 1)

Approach B: Create a list of Leg objects and then call the Combo Market Ordercombo_market_order, Combo Limit Ordercombo_limit_order, or Combo Leg Limit Ordercombo_leg_limit_order method.

var legs = new List<Leg>()
    {
        Leg.Create(call.Symbol, -1),
        Leg.Create(put.Symbol, 1),
        Leg.Create(chain.Underlying.Symbol, chain.Underlying.SymbolProperties.ContractMultiplier)
    };
ComboMarketOrder(legs, 1);

legs = [
    Leg.create(call.symbol, -1),
    Leg.create(put.symbol, 1),
    Leg.create(chain.underlying.symbol, chain.underlying.symbol_properties.contract_multiplier)
]
self.combo_market_order(legs, 1)

This is a limited-profit-limited-loss strategy. The payoff is

$$ \begin{array}{rcll} C_T & = & (S_T - K^{C})^{+}\\ P_T & = & (K^{P} - S_T)^{+}\\ Payoff_T & = & (S_T - S_0 - C_T + P_T + C_0 - P_0)\times m - fee \end{array} $$ $$ \begin{array}{rcll} \textrm{where} & C_T & = & \textrm{Call value at time T}\\ & P_T & = & \textrm{Put value at time T}\\ & S_T & = & \textrm{Underlying asset price at time T}\\ & K^{C} & = & \textrm{Call strike price}\\ & K^{P} & = & \textrm{Put strike price}\\ & Payoff_T & = & \textrm{Payout total at time T}\\ & S_0 & = & \textrm{Underlying asset price when the trade opened}\\ & C_0 & = & \textrm{Call price when the trade opened (credit received)}\\ & P_0 & = & \textrm{Put price when the trade opened (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 $K^{C} - S_T + C_0 - P_0$. It occurs when the underlying price is at or above the strike price of the call at expiration.

The maximum profit is $S_T - K^{P} + C_0 - P_0$. It occurs when the underlying price is at or below the strike price of the put at expiration.

If the Option is American Option, there is a risk of early assignment on the contract you sell.

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

Asset	Price ($)	Strike ($)
Call	2.85	845.00
Put	6.00	822.50
Underlying Equity at position opens	833.17	-
Underlying Equity at expiration	843.25	-

Therefore, the payoff is

$$ \begin{array}{rcll} C_T & = & (S_T - K^{C})^{+}\\ & = & (843.365 - 845.00)^{+}\\ & = & 0\\ P_T & = & (K^{P} - S_T)^{+}\\ & = & (822.50 - 843.365)^{+}\\ & = & 0\\ Payoff_T & = & (S_T - S_0 - C_T + P_T + C_0 - P_0)\times m - fee\\ & = & (843.25 - 833.17 - 0 + 0 + 2.85 - 6.00)\times100-1.00\times3\\ & = & 690\\ \end{array} $$

So, the strategy gains $690.

The following algorithm implements a protective collar Option strategy: