Building the Par-Yield Curve

Introduction

In our recent lessons, we have progressively built a sophisticated toolkit for analyzing the term structure of interest rates. Starting with raw bond data, you learned to bootstrap a discrete spot curve, fit a continuous CubicSpline to it, and then derive the continuous instantaneous forward rate curve. You now have a Python YieldCurve class that can provide both the spot rate $r(T)$ and forward rate $f(T)$ for any maturity $T$.

This lesson will complete the trio of fundamental interest rate curves by focusing on the par-yield curve. We will define what a par yield represents, derive its mathematical relationship to the spot rate curve you've already constructed, and explain its significant practical role in financial markets. By the end of this lesson, you will have implemented the logic to compute and visualize all three curves—spot, forward, and par—from a single underlying model.

1. What is a Par-Yield Curve?

Before we dive into the math, let's establish the core concept.

A par bond is a bond whose market price is exactly equal to its face value (typically 100).

The par yield for a specific maturity $T$ is the coupon rate that a hypothetical bond of that maturity must have in order to be priced at par.

A par-yield curve is a plot of these par yields against their corresponding maturities.

Essentially, for each point on the curve, you are asking: "What coupon rate would make a new bond with maturity $T$ trade at exactly 100, given today's term structure of interest rates?"

The comment by user closedloop in the following Stack Overflow thread provides a succinct and practical definition.

In practice, the most recently issued government bonds (called "on-the-run" treasuries) trade at prices very close to par. Their coupon rates are set based on prevailing market conditions at the time of issuance. As a result, a collection of on-the-run treasuries of different maturities effectively forms a par-yield curve. This is why par curves are often what is directly observed and quoted in the market.

The image below shows a table of such "par Treasuries," where the coupon rate (listed as "Yield") for each tenor has been set so that the price is exactly 100.

2. Deriving the Par Yield from the Spot Curve

Now that we have the concept, we can formalize the derivation. Our goal is to find the par yield for a given maturity $T$, denoted $y_p(T)$, using our existing continuous spot rate curve $r(t)$.

Let's consider a bond with:

• Face Value: $FV$
• Maturity: $T$ years
• Coupon Payment Frequency: $m$ times per year
• Coupon Rate: $c$

The coupon payment per period is $c\cdot FV/m$. The payment times are $t_i=i/m$ for $i=1,2,\dots ,n$, where $n=T\cdot m$ is the total number of payments.

From our previous work, the price $P$ of this bond, discounted using the continuous spot rate curve $r(t)$, is:

We can separate the coupon and principal payments:

By definition, for a par bond, $P=FV$, and the coupon rate $c$ is the par yield, $y_p(T)$. Substituting these in, we get:

We can now solve for $y_p(T)$. First, divide the entire equation by $FV$:

Rearranging to isolate the term with $y_p(T)$:

Finally, solving for the par yield $y_p(T)$:

This is the key formula. It directly expresses the par yield for maturity $T$ as a function of the entire spot rate curve up to that maturity. The term $e^{-r(T)T}$ is the price of a zero-coupon bond maturing at $T$, and the summation in the denominator is the present value of an annuity of $1 per period, with each payment discounted by its corresponding spot rate.

The following paper provides a similar derivation using discrete compounding, but the underlying principle of setting the price to par and solving for the coupon is identical.

The reasoning behind this relationship is that the par yield is a coupon-weighted average of the spot rates. For an upward-sloping curve, the earlier, lower spot rates drag the par yield down below the final spot rate $r(T)$. Conversely, for a downward-sloping curve, the earlier, higher spot rates pull the par yield up.

This chart visually summarizes the typical relationship in a normal, upward-sloping yield curve environment.

3. Python Implementation

Let's integrate this new capability into our YieldCurve class. We will add a par_yield method that implements our derived formula and update the plotting method to visualize all three curves.

import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import CubicSpline
from scipy.optimize import brentq
from typing import List, Dict, Tuple




# ========== CLASS 1: THE YIELD CURVE OBJECT (UPDATED) ==========
class YieldCurve:
    """
    Represents a continuous yield curve and allows derivation of forward and par curves.
    """
    def __init__(self, tenors: List[float], rates: List[float]):
        self._spline = CubicSpline(tenors, rates, bc_type='natural')
        self._spline_deriv = self._spline.derivative(nu=1)
        self.tenors = np.array(tenors)
        self.rates = np.array(rates)

    def spot_rate(self, t: float) -> float:
        """Returns the continuously compounded spot rate for a given tenor."""
        return self._spline(t)

    def forward_rate(self, t: float) -> float:
        """Returns the continuously compounded instantaneous forward rate for a given tenor."""
        if t == 0:
            return self.spot_rate(0)
        r_t = self.spot_rate(t)
        r_prime_t = self._spline_deriv(t)
        return r_t + t * r_prime_t
        
    def par_yield(self, t: float, frequency: int = 2) -> float:
        """
        Calculates the par yield for a given maturity t.
        Assumes semi-annual coupons by default.
        """
        if t == 0:
            return self.spot_rate(0)

        num_periods = int(round(t * frequency))
        payment_times = np.linspace(1/frequency, t, num_periods)
        



        # Calculate the price of a zero-coupon bond maturing at T
        # This is the numerator term: 1 - e^(-r(T)T)
        zero_price = np.exp(-self.spot_rate(t) * t)
        



        # Calculate the annuity factor (the summation in the denominator)
        # Sum of discount factors for each coupon payment
        annuity_factor = 0.0
        for t_i in payment_times:
            annuity_factor += np.exp(-self.spot_rate(t_i) * t_i)
            



        # Par Yield Formula: y_p = m * (1 - P(0,T)) / (Annuity Factor)
        # Note: the annuity factor as calculated is sum(e^-rt), our formula has sum(1/m * e^-rt)
        # So we use m / (sum(e^-rt)) which is equivalent to 1 / (1/m * sum(e^-rt))
        par_yield = frequency * (1 - zero_price) / annuity_factor
        
        return par_yield

    def plot_all_curves(self, t_max: float = None, frequency: int = 2):
        """Plots the discrete points and the continuous spot, forward, and par curves."""
        if t_max is None:
            t_max = self.tenors.max()
        
        plot_tenors = np.linspace(0.1, t_max, 300) # Start from 0.1 to avoid t=0 issues in plotting
        spot_rates = self.spot_rate(plot_tenors)
        forward_rates = np.array([self.forward_rate(t) for t in plot_tenors])
        par_yields = np.array([self.par_yield(t, frequency) for t in plot_tenors])
        
        plt.figure(figsize=(14, 8))
        plt.plot(self.tenors, self.rates, 'o', markersize=8, label='Bootstrapped Points')
        plt.plot(plot_tenors, spot_rates, '-', lw=2, label='Spot Curve')
        plt.plot(plot_tenors, forward_rates, '--', lw=2, label='Forward Curve')
        plt.plot(plot_tenors, par_yields, ':', lw=2, label=f'Par Curve ({frequency} p.a.)')
        
        plt.title('Spot, Forward, and Par-Yield Curves')
        plt.xlabel('Tenor (Years)')
        plt.ylabel('Continuously Compounded Rate / Par Yield')
        plt.grid(True, linestyle='--', alpha=0.6)
        plt.legend()
        plt.show()


```grasp
{
  "type": "exercise",
  "id": "0510b6fa-c37d-40fd-a80a-76052bc2de46"
}