Arithmetic vs Geometric Returns: The Plot Twist Hiding in Your Performance Report

“Same returns, different stories.” — Every portfolio ever.

You’ve already wrangled returns in Excel, thrown some pandas at time series, and even made a few backtests blush. Now it’s time to decode a choice that quietly reshapes everything from your performance charts to your financial sanity: arithmetic vs geometric returns. This is the difference between “average experience” and “actual outcome,” also known as the reason your 0% average can still leave you broke.

What Is the Difference Between Arithmetic vs Geometric Returns?

Arithmetic return (A): The simple average of periodic returns.
- Formula:
  A = (1/n) Σ r_t
- Meaning: What did the average period look like? Good for one-period expectations.
Geometric return (G), a.k.a. CAGR: The compound average growth rate.
- Formula:
  G = (Π (1 + r_t))^(1/n) − 1
- Meaning: What rate per period would give the same final wealth if it were earned every time? Good for multi-period performance.

If you like logs (and your last module told you to), define log-returns:
ℓ_t = ln(1 + r_t). Then the average log-return is L = (1/n) Σ ℓ_t and G = e^L − 1. Logs turn compounding into addition. Happy quants, happy life.

How Does Compounding Change the Math?

Imagine two years: +10%, then −10%.

Arithmetic: (10% + (−10%)) / 2 = 0%
Looks fine. Chill. Neutral vibe.
Geometric: √(1.10 × 0.90) − 1 = −0.5%
Your money shrank. By a little. But still: shrank.

Why the difference? Because wealth compounds multiplicatively. Your base changes. Losing 10% after gaining 10% does not cancel; it taxes your previous gain. That “tax” is volatility, and volatility is kryptonite to geometric returns.

Why Does Volatility Drag Geometric Returns?

Concavity alert: ln(·) is concave, so by Jensen’s inequality:
E[ln(1 + R)] ≤ ln(1 + E[R]).
Exponentiate both sides and subtract 1:
exp(E[ln(1 + R)]) − 1 ≤ E[R].
Translation: Expected geometric return ≤ expected arithmetic return when R > −1.
Rule of thumb (small returns):
Average log-return ≈ arithmetic mean − 0.5 × variance.
This is the intuition behind the “volatility drag.” Bigger σ², lower long-run growth.

Volatility is not just scary; it’s expensive.

Examples of Arithmetic vs Geometric Returns

1) Same every period (the cozy fairytale)

Returns: +5%, +5%, +5%, +5%
A = 5%
G = 5%
Moral: If every period is a clone, A = G. Life is simple, but also fake.

2) Up then down (the sequel no one asked for)

Returns: +10%, −10%
A = 0%
G ≈ −0.5%
Wealth: $100 → $110 → $99

3) Higher volatility (rollercoaster economics)

Returns: +30%, −20%, +25%, −25%
A = (30 − 20 + 25 − 25)/4 = 2.5%
G = (1.30 × 0.80 × 1.25 × 0.75)^(1/4) − 1 ≈ −2.0%
That gap? Volatility eating your compounding for breakfast.

When Do You Use Arithmetic vs Geometric Returns?

Here’s the cheat sheet you wish someone taped to your monitor:

Task	Use	Why
Forecast next period’s expected return (e.g., CAPM input)	Arithmetic	One-period expectation lives here.
Report multi-period performance (CAGR)	Geometric	It matches how wealth actually grows.
Compare strategies in a backtest	Geometric for performance; Arithmetic for risk models	You care about realized compounding, but models use arithmetic for expectations.
Sharpe ratio (classical)	Arithmetic mean of excess returns	Standard definition is per-period arithmetic mean.
Long-run growth optimization / Kelly logic	Geometric (log returns)	Growth rate is E[ln(1 + R)].
Risk–return visualization (from last module)	Either; label clearly	Scatter with arithmetic mean vs σ, but annotate CAGR for intuition.

If the question is “What will my wealth be after N periods?” use geometric.
If the question is “What do I expect next period?” use arithmetic.

Common Mistakes in Arithmetic vs Geometric Returns

