Dynamic Portfolio Choice

MIT OCW 18.S096 + 15.450 (CC BY-NC-SA 4.0)

Static optimization picks weights once. Dynamic portfolio choice adjusts allocations over time as wealth, market conditions, and the investment horizon change. The Bellman equation turns a T-period problem into T one-period problems, each informed by the future.

Multi-period optimization

A myopic (single-period) investor maximizes E[U(W₁)]. A dynamic investor maximizes E[U(W_T)] by choosing a sequence of allocations w₀, w₁, ..., w_T-1. With CRRA utility and i.i.d. returns, the myopic solution happens to be optimal. But when returns are predictable or the horizon matters (as with labor income), the dynamic solution differs.

Scheme

; Multi-period wealth evolution
; W_{t+1} = W_t * (1 + w*r_risky + (1-w)*r_safe)

(define (evolve-wealth wealth weight r-risky r-safe)
  (* wealth (+ 1 (+ (* weight r-risky)
                     (* (- 1 weight) r-safe)))))

; CRRA utility: U(W) = W^(1-gamma) / (1-gamma)
(define (crra-utility wealth gamma)
  (if (= gamma 1)
      (log wealth)
      (/ (expt wealth (- 1 gamma)) (- 1 gamma))))

; 3-period simulation: 60/40 allocation
(define w 0.60)
(define r-safe 0.02)

(define w0 100000)
(define w1 (evolve-wealth w0 w 0.08 r-safe))
(define w2 (evolve-wealth w1 w -0.05 r-safe))
(define w3 (evolve-wealth w2 w 0.12 r-safe))

(display "Period 0: $") (display w0) (newline)
(display "Period 1: $") (display (round w1)) (newline)
(display "Period 2: $") (display (round w2)) (newline)
(display "Period 3: $") (display (round w3)) (newline)
(display "CRRA utility (gamma=2): ")
(display (crra-utility w3 2))

Rebalancing rules

Drift pushes the portfolio away from target weights. Calendar rebalancing resets weights on a fixed schedule (monthly, quarterly). Threshold rebalancing triggers only when a weight deviates beyond a band (e.g., +/-5%). Threshold rebalancing trades less often but captures larger mispricings. Transaction costs determine which rule dominates.

Scheme

; Rebalancing simulation: calendar vs. threshold

(define (drift-weight w r-stock r-bond)
  ; After returns, stock weight drifts
  (let* ((stock (* w (+ 1 r-stock)))
         (bond (* (- 1 w) (+ 1 r-bond)))
         (total (+ stock bond)))
    (/ stock total)))

(define target 0.60)
(define threshold 0.05)

