Replicating Piecewise-Linear Payoffs with Calls and Bonds
Summary
The document presents a static replication method for a continuous, piecewise-linear European payoff. It begins with a zero-coupon bond paying the payoff at the lowest underlying value. At each breakpoint, the change in the payoff’s slope determines a position in calls: hold the interval slope in calls at its lower strike and offset that position at the next strike. A final call position reproduces the slope beyond the highest breakpoint.
For the example, the method yields a bond paying 30, long calls at strikes 0 and 30, and short calls at strike 10, with quantities chosen to match the payoff’s slopes. The document also notes that another decomposition can be obtained using put-call parity, and mentions an algorithmic implementation as an alternative. The construction assumes a continuous payoff with known breakpoints and a linear final segment. It describes terminal payoff replication, not the prices, market availability, or transaction costs of the instruments.
Key ideas
- A continuous piecewise-linear payoff can be built from a bond and options struck at its breakpoints.
- Each interval’s slope determines call positions at the interval’s lower and upper strikes.
- The position in the highest-strike call reproduces the payoff slope above the final breakpoint.
- Put-call parity can transform the replication into alternative portfolios.
- Static payoff matching does not by itself establish the portfolio’s cost or practical execution.
Tags
Full text
# Replicate a Portfolio with Given Payoff
# Replicate a Portfolio with Given Payoff
Looking for a convincing general strategy [not trial and error] to solve these kind of questions:
Any help will be super helpful!
Thanks a bunch!
Replicate a portfolio on an underlying asset $S$ with payoff at time $T$ equal to:
$$ \begin{align} V(T) & = 2S(T) + 30 & & \text{if } 0 \leq S(T) < 10 \\[6pt] V(T) & = -3S(T) + 80 & & \text{if } 10 \leq S(T) < 30 \\[6pt] V(T) &= S(T) − 40 & & \text{if } 30 \leq S(T) \end{align}$$
## Answer by LocalVolatility (score 8, accepted)
https://quant.stackexchange.com/a/37420
Consider the case where we are interested in decomposing a continuous and piece-wise linear European payoff function $V \left( S_T \right)$ over $n$ intervals with $n + 1$ node points $S_i$ for $i = 0, 1, \ldots, n$. Without loss of generality, we assume that $S_0 = 0$ and write $V_i$ as short-hand for $V \left( S_i \right)$. We assume that the slope of the payoff function for $S > S_n$ is $x_{n + 1}$.
Take the following steps in order to replicate this payoff:
- Buy zero-coupon bonds with a notional value of $V_0$.
- For each $i \in 1, \ldots n$, buy $x_i = \left( V_i - V_{i - 1} \right) / \left( S_i - S_{i - 1} \right)$ European call options with a strike of $S_{i - 1}$ and sell the same amount withe a strike of $S_i$.
- Buy $x_{n + 1}$ European call options with a strike of $S_n$.
All contracts mature at time $T$.
Applying this to your example, we have $n = 2$ and obtain the following portfolio:
- Buy zero-coupon bonds with a notional value of 30 USD.
- Buy 2 call options with a strike of 0 USD and sell 2 call options with a strike of 10 USD.
- Sell 3 call options with a strike of 10 USD and buy 3 call options with a strike of 30 USD.
- Buy one call option with a strike of 30 USD.
Our net positions are thus:
- Long a zero-coupon bond with with a notional value of 30 USD.
- Long 2 zero-strike call options.
- Short 5 call options with a strike of 10 USD.
- Long 4 call options with a strike of 30 USD.
Note that this decomposition is not unique as you can always apply put/call parity to any of the positions.
## Answer by vonjd (score 4)
https://quant.stackexchange.com/a/59117
I provide a general algorithm and an implementation in R to solve those kinds of problems in general: Financial Engineering: Static Replication of any Payoff Function.
For your example:
```
payoff <- data.frame(pi = c(0, 10, 30, 40, Inf), f_pi = c(30, 50, -10, 0, Inf))
payoff
## pi f_pi
## 1 0 30
## 2 10 50
## 3 30 -10
## 4 40 0
## 5 Inf Inf
plot_payoff(payoff)
```
```
replicate_payoff(payoff)
## zerobonds nominal calls call_strike puts put_strike
## 1 1 30 2 -5 4 0 10 30
## 2 1 50 -3 4 10 30 -2 10
## 3 -1 10 1 30 3 -5 30 10
## 4 1 40 -1 4 -5 40 30 10
```
The first solution is the same as the one given by @LocalVolatility.
## Answer by jherek (score 0)
https://quant.stackexchange.com/a/76786
There is a paper from Gary Kennedy precisely about this question:A Reduction Algorithm for a Class of Payoff Formulae (2010)Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)
This summary was written by Stratmill's research agent from the original; it is not a copy of the source.