1. Introduction: The Execution Dilemma
Large institutional trade orders cannot be executed instantly. Attempting to buy or sell a massive block of shares in a single trade exhausts the immediately available liquidity, resulting in severe **market impact** and poor prices. Instead, traders split large parent orders into smaller child orders and distribute them over a specified time horizon.
However, stretching the execution schedule introduces a critical trade-off. Executing too fast leads to high transaction costs (temporary market impact). Executing too slowly exposes the remaining position to price volatility risk (market risk). Solving this trade-off is the core objective of **optimal execution** frameworks.
2. The Almgren-Chriss Framework
Developed by Robert Almgren and Neil Chriss in their seminal papers (1999, 2000), the Almgren-Chriss framework models optimal execution as a multi-stage portfolio optimization problem. Let $X_t$ be the number of shares remaining to be executed at step $t$, for $t = 0, \dots, N$, starting with $X_0 = Q$ shares and ending with $X_N = 0$.
The size of each child trade is $u_t = X_{t-1} - X_t$. The mid-price of the asset $S_t$ evolves according to permanent and temporary impact components:
$S_t = S_{t-1} + \sigma \cdot \tau^{1/2} \cdot \xi_t - \tau \cdot \gamma(u_t / \tau)$
Where $\sigma$ is asset volatility, $\tau$ is step duration, $\xi_t$ is independent Gaussian noise, and $\gamma$ is the permanent impact function. The actual execution price $\tilde{S}_t$ includes temporary impact $\eta$:
$\tilde{S}_t = S_t - \eta(u_t / \tau)$
Under the linear impact assumption where $\gamma(v) = \gamma v$ and $\eta(v) = \eta v$, the total expected transaction cost (expected shortfall) $E[x]$ and variance $V[x]$ of the execution capture the core trade-off:
| Metric | Equation | Key Drivers |
|---|---|---|
| Expected Cost $E[x]$ | $E[x] = \frac{1}{2} \gamma Q^2 + \eta \sum_{t=1}^N \frac{u_t^2}{\tau}$ | Temporary impact coefficient $\eta$, permanent coefficient $\gamma$, trade sizes $u_t$. |
| Variance $V[x]$ | $V[x] = \sigma^2 \sum_{t=1}^N \tau X_t^2$ | Asset volatility $\sigma$, remaining holdings $X_t$ over time. |
3. The Efficient Frontier of Trade Execution
To find the optimal schedule, we minimize the utility function $U(x) = E[x] + \lambda V[x]$, where $\lambda$ represents the trader's risk aversion. High $\lambda$ values prioritize risk minimization (speeding up trades), whereas low $\lambda$ values focus on minimizing impact cost (slowing down trades).
By varying $\lambda$, we construct the **efficient frontier of execution**. Under linear assumptions, the optimal remaining holdings $X_j$ at step $j$ follow a hyperbolic profile:
$X_j = \frac{\sinh(\kappa(T - t_j))}{\sinh(\kappa T)} \cdot Q$
Where the rate of decay $\kappa$ is defined by $\kappa \approx \sqrt{\frac{\lambda \sigma^2}{\eta}} + \mathcal{O}(\tau)$. This elegant closed-form solution allows risk desks to calculate the optimal execution trajectory instantly.
4. Python Implementation: Calculating the Almgren-Chriss Trajectory
The following Python script computes the optimal remaining holdings trajectory based on volatility, liquidity parameters, and risk aversion $\lambda$:
import numpy as np
def calculate_optimal_trajectory(q, time_horizon, steps, volatility, eta, lmbda):
"""
Computes the optimal Almgren-Chriss remaining share inventory.
"""
tau = time_horizon / steps
# Calculate decay rate kappa
kappa = np.sqrt((lmbda * (volatility ** 2)) / (eta - 0.5 * lmbda * (volatility ** 2) * tau))
t = np.linspace(0, time_horizon, steps + 1)
trajectory = np.zeros(steps + 1)
for j in range(steps + 1):
trajectory[j] = (np.sinh(kappa * (time_horizon - t[j])) / np.sinh(kappa * time_horizon)) * q
return t, trajectory
# Example Parameters: Sell 100,000 shares over 5 hours in 10 steps
times, inventory = calculate_optimal_trajectory(
q=100000, time_horizon=5.0, steps=10,
volatility=0.2, eta=1e-5, lmbda=1e-6
)
for step, inv in enumerate(inventory):
print(f"Step {step} (t={times[step]:.1f}h): {int(inv):,} shares remaining")
5. Conclusion
The Almgren-Chriss framework is a foundational pillar of transaction cost analysis (TCA) and execution algorithms. While modern setups incorporate non-linear market impact dynamics and machine learning adapters, the core risk-cost trade-off remains the central driver behind trade scheduling across global electronic markets.