Contents

Introduction
Implementation
Summary
Algorithm

Option Strategies

Protective Collar

Introduction

A Protective Collar is an options strategy that involves the combination a Covered Call and a long put (protective put), with a lower strike price than the shorted call. This could provide additional protection to limit the drawdown when the underlying price drop too deep when compared to the covered call.

This is a limited-profit-limited-loss strategy. The payoff is as follows:

$Payoff_{call}=(Price_{underlying}-Strike_{call})^{+}$

$Payoff_{put}=(Strike_{put}-Price_{underlying})^{+}$

$$Payoff=(Price^{T=expiry}_{underlying}-Price^{T=trade\ open}_{underlying}-Payoff_{call}+Payoff_{put}\\ +credit\ received_{call}-debit\ paid_{put})\times multiplier-commissions$$

protective collar strategy payoff

The maximum profit is the call strike minus underlying price, plus the net premium (or minus the net debit paid) of option trades after commission when opening the trade, where the underlying price has price the same as or above the strike price of the call at expiration.

The maximum profit is the underlying price minus put strike, plus the net premium (or minus the net debit paid) of option trades after commission when opening the trade, where the underlying price has price the same as or below the strike price of the put at expiration.

If the option is American option, there will be a risk of early assignment on the shorted option.

Implementation

Follow these steps to implement the protective collar strategy.

  1. In the Initialize method, set the start date, end date, cash, and Option universe.
    2. private Symbol _symbol;

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

    var option = AddOption("GOOG", Resolution.Minute);
    _symbol = option.Symbol;
    option.SetFilter(universe => universe.Strikes(-10, 10)
                                            .Expiration(TimeSpan.FromDays(0), TimeSpan.FromDays(30)));
}
    def Initialize(self) -> None:
    self.SetStartDate(2017, 4, 1)
    self.SetEndDate(2017, 4, 30)
    self.SetCash(100000)
    
    equity = self.AddEquity("GOOG", Resolution.Minute)
    option = self.AddOption("GOOG", Resolution.Minute)
    self.symbol = option.Symbol

    # set our strike/expiry filter for this option chain
    option.SetFilter(-10, +10, timedelta(0), timedelta(30))
  2. In the OnData method, select the Option contracts.
    3. public override void OnData(Slice slice)
{
    if (Portfolio.Invested) return;

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

    // sort the optionchain by expiration date and choose the furthest date
    var expiry = chain.OrderBy(x => x.Expiry).Last().Expiry;

    // filter the call and put options from the contracts expires on that 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;

    // sort the contracts according to their strike prices
    var callContracts = calls.OrderBy(x => x.Strike);
    var putContracts = puts.OrderBy(x => x.Strike);

    // select the furthest OTM contracts
    var call = callContracts.Last();
    var put = putContracts.First();
    def OnData(self, slice: Slice) -> None:
    # avoid extra orders
    if self.Portfolio.Invested: return

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

    # choose the furthest expiration date within 30 days from now on
    expiry = sorted(chain, key = lambda x: x.Expiry)[-1].Expiry
    # filter the call options contracts
    call = [x for x in chain if x.Right == OptionRight.Call and x.Expiry == expiry]
    # filter the put options contracts
    put = [x for x in chain if x.Right == OptionRight.Put and x.Expiry == expiry]

    if not call or not put: return

    self.otm_call = sorted(call, key = lambda x: x.Strike)[-1]
    self.otm_put = sorted(put, key = lambda x: x.Strike)[0]
  3. In the OnData method, submit the order.
    4.     Sell(call.Symbol, 1);
    Buy(put.Symbol, 1);
    Buy(_equity, 100);
}
    self.Sell(self.otm_call.Symbol, 1) # sell the OTM call
self.Buy(self.otm_put.Symbol, 1) # buy the OTM put
self.Buy("GOOG", 100)     # buy 100 shares of the underlying stock

Summary

In this algorithm, we've realised the below payout at expiration (2017-4-22).

ItemsPrice
Price of call$ 2.85
Price of put$ 6.00
Price of underlying stock when trade open$ 833.17
Strike of call$ 845.00
Strike of put$ 822.50
Price of underlying at expiration$ 843.19
Commission per trade$ 1.00
$Payoff_{call}=(843.19-845.00)^{+}=0$

$Payoff_{put}=(822.50-843.19)^{+}=0$

$Payoff=(843.19-833.17+0-0+2.85-6.00)\times100-1.00\times3=684$

So, the strategy gains $684.

Algorithm

Backtest using SetFilter

Backtest using OptionChainProvider

You can also see our Videos. You can also get in touch with us via Discord.

Did you find this page helpful?

Contribute to the documentation: