Now, let’s combine all four types of payoffs for the following: a call option with a strike price of $100, a put option with a strike price of $100, a bond which in total pays off $100, and the underlying stock.

#Set up 4 payoff schemes
#1. A bond priced which pays $100 in a year
#2. A put with a strike price of $100
#3. A call with a strike price of $100
#4. A stock which is currently priced at $100

#Create a dataframe of payoffs
payoffs = pd.DataFrame(list(range(0,201)), columns=['Stock'])
payoffs['Put'] = payoffs['Stock'].apply(lambda x: max(0, 100-x))
payoffs['Call'] = payoffs['Stock'].apply(lambda x: max(0, x-100))
payoffs['Bond'] = 100

#Graph all payoffs
ax = payoffs.plot(kind='line')
ax.axhline(0, linestyle='--', color='grey')
plt.xlabel('Stock Price')
plt.ylabel('Payoff')
plt.title("All Payoffs")
plt.show()

Certain combinations are given specific names. One of these is called a protective put. It happens when you own the stock but also have a put option. This locks in a minimum payoff that you can get. Let’s create the payoff graph of combining the two.

#Now consider a protective put
payoffs['Protective Put'] = payoffs['Stock'] + payoffs['Put']

ax = payoffs['Protective Put'].plot(kind='line')
ax.axhline(0, linestyle='--', color='grey')
plt.xlabel('Stock Price')
plt.ylabel('Payoff')
plt.title("Protective Put")
plt.show()

What about the other two instruments? If we add a bond and a call, what is the combined payoff?

#And a bond and call option
payoffs['Bond & Call'] = payoffs['Bond'] + payoffs['Call']

ax = payoffs['Bond & Call'].plot(kind='line')
ax.axhline(0, linestyle='--', color='grey')
plt.xlabel('Stock Price')
plt.ylabel('Payoff')
plt.title('Bond & Call')
plt.show()

You can confirm that these two combined payoffs represented prior equal each other at every stock price. To prevent arbitrage, the cost of the two combined payoffs need to be priced the same. This leads to a relationship called put-call parity. The present value of the strike price (what we would have to pay for a bond that pays the strike price X at expiration) and the price of a call option needs to have the same price as the stock price and the price of a put. This only works for put and call options with the same strike price.

#Confirm the payoffs are the same
print(abs(payoffs['Bond & Call'] - payoffs['Protective Put']).max())

There are many other forms of classic combinations. For example, the combination of a put and a call is called a straddle and allows an investor to profit of volatility is high…. when either a large negative return or large positive return occurs, the investor will have a large payoff.

#Compute option payoffs
payoffs = pd.DataFrame(list(range(0,201)), columns=['Stock'])
payoffs['$100 Put'] = payoffs['Stock'].apply(lambda x: max(0, 100-x))
payoffs['$100 Call'] = payoffs['Stock'].apply(lambda x: max(0, x-100))

#Graph the call and put payoffs
ax = payoffs[['$100 Put', '$100 Call']].plot(kind='line')
ax.axhline(0, linestyle='--', color='grey')
plt.xlabel('Stock Price')
plt.ylabel('Payoff')
plt.title("Call & Put Payoffs")
plt.show()

#Compute the straddle patoff
payoffs['Straddle Payoff'] = payoffs['$100 Put'] + payoffs['$100 Call']

#Graph the straddle payoff
ax = payoffs[['Straddle Payoff']].plot(kind='line')
ax.axhline(0, linestyle='--', color='grey')
plt.xlabel('Stock Price')
plt.ylabel('Payoff')
plt.title("Straddle Payoff")
plt.show()

Someone might also want to target the extremes more. A strangle would achieve this where the option buyer takes a put and a call where the put has a lower strike price than the call. In between the strike prices, there is no payoff, but past either strike price there is a payoff.

#Compute option payoffs
payoffs = pd.DataFrame(list(range(0,201)), columns=['Stock'])
payoffs['$90 Put'] = payoffs['Stock'].apply(lambda x: max(0, 90-x))
payoffs['$110 Call'] = payoffs['Stock'].apply(lambda x: max(0, x-110))

#Graph the call and put payoffs
ax = payoffs[['$90 Put', '$110 Call']].plot(kind='line')
ax.axhline(0, linestyle='--', color='grey')
plt.xlabel('Stock Price')
plt.ylabel('Payoff')
plt.title("Call & Put Payoffs")
plt.show()

#Compute the strangle patoff
payoffs['Strangle Payoff'] = payoffs['$90 Put'] + payoffs['$110 Call']

#Graph the straddle payoff
ax = payoffs[['Strangle Payoff']].plot(kind='line')
ax.axhline(0, linestyle='--', color='grey')
plt.xlabel('Stock Price')
plt.ylabel('Payoff')
plt.title("Strangle Payoff")
plt.show()