Qué es un retorno (y por qué no es lo que crees)

Si tu cuenta sube un 50 % y luego baja un 50 %, no estás en el mismo sitio. Estás un 25 % abajo. Esa asimetría, que parece un truco de matemáticas, es la razón por la que las pérdidas grandes son tan difíciles de recuperar y por la que los backtests se calculan con logaritmos.

El problema

Todos hablamos en porcentajes, pero los porcentajes no se pueden sumar así como así. Un +10 % y un −10 % no dan cero. Un retorno mensual del 2 % doce veces no es un 24 % anual. Y un −50 % no se arregla con un +50 %. Hasta que esto no te salga solo, cualquier número que veas en una ficha de estrategia te va a engañar.

Tres capas

Intuición

Imagina que tienes 100 € y te dicen que "has ganado un 50 %". Tienes 150. Ahora "pierdes un 50 %". Pero ese 50 % se calcula sobre lo que tienes ahora, 150, no sobre los 100 del principio. Pierdes 75. Te quedan 75.

Los porcentajes miran siempre al punto de partida de cada paso, y ese punto de partida cambia. Por eso perder es más caro que ganar: cuando pierdes, lo siguiente lo ganas sobre una base más pequeña. Cuanto más profundo caes, más empinada es la subida de vuelta.

Hay una forma de medir los cambios que sí se puede sumar como si fueran euros. Se llama retorno logarítmico y por eso lo usa todo el mundo que hace cálculos en serio. Con él, el +50 % y el −50 % no son simétricos, y eso es justo lo que queremos: que los números digan la verdad.

Ejemplo numérico

Tres días de precios: 100 → 150 → 75.

Cuatro formas de resumir estos dos días:

1. Sumar los simples: +50 % − 50 % = 0 %. Falso. Tienes 75, no 100.
2. Multiplicar (1 + r): 1,5 × 0,5 = 0,75 → −25 %. Verdad.
3. Sumar los log: 0,4055 − 0,6931 = −0,2877. Es la "verdad en logaritmos".
4. Deshacer el log: e^(−0,2877) − 1 = 0,75 − 1 = −25 %. Coincide con la 2.

Y el precio de recuperar pérdidas:

Formal

Sea $P_t$ el precio en $t$. Se definen:

• Retorno simple: $R_t = \dfrac{P_t - P_{t-1}}{P_{t-1}} = \dfrac{P_t}{P_{t-1}} - 1$
• Retorno logarítmico: $r_t = \ln\!\left(\dfrac{P_t}{P_{t-1}}\right) = \ln(1 + R_t)$

Propiedades que importan:

1. Agregación temporal. Los log-retornos se suman: $r_{0 \to T} = \sum_{t=1}^{T} r_t$. Los simples se componen: $1 + R_{0\to T} = \prod_{t=1}^{T}(1 + R_t)$. Sumar retornos simples en el tiempo es un error.
2. Agregación entre activos. El retorno simple de una cartera es la media ponderada de los retornos simples: $R_p = \sum_i w_i R_i$. Con log-retornos esa igualdad no se cumple exactamente. Por eso: log para series temporales de un activo, simple para carteras en un mismo periodo.
3. Aproximación. Para $|R|$ pequeño, $\ln(1+R) \approx R - R^2/2$. Con retornos diarios del orden del 1 % la diferencia es de 0,005 %: irrelevante. Con retornos del 50 % la diferencia es enorme. Los log siempre son menores que los simples, y la diferencia castiga más a las subidas grandes que a las bajadas.
4. Recuperación. Tras una pérdida $L$ (en simple), el retorno necesario para volver al origen es $\dfrac{L}{1 - L}$. En log-retornos la respuesta es trivial: necesitas exactamente $+|r|$, la simetría es perfecta.
5. Distribución. Si se asume que los log-retornos son normales, los precios siguen una distribución log-normal y nunca son negativos. Es el supuesto de fondo del movimiento browniano geométrico que verás en el Nivel 4. Los datos reales tienen colas más gordas que la normal; eso es asunto del Nivel 1.

