Case study: option payoff diagrams

The call: a ramp moved right

A call option gives its owner the right, not the duty, to buy a stock at a fixed price $K$ on a fixed date. That price is the strike, and $S$ is the stock price on that date.

If $S > K$, the owner buys at $K$ and can sell at $S$, gaining $S - K$. If $S \le K$, buying at $K$ would be pointless, so the owner lets the option lapse and gets 0. Both cases fit in one formula.

As a function (lesson 1.1.1), its domain is $S \ge 0$, since a share cannot be worth less than nothing. Its range is $[0, \infty)$: a call never costs its owner anything at expiry, and its payoff has no upper limit. At $S = K$ both pieces give 0, so it does not matter which piece the boundary belongs to.

Profit: the payoff moved down

An option is not free. The buyer pays a premium up front, say $5. The profit at expiry is the payoff minus the premium: the same ramp moved down by 5, the $f(x) + k$ rule with $k = -5$.

The buyer breaks even where the profit is zero. That is the method of lesson 1.1.1: solve $f(S) = 0$.

Below the strike the profit is $-5$, never 0. Above it the profit is $S - 105$, which is zero at $S = 105$.

The same algebra answers "where must the stock end for a profit of $15?". Above the strike the profit $S - 105$ is one-to-one, so it has an inverse (lesson 1.1.3): $S = 105 + 15 = 120$.

Below the strike the profit is not one-to-one: every price up to 100 gives $-5$. A loss of $5 cannot tell you where the stock ended.

This ignores the interest the premium could have earned until expiry; module 1.4 handles that.

The put: the ramp flipped

A put option gives the right to sell at $K$. It pays when the stock ends below the strike: $\max(K - S, 0)$. Write it as $\max\big(-(S - K), 0\big)$ and it is the call's ramp with the input flipped, the $f(-x)$ rule from lesson 1.1.2, mirrored about $S = K$.

The put's range is different from the call's. The stock cannot fall below 0, so the most a put can pay is $K$, reached at $S = 0$: its range is $[0, K]$. A put with strike 100 bought for $4 breaks even at $S = 96$, and its largest possible profit is $96.

Selling: the payoff flipped over

Selling an option flips its payoff over the horizontal axis, the $-f(x)$ rule. The seller of a call receives the premium now and owes $\max(S - K, 0)$ later. With $K = 100$ and a $5 premium, the seller's profit is $5 - \max(S - 100, 0)$.

That profit is at most $5, earned whenever $S \le 100$. Above the strike it falls without limit: $-45$ at $S = 150$ and $-95$ at $S = 200$. Its range is $(-\infty, 5]$, which is why desks watch sold calls closely.

A sold put has a floor: selling the $4 put loses at most $96, at $S = 0$.

Desks record the direction as a sign. A quantity of $+1$ is an option bought (a long position) and $-1$ an option sold (a short position). The premium is cash paid (negative) for a buyer and cash received (positive) for a seller.

Strategies: add the payoffs

A position that holds several options pays the sum of their payoffs. Two classic examples follow.

A straddle buys a call and a put with the same strike. Its payoff is $\max(S - K, 0) + \max(K - S, 0)$, the ramp plus its mirror image. Lesson 1.1.2 showed that this sum is an absolute value, so the payoff is $|S - K|$, the distance from lesson 0.3.3.

A straddle pays when the stock moves a lot, in either direction.

The straddle costs both premiums, $5 + 4 = 9$ dollars. It breaks even where $|S - 100| = 9$, which by lesson 0.3.3 means $S = 91$ or $S = 109$. It makes money when the stock ends further than 9 from the strike.

A bull call spread buys a call at 95 and sells a call at 105. Its payoff is a function with three pieces (lesson 1.1.2), and the pieces meet at both strikes:

Above 105 the sold call, a flipped ramp, cancels the bought call's rise. So the payoff is capped at 10, the gap between the strikes.

Now build positions yourself. Start from a preset, then change a side, a strike or a premium, and watch the break-evens and the largest gain and loss follow. The bull spread preset pays $8 for the 95 call and receives $3 for the 105 call, so it costs $5 and breaks even at 100. Try selling the put of the straddle instead of buying it.

On a desk: units, conventions and bad inputs

The diagrams so far are per share. A practitioner meets a few more things before trusting a number.

• Per share or per contract. A standard US stock option contract covers 100 shares, so its payoff is stretched by 100, the $a\,f(x)$ rule. A call paying $20 a share pays $2,000 a contract. Contract sizes differ between markets, so check the terms.
• Against the return. Traders often plot a payoff against the stock's return $R$, the fractional change in price. With today's price $S_0$, the final price is $S = S_0(1 + R)$, so the payoff becomes a composition (lesson 1.1.3). With $S_0 = K = 100$ it is $\max(100R, 0) = 100\max(R, 0)$, a ramp stretched by 100, with domain $R \ge -1$ (a fall of 100%).
• Bad inputs. A negative price or strike is a data error, not a market state: it lies outside the domain. Code should stop with an error rather than return a number. The same holds for a misspelt option type: reading "Call" as a put would silently mirror the diagram.
• The sign of the quantity. A missing minus sign turns a sold option into a bought one and flips the diagram over the axis. Check one leg by hand.

A payoff diagram also has limits. It shows value at expiry only. Before then, an option's value also depends on how far the price may still move, so it is not the ramp.

Finding that value is the job of option pricing, starting with the Black–Scholes integrals of case study 2.6.5. The diagram ignores interest on the premium (module 1.4), and some options can be exercised before expiry.

import numpy as np

S = np.array([80.0, 90.0, 100.0, 110.0, 120.0])


def test_call_in_the_money():
    """A call with strike 100 pays 20 when the stock ends at 120"""
    expect_close(payoff(120, 100, "call"), 20.0, what='payoff(120, 100, "call")')


def test_call_out_of_the_money():
    """A call with strike 100 pays nothing when the stock ends at 90"""
    expect_close(payoff(90, 100, "call"), 0.0, what='payoff(90, 100, "call")')


def test_put():
    """A put with strike 100 pays 100 − S below the strike and 0 above it"""
    expect_close(payoff(S, 100, "put"), [20.0, 10.0, 0.0, 0.0, 0.0], what='payoff(S, 100, "put")')


def test_call_array():
    """A call works on a whole array of final prices"""
    expect_close(payoff(S, 100, "call"), [0.0, 0.0, 0.0, 10.0, 20.0], what='payoff(S, 100, "call")')


def test_put_call_difference():
    """Call minus put with the same strike is S − K"""
    expect_close(payoff(S, 95, "call") - payoff(S, 95, "put"), S - 95, what="call − put")


def test_unknown_kind():
    """An unknown kind raises ValueError"""
    try:
        payoff(100, 100, "swap")
    except ValueError:
        return
    raise AssertionError('expected ValueError for kind="swap"')


def test_negative_price():
    """A negative stock price raises ValueError"""
    try:
        payoff(np.array([90.0, -5.0]), 100, "call")
    except ValueError:
        return
    raise AssertionError("expected ValueError for a stock price of −5")

import numpy as np

S = np.array([80.0, 90.0, 100.0, 110.0, 120.0])


def test_single_call():
    """One call bought is just the call's payoff"""
    expect_close(strategy_payoff(S, [("call", 100, 1)]), [0.0, 0.0, 0.0, 10.0, 20.0], what="one call")


def test_straddle():
    """A call and a put with strike 100 pay |S − 100|"""
    legs = [("call", 100, 1), ("put", 100, 1)]
    expect_close(strategy_payoff(S, legs), np.abs(S - 100), what="straddle")


def test_bull_spread():
    """Buy the 95 call, sell the 105 call: the payoff is capped at 10"""
    legs = [("call", 95, 1), ("call", 105, -1)]
    expect_close(strategy_payoff(S, legs), [0.0, 0.0, 5.0, 10.0, 10.0], what="bull spread 95/105")


def test_sold_call():
    """Selling a call flips its payoff: −max(S − 100, 0)"""
    expect_close(strategy_payoff(S, [("call", 100, -1)]), [0.0, 0.0, 0.0, -10.0, -20.0], what="one call sold")


def test_quantity():
    """Two puts pay twice as much as one"""
    expect_close(strategy_payoff(S, [("put", 100, 2)]), [40.0, 20.0, 0.0, 0.0, 0.0], what="two puts")


def test_no_legs():
    """No legs at all pay nothing, at every price"""
    expect_close(strategy_payoff(S, []), np.zeros(5), what="no legs")


def test_unknown_kind():
    """A leg with an unknown kind raises ValueError instead of being read as a put"""
    try:
        strategy_payoff(S, [("Call", 100, 1)])
    except ValueError:
        return
    raise AssertionError('expected ValueError for kind="Call" (a capital C is a typo, not a put)')