# Option Strategies

### Introduction

Call calendar spread, which also known as call horizontal spread, is a combination of a longer-term (far-leg/front-month) call and a shorter-term (near-leg/back-month) call, where all calls have the same underlying stock and the same strike price.

It consists of buying a longer-term call and selling a shorter-term call. It is a option strategy profitting from an decrease in price movement, as well as time decay value. It is because the theta $\theta$ (the option price decay by 1 day closer to maturity) of shorter-term call is larger than longer-term.

This is a limited-reward-limited-risk strategy. The payoff is taken at the shorter-term expiration. The payoff is as follows:

$Payoff_{shorter\ term\ call}=(Price_{underlying}-Strike)^{+}$

$Profit/Loss^{t}=(Price^{t}_{longer\ term\ call}-Payoff_{shorter\ term\ call}+credit\ received_{shorter\ term\ call}-debit\ paid_{longer\ term\ call})\times multiplier-commissions$

where $t$ is the expiration of shorter-term call

The maximum profit is undetermined as a dependent of volatility but limited, where the underlying price stays the same as the trade opened and the spread of the calls are at maximum.

Maximum loss is the net debit paid after commission when opening the trade, where the underlying price moves very deep ITM or OTM so the spread of both calls close to zero.

If the option is American option, there will be a risk of early assignment on the shorted option. Naked longed call would pose risk of losing all debit paid if its position is not closed with shorted call together and the price dropped below its strike.

#### Short Call Butterfly

It consists of selling a longer-term call and buying a shorter-term call. It is a option strategy profitting from an increase in price movement.

The payoff is taken at the shorter-term expiration. This is a limited-reward-limited-risk strategy. The payoff is as follows:

$Profit/Loss^{t}=(Payoff_{shorter\ term\ call}-Price^{t}_{longer\ term\ call}+credit\ received_{longer\ term\ call}-debit\ paid_{shorter\ term\ call})\times multiplier-commissions$

where $t$ is the expiration of shorter-term call

The maximum profit is the net credit received after commission when opening the trade, where the underlying price moves very deep ITM or OTM so the spread of both calls close to zero.

Maximum loss is undetermined as a dependent of volatility but limited, where the underlying price is at the same level when the trade opened and the spread of the 2 calls are at its maximum.

If the option is American option, there will be a risk of early assignment on the shorted option. Also, if the call positions are not closed together, the naked shorted call will have unlimited drawdown risk after the longed call expires.

### Implementation

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, 2, 1);
SetEndDate(2017, 2, 19);
SetCash(500000);

_symbol = option.Symbol;
option.SetFilter(universe => universe.IncludeWeeklys()
.Strikes(-1, 1)
.Expiration(TimeSpan.FromDays(0), TimeSpan.FromDays(62)));
}
def Initialize(self) -> None:
self.SetStartDate(2017, 2, 1)
self.SetEndDate(2017, 2, 19)
self.SetCash(500000)

self.symbol = option.Symbol
option.SetFilter(self.UniverseFunc)

def UniverseFunc(self, universe: OptionFilterUniverse) -> OptionFilterUniverse:
return universe.Strikes(-1, 1).Expiration(timedelta(0), timedelta(62))
3. In the OnData method, select the Option contracts.
4. 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;

// get at-the-money strike
var atmStrike = chain.OrderBy(x => Math.Abs(x.Strike - chain.Underlying.Price)).First().Strike;

// filter the call options from the contracts which is ATM in the option chain.
var calls = chain.Where(x => x.Strike == atmStrike && x.Right == OptionRight.Call);
if (calls.Count() == 0) return;

// sorted the optionchain by expiration date
var expiries = calls.Select(x => x.Expiry).OrderBy(x => x);

// select the farest expiry as far-leg expiry, and the nearest expiry as near-leg expiry
var nearExpiry = expiries.First();
var farExpiry = expiries.Last();
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

# get at-the-money strike
atm_strike = sorted(chain, key=lambda x: abs(x.Strike - chain.Underlying.Price))[0].Strike

# filter the call options from the contracts which is ATM in the option chain.
calls = [i for i in chain if i.Strike == atm_strike and i.Right == OptionRight.Call]
if len(calls) == 0: return

# sorted the optionchain by expiration date
expiries = sorted([x.Expiry for x in calls])

# select the farest expiry as far-leg expiry, and the nearest expiry as near-leg expiry
near_expiry = expiries[0]
far_expiry = expiries[-1]
5. In the OnData method, call the OptionStrategies.CallCalendarSpread method and then submit the order.
6.     var optionStrategy = OptionStrategies.CallCalendarSpread(_symbol, atmStrike, nearExpiry, farExpiry);
// We open a position with 1 unit of the option strategy
Sell(optionStrategy, 1);     // if short call calendar spread
}
option_strategy = OptionStrategies.CallCalendarSpread(self.symbol, atm_strike, near_expiry, far_expiry)
# We open a position with 1 unit of the option strategy
self.Sell(option_strategy, 1)   # if short call calendar spread

### Summary

In this algorithm, we've realised the below payout at shorter-term call's expiration (2022-2-19).

ItemsPrice
Price of longer-term call$20.00 Price of shorter-term call$ 11.30
Strike of calls$800.00 Price of longer-term call at shorter-term expiration$ 31.35
Price of underlying at shorter-term expiration$828.07 Commission per trade$ 1.00
$Payoff_{shorter\ term\ call}=(828.07-800.00)^{+}=28.07$

$Payoff_{total}=(31.35-28.07+11.30-20.00)\times100-1.00\times2=-544$

So, the strategy losses \$544.

### Algorithm

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