Ejemplo trabajado con código

# numpy 2.4 · pandas 3.0 — Retorno simple vs logarítmico y por qué +50 % y −50 % no se anulan
import numpy as np, pandas as pd
 
precios = pd.Series([100.0, 150.0, 75.0], index=["día 0", "día 1", "día 2"])
r_simple = precios.pct_change()
r_log = np.log(precios).diff()
 
tabla = pd.DataFrame({"precio": precios, "r_simple": r_simple, "r_log": r_log})
print(tabla.round(4).to_string())
print()
print(f"Suma de retornos simples:     {r_simple.sum():+.4f}  -> parece que estás igual")
print(f"Producto (1+r) - 1:           {(1 + r_simple).prod() - 1:+.4f}  -> la verdad")
print(f"Suma de retornos log:         {r_log.sum():+.4f}  -> los log sí se suman")
print(f"exp(suma log) - 1:            {np.exp(r_log.sum()) - 1:+.4f}  -> y recuperas el retorno real")
print()
# Cuánto hace falta para recuperar una pérdida
for perdida in [0.10, 0.25, 0.50, 0.75, 0.90]:
    print(f"Pierdes {perdida:>4.0%}  -> hace falta un {perdida/(1-perdida):>+6.0%} para volver a cero")

       precio  r_simple   r_log
día 0   100.0       NaN     NaN
día 1   150.0       0.5  0.4055
día 2    75.0      -0.5 -0.6931
 
Suma de retornos simples:     +0.0000  -> parece que estás igual
Producto (1+r) - 1:           -0.2500  -> la verdad
Suma de retornos log:         -0.2877  -> los log sí se suman
exp(suma log) - 1:            -0.2500  -> y recuperas el retorno real
 
Pierdes  10%  -> hace falta un   +11% para volver a cero
Pierdes  25%  -> hace falta un   +33% para volver a cero
Pierdes  50%  -> hace falta un  +100% para volver a cero
Pierdes  75%  -> hace falta un  +300% para volver a cero
Pierdes  90%  -> hace falta un  +900% para volver a cero

Figura

El error típico

Anualizar un retorno mensual multiplicando por 12. Un retorno del 2 % cada mes no es un 24 % al año, es 1,02^12 − 1 = 26,8 %. Y al revés, y peor: sumar los retornos diarios de un backtest para sacar el total. Con retornos pequeños el error es pequeño, pero con una racha de pérdidas fuertes el "total" sumado dice que estás mucho mejor de lo que estás. Si alguna vez ves una ficha con "retorno acumulado" y la suma de los mensuales cuadra exactamente, sospecha: alguien ha sumado lo que había que multiplicar.

Quiz

Ejercicio

Descarga en TradingView (o con el script de M0.5 más adelante) los últimos 20 cierres diarios de cualquier activo, o usa esta serie si prefieres hacerlo a mano: 100, 102, 99, 101, 105, 103, 98, 96, 100, 104.

1. Calcula los 9 retornos simples y los 9 retornos log.
2. Suma los log y compruébalo contra ln(104/100).
3. Multiplica los (1 + simple) y comprueba que da 1,04.
4. Suma los simples y anota cuánto se aleja de +4 %.

Resultado verificable con la serie dada: suma de log = ln(1,04) = 0,03922; producto de (1 + simple) = 1,0400; suma de simples = 0,04406 (se pasa en casi medio punto porcentual, y eso con movimientos de solo un 2-5 %). Solución con código en el repo del módulo.

Qué te llevas

1. Los porcentajes miran al punto de partida de cada paso, por eso las pérdidas cuestan más de recuperar de lo que costaron.
2. Log-retornos para agregar en el tiempo (se suman); simples para agregar entre activos (se ponderan).
3. Si una cifra de retorno acumulado cuadra con la suma de los parciales, alguien ha hecho trampa sin querer.

Siguiente lección: Riesgo: volatilidad y drawdown. Dos activos con el mismo retorno esperado, uno te deja dormir y otro te quita un cuarto de la cuenta por el camino.