Future price and expected future spot price

The relationship between the futures price and the expected future spot price depends on the systematic risk of the underlying asset. To see why, consider an investor who takes a long position in a futures contract with maturity \(T\). This contract has a zero initial value. At maturity, the investor pays the futures price \(F_0\) and receives the asset, worth the spot price \(S_T\). The payoff at time \(T\) is thus \(S_T - F_0\).

The present value (PV) of this future payoff must be zero for the contract to be fairly priced today. We find the PV by discounting each component of the payoff at the appropriate rate:

\[PV = PV(S_T) - PV(F_0) = 0\]

The futures price \(F_0\) is a known amount of cash to be paid at time \(T\), so we discount it at the risk-free rate \(r\). The future spot price \(S_T\) is uncertain, so we discount its expected value at a risk-adjusted rate \(k\), which reflects the asset’s systematic risk. This gives:

\[E(S_T)e^{-kT} - F_0e^{-rT} = 0\]

Rearranging this equilibrium condition, we find the relationship between the futures price and the expected future spot price:

\[F_0 = E(S_T) e^{(r-k)T}\]

When the asset’s return is uncorrelated with the broad market (\(k = r\)), the futures price is an unbiased estimate of the expected future spot price. Positive systematic risk raises \(k\) above \(r\) so that \(F_0\) understates \(E(S_T)\) (normal backwardation). Negative systematic risk does the opposite, producing contango relative to the expected future spot price.

Underlying asset	Required return	Relationship
No systematic risk	\(k = r\)	\(F_0 = E(S_T)\)
Positive systematic risk	\(k > r\)	\(F_0 < E(S_T)\) (normal backwardation)
Negative systematic risk	\(k < r\)	\(F_0 > E(S_T)\) (contango)

The interactive lab below keeps the risk-free rate and the expected market return fixed. Use the beta slider to change the asset’s exposure to market risk, observe how the required return \(k\) adjusts through the CAPM, and watch how the expected future spot price moves relative to the futures curve.

Tip

How to explore

• Move the beta slider to alter the asset’s systematic risk.
• Click New market scenario to generate a fresh geometric Brownian path for the index.
• Track how the futures line hugs the discounted spot price while the expected future spot price reflects the CAPM required return.
• Use the relationship badge to determine whether you are in normal backwardation, contango, or the neutral case.

Plot = require("@observablehq/plot")
d3 = require("d3@7")
Inputs = require("@observablehq/inputs")
htl = require("htl")

mulberry32 = seed => {
  return function () {
    let t = seed += 0x6D2B79F5
    t = Math.imul(t ^ t >>> 15, t | 1)
    t ^= t + Math.imul(t ^ t >>> 7, t | 61)
    return ((t ^ t >>> 14) >>> 0) / 4294967296
  }
}

randomNormal = rng => {
  let u = 0, v = 0
  while (u === 0) u = rng()
  while (v === 0) v = rng()
  return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v)
}

riskFreeRate = 0.03
marketExpectedReturn = 0.08
marketVol = 0.20
assetResidualVol = 0.12
timeHorizonYears = 1
steps = 120
spotToday = 100
marketStart = 100
baseSeed = 20241201
percentFormat = d3.format(".1%")
priceFormat = d3.format(",.2f")
betaFormat = d3.format("+.2f")
timeFormat = d3.format(".1f")
tooltipTimeFormat = d3.format(".3f")

viewof beta = Inputs.range([-1.0, 2.0], {
  value: 0.6,
  step: 0.05,
  label: "Asset beta (β)"
})

requiredReturn = riskFreeRate + beta * (marketExpectedReturn - riskFreeRate)
expectedFutureSpotPrice = spotToday * Math.exp(requiredReturn * timeHorizonYears)
futuresPrice0 = spotToday * Math.exp(riskFreeRate * timeHorizonYears)

mutable pathTrigger = 0

viewof newScenario = {
  const button = htl.html`<button style="background: white; color: #495057; border: 1px solid #adb5bd; border-radius: 6px; padding: 0.3rem 0.8rem; font-weight: 500; font-size: 0.9rem; cursor: pointer;">New market scenario</button>`
  button.addEventListener("click", () => {
    mutable pathTrigger = pathTrigger + 1
  })
  return button
}

relationshipDetails = {
  const diff = futuresPrice0 - expectedFutureSpotPrice
  const tolerance = 1e-6
  if (Math.abs(diff) <= tolerance) {
    return {
      title: "Unbiased",
      text: "F₀ equals E(S_T): with zero systematic risk, the futures price is an unbiased forecast of the spot price.",
      variant: "neutral"
    }
  }
  if (diff < 0) {
    return {
      title: "Normal backwardation",
      text: "F₀ is below E(S_T): positive systematic risk (β > 0) lifts the required return, so the expected spot price sits above the futures price.",
      variant: "backwardation"
    }
  }
  return {
    title: "Contango",
    text: "F₀ is above E(S_T): negative systematic risk (β < 0) lowers the required return, pushing the expected spot price below the futures price.",
    variant: "contango"
  }
}

relationshipBadge = {
  const { title, text, variant } = relationshipDetails
  const colorMap = {
    neutral: "#495057",
    backwardation: "#2b8a3e",
    contango: "#c92a2a"
  }
  return htl.html`<div class="relationship-card ${variant}">
    <div class="relationship-header" style="color: ${colorMap[variant]};">${title}</div>
    <p>${text}</p>
  </div>`
}

paths = {
  beta;
  pathTrigger;
  const rng = mulberry32(baseSeed + pathTrigger)
  const dt = timeHorizonYears / steps
  const rfStep = Math.exp(riskFreeRate * dt) - 1
  const data = []
  let indexLevel = marketStart
  let assetPrice = spotToday
  for (let step = 0; step <= steps; step += 1) {
    if (step > 0) {
      const zMarket = randomNormal(rng)
      const logReturnMarket = (marketExpectedReturn - 0.5 * marketVol ** 2) * dt + marketVol * Math.sqrt(dt) * zMarket
      const nextMarket = indexLevel * Math.exp(logReturnMarket)
      const marketSimpleReturn = nextMarket / indexLevel - 1
      const zIdio = randomNormal(rng)
      const assetSimpleReturn = rfStep + beta * (marketSimpleReturn - rfStep) + assetResidualVol * Math.sqrt(dt) * zIdio
      assetPrice = Math.max(0.01, assetPrice * (1 + assetSimpleReturn))
      indexLevel = nextMarket
    }
    const time = step * dt
    const timeRemaining = Math.max(0, timeHorizonYears - time)
    const futuresPrice = assetPrice * Math.exp(riskFreeRate * timeRemaining)
    data.push({
      step,
      time,
      marketIndex: indexLevel,
      assetPrice,
      futuresPrice
    })
  }
  return data
}

plotData = paths.flatMap(row => ([
  { time: row.time, value: row.marketIndex, series: "Market index" },
  { time: row.time, value: row.assetPrice, series: "Asset price" },
  { time: row.time, value: row.futuresPrice, series: "Futures price" }
]))

Plot.plot({
  height: 360,
  marginLeft: 64,
  marginRight: 24,
  color: {
    legend: true,
    domain: ["Market index", "Asset price", "Futures price"],
    range: ["#023e8a", "#ff7f0e", "#2ca02c"]
  },
  x: {
    label: "Years",
    tickFormat: timeFormat,
    grid: true
  },
  y: {
    label: "Price level",
    grid: true
  },
  marks: [
    Plot.line(plotData, { x: "time", y: "value", stroke: "series", strokeWidth: 2 }),
    Plot.ruleX(paths, Plot.pointerX({x: "time", stroke: "grey"})),
    Plot.dot(plotData, Plot.pointerX({x: "time", y: "value", stroke: "series"})),
    Plot.tip(paths, Plot.pointerX({
      x: "time",
      frameAnchor: "top-left",
      dx: 10,
      dy: 10,
      title: d => [
        `t = ${tooltipTimeFormat(d.time)}`,
        `Market index: ${priceFormat(d.marketIndex)}`,
        `Asset price: ${priceFormat(d.assetPrice)}`,
        `Futures price: ${priceFormat(d.futuresPrice)}`
      ].join("\n")
    }))
  ]
})

metricsTable = {
  const rows = [
    ["Risk-free rate r", percentFormat(riskFreeRate)],
    ["Expected market return E[Rₘ]", percentFormat(marketExpectedReturn)],
    ["Asset beta β", betaFormat(beta)],
    ["Required return k", percentFormat(requiredReturn)],
    ["Expected future spot price E(S_T)", `$${priceFormat(expectedFutureSpotPrice)}`],
    ["Futures price today F₀", `$${priceFormat(futuresPrice0)}`]
  ]
  return htl.html`<table class="metric-table">
    ${rows.map(([label, value]) => htl.html`<tr><th>${label}</th><td>${value}</td></tr>`) }
  </table>`
}

html`<div class="relationship-wrapper">${relationshipBadge}${metricsTable}</div>`

html`<p class="caption">The market index follows geometric Brownian motion with drift ${percentFormat(marketExpectedReturn)} and volatility ${percentFormat(marketVol)}. The asset path shares market shocks through β and adds idiosyncratic noise. The futures curve stays anchored to the asset price through cost-of-carry, while E(S<sub>T</sub>) responds to the CAPM-required return.</p>`

Normal backwardation and contango

When \(F_0 < E(S_T)\) we say the market is in normal backwardation: investors demand a premium for warehousing positive systematic risk, so the expected spot price climbs above the locked-in futures level. When \(F_0 > E(S_T)\) the market is in contango relative to the expected spot price: the asset hedges market swings, investors accept a lower required return, and the futures price sits above the expectation. In practice the terms are sometimes used relative to the current spot price rather than the expected future spot price, so always double-check the context.