goal-based-allocation 0.3.0__py3-none-any.whl

goal_based_allocation/laplace_inversion.py

@@ -0,0 +1,297 @@
+"""
+Laplace Transform Numerical Inversion Methods.
+
+Two methods implemented from MATLAB originals:
+1. Stehfest (1970): Real-valued, N=14 terms, simple but less accurate for oscillatory functions
+2. Abate-Whitt (1995): Complex-valued Euler acceleration, more accurate for general transforms
+
+Both methods invert F_hat(p) to f(t) where F_hat(p) = integral_0^inf e^{-pt} f(t) dt.
+
+Usage:
+    g: callable, g(p_array) -> array of shape (len(p_array), Nx)
+       where Nx is the number of spatial points evaluated simultaneously.
+       For scalar output, g(p_array) -> array of shape (len(p_array), 1) or (len(p_array),)
+    t: float, the time point at which to invert
+
+Returns:
+    f: array of shape (Nx,) — the inverted values at time t
+"""
+import numpy as np
+from math import comb
+
+
+def laplace_invert_stehfest(g, t, N=14):
+    """
+    Stehfest algorithm for numerical Laplace inversion.
+    
+    Real-valued method using N evaluation points along the real axis.
+    Best for smooth, non-oscillatory transforms.
+    
+    Parameters
+    ----------
+    g : callable
+        Laplace-domain function. g(p_array) returns array of shape (len(p_array), Nx).
+    t : float
+        Time point for inversion. Must be > 0.
+    N : int
+        Number of terms. Must be even. Default 14. Options: 10, 14, 20.
+    
+    Returns
+    -------
+    f : ndarray of shape (Nx,)
+    """
+    # Pre-computed Stehfest weights for standard N values
+    if N == 10:
+        Q = np.array([
+            0.083333333333333300,
+            -32.083333333333300000,
+            1279.000000000000000000,
+            -15623.666666666700000000,
+            84244.166666666700000000,
+            -236957.500000000000000000,
+            375911.666666667000000000,
+            -340071.666666667000000000,
+            164062.500000000000000000,
+            -32812.500000000000000000,
+        ])
+    elif N == 14:
+        Q = np.array([
+            0.002777777777777780,
+            -6.402777777777780000,
+            924.050000000000000000,
+            -34597.927777777800000000,
+            540321.111111111000000000,
+            -4398346.366666670000000000,
+            21087591.777777800000000000,
+            -63944913.044444400000000000,
+            127597579.550000000000000000,
+            -170137188.083333000000000000,
+            150327467.033333000000000000,
+            -84592161.499999900000000000,
+            27478884.766666600000000000,
+            -3925554.966666660000000000,
+        ])
+    elif N == 20:
+        Q = np.array([
+            -1 / 181440,
+            27649 / 181440,
+            -98671 / 840,
+            131108917 / 7560,
+            -2790568153 / 3024,
+            119821402447 / 5040,
+            -377374859491 / 1080,
+            24504756082873 / 7560,
+            -68130546312319 / 3360,
+            1.62324987232298e15 / 18144,
+            -6.50963449161629e15 / 22680,
+            1.72113986590941e15 / 2520,
+            -1.84325248304221e16 / 15120,
+            3.53715940981875e15 / 2160,
+            -830177453365403 / 504,
+            1.84754992631967e15 / 1512,
+            -3.92398206772844e15 / 6048,
+            470366372878831 / 2016,
+            -28868125000000 / 567,
+            2886812500000 / 567,
+        ])
+    else:
+        raise ValueError(f"N must be 10, 14, or 20, got {N}")
+
+    # Evaluation points: p_k = k * ln(2) / t
+    s = np.log(2) / t
+    transform_points = s * np.arange(1, N + 1)
+
+    # Evaluate the Laplace-domain function at all points
+    gp = np.real(g(transform_points))
+
+    # Handle 1D output
+    if gp.ndim == 1:
+        gp = gp.reshape(-1, 1)
+
+    Nx = gp.shape[1]
+    f = np.zeros(Nx)
+
+    for k in range(N):
+        f += s * Q[k] * gp[k, :]
+
+    return f
+
+
+def laplace_invert_abate_whitt(g, t, N=25, M=12, tol=1e-8):
+    """
+    Abate-Whitt Euler acceleration method for Laplace inversion.
+    
+    Complex-valued method using the Bromwich integral with Euler summation
+    acceleration. More accurate than Stehfest for general transforms,
+    especially oscillatory or discontinuous functions.
+    
+    Reference: Abate, J. and Whitt, W. (1995). Numerical Inversion of Laplace
+    Transforms of Probability Distributions. ORSA Journal on Computing 7(1):36-43.
+    
+    Parameters
+    ----------
+    g : callable
+        Laplace-domain function. g(p_array) returns array of shape (len(p_array), Nx).
+        Must handle complex-valued arguments.
+    t : float
+        Time point for inversion. Must be > 0.
+    N : int
+        Number of terms in the main sum. Default 25.
+    M : int
+        Number of Euler acceleration terms. Default 12.
+    tol : float
+        Tolerance parameter controlling the Bromwich contour shift. Default 1e-8.
+    
+    Returns
+    -------
+    f : ndarray of shape (Nx,)
+    """
+    A = -np.log(tol)
+    exp_At = np.exp(0.5 * A) / t
+
+    # Euler acceleration weights: c_k = C(M,k) * 0.5^M
+    p_half = 0.5 ** M
+    c = np.array([p_half * comb(M, k) for k in range(1, M + 1)])
+
+    # Imaginary step
+    h = 1j * np.pi / t
+    # Real shift
+    x = 0.5 * A / t
+
+    # Build evaluation points: x, x+h, x+2h, ..., x+(N+M)*h
+    n_total = 1 + N + M
+    transform_points = np.zeros(n_total, dtype=complex)
+    transform_points[0] = x
+    for k in range(1, n_total):
+        transform_points[k] = x + k * h
+
+    # Evaluate the Laplace-domain function at all points
+    gp = g(transform_points)
+
+    # Handle 1D output
+    if gp.ndim == 1:
+        gp = gp.reshape(-1, 1)
+
+    Nx = gp.shape[1]
+    f = np.zeros(Nx)
+
+    for nx in range(Nx):
+        # Main alternating sum (first 1+N terms)
+        s = 0.5 * np.real(gp[0, nx])
+        sign = -1
+        for k in range(1, N + 1):
+            s += sign * np.real(gp[k, nx])
+            sign = -sign
+
+        # Euler acceleration (next M terms)
+        est = p_half * s
+        for k in range(M):
+            s += sign * np.real(gp[N + 1 + k, nx])
+            est += c[k] * s
+            sign = -sign
+
+        f[nx] = exp_At * est
+
+    return f
+
+
+# ============================================================
+# TESTS
+# ============================================================
+def test_inversions():
+    """
+    Test both methods against known Laplace transform pairs.
+    """
+    print("=" * 70)
+    print("TESTING LAPLACE INVERSION METHODS")
+    print("=" * 70)
+
+    # Test 1: f(t) = exp(-a*t), F(p) = 1/(p+a)
+    a = 2.0
+    def g1(p):
+        return (1.0 / (p + a)).reshape(-1, 1)
+
+    print("\nTest 1: f(t) = exp(-a*t), a=2")
+    for t in [0.5, 1.0, 2.0, 5.0]:
+        exact = np.exp(-a * t)
+        fs = laplace_invert_stehfest(g1, t)[0]
+        fa = laplace_invert_abate_whitt(g1, t)[0]
+        print(f"  t={t:.1f}: exact={exact:.8f}, Stehfest={fs:.8f} (err={abs(fs-exact):.2e}), "
+              f"AbateWhitt={fa:.8f} (err={abs(fa-exact):.2e})")
+
+    # Test 2: f(t) = t*exp(-a*t), F(p) = 1/(p+a)^2
+    def g2(p):
+        return (1.0 / (p + a) ** 2).reshape(-1, 1)
+
+    print(f"\nTest 2: f(t) = t*exp(-a*t), a={a}")
+    for t in [0.5, 1.0, 2.0, 5.0]:
+        exact = t * np.exp(-a * t)
+        fs = laplace_invert_stehfest(g2, t)[0]
+        fa = laplace_invert_abate_whitt(g2, t)[0]
+        print(f"  t={t:.1f}: exact={exact:.8f}, Stehfest={fs:.8f} (err={abs(fs-exact):.2e}), "
+              f"AbateWhitt={fa:.8f} (err={abs(fa-exact):.2e})")
+
+    # Test 3: f(t) = sin(w*t), F(p) = w/(p^2+w^2)
+    w = 3.0
+    def g3(p):
+        return (w / (p ** 2 + w ** 2)).reshape(-1, 1)
+
+    print(f"\nTest 3: f(t) = sin(w*t), w={w} (oscillatory)")
+    for t in [0.5, 1.0, 2.0, 5.0]:
+        exact = np.sin(w * t)
+        fs = laplace_invert_stehfest(g3, t)[0]
+        fa = laplace_invert_abate_whitt(g3, t)[0]
+        print(f"  t={t:.1f}: exact={exact:+.8f}, Stehfest={fs:+.8f} (err={abs(fs-exact):.2e}), "
+              f"AbateWhitt={fa:+.8f} (err={abs(fa-exact):.2e})")
+
+    # Test 4: f(t) = 1 (step function), F(p) = 1/p
+    def g4(p):
+        return (1.0 / p).reshape(-1, 1)
+
+    print(f"\nTest 4: f(t) = 1 (constant)")
+    for t in [0.5, 1.0, 2.0, 5.0]:
+        exact = 1.0
+        fs = laplace_invert_stehfest(g4, t)[0]
+        fa = laplace_invert_abate_whitt(g4, t)[0]
+        print(f"  t={t:.1f}: exact={exact:.8f}, Stehfest={fs:.8f} (err={abs(fs-exact):.2e}), "
+              f"AbateWhitt={fa:.8f} (err={abs(fa-exact):.2e})")
+
+    # Test 5: Multi-output — f(t) = [exp(-t), exp(-2t), exp(-3t)]
+    def g5(p):
+        # p is array of shape (n_p,)
+        # Return shape (n_p, 3)
+        result = np.zeros((len(p), 3), dtype=complex if np.iscomplexobj(p) else float)
+        for j, a_j in enumerate([1.0, 2.0, 3.0]):
+            result[:, j] = 1.0 / (p + a_j)
+        return result
+
+    print(f"\nTest 5: Multi-output f(t) = [exp(-t), exp(-2t), exp(-3t)]")
+    t = 1.0
+    exact = np.array([np.exp(-1), np.exp(-2), np.exp(-3)])
+    fs = laplace_invert_stehfest(g5, t)
+    fa = laplace_invert_abate_whitt(g5, t)
+    for j in range(3):
+        print(f"  f_{j+1}: exact={exact[j]:.8f}, Stehfest={fs[j]:.8f} (err={abs(fs[j]-exact[j]):.2e}), "
+              f"AbateWhitt={fa[j]:.8f} (err={abs(fa[j]-exact[j]):.2e})")
+
+    # Test 6: Survival probability proxy — F(p) = exp(-sqrt(2p)) / p
+    # f(t) = erfc(1/sqrt(2t))
+    from scipy.special import erfc
+    def g6(p):
+        return (np.exp(-np.sqrt(2 * p)) / p).reshape(-1, 1)
+
+    print(f"\nTest 6: f(t) = erfc(1/sqrt(2t)) — survival-type function")
+    for t in [0.5, 1.0, 2.0, 5.0, 10.0]:
+        exact_val = erfc(1.0 / np.sqrt(2 * t))
+        fs = laplace_invert_stehfest(g6, t)[0]
+        fa = laplace_invert_abate_whitt(g6, t)[0]
+        print(f"  t={t:5.1f}: exact={exact_val:.8f}, Stehfest={fs:.8f} (err={abs(fs-exact_val):.2e}), "
+              f"AbateWhitt={fa:.8f} (err={abs(fa-exact_val):.2e})")
+
+    print("\n" + "=" * 70)
+    print("ALL TESTS COMPLETE")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    test_inversions()

