Convert straddles into delta-neutral straddles

Hi Nico,

To make the overall position delta-neutral, supplement the position with long or short holdings in the underlying asset.

Best,
Derek Melchin

Want to invest in QuantConnect as we build the Linux of quant finance? Checkout our Wefunder campaign to join the revolution.

Hey Derek Melchin,

thank you for responding.

So Delta tends to increase as we get closer to expiration for  at-the-money options. How much is that and on what timeframe?

I'm asking that because I construct straddles with a filter of 30, 63 days and an atm strike price. Also I'm trading them for a max of 30 days before an earnings announcement. Is it enough for this timeframe to hedge them one time or does this need to happen every day?

Is it enough and the delta will not move more than lets say 0.05 for this timeframe then I simply could setholdings after buying the options. But if that isnt the case and the Delta moves beyond that or even more I will have to adjust it each day…

In short:

• check for invested contracts of a symbol
• select for each symbol the contracts
• check sum of delta and set holdings

The problem is that I cant access the Delta. I checked the documentation and the way Greeks are saved is: OptionChains > Symbol > Contracts > Values > Greeks > Delta.

#checks for invested options, saves them in a list
option_invested = [x.Key for x in self.Portfolio if x.Value.Invested and x.Value.Type==SecurityType.Option]
#returns if no options are invested
if option_invested is None: return
        for symbol in self.options:
        	#optionChains
            sort = [x.Value.Contracts for x in data.OptionChains if x.Key == symbol]

I'm not sure how to access the Delta, I also tried using self.Portfolio[symbol] but htat didnt work.

What am I doing wrong?

So I think I was able to access the delta but I have one more question. Is this done the right way? Also you mentioned holdings, should I use that instead of a market order and what about the quantity? 

option_invested = [x.Key for x in self.Portfolio if x.Value.Invested and x.Value.Type==SecurityType.Option]
if len(option_invested) == 0: return
        for symbol in self.options:
            #checks if symbol from loop is invested
            symbol_inv = [option for option in [x.Key for x in self.Portfolio if x.Value.Invested and x.Value.Type==SecurityType.Option] if option.Underlying == symbol.Underlying]
            #if there are no contracts for symbol do another symbol
            if len(symbol_inv) == 0: continue
            traded_contracts = [kvp.Value for kvp in data.OptionChains if kvp.Key == symbol]
            call = [i for i in symbol_inv if i.ID.OptionRight == OptionRight.Call][0]
            put = [i for i in symbol_inv if i.ID.OptionRight == OptionRight.Put][0]
            contracts = filter(lambda x: x.Symbol == call or x.Symbol == put, traded_contracts[0])
      
            
            deltas = [i.Greeks.Delta for i in contracts]
            delta=sum(deltas)
            if delta < 0 and delta > -0.05:
                order = (self.Securities[symbol.Underlying].Price/1*delta)
                self.MarketOrder(symbol.Underlying, order)
            if delta > 0 and delta > 0.05:
                order = (self.Securities[symbol.Underlying].Price/1*delta)
                self.MarketOrder(symbol.Underlying, -order)

Thanks in advance!

SO I'm still asking myself if this is right. I changed a few things but by using set holdings and a lot of symbols I get errors that I dont have enough money. How should I change this to make it work?

if len(option_invested) == 0: return
        for symbol in self.options:
            
            #checks if symbol from loop is invested
            symbol_inv = [option for option in [x.Key for x in self.Portfolio if x.Value.Invested and x.Value.Type==SecurityType.Option] if option.Underlying == symbol.Underlying]
            #if there are no contracts for symbol do another symbol
            
            if len(symbol_inv) == 0: 
                self.Liquidate(symbol.Underlying)
                continue
            try:
                traded_contracts = [kvp.Value for kvp in data.OptionChains if kvp.Key == symbol]
                call = [i for i in symbol_inv if i.ID.OptionRight == OptionRight.Call][0]
                put = [i for i in symbol_inv if i.ID.OptionRight == OptionRight.Put][0]
                if len(traded_contracts) == 0: continue
                contracts = filter(lambda x: x.Symbol == call or x.Symbol == put, traded_contracts[0])
        
                
                deltas = [i.Greeks.Delta for i in contracts]
                delta=sum(deltas)
                if abs(self.previous_delta[symbol][0] - delta) > 0.05:
                    self.SetHoldings(call.Underlying, delta)
                    self.previous_delta[symbol] = delta
            except:
                continue

Hi Nico,

Instead of adjusting the hedge on a set schedule, it's common to just set a threshold delta value that's acceptable. When the threshold is breached, increase/decrease the underlying position to make the overall position delta-neutral again.

We should use manual orders instead of using the SetHoldings method since the net delta of the overall position tells us the exact number of shares to buy/sell. 

See the attached backtest for reference.

Best,
Derek Melchin

Want to invest in QuantConnect as we build the Linux of quant finance? Checkout our Wefunder campaign to join the revolution.

Thank you Derek Melchin, this will help me tremendously! 
Im currently not at home so I can’t backtest this. I looked for this hedging method on the internet and I didn’t found a RULE to follow. Could you provide me the theory behind this or lead me to the right direction? 

Thanks in advance!
 

Hey Derek Melchin, I implemented your example in my own code. I changed a few things because I had different symbols.

if len(option_invested) == 0: return
        for symbol in self.options:
            
            #checks if symbol from loop is invested
            symbol_inv = [option for option in [x.Key for x in self.Portfolio if x.Value.Invested and x.Value.Type==SecurityType.Option] if option.Underlying == symbol.Underlying]
            #if there are no contracts for symbol do another symbol
            
            if len(symbol_inv) == 0: 
                self.Liquidate(symbol.Underlying)
                continue
            
            
            try:
                
                traded_contracts = [kvp.Value for kvp in data.OptionChains if kvp.Key == symbol]
                call = [i for i in symbol_inv if i.ID.OptionRight == OptionRight.Call][0]
                put = [i for i in symbol_inv if i.ID.OptionRight == OptionRight.Put][0]
                if len(traded_contracts) == 0: continue
                contracts = filter(lambda x: x.Symbol == call or x.Symbol == put, traded_contracts[0])
        
                
                deltas = [i.Greeks.Delta for i in contracts]
                dela = sum(deltas) * (self.Portfolio[call].Quantity + self.Portfolio[put].Quantity)

                mult = [i for i in self.options_info if i.Symbol == symbol]
                #multiplier = chain.Contracts.get(symbol).OptionMulitiplier
                delta=dela * mult[0].ContractMultiplier
                underlying_delta = self.Portfolio[symbol.Underlying].Quantity
                net_delta = delta + underlying_delta
                quantity = int(net_delta)
                
                if abs(quantity) >= self.delta_threshold:
                    self.MarketOrder(symbol.Underlying, quantity)
                if symbol.Underlying =='AAPL':
                    
                    self.Plot("AAPL_delta", "Quantity", delta)
                    self.Plot("AAPL_net_delta", "Quantity", net_delta)
                    
            except:
                continue

I added a picture of the results:

Do these results look right? I'm asking because normally positive results would be connected to buying randomly a lot of shares. Btw AAPL indicator is the only one that gets updated at least daily. Also if it does delta-hedging why does the net_delta value not change when trying the same approach but commenting the market order.

Buy-Sell(hedge):

No buying or selling:

So Nico Xenox are u trying to implement stratergies as described at 

Hey Derek Melchin and Newoptionz,

I understand it the following way: the objective is to bring delta down to a minimum. For that we have to meassure delta of the used options:

sum(deltas) * (self.Portfolio[call].Quantity + self.Portfolio[put].Quantity)

to make it easier we multiply that by the option multiplier. Then we add the underlying delta, which is the stock. Every stock has a delta of 1 thats why we can just use the quantity. At the end we check if the addition is bigger then a threshold. 

Also shouldn't the quantity be like this (negative)?

self.MarketOrder(symbol.Underlying, -quantity)

positive q:

negative q:

As you can see the values in the negative quantity are between -100 and 100 while the other one is between -2k and 1k.

I'm asking because if I let the quantity be positive it always has Insufficient buying power to complete orders.

Hi Nico,

The order quantity should be -1 * the net delta.

net_delta = contract_delta + underlying_delta
quantity = -int(net_delta)

Refer to the attached backtest above.

Best,
Derek Melchin

Want to invest in QuantConnect as we build the Linux of quant finance? Checkout our Wefunder campaign to join the revolution.