Option Strategies

Long Iron Butterfly

Introduction

The Long Iron Butterfly is an option strategy which involves four Option contracts. All the contracts have the same underlying stock and expiration, but the order of strike prices for the four contracts is $A>B>C$. The following table describes the strike price of each contract:

PositionStrike
1 OTM call $A$
-1 ATM call $B$
-1 ATM put $B$
1 OTM put $C=B-(A-B)$

The long iron butterfly consists of selling an OTM call, selling an OTM put, buying an ATM call, and buying an ATM put. This strategy profits from a decrease in price movement (implied volatility).

Implementation

Follow these steps to implement the long iron butterfly strategy:

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

public override void Initialize()
{
    SetStartDate(2024, 9, 1);
    SetEndDate(2024, 12, 31);
    SetCash(100000);

    UniverseSettings.Asynchronous = true;
    var option = AddOption("GOOG", Resolution.Minute);
    _symbol = option.Symbol;
    option.SetFilter(universe => universe.IncludeWeeklys().IronButterfly(30, 5));
}
    def initialize(self) -> None:
    self.set_start_date(2024, 9, 1)
    self.set_end_date(2024, 12, 31)
    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().iron_butterfly(30, 5));

    The IronButterflyiron_butterfly filter narrows the universe down to just the four contracts you need to form a long iron butterfly.

  2. In the OnDataon_data method, select the contracts in the strategy legs.
    3. public override void OnData(Slice slice)
{
    if (Portfolio.Invested ||
        !slice.OptionChains.TryGetValue(_symbol, out var chain))
    {
        return;
    }

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

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

    // Get the ATM and OTM strike prices
    var atmStrike = calls.OrderBy(x => Math.Abs(x.Strike - chain.Underlying.Price)).First().Strike;
    var otmPutStrike = puts.Min(x => x.Strike);
    var otmCallStrike = 2 * atmStrike - otmPutStrike;
    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 expiry
    expiry = max([x.expiry for x in chain])

    # Separate the call and put contracts
    calls = [i for i in chain if i.right == OptionRight.CALL and i.expiry == expiry]
    puts = [i for i in chain if i.right == OptionRight.PUT and i.expiry == expiry]
    if not calls or not puts:
        return

    # Get the ATM and OTM strike prices
    atm_strike = sorted(calls, key = lambda x: abs(chain.underlying.price - x.strike))[0].strike
    otm_put_strike = min([x.strike for x in puts])
    otm_call_strike = 2 * atm_strike - otm_put_strike
  3. In the OnDataon_data method, select the contracts and place the orders.

    4. Approach A: Call the OptionStrategies.IronButterflyOptionStrategies.iron_butterfly method with the details of each leg and then pass the result to the Buybuy method.

    var ironButterfly = OptionStrategies.IronButterfly(_symbol, otmPutStrike, atmStrike, otmCallStrike, expiry);
Buy(ironButterfly, 2);
    iron_butterfly = OptionStrategies.iron_butterfly(self._symbol, otm_put_strike, atm_strike, otm_call_strike, expiry)
self.buy(iron_butterfly, 2)

    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.

    // Select the contracts
var atmCall = calls.Single(x => x.Strike == atmStrike);
var atmPut = puts.Single(x => x.Strike == atmStrike);
var otmCall = calls.Single(x => x.Strike == otmCallStrike);
var otmPut = puts.Single(x => x.Strike == otmPutStrike);

var legs = new List<Leg>()
    {
        Leg.Create(atmCall.Symbol, -1),
        Leg.Create(atmPut.Symbol, -1),
        Leg.Create(otmCall.Symbol, 1),
        Leg.Create(otmPut.Symbol, 1)
    };
ComboMarketOrder(legs, 1);
    # Select the contracts
atm_call = [x for x in calls if x.strike == atm_strike][0]
atm_put = [x for x in puts if x.strike == atm_strike][0]
otm_call = [x for x in calls if x.strike == otm_call_strike][0]
otm_put = [x for x in puts if x.strike == otm_put_strike][0]

legs = [
    Leg.create(atm_call.symbol, -1),
    Leg.create(atm_put.symbol, -1),
    Leg.create(otm_call.symbol, 1),
    Leg.create(otm_put.symbol, 1)
]
self.combo_market_order(legs, 1)

Strategy Payoff

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

$$ \begin{array}{rcll} C^{OTM}_T & = & (S_T - K^C_{OTM})^{+}\\ C^{ATM}_T & = & (S_T - K^C_{ATM})^{+}\\ P^{OTM}_T & = & (K^P_{OTM} - S_T)^{+}\\ P^{ATM}_T & = & (K^P_{ATM} - S_T)^{+}\\ P_T & = & (C^{OTM}_T + P^{OTM}_T - C^{ATM}_T - P^{ATM}_T - C^{OTM}_0 - P^{OTM}_0 + C^{ATM}_0 + P^{ATM}_0)\times m - fee \end{array} $$ $$ \begin{array}{rcll} \textrm{where} & C^{OTM}_T & = & \textrm{OTM call value at time T}\\ & C^{ATM}_T & = & \textrm{ATM call value at time T}\\ & P^{OTM}_T & = & \textrm{OTM 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^C_{OTM} & = & \textrm{OTM call strike price}\\ & K^C_{ATM} & = & \textrm{ATM call strike price}\\ & K^P_{OTM} & = & \textrm{OTM put strike price}\\ & K^P_{ATM} & = & \textrm{ATM put strike price}\\ & P_T & = & \textrm{Payout total at time T}\\ & C^{OTM}_0 & = & \textrm{OTM call value at position opening (debit paid)}\\ & C^{ATM}_0 & = & \textrm{ATM call value at position opening (credit received)}\\ & 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:

Strategy payoff decomposition and analysis of long iron butterfly

The maximum profit is the net credit received, $C^{ATM}_0 + P^{ATM}_0 - C^{OTM}_0 - P^{OTM}_0$. It occurs when the underlying price stays the same as when you opened the trade.

The maximum loss is $K^C_{OTM} - K^C_{ATM} - C^{ATM}_0 - P^{ATM}_0 + C^{OTM}_0 + P^{OTM}_0$. It occurs when the underlying price is below the OTM put strike price or above the OTM call strike price at expiration.

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

Example

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

AssetPrice ($)Strike ($)
OTM call1.35855.00
OTM put1.50810.00
ATM call10.30832.50
ATM put9.50832.50
Underlying Equity at expiration843.25-

Therefore, the payoff is

$$ \begin{array}{rcll} C^{OTM}_T & = & (S_T - K^C_{OTM})^{+}\\ & = & (843.25-855.00)^{+}\\ & = & 0\\ C^{ATM}_T & = & (S_T - K^C_{ATM})^{+}\\ & = & (843.25-832.50)^{+}\\ & = & 10.75\\ P^{OTM}_T & = & (K^P_{OTM} - S_T)^{+}\\ & = & (810.00-843.25)^{+}\\ & = & 0\\ P^{ATM}_T & = & (K^P_{ATM} - S_T)^{+}\\ & = & (832.50.00-843.25)^{+}\\ & = & 0\\ P_T & = & (C^{ATM}_T + P^{ATM}_T - C^{OTM}_T - P^{OTM}_T - C^{ATM}_0 - P^{ATM}_0 + C^{OTM}_0 + P^{OTM}_0)\times m - fee\\ & = & (10.75+0-0-0-10.30-9.50+1.35+1.50)\times100-1\times4\\ & = & -624 \end{array} $$

So, the strategy losses $624.

The following algorithm implements a long iron butterfly Option strategy:

public class LongButterflyStrategy : QCAlgorithm
{
    private Symbol _symbol;

    public override void Initialize()
    {
        SetStartDate(2024, 9, 1);
        SetEndDate(2024, 12, 31);
        SetCash(100000);

        var option = AddOption("GOOG", Resolution.Minute);
        _symbol = option.Symbol;
        option.SetFilter(universe => universe.IncludeWeeklys().IronButterfly(30, 5));
    }

    public override void OnData(Slice slice)
    {
        if (Portfolio.Invested ||
        !slice.OptionChains.TryGetValue(_symbol, out var chain))
        {
            return;
        }

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

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

        // Get the ATM and OTM strike prices
        var atmStrike = calls.OrderBy(x => Math.Abs(x.Strike - chain.Underlying.Price)).First().Strike;
        var otmPutStrike = puts.Min(x => x.Strike);
        var otmCallStrike = 2 * atmStrike - otmPutStrike;

        // Order Strategy
        var ironButterfly = OptionStrategies.IronButterfly(_symbol, otmPutStrike, atmStrike, otmCallStrike, expiry);
        Buy(ironButterfly, 1);
    }
}
class LongButteflyOptionStrategy(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2024, 9, 1)
        self.set_end_date(2024, 12, 31)
        self.set_cash(100000)
        
        option = self.add_option("GOOG", Resolution.MINUTE)
        self._symbol = option.symbol

        # set our strike/expiry filter for this option chain
        option.set_filter(lambda x: x.include_weeklys().iron_butterfly(30, 5))

    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 expiry
        expiry = max([x.expiry for x in chain])

        # Separate the call and put contracts
        calls = [i for i in chain if i.right == OptionRight.CALL and i.expiry == expiry]
        puts = [i for i in chain if i.right == OptionRight.PUT and i.expiry == expiry]
        if not calls or not puts:
            return

        # Get the ATM and OTM strike prices
        atm_strike = sorted(calls, key = lambda x: abs(x.strike - chain.underlying.price))[0].strike
        otm_put_strike = min([x.strike for x in puts])
        otm_call_strike = 2 * atm_strike - otm_put_strike

        iron_butterfly = OptionStrategies.iron_butterfly(self._symbol, otm_put_strike, atm_strike, otm_call_strike, expiry)
        self.buy(iron_butterfly, 1)

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: