Efficient Markets

OpenStax Principles of Finance (CC BY 4.0) · MIT OCW 15.401 (CC BY-NC-SA 4.0)

The Efficient Market Hypothesis says prices fully reflect available information. You can't consistently beat the market because by the time you know something, the price already moved. The debate is over how much information "available" includes.

Three forms of efficiency

Weak form: prices reflect all past trading data. Technical analysis cannot produce excess returns. Semi-strong form: prices reflect all publicly available information. Fundamental analysis cannot beat the market either. Strong form: prices reflect all information, public and private. Even insiders cannot profit. Each stronger form subsumes the one below it.

Scheme

; Testing weak-form efficiency: autocorrelation of returns
; If markets are weak-form efficient, returns should be uncorrelated

(define (mean lst)
  (/ (apply + lst) (length lst)))

(define (autocorrelation returns lag)
  (let* ((n (length returns))
         (mu (mean returns))
         (demeaned (map (lambda (r) (- r mu)) returns))
         (pairs (let loop ((i 0) (acc '()))
                  (if (>= (+ i lag) n) (reverse acc)
                      (loop (+ i 1)
                            (cons (* (list-ref demeaned i)
                                     (list-ref demeaned (+ i lag)))
                                  acc)))))
         (variance (mean (map (lambda (r) (* r r)) demeaned))))
    (/ (mean pairs) variance)))

; Simulated daily returns (random-ish)
(define returns '(0.012 -0.008 0.005 -0.003 0.015
                  -0.010 0.007 -0.002 0.009 -0.006
                  0.011 -0.007 0.003 -0.004 0.008
                  -0.012 0.006 -0.001 0.010 -0.009))

(display "Lag-1 autocorrelation: ")
(display (/ (round (* (autocorrelation returns 1) 1000)) 1000)) (newline)
(display "Lag-2 autocorrelation: ")
(display (/ (round (* (autocorrelation returns 2) 1000)) 1000)) (newline)
(display "Near zero = consistent with weak-form efficiency")

; Testing weak-form efficiency: autocorrelation of returns
; If markets are weak-form efficient, returns should be uncorrelated

(define (mean lst)
  (/ (apply + lst) (length lst)))

(define (autocorrelation returns lag)
  (let* ((n (length returns))
         (mu (mean returns))
         (demeaned (map (lambda (r) (- r mu)) returns))
         (pairs (let loop ((i 0) (acc '()))
                  (if (>= (+ i lag) n) (reverse acc)
                      (loop (+ i 1)
                            (cons (* (list-ref demeaned i)
                                     (list-ref demeaned (+ i lag)))
                                  acc)))))
         (variance (mean (map (lambda (r) (* r r)) demeaned))))
    (/ (mean pairs) variance)))

; Simulated daily returns (random-ish)
(define returns '(0.012 -0.008 0.005 -0.003 0.015
                  -0.010 0.007 -0.002 0.009 -0.006
                  0.011 -0.007 0.003 -0.004 0.008
                  -0.012 0.006 -0.001 0.010 -0.009))

(display "Lag-1 autocorrelation: ")
(display (/ (round (* (autocorrelation returns 1) 1000)) 1000)) (newline)
(display "Lag-2 autocorrelation: ")
(display (/ (round (* (autocorrelation returns 2) 1000)) 1000)) (newline)
(display "Near zero = consistent with weak-form efficiency")

Random walk hypothesis

If markets are efficient, price changes are unpredictable. The random walk model says tomorrow's price equals today's price plus a random shock: Pₜ₊₁ = Pₜ + εₜ. This does not mean prices are random — it means changes are random. A stock can trend upward on average (drift) while its daily moves remain unpredictable.

Scheme

; Random walk simulation
; P(t+1) = P(t) * (1 + drift + sigma * z)
; where z is a random standard normal shock

; Simple pseudo-random via linear congruential generator
(define (lcg seed) (modulo (+ (* 1103515245 seed) 12345) (expt 2 31)))

; Map uniform to approximate normal (Box-Muller-ish, simplified)
(define (pseudo-normal seed)
  (let* ((s1 (lcg seed))
         (u1 (/ s1 (expt 2 31)))
         (s2 (lcg s1))
         (u2 (/ s2 (expt 2 31)))
         ; Approximate: use (u1 + u2 + ... - 6) for central limit
         (s3 (lcg s2)) (u3 (/ s3 (expt 2 31)))
         (s4 (lcg s3)) (u4 (/ s4 (expt 2 31)))
         (s5 (lcg s4)) (u5 (/ s5 (expt 2 31)))
         (s6 (lcg s5)) (u6 (/ s6 (expt 2 31))))
    (list (- (+ u1 u2 u3 u4 u5 u6) 3) s6)))

; Simulate 10 days
(define (random-walk P0 drift sigma days seed)
  (let loop ((day 0) (price P0) (s seed))
    (if (> day days) 'done
        (begin
          (display "Day ") (display day)
          (display ": $") (display (/ (round (* price 100)) 100)) (newline)
          (if (= day days) 'done
              (let* ((rn (pseudo-normal s))
                     (z (car rn))
                     (next-s (cadr rn))
                     (ret (+ drift (* sigma z)))
                     (next-price (* price (+ 1 ret))))
                (loop (+ day 1) next-price next-s)))))))

(display "=== Random walk: drift=0.05%/day, vol=1.5% ===" ) (newline)
(random-walk 100 0.0005 0.015 10 42)

; Random walk simulation
; P(t+1) = P(t) * (1 + drift + sigma * z)
; where z is a random standard normal shock

; Simple pseudo-random via linear congruential generator
(define (lcg seed) (modulo (+ (* 1103515245 seed) 12345) (expt 2 31)))

; Map uniform to approximate normal (Box-Muller-ish, simplified)
(define (pseudo-normal seed)
  (let* ((s1 (lcg seed))
         (u1 (/ s1 (expt 2 31)))
         (s2 (lcg s1))
         (u2 (/ s2 (expt 2 31)))
         ; Approximate: use (u1 + u2 + ... - 6) for central limit
         (s3 (lcg s2)) (u3 (/ s3 (expt 2 31)))
         (s4 (lcg s3)) (u4 (/ s4 (expt 2 31)))
         (s5 (lcg s4)) (u5 (/ s5 (expt 2 31)))
         (s6 (lcg s5)) (u6 (/ s6 (expt 2 31))))
    (list (- (+ u1 u2 u3 u4 u5 u6) 3) s6)))

; Simulate 10 days
(define (random-walk P0 drift sigma days seed)
  (let loop ((day 0) (price P0) (s seed))
    (if (> day days) 'done
        (begin
          (display "Day ") (display day)
          (display ": $") (display (/ (round (* price 100)) 100)) (newline)
          (if (= day days) 'done
              (let* ((rn (pseudo-normal s))
                     (z (car rn))
                     (next-s (cadr rn))
                     (ret (+ drift (* sigma z)))
                     (next-price (* price (+ 1 ret))))
                (loop (+ day 1) next-price next-s)))))))

(display "=== Random walk: drift=0.05%/day, vol=1.5% ===" ) (newline)
(random-walk 100 0.0005 0.015 10 42)

Event studies

An event study tests semi-strong efficiency by measuring how quickly prices adjust to new information. Calculate abnormal returns — actual return minus expected return — around the event date. If the market is semi-strong efficient, all adjustment happens immediately: abnormal returns cluster at day zero with no drift before or after.

Scheme

; Event study: compute cumulative abnormal returns (CAR)
; Abnormal return = actual return - expected return (from market model)

(define (abnormal-returns actual-returns market-returns alpha beta)
  (map (lambda (r-i r-m)
         (- r-i (+ alpha (* beta r-m))))
       actual-returns market-returns))

(define (cumulative-sum lst)
  (let loop ((remaining lst) (total 0) (acc '()))
    (if (null? remaining) (reverse acc)
        (let ((new-total (+ total (car remaining))))
          (loop (cdr remaining) new-total (cons new-total acc))))))

; Stock returns around earnings announcement (day -3 to +3)
; Market model: E[R_i] = alpha + beta * R_m
(define alpha 0.0001) (define beta 1.2)
(define stock-returns  '(-0.002  0.001  0.003  0.045 -0.005  0.001  0.000))
(define market-returns '( 0.001  0.002 -0.001  0.003  0.001  0.000  0.002))
(define days '(-3 -2 -1 0 1 2 3))

(define AR (abnormal-returns stock-returns market-returns alpha beta))
(define CAR (cumulative-sum AR))

(display "Day   AR       CAR") (newline)
(for-each (lambda (d ar car-val)
  (display d) (display "    ")
  (display (/ (round (* ar 10000)) 10000)) (display "   ")
  (display (/ (round (* car-val 10000)) 10000)) (newline))
  days AR CAR)

(display "Most abnormal return at day 0 = efficient adjustment")

; Event study: compute cumulative abnormal returns (CAR)
; Abnormal return = actual return - expected return (from market model)

(define (abnormal-returns actual-returns market-returns alpha beta)
  (map (lambda (r-i r-m)
         (- r-i (+ alpha (* beta r-m))))
       actual-returns market-returns))

(define (cumulative-sum lst)
  (let loop ((remaining lst) (total 0) (acc '()))
    (if (null? remaining) (reverse acc)
        (let ((new-total (+ total (car remaining))))
          (loop (cdr remaining) new-total (cons new-total acc))))))

; Stock returns around earnings announcement (day -3 to +3)
; Market model: E[R_i] = alpha + beta * R_m
(define alpha 0.0001) (define beta 1.2)
(define stock-returns  '(-0.002  0.001  0.003  0.045 -0.005  0.001  0.000))
(define market-returns '( 0.001  0.002 -0.001  0.003  0.001  0.000  0.002))
(define days '(-3 -2 -1 0 1 2 3))

(define AR (abnormal-returns stock-returns market-returns alpha beta))
(define CAR (cumulative-sum AR))

(display "Day   AR       CAR") (newline)
(for-each (lambda (d ar car-val)
  (display d) (display "    ")
  (display (/ (round (* ar 10000)) 10000)) (display "   ")
  (display (/ (round (* car-val 10000)) 10000)) (newline))
  days AR CAR)

(display "Most abnormal return at day 0 = efficient adjustment")

Anomalies and challenges to EMH

Several persistent patterns challenge the EMH. The January effect: small stocks outperform in January. The momentum effect: past winners keep winning for 3-12 months. The value premium: high book-to-market stocks earn more than growth stocks. Defenders argue these are compensation for risk; critics say they're evidence of behavioral biases. The debate is unresolved.

Scheme

; Momentum strategy backtest (simplified)
; Buy past winners, sell past losers

(define (momentum-signal returns lookback)
  ; Sum of past 'lookback' returns as signal
  (let loop ((i lookback) (signals '()))
    (if (>= i (length returns)) (reverse signals)
        (let ((past (let inner ((j 0) (sum 0))
                      (if (>= j lookback) sum
                          (inner (+ j 1) (+ sum (list-ref returns (- i j 1))))))))
          (loop (+ i 1) (cons past signals))))))

; Simulated monthly returns for one stock
(define monthly-returns '(0.02 0.05 -0.01 0.03 0.04
                          -0.02 0.06 0.01 -0.03 0.02
                          0.04 0.03))

(define signals (momentum-signal monthly-returns 3))

(display "Month  Signal  Return  Strategy") (newline)
(let loop ((i 0) (cum-ret 0))
  (if (>= i (length signals))
      (begin (newline) (display "Cumulative strategy return: ")
             (display (/ (round (* cum-ret 10000)) 10000)))
      (let* ((sig (list-ref signals i))
             (ret (list-ref monthly-returns (+ i 3)))
             ; Go long if past return > 0, short if < 0
             (position (if (> sig 0) 1 -1))
             (strat-ret (* position ret)))
        (display (+ i 4)) (display "      ")
        (display (/ (round (* sig 1000)) 1000)) (display "  ")
        (display ret) (display "    ")
        (display (/ (round (* strat-ret 1000)) 1000)) (newline)
        (loop (+ i 1) (+ cum-ret strat-ret)))))

; Momentum strategy backtest (simplified)
; Buy past winners, sell past losers

(define (momentum-signal returns lookback)
  ; Sum of past 'lookback' returns as signal
  (let loop ((i lookback) (signals '()))
    (if (>= i (length returns)) (reverse signals)
        (let ((past (let inner ((j 0) (sum 0))
                      (if (>= j lookback) sum
                          (inner (+ j 1) (+ sum (list-ref returns (- i j 1))))))))
          (loop (+ i 1) (cons past signals))))))

; Simulated monthly returns for one stock
(define monthly-returns '(0.02 0.05 -0.01 0.03 0.04
                          -0.02 0.06 0.01 -0.03 0.02
                          0.04 0.03))

(define signals (momentum-signal monthly-returns 3))

(display "Month  Signal  Return  Strategy") (newline)
(let loop ((i 0) (cum-ret 0))
  (if (>= i (length signals))
      (begin (newline) (display "Cumulative strategy return: ")
             (display (/ (round (* cum-ret 10000)) 10000)))
      (let* ((sig (list-ref signals i))
             (ret (list-ref monthly-returns (+ i 3)))
             ; Go long if past return > 0, short if < 0
             (position (if (> sig 0) 1 -1))
             (strat-ret (* position ret)))
        (display (+ i 4)) (display "      ")
        (display (/ (round (* sig 1000)) 1000)) (display "  ")
        (display ret) (display "    ")
        (display (/ (round (* strat-ret 1000)) 1000)) (newline)
        (loop (+ i 1) (+ cum-ret strat-ret)))))

Neighbors

📈 Options — option pricing assumes markets are efficient enough for no-arbitrage
📈 Behavioral Finance — the counterargument: systematic irrationality
📊 Statistics — hypothesis testing methods behind event studies
🎰 Probability — random walks and martingale theory

← Options · 8 of 12 by june.kim Behavioral Finance · 10 of 12 →