goal_based_allocation/mandate_utils.py

@@ -0,0 +1,314 @@
+"""Mandate terminal wealth: analytical vs MC for all three mandates.
+Produces:
+  1. Per-mandate comparison (3 panels): MC histogram + analytical curves
+  2. All mandates analytical density overlay
+  3. All mandates analytical CDF overlay
+"""
+import numpy as np
+import matplotlib; matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from .regime_switch_paper import (create_paper_assets, create_paper_mandates,
+    RegimeSwitchParams, AssetSpecification, compute_density, compute_survival,
+    compute_overshoot_density)
+
+RHO = np.array([[1,0.3,0.3],[0.3,1,0.8],[0.3,0.8,1]])
+
+
+def mandate_effective_asset(mandate):
+    alloc = mandate.allocations
+    assets_list = list(alloc.keys())
+    w = np.array([alloc[a] for a in assets_list])
+    n_a = len(assets_list)
+    sig_g = np.array([a.params.sigma0 for a in assets_list])
+    sig_s = np.array([a.params.sigma1 for a in assets_list])
+    cov_g = np.outer(sig_g, sig_g) * RHO[:n_a,:n_a]
+    cov_s = np.outer(sig_s, sig_s) * RHO[:n_a,:n_a]
+    sig_port_g = np.sqrt(w @ cov_g @ w)
+    sig_port_s = np.sqrt(w @ cov_s @ w)
+    mu_g = sum(alloc[a]*a.mu_growth for a in assets_list)
+    mu_s = sum(alloc[a]*a.mu_stress for a in assets_list)
+
+    # Portfolio jump sizes via numerical integration (paper eq:eta_port)
+    from .client_solver import portfolio_eta_quadrature
+    etas0 = [a.params.eta0 for a in assets_list]
+    etas1 = [a.params.eta1 for a in assets_list]
+    eta0_p = portfolio_eta_quadrature(w, etas0, crash=True)
+    eta1_p = portfolio_eta_quadrature(w, etas1, crash=False)
+
+    lam01 = assets_list[0].params.lambda01
+    lam10 = assets_list[0].params.lambda10
+    par = RegimeSwitchParams(sigma0=sig_port_g, sigma1=sig_port_s,
+        lambda01=lam01, lambda10=lam10, eta0=eta0_p, eta1=eta1_p)
+    L0 = sum(alloc[a]*a.pi_floor for a in assets_list)
+    return AssetSpecification(f'mandate_{mandate.name}', par,
+        mu_growth=mu_g, mu_stress=mu_s, pi0=100.0, pi_floor=L0)
+
+
+def simulate_mandate_mc(eff, T=10.0, n_paths=200_000, seed=42):
+    rng = np.random.default_rng(seed)
+    par = eff.params; r_c = 0.02-0.03
+    n_steps = int(T*260); dt = T/n_steps; sqrt_dt = np.sqrt(dt)
+    X = np.full(n_paths, eff.x0)
+    regime = np.zeros(n_paths, dtype=int)
+    stopped = np.zeros(n_paths, dtype=bool)
+    X_at_stop = np.zeros(n_paths)
+    stop_time = np.full(n_paths, np.inf)
+    is_jump = np.zeros(n_paths, dtype=bool)
+    for step in range(n_steps):
+        alive = ~stopped
+        nu = np.where(regime==0, eff.nu0, eff.nu1)
+        sig = np.where(regime==0, par.sigma0, par.sigma1)
+        dW = rng.standard_normal(n_paths)*sqrt_dt
+        u = rng.uniform(size=n_paths)
+        X_new = X + nu*dt + sig*dW
+        p_sw = np.where(regime==0, par.lambda01*dt, par.lambda10*dt)
+        sw = alive & (u < p_sw)
+        crash = sw & (regime==0); recov = sw & (regime==1)
+        if par.eta0>0 and np.any(crash):
+            X_new[crash] = X[crash] - rng.exponential(par.eta0, size=np.sum(crash))
+        if par.eta1>0 and np.any(recov):
+            X_new[recov] = X[recov] + rng.exponential(par.eta1, size=np.sum(recov))
+        regime = np.where(crash,1,np.where(recov,0,regime))
+        X = np.where(alive, X_new, X)
+        newly = alive & (X<=0)
+        if np.any(newly):
+            stopped[newly]=True; X_at_stop[newly]=X[newly]
+            stop_time[newly]=(step+1)*dt; is_jump[newly]=crash[newly]
+    L_T = eff.pi_floor*np.exp(-0.01*T)
+    Pi_T = np.where(stopped, L_T*np.exp(X_at_stop), L_T*np.exp(X))
+    return {'Pi_T': Pi_T, 'L_T': L_T, 'survived': ~stopped,
+            'is_overshoot': stopped & is_jump, 'n_paths': n_paths}
+
+
+def compute_mandate_analytical(eff, T=10.0):
+    r_c = -0.01; L_T = eff.pi_floor*np.exp(r_c*T)
+    surv = compute_survival(T, eff.x0, eff)
+
+    # Survived density
+    x_grid = np.linspace(0.001, 6.0, 800)
+    d0, d1 = compute_density(T, x_grid, eff)
+    d_total = d0 + d1
+    Pi_surv = L_T * np.exp(x_grid)
+    dens_surv = d_total / (L_T * np.exp(x_grid))
+
+    # Overshoot density
+    d_ov = np.linspace(0.001, 5.0, 400)
+    f_ov = compute_overshoot_density(T, d_ov, eff)
+    over_mass = np.trapezoid(f_ov, d_ov)
+    Pi_ov = L_T * np.exp(-d_ov)
+    dens_ov = f_ov / (L_T * np.exp(-d_ov))
+
+    return {
+        'surv': surv, 'over_mass': over_mass, 'floor': 1-surv-over_mass,
+        'L_T': L_T,
+        'Pi_surv': Pi_surv, 'dens_surv': dens_surv,
+        'Pi_ov': Pi_ov, 'dens_ov': dens_ov,
+        'x_grid': x_grid, 'd_total': d_total,
+        'd_ov_grid': d_ov, 'f_ov': f_ov,
+    }
+
+
+def figure1_per_mandate():
+    """Three-panel: per-mandate MC vs analytical comparison."""
+    assets = create_paper_assets()
+    mandates = create_paper_mandates(assets)
+    T = 10.0; n_paths = 200_000
+    fig, axes = plt.subplots(3, 1, figsize=(12, 14), dpi=150)
+
+    mandate_order = ['conservative', 'balanced', 'growth']
+    labels = {'conservative': '70/20/10', 'balanced': '40/40/20', 'growth': '10/45/45'}
+
+    for idx, mname in enumerate(mandate_order):
+        ax = axes[idx]; m = mandates[mname]
+        eff = mandate_effective_asset(m)
+        an = compute_mandate_analytical(eff, T)
+        mc = simulate_mandate_mc(eff, T, n_paths, seed=42)
+
+        surv_mc = np.mean(mc['survived'])
+        over_mc = np.mean(mc['is_overshoot'])
+        floor_mc = np.mean(~mc['survived'] & ~mc['is_overshoot'])
+        Pi_surv_mc = mc['Pi_T'][mc['survived']]
+        Pi_over_mc = mc['Pi_T'][mc['is_overshoot']]
+
+        print(f"{mname}: An surv={an['surv']:.4f} MC={surv_mc:.4f}, "
+              f"An over={an['over_mass']:.4f} MC={over_mc:.4f}")
+
+        # Range: find where analytical density drops to ~0.1% of peak
+        peak = np.max(an['dens_surv'])
+        pi_hi = float(an['Pi_surv'][np.searchsorted(-an['dens_surv'][::-1], -peak*0.005)])
+        pi_hi = max(pi_hi, np.percentile(Pi_surv_mc, 99.9)) * 1.05
+        pi_lo = min(-10, np.min(Pi_over_mc)-5) if len(Pi_over_mc)>0 else -10
+
+        bins = np.linspace(pi_lo, pi_hi, 60)
+        dx = bins[1]-bins[0]; ctrs = 0.5*(bins[:-1]+bins[1:])
+        h_s,_ = np.histogram(Pi_surv_mc, bins=bins)
+        h_o,_ = np.histogram(Pi_over_mc, bins=bins)
+
+        ax.bar(ctrs, h_s/(n_paths*dx), width=dx, alpha=0.3, color='steelblue',
+               edgecolor='none', label='Survived (MC)')
+        ax.bar(ctrs, h_o/(n_paths*dx), width=dx, alpha=0.4, color='salmon',
+               edgecolor='none', label='Overshoot (MC)')
+
+        mask = (an['Pi_surv']>pi_lo) & (an['Pi_surv']<pi_hi) & (an['dens_surv']>0)
+        ax.plot(an['Pi_surv'][mask], an['dens_surv'][mask], 'k-', lw=1.8, label='Analytical')
+        mask_o = (an['Pi_ov']>pi_lo) & (an['Pi_ov']<pi_hi) & (an['dens_ov']>0)
+        if np.any(mask_o):
+            ax.plot(an['Pi_ov'][mask_o], an['dens_ov'][mask_o], 'r-', lw=1.8, label='Overshoot (An)')
+
+        ax.axvline(an['L_T'], color='red', ls='--', lw=1, alpha=0.5)
+        ymax = max(np.max(h_s/(n_paths*dx)), np.max(h_o/(n_paths*dx))) * 1.15
+        ax.set_ylim(0, ymax); ax.set_xlim(pi_lo, pi_hi)
+
+        ax.text(an['L_T']+2, ymax*0.85,
+                f'$L_T$={an["L_T"]:.0f}\nFloor: {floor_mc:.1%}\nOver: {over_mc:.1%}',
+                fontsize=8, color='red', va='top')
+
+        dname = mname.capitalize()
+        ax.set_title(f'{dname} ({labels[mname]}) — '
+                     f'$\\sigma$=[{eff.params.sigma0:.1%},{eff.params.sigma1:.1%}], '
+                     f'$\\eta$={eff.params.eta0:.3f}', fontsize=11)
+        ax.set_xlabel('Terminal wealth $\\Pi_T$', fontsize=10)
+        ax.set_ylabel('Density', fontsize=10)
+        ax.legend(fontsize=7, loc='upper right')
+        ax.grid(True, alpha=0.3)
+        ax.text(0.02, 0.97,
+            f'Surv: An={an["surv"]:.3f} MC={surv_mc:.3f}\n'
+            f'E[$\\Pi_T$|s]={np.mean(Pi_surv_mc):.1f}, σ={np.std(Pi_surv_mc):.1f}',
+            transform=ax.transAxes, fontsize=8, va='top',
+            bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
+
+    fig.suptitle('Mandate Terminal Wealth: Analytical vs MC ($T$=10y, $\\rho_{eq,pe}$=0.8)',
+                 fontsize=13, y=0.99)
+    plt.tight_layout(rect=[0, 0, 1, 0.97])
+    for ext in ['pdf','png']:
+        fig.savefig(f'/mnt/user-data/outputs/mandate_comparison.{ext}', bbox_inches='tight', dpi=150)
+    print("Saved mandate_comparison")
+
+
+def figure2_density_overlay():
+    """All three mandate densities on one plot."""
+    assets = create_paper_assets()
+    mandates = create_paper_mandates(assets)
+    T = 10.0
+
+    fig, ax = plt.subplots(1, 1, figsize=(12, 6), dpi=150)
+    colors = {'conservative': 'C0', 'balanced': 'C1', 'growth': 'C2'}
+    labels = {'conservative': 'Conservative (70/20/10)',
+              'balanced': 'Balanced (40/40/20)',
+              'growth': 'Growth (10/45/45)'}
+
+    for mname in ['conservative', 'balanced', 'growth']:
+        eff = mandate_effective_asset(mandates[mname])
+        an = compute_mandate_analytical(eff, T)
+        c = colors[mname]
+
+        # Survived + overshoot on same axis
+        mask = an['dens_surv'] > 1e-6
+        ax.plot(an['Pi_surv'][mask], an['dens_surv'][mask], color=c, lw=2,
+                label=labels[mname])
+        ax.fill_between(an['Pi_surv'][mask], 0, an['dens_surv'][mask], color=c, alpha=0.1)
+
+        # Overshoot
+        mask_o = an['dens_ov'] > 1e-6
+        if np.any(mask_o):
+            ax.plot(an['Pi_ov'][mask_o], an['dens_ov'][mask_o], color=c, lw=1.5, ls='--')
+            ax.fill_between(an['Pi_ov'][mask_o], 0, an['dens_ov'][mask_o], color=c, alpha=0.08)
+
+        # Floor line
+        ax.axvline(an['L_T'], color=c, ls=':', lw=0.8, alpha=0.5)
+
+        # Annotation
+        print(f"{mname}: surv={an['surv']:.3f}, over={an['over_mass']:.3f}, L_T={an['L_T']:.0f}")
+
+    ax.set_title('Mandate Terminal Wealth Density ($T$=10y)', fontsize=13)
+    ax.set_xlabel('Terminal wealth $\\Pi_T$', fontsize=11)
+    ax.set_ylabel('Density', fontsize=11)
+    ax.legend(fontsize=10)
+    ax.set_xlim(-20, 350); ax.set_ylim(bottom=0)
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    for ext in ['pdf','png']:
+        fig.savefig(f'/mnt/user-data/outputs/mandate_density_overlay.{ext}', bbox_inches='tight', dpi=150)
+    print("Saved mandate_density_overlay")
+
+
+def figure3_cdf_overlay():
+    """All three mandate CDFs on one plot."""
+    assets = create_paper_assets()
+    mandates = create_paper_mandates(assets)
+    T = 10.0
+
+    fig, ax = plt.subplots(1, 1, figsize=(12, 6), dpi=150)
+    colors = {'conservative': 'C0', 'balanced': 'C1', 'growth': 'C2'}
+    labels = {'conservative': 'Conservative (70/20/10)',
+              'balanced': 'Balanced (40/40/20)',
+              'growth': 'Growth (10/45/45)'}
+
+    for mname in ['conservative', 'balanced', 'growth']:
+        eff = mandate_effective_asset(mandates[mname])
+        an = compute_mandate_analytical(eff, T)
+        c = colors[mname]
+        L_T = an['L_T']
+
+        # Build CDF from overshoot + floor atom + survived density
+        # Need a unified Pi grid
+        Pi_grid = np.linspace(-20, 400, 2000)
+        cdf = np.zeros_like(Pi_grid)
+
+        # Overshoot CDF: ∫_{-∞}^{Π} f_over dΠ'
+        # f_over is in terms of d = -ln(Π/L_T), so integrate in d
+        # P(Π_over ≤ Π) = P(d ≥ -ln(Π/L_T)) = ∫_{d_min}^∞ f_ov dd
+        for i, pi in enumerate(Pi_grid):
+            if pi <= 0:
+                # Overshoot tail: very low wealth
+                d_val = -np.log(max(pi, 0.01)/L_T) if pi > 0 else 10.0
+                # P(Π_ov ≤ pi) = mass in overshoot with d ≥ d_val
+                mask = an['d_ov_grid'] >= d_val
+                if np.any(mask):
+                    cdf[i] = np.trapezoid(an['f_ov'][mask], an['d_ov_grid'][mask])
+            elif pi < L_T:
+                # Below floor: overshoot only
+                d_val = -np.log(pi/L_T)
+                mask = an['d_ov_grid'] >= d_val
+                cdf[i] = np.trapezoid(an['f_ov'][mask], an['d_ov_grid'][mask]) if np.any(mask) else an['over_mass']
+            else:
+                # Above floor: overshoot + floor + survived up to pi
+                x_val = np.log(pi/L_T)
+                mask_x = an['x_grid'] <= x_val
+                surv_below = np.trapezoid(an['d_total'][mask_x], an['x_grid'][mask_x]) if np.any(mask_x) else 0
+                cdf[i] = an['over_mass'] + an['floor'] + surv_below
+
+        ax.plot(Pi_grid, cdf, color=c, lw=2, label=labels[mname])
+        ax.axvline(L_T, color=c, ls=':', lw=0.8, alpha=0.5)
+
+        # Mark key quantiles
+        for q in [0.05, 0.5]:
+            idx = np.searchsorted(cdf, q)
+            if idx < len(Pi_grid):
+                ax.plot(Pi_grid[idx], q, 'o', color=c, markersize=4)
+                ax.annotate(f'{q:.0%}: {Pi_grid[idx]:.0f}', xy=(Pi_grid[idx], q),
+                           xytext=(Pi_grid[idx]+5, q+0.03), fontsize=7, color=c)
+
+    ax.axhline(1.0, color='gray', ls='-', lw=0.5, alpha=0.3)
+    ax.set_title('Mandate Terminal Wealth CDF ($T$=10y)', fontsize=13)
+    ax.set_xlabel('Terminal wealth $\\Pi_T$', fontsize=11)
+    ax.set_ylabel('$P(\\Pi_T \\leq \\Pi)$', fontsize=11)
+    ax.legend(fontsize=10, loc='lower right')
+    ax.set_xlim(-20, 350); ax.set_ylim(0, 1.05)
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    for ext in ['pdf','png']:
+        fig.savefig(f'/mnt/user-data/outputs/mandate_cdf_overlay.{ext}', bbox_inches='tight', dpi=150)
+    print("Saved mandate_cdf_overlay")
+
+
+if __name__ == "__main__":
+    print("="*60)
+    figure1_per_mandate()
+    print()
+    figure2_density_overlay()
+    print()
+    figure3_cdf_overlay()
+    print("\nAll done.")