; Simulate 4 quarters of stock/bond returns
(define stock-returns '(0.10 -0.03 0.08 -0.12))
(define bond-returns '(0.01 0.02 0.01 0.03))

; Calendar rebalancing: reset to target every period
(display "=== Calendar Rebalancing ===") (newline)
(let loop ((rets-s stock-returns) (rets-b bond-returns) (w target) (trades 0))
  (if (null? rets-s)
      (begin (display "Total trades: ") (display trades) (newline))
      (let ((drifted (drift-weight w (car rets-s) (car rets-b))))
        (display "  Drifted: ") (display (round (* drifted 100)))
        (display "% -> rebalance to 60%") (newline)
        (loop (cdr rets-s) (cdr rets-b) target (+ trades 1)))))

(newline)

; Threshold rebalancing: trade only if |w - target| > threshold
(display "=== Threshold Rebalancing ===") (newline)
(let loop ((rets-s stock-returns) (rets-b bond-returns) (w target) (trades 0))
  (if (null? rets-s)
      (begin (display "Total trades: ") (display trades) (newline))
      (let* ((drifted (drift-weight w (car rets-s) (car rets-b)))
             (rebal? (> (abs (- drifted target)) threshold))
             (new-w (if rebal? target drifted)))
        (display "  Drifted: ") (display (round (* drifted 100))) (display "%")
        (if rebal? (display " -> REBALANCE") (display " -> hold"))
        (newline)
        (loop (cdr rets-s) (cdr rets-b) new-w (+ trades (if rebal? 1 0))))))

; Rebalancing simulation: calendar vs. threshold

(define (drift-weight w r-stock r-bond)
  ; After returns, stock weight drifts
  (let* ((stock (* w (+ 1 r-stock)))
         (bond (* (- 1 w) (+ 1 r-bond)))
         (total (+ stock bond)))
    (/ stock total)))

(define target 0.60)
(define threshold 0.05)

; Simulate 4 quarters of stock/bond returns
(define stock-returns '(0.10 -0.03 0.08 -0.12))
(define bond-returns '(0.01 0.02 0.01 0.03))

; Calendar rebalancing: reset to target every period
(display "=== Calendar Rebalancing ===") (newline)
(let loop ((rets-s stock-returns) (rets-b bond-returns) (w target) (trades 0))
  (if (null? rets-s)
      (begin (display "Total trades: ") (display trades) (newline))
      (let ((drifted (drift-weight w (car rets-s) (car rets-b))))
        (display "  Drifted: ") (display (round (* drifted 100)))
        (display "% -> rebalance to 60%") (newline)
        (loop (cdr rets-s) (cdr rets-b) target (+ trades 1)))))

(newline)

; Threshold rebalancing: trade only if |w - target| > threshold
(display "=== Threshold Rebalancing ===") (newline)
(let loop ((rets-s stock-returns) (rets-b bond-returns) (w target) (trades 0))
  (if (null? rets-s)
      (begin (display "Total trades: ") (display trades) (newline))
      (let* ((drifted (drift-weight w (car rets-s) (car rets-b)))
             (rebal? (> (abs (- drifted target)) threshold))
             (new-w (if rebal? target drifted)))
        (display "  Drifted: ") (display (round (* drifted 100))) (display "%")
        (if rebal? (display " -> REBALANCE") (display " -> hold"))
        (newline)
        (loop (cdr rets-s) (cdr rets-b) new-w (+ trades (if rebal? 1 0))))))

Dynamic programming and the Bellman equation

The Bellman equation decomposes a T-period problem into nested one-period problems: V(W,t) = max_w E[V(W', t+1)]. Solve backwards from the terminal condition V(W,T) = U(W). At each step, the optimal weight depends on current wealth and time remaining. This is the fundamental tool of dynamic optimization.

Scheme

; Bellman equation: 2-period discrete example
; States: wealth can go up or down each period
; Choose weight w in {0, 0.5, 1.0} to maximize E[U(W_T)]

(define gamma 2)
(define (utility w) (/ (expt w (- 1 gamma)) (- 1 gamma)))
(define r-up 0.10)
(define r-down -0.05)
(define r-safe 0.02)
(define prob-up 0.6)

(define (portfolio-return w r)
  (+ (* w r) (* (- 1 w) r-safe)))

; Terminal value function
(define (v-terminal wealth) (utility wealth))

; One-period value: E[V(W')]
(define (expected-value wealth weight v-next)
  (let ((w-up (* wealth (+ 1 (portfolio-return weight r-up))))
        (w-dn (* wealth (+ 1 (portfolio-return weight r-down)))))
    (+ (* prob-up (v-next w-up))
       (* (- 1 prob-up) (v-next w-dn)))))

; Optimize over weights at t=1 (last decision)
(define weights '(0.0 0.25 0.5 0.75 1.0))

(define (best-weight wealth v-next)
  (let loop ((ws weights) (best-w 0) (best-v -999999))
    (if (null? ws) best-w
        (let ((ev (expected-value wealth (car ws) v-next)))
          (if (> ev best-v)
              (loop (cdr ws) (car ws) ev)
              (loop (cdr ws) best-w best-v))))))

(define w0 100000)
(define opt-w (best-weight w0 v-terminal))
(display "Optimal weight at t=0: ")
(display (* opt-w 100)) (display "%") (newline)

(define ev (expected-value w0 opt-w v-terminal))
(display "Expected utility: ") (display ev)

; Bellman equation: 2-period discrete example
; States: wealth can go up or down each period
; Choose weight w in {0, 0.5, 1.0} to maximize E[U(W_T)]

(define gamma 2)
(define (utility w) (/ (expt w (- 1 gamma)) (- 1 gamma)))
(define r-up 0.10)
(define r-down -0.05)
(define r-safe 0.02)
(define prob-up 0.6)

(define (portfolio-return w r)
  (+ (* w r) (* (- 1 w) r-safe)))

; Terminal value function
(define (v-terminal wealth) (utility wealth))

; One-period value: E[V(W')]
(define (expected-value wealth weight v-next)
  (let ((w-up (* wealth (+ 1 (portfolio-return weight r-up))))
        (w-dn (* wealth (+ 1 (portfolio-return weight r-down)))))
    (+ (* prob-up (v-next w-up))
       (* (- 1 prob-up) (v-next w-dn)))))

; Optimize over weights at t=1 (last decision)
(define weights '(0.0 0.25 0.5 0.75 1.0))

(define (best-weight wealth v-next)
  (let loop ((ws weights) (best-w 0) (best-v -999999))
    (if (null? ws) best-w
        (let ((ev (expected-value wealth (car ws) v-next)))
          (if (> ev best-v)
              (loop (cdr ws) (car ws) ev)
              (loop (cdr ws) best-w best-v))))))

(define w0 100000)
(define opt-w (best-weight w0 v-terminal))
(display "Optimal weight at t=0: ")
(display (* opt-w 100)) (display "%") (newline)

(define ev (expected-value w0 opt-w v-terminal))
(display "Expected utility: ") (display ev)

Merton's continuous-time portfolio problem

Merton (1969) solved the portfolio problem in continuous time. With CRRA utility and a single risky asset following geometric Brownian motion, the optimal stock allocation is w* = (μ − r) / (γ σ²). The result is constant over time and independent of wealth—a striking simplicity. It says: the more risk-averse you are (higher γ), or the more volatile the asset (higher σ), the less you hold.

Scheme

; Merton's optimal portfolio rule
; w* = (mu - r) / (gamma * sigma^2)

(define (merton-weight mu r-safe gamma sigma)
  (/ (- mu r-safe) (* gamma (* sigma sigma))))

; Equity premium 6%, risk-free 2%, vol 20%
(define mu 0.08)
(define r 0.02)
(define sigma 0.20)

; Different risk aversion levels
(display "=== Merton Optimal Stock Weight ===") (newline)
(for-each
  (lambda (gamma)
    (let ((w (merton-weight mu r gamma sigma)))
      (display "  gamma=") (display gamma)
      (display "  w*=") (display (* (round (* w 1000)) 0.1))
      (display "%") (newline)))
  '(1 2 3 5 10))

(newline)
; Higher volatility reduces allocation
(display "=== Volatility Sensitivity (gamma=3) ===") (newline)
(for-each
  (lambda (s)
    (let ((w (merton-weight mu r 3 s)))
      (display "  sigma=") (display (* s 100)) (display "%")
      (display "  w*=") (display (* (round (* w 1000)) 0.1))
      (display "%") (newline)))
  '(0.10 0.15 0.20 0.25 0.30))

Horizon effects and lifecycle investing

Young investors have more human capital (future labor income), which acts like a bond. So they should hold more stocks. As retirement approaches, the bond-like human capital shrinks, and the portfolio should shift toward bonds. This is the theoretical basis for target-date funds. The glide path is not arbitrary—it follows from the Bellman equation with labor income as a state variable.

Scheme

; Lifecycle glide path: stock allocation vs. years to retirement
; Human capital decays, so stock allocation decreases

(define (glide-path years-to-retire total-wealth annual-income discount-rate)
  ; PV of human capital ~ income * annuity factor
  (let* ((hc (if (= years-to-retire 0) 0
                 (* annual-income
                    (/ (- 1 (expt (+ 1 discount-rate) (- years-to-retire)))
                       discount-rate))))
         (total (+ total-wealth hc))
         ; Target: 60% of total wealth in stocks
         ; But stocks come only from financial wealth
         (stock-target (* 0.60 total))
         (stock-weight (min 1.0 (/ stock-target total-wealth))))
    stock-weight))

(define income 75000)
(define rate 0.03)

(display "=== Lifecycle Glide Path ===") (newline)
(display "Years  Financial   Human Cap   Stock%") (newline)
(for-each
  (lambda (pair)
    (let* ((yrs (car pair))
           (fin-wealth (cadr pair))
           (w (glide-path yrs fin-wealth income rate)))
      (display "  ") (display yrs)
      (display "     $") (display fin-wealth)
      (display "      ") (display (* (round (* w 1000)) 0.1))
      (display "%") (newline)))
  '((30 50000) (20 200000) (10 500000) (5 800000) (0 1000000)))

; Lifecycle glide path: stock allocation vs. years to retirement
; Human capital decays, so stock allocation decreases

(define (glide-path years-to-retire total-wealth annual-income discount-rate)
  ; PV of human capital ~ income * annuity factor
  (let* ((hc (if (= years-to-retire 0) 0
                 (* annual-income
                    (/ (- 1 (expt (+ 1 discount-rate) (- years-to-retire)))
                       discount-rate))))
         (total (+ total-wealth hc))
         ; Target: 60% of total wealth in stocks
         ; But stocks come only from financial wealth
         (stock-target (* 0.60 total))
         (stock-weight (min 1.0 (/ stock-target total-wealth))))
    stock-weight))

(define income 75000)
(define rate 0.03)

(display "=== Lifecycle Glide Path ===") (newline)
(display "Years  Financial   Human Cap   Stock%") (newline)
(for-each
  (lambda (pair)
    (let* ((yrs (car pair))
           (fin-wealth (cadr pair))
           (w (glide-path yrs fin-wealth income rate)))
      (display "  ") (display yrs)
      (display "     $") (display fin-wealth)
      (display "      ") (display (* (round (* w 1000)) 0.1))
      (display "%") (newline)))
  '((30 50000) (20 200000) (10 500000) (5 800000) (0 1000000)))

Neighbors

📉 Finance II Ch.11 — VaR constraints shape the feasible set for dynamic optimization
📉 Finance II Ch.4 — mean-variance optimization is the single-period special case
∫ Calculus Ch.11 — stochastic calculus underpins Merton's continuous-time solution

← Value at Risk · 11 of 12 by june.kim