Averaging percentages to tell a multi-year story. Don’t. Your money doesn’t average; it compounds.
Annualizing the wrong way.
- Use geometric to annualize realized multi-period returns: (Π(1 + r_month))^12 − 1 is only valid if you’re compounding the actual sequence.
- For expected returns under IID, E[R_annual] ≈ 12 × E[R_month] (arithmetic), but realized wealth won’t follow that exactly. Label assumptions.
Using geometric returns in mean–variance optimization. That model expects arithmetic means. Wrong input, wrong frontier, wrong conclusions.
Forgetting sequence risk. Two portfolios with the same A can have drastically different G because order matters for compounding.
Not noticing −100% kills G instantly. One wipeout and the product goes to zero. Arithmetic mean might still look deceptively okay.

How Does Rebalancing Change the Story?

Buy-and-hold a single asset: your long-run growth is governed by G of that asset’s returns.
Constantly rebalanced multi-asset portfolio (fixed weights): compounding still happens, but on the portfolio’s rebalanced returns. The relevant long-run growth is still the portfolio’s geometric (log) average, not the simple arithmetic of components.
For modeling the next period in optimization land: stick with arithmetic expected returns and the covariance matrix (hi, last module). Then report CAGR for investor-facing performance.

Quants build with arithmetic, storytellers report with geometric. Be both.

A Tiny Probability Detour (the good kind)

Let R_t be a random simple return with mean μ and variance σ².

Arithmetic expectation: E[R_t] = μ (one-period expected return).
Geometric growth rate (per period): g = exp(E[ln(1 + R_t)]) − 1.
Jensen tells us g ≤ μ (approximately and under R > −1), with inequality stricter when σ² is bigger.
Small-returns approximation (intuition only):
E[ln(1 + R)] ≈ μ − 0.5 σ².
So, roughly, G ≈ μ − 0.5 σ². Don’t treat this as an identity; it’s a vibe check.

Quick Python and Excel Recipes (because tools matter)

Python (pandas)

import pandas as pd
import numpy as np

# r: Series of simple returns, e.g., 0.01 for 1%
A = r.mean()
G = (1 + r).prod()**(1/len(r)) - 1

# Annualize (monthly data):
A_annual_exp = A * 12                   # expected arithmetic annual return
G_annual_realized = (1 + r).prod() - 1  # realized buy-and-hold over the year(s)

# Average log-return and its annualized version
L = np.log1p(r).mean()
G_from_logs = np.expm1(L)               # per-period geometric
L_annual = L * 12
G_annual_from_logs = np.expm1(L_annual)

Excel

Arithmetic mean: =AVERAGE(range_of_returns)
Geometric mean: =GEOMEAN(1+range_of_returns)-1
CAGR from start and end values: =(Ending/Beginning)^(1/Years)-1
Annualize arithmetic expectation (monthly): =12*AVERAGE(range)
Label clearly: that’s an expectation, not realized CAGR.

Mini Case Study: Two Strategies, Same A, Different G

Strategy Smooth: monthly returns are a steady +0.8%.
- A ≈ 0.8%
- G ≈ 0.8%
- σ ≈ tiny. Life is a calm pond.
Strategy Spicy: flips between +5% and −3% randomly with the same arithmetic mean ≈ 0.8%.
- A ≈ 0.8%
- G < 0.8% (often materially lower due to volatility drag)
- σ is loud. CAGR loses altitude.

On a risk–return scatter (remember that visualization lab?), both might sit at similar expected returns, but their CAGRs and drawdowns will disagree loudly. That’s why plotting is therapy.

FAQs You Didn’t Ask But Will Brag About Later

Can the geometric return be higher than arithmetic? Only in math fanfic. In real portfolios with variability: no.
Which do regulators like for performance reporting? Geometric (CAGR). Because it respects time.
Which do asset-pricing models use? Arithmetic. Because they predict one step ahead.

Summary and Key Takeaways

Arithmetic vs geometric returns is not a pedantic quibble; it’s the core of how you measure risk and reward over time.
Arithmetic tells you the expected next-period return; geometric tells you the actual compounded growth path.
Volatility creates a gap: A ≥ G, with the gap widening as σ² rises (volatility drag).
In backtests, report both: use arithmetic for modeling and Sharpe; use geometric for performance and investor sanity.
Label your annualizations. Expected ≠ realized. Period.

The market pays in geometric, even if the models speak arithmetic. Learn to translate — your future self will send a thank-you card.

Risk, Return, and Probability

Content