Bayesian Lenses and Statistical Games

Toby St Clere Smithe · 2021 · arxiv arXiv:2109.04461

Prereqs: 🍞 Fritz 2020 (Markov categories, Bayesian inversion). 🍞 Hedges 2018 (compositional games) helps but isn't required.

A Bayesian lens pairs a forward channel (prediction) with a backward channel (Bayesian update). Composing lenses gives you a system that predicts and then corrects — active inference falls out as the equilibrium of a statistical game.

Lenses: forward and backward

A lens is a pair: a get (forward pass, observation) and a put (backward pass, update). In the Bayesian setting, get is a likelihood channel and put is the Bayesian inverse — the posterior update given new evidence.

Scheme

; A Bayesian lens: (forward, backward)
; Forward: prior -> observation distribution
; Backward: (prior, observation) -> posterior

(define (make-lens forward backward)
  (list forward backward))

(define (lens-forward L) (car L))
(define (lens-backward L) (cadr L))

; Example: coin with unknown bias
; Forward: bias -> coin outcome distribution
(define (coin-forward bias)
  (list (cons 'heads bias) (cons 'tails (- 1 bias))))

; Backward: Bayesian update on bias given outcome
(define (coin-backward prior outcome)
  ; Simplified: if heads, shift belief toward higher bias
  (if (eq? outcome 'heads)
    (min 1.0 (+ prior 0.1))
    (max 0.0 (- prior 0.1))))

(define coin-lens (make-lens coin-forward coin-backward))

(display "prior: 0.5") (newline)
(display "observe heads -> posterior: ")
(display (coin-backward 0.5 'heads)) (newline)
(display "observe tails -> posterior: ")
(display (coin-backward 0.5 'tails))

Python

# Bayesian lens: forward prediction + backward update
def coin_forward(bias):
    return {"heads": bias, "tails": 1 - bias}

def coin_backward(prior, outcome):
    # Simplified Bayesian update
    if outcome == "heads":
        return min(1.0, prior + 0.1)
    return max(0.0, prior - 0.1)

print(f"prior: 0.5")
print(f"observe heads -> posterior: {coin_backward(0.5, 'heads')}")
print(f"observe tails -> posterior: {coin_backward(0.5, 'tails')}")

Bayesian inversion as the backward pass

The backward channel is the Bayesian inverse: given a prior and an observation, compute the posterior. This isn't an arbitrary update — it's the unique channel that makes the joint distribution factor correctly.

Scheme

; Bayesian inversion: P(A|B) = P(B|A) * P(A) / P(B)

(define (bayes-update prior likelihood evidence)
  ; prior: alist of (hypothesis . probability)
  ; likelihood: hypothesis -> (evidence . probability)
  ; evidence: observed value
  (let* ((joint (map (lambda (hp)
    (let ((h (car hp)) (ph (cdr hp)))
      (let ((pe-given-h (cdr (assoc evidence (likelihood h)))))
        (cons h (* ph pe-given-h)))))
    prior))
    (total (apply + (map cdr joint))))
    (map (lambda (jp) (cons (car jp) (/ (cdr jp) total))) joint)))

; Two hypotheses: fair coin (0.5) or biased (0.8)
(define prior '((fair . 0.5) (biased . 0.5)))

(define (likelihood h)
  (if (eq? h 'fair)
    '((heads . 0.5) (tails . 0.5))
    '((heads . 0.8) (tails . 0.2))))

(display "prior: ") (display prior) (newline)
(display "after heads: ")
(display (bayes-update prior likelihood 'heads)) (newline)
(display "after tails: ")
(display (bayes-update prior likelihood 'tails))

Python

# Bayesian inversion
def bayes_update(prior, likelihood, evidence):
    joint = {h: ph * likelihood(h)[evidence] for h, ph in prior.items()}
    total = sum(joint.values())
    return {h: p / total for h, p in joint.items()}

prior = {"fair": 0.5, "biased": 0.5}
def likelihood(h):
    return {"heads": 0.5, "tails": 0.5} if h == "fair" else {"heads": 0.8, "tails": 0.2}

print(f"prior: {prior}")
print(f"after heads: {bayes_update(prior, likelihood, 'heads')}")
print(f"after tails: {bayes_update(prior, likelihood, 'tails')}")

Composing lenses

Two Bayesian lenses compose: the forward passes chain (predict through both stages), and the backward passes chain in reverse (update flows back). This is the categorical structure of lenses — composition is well-defined and associative.

Scheme

; Composing lenses: forward chains, backward reverses
; L1: A -> B, L2: B -> C
; Composed: A -> C (forward), C -> A (backward)

(define (compose-lens L1 L2)
  (let ((f1 (car L1)) (b1 (cadr L1))
        (f2 (car L2)) (b2 (cadr L2)))
    (list
      ; Forward: f2(f1(a))
      (lambda (a) (f2 (f1 a)))
      ; Backward: b1(a, b2(f1(a), c))
      (lambda (a c) (b1 a (b2 (f1 a) c))))))

(define L1 (list (lambda (x) (+ x 1))
                 (lambda (x obs) (- obs 1))))
(define L2 (list (lambda (x) (* x 2))
                 (lambda (x obs) (/ obs 2))))

(define L (compose-lens L1 L2))
(display "forward(3) = ") (display ((car L) 3)) (newline)
(display "backward(3, 10) = ") (display ((cadr L) 3 10))
; forward: (3+1)*2 = 8, backward: recovers via inverse

Python

# Composing Bayesian lenses: forward chains, backward reverses
def compose_lens(L1, L2):
    f1, b1 = L1
    f2, b2 = L2
    forward = lambda a: f2(f1(a))
    backward = lambda a, c: b1(a, b2(f1(a), c))
    return (forward, backward)

L1 = (lambda x: x + 1, lambda x, obs: obs - 1)
L2 = (lambda x: x * 2, lambda x, obs: obs / 2)

L = compose_lens(L1, L2)
print(f"forward(3) = {L[0](3)}")      # (3+1)*2 = 8
print(f"backward(3, 10) = {L[1](3, 10)}")  # recovers via inverse

Free energy as the game's objective

A statistical game has players that minimize variational free energy — the gap between their model's predictions and the actual observations. The equilibrium of the game is active inference: each agent updates its beliefs to minimize surprise.

Scheme

; Free energy: surprise + complexity
; F = -log P(observation | model) + KL(posterior || prior)
; At equilibrium, agents minimize F

(define (log2 x) (/ (log x) (log 2)))

(define (free-energy obs-prob kl-div)
  (+ (- (log2 obs-prob)) kl-div))

; Good model: high observation probability, low divergence
(display "good model: F = ")
(display (free-energy 0.8 0.1)) (newline)

; Bad model: low observation probability, high divergence
(display "bad model:  F = ")
(display (free-energy 0.1 2.0)) (newline)

; Active inference minimizes F by updating beliefs
(display "Agents update beliefs to reduce free energy.")

Python

import math

def free_energy(obs_prob, kl_div):
    return -math.log2(obs_prob) + kl_div

# Good model: high observation probability, low divergence
print(f"good model: F = {free_energy(0.8, 0.1):.3f}")

# Bad model: low observation probability, high divergence
print(f"bad model:  F = {free_energy(0.1, 2.0):.3f}")

print("Agents update beliefs to reduce free energy.")

Notation reference

Paper	Scheme	Meaning
(f, f†)	(make-lens fwd bwd)	Bayesian lens (forward, inverse)
f†	(bayes-update ...)	Bayesian inverse channel
F	(free-energy ...)	Variational free energy
L₁ ⊙ L₂	(compose-lens L1 L2)	Lens composition
BayesLens(C)	; category of Bayesian lenses	Category with Bayesian backward passes

Neighbors

Other paper pages

🍞 Fritz 2020 — the Markov category where these lenses live
🍞 Capucci 2021 — cybernetic lenses (the general framework)
🍞 Hedges 2018 — compositional game theory (the game structure)
🍞 Cho, Jacobs 2015 — states/effects duality (related to forward/backward)

Foundations (Wikipedia)

Translation notes

The Bayesian update examples use finite hypothesis spaces with explicit probability tables. Smithe works with Bayesian inversions in arbitrary Markov categories, where the backward channel is defined via a universal property (the disintegration). For example: the coin-bias update on this page shifts a point estimate by ±0.1. In the paper, the backward channel is the exact Bayesian posterior computed via disintegration of the joint measure — a construction that works over continuous parameter spaces and requires measure-theoretic conditioning. The predict-then-update structure is identical. The exactness of the inversion is not.

Every example is Simplified.

Ready for the real thing? arxiv

Read the paper. Start at §3 for Bayesian lenses, §5 for statistical games and free energy.

Framework connection: The backward pass of a Bayesian lens corresponds to the Natural Framework's Consolidate stage — the policy update that reads from persistent memory. (The Natural Framework)

← Leinster 2021 · 14 of 21 by june.kim Parzygnat 2020 · 16 of 21 →