Towards Foundations of Categorical Cybernetics

Capucci, Gavranović, Hedges, Rischel · 2021 · arxiv arXiv:2105.06332

Prereqs: 🍞 Hedges 2018 (open games, selection functions). 5 min.

Goals are selection relations — predicates on (choice, context) pairs. An agent is a parametrised optic (forward pass + backward pass) with a selection relation ε(x, k) that says which choices x are acceptable given a context k : X → R mapping alternatives to outcomes. Composing agents = composing optics = wiring forward and backward channels.

Optics — forward and backward

An optic pairs a forward map (observation → action) with a backward map (action + consequence → updated state). Think lens from functional programming: get/set. In cybernetics, the forward pass is "act" and the backward pass is "learn from consequences."

Scheme

; An optic: forward + backward
; forward: observation -> action
; backward: (observation, action, consequence) -> update

(define (make-optic name fwd bwd)
  (list name fwd bwd))

(define (optic-fwd o) (cadr o))
(define (optic-bwd o) (caddr o))

; Thermostat optic
(define thermostat
  (make-optic 'thermostat
    (lambda (temp) (if (< temp 20) 'heat 'cool))       ; forward: act
    (lambda (temp action result)                         ; backward: learn
      (list 'observed temp 'did action 'got result))))

(display "fwd(18): ") (display ((optic-fwd thermostat) 18)) (newline)
(display "fwd(25): ") (display ((optic-fwd thermostat) 25)) (newline)
(display "bwd: ")
(display ((optic-bwd thermostat) 18 'heat 21)) (newline)
; Forward acts, backward learns from consequences

Parametrised optics — agents with tunable parameters

A parametrised optic adds parameters: the forward map depends on a parameter (policy/weights), and the backward map produces a parameter update. This is the agent abstraction. The parameter is what learning updates.

Scheme

; Parametrised optic: forward depends on parameter
; backward produces parameter update

(define (make-para-optic name fwd bwd)
  (list name fwd bwd))

; Agent with a threshold parameter
(define agent
  (make-para-optic 'threshold-agent
    (lambda (param obs)                    ; fwd(param, obs)
      (if (> obs param) 'accept 'reject))
    (lambda (param obs action reward)      ; bwd -> param update
      (if (> reward 0) param               ; good outcome: keep param
          (+ param 1)))))                   ; bad outcome: raise threshold

(define param 50)
(display "param=50, obs=60: ") (display ((cadr agent) param 60)) (newline)
(display "param=50, obs=40: ") (display ((cadr agent) param 40)) (newline)

; Bad outcome -> update parameter
(define new-param ((caddr agent) param 40 'reject -1))
(display "bad outcome, new param: ") (display new-param)
; 51 — threshold raised after bad experience

Selection relations — goals as two-place predicates

In Hedges 2018, a selection function picks the best action. Capucci generalizes to a selection relation: ε ⊆ X × (X → R), a predicate on (choice, context) pairs. The context k : X → R maps every alternative choice to its outcome — so ε(x, k) means "x is acceptable given what the alternatives would yield." Not "the best action" but "any action that's good enough, relative to the landscape of alternatives."

Scheme

; Selection relation: which actions are acceptable?
; Not "pick the best" but "which ones are good enough?"

(define (make-goal name predicate)
  (list name predicate))

(define (satisfies? goal action context)
  ((cadr goal) action context))

; Goal: profit > 0
(define profitable
  (make-goal 'profitable
    (lambda (action context)
      (> (- (* action context) 10) 0))))

; Which prices are acceptable at demand=5?
(define prices '(1 2 3 4 5))
(for-each (lambda (p)
  (display "price=") (display p)
  (display " at demand=5: ")
  (display (if (satisfies? profitable p 5) "accept" "reject"))
  (newline))
prices)
; Selection relation: all prices where profit > 0
; Not a single best — a set of acceptable actions

Confidence: Simplified. Real selection relations live on parametrised optics in a monoidal category, with the context k derived from the optic's backward channel. Same two-place predicate structure.

Composing agents — wiring optics

Two parametrised optics compose by wiring: agent 1's forward output feeds agent 2's forward input (the action becomes the observation), and agent 2's backward output feeds agent 1's backward input (consequences flow back). The whole system satisfies the composite goal when each agent satisfies its local goal given the context the other provides.

Scheme

; Composing two agents: wire forward and backward

(define (compose-optics o1 o2)
  (list 'composed
    (lambda (obs)    ; forward: chain
      (let ((mid ((cadr o1) obs)))
        ((cadr o2) mid)))
    (lambda (obs consequence)  ; backward: reverse chain
      (let* ((mid ((cadr o1) obs))
             (bwd2 ((caddr o2) mid consequence))
             (bwd1 ((caddr o1) obs bwd2)))
        (list bwd1 bwd2)))))

; Sensor: raw -> feature
(define sensor
  (list 'sensor
    (lambda (raw) (* raw 0.1))           ; forward: scale
    (lambda (raw err) (* err 10))))      ; backward: scale gradient

; Actuator: feature -> action
(define actuator
  (list 'actuator
    (lambda (feat) (if (> feat 5) 'on 'off))  ; forward: threshold
    (lambda (feat consequence) consequence)))  ; backward: pass through

(define system (compose-optics sensor actuator))

(display "system fwd(100): ") (display ((cadr system) 100)) (newline)
(display "system fwd(30):  ") (display ((cadr system) 30)) (newline)
; Forward chains, backward chains in reverse

; Composing two agents: wire forward and backward

(define (compose-optics o1 o2)
  (list 'composed
    (lambda (obs)    ; forward: chain
      (let ((mid ((cadr o1) obs)))
        ((cadr o2) mid)))
    (lambda (obs consequence)  ; backward: reverse chain
      (let* ((mid ((cadr o1) obs))
             (bwd2 ((caddr o2) mid consequence))
             (bwd1 ((caddr o1) obs bwd2)))
        (list bwd1 bwd2)))))

; Sensor: raw -> feature
(define sensor
  (list 'sensor
    (lambda (raw) (* raw 0.1))           ; forward: scale
    (lambda (raw err) (* err 10))))      ; backward: scale gradient

; Actuator: feature -> action
(define actuator
  (list 'actuator
    (lambda (feat) (if (> feat 5) 'on 'off))  ; forward: threshold
    (lambda (feat consequence) consequence)))  ; backward: pass through

(define system (compose-optics sensor actuator))

(display "system fwd(100): ") (display ((cadr system) 100)) (newline)
(display "system fwd(30):  ") (display ((cadr system) 30)) (newline)
; Forward chains, backward chains in reverse

Goals compose via the Nash product

The paper's composition theorem for goals is the Nash product ε ⊠ δ: agents x and y are jointly acceptable iff each is acceptable given the other's choice as context. This is the paper's actual claim. The bridge to Staton's Hoare logic — goals as postconditions, composition via COMP — is an editorial connection, not something Capucci et al. prove. But the structural parallel is real: in both cases, a global goal decomposes into local goals at an interface.

Scheme

; Goals compose: local goals + compatible interfaces => global goal
; Same structure as Hoare COMP

(define (check-pipeline stages goals input)
  (let loop ((val input) (ss stages) (gs goals) (i 1))
    (if (null? ss) (begin (display "All goals satisfied.") (newline))
        (let* ((stage (car ss))
               (goal (car gs))
               (output (stage val))
               (ok (goal output)))
          (display "Stage ") (display i)
          (display ": ") (display val)
          (display " -> ") (display output)
          (display (if ok " [goal met]" " [FAILED]"))
          (newline)
          (if ok (loop output (cdr ss) (cdr gs) (+ i 1))
                 (display "Pipeline goal violated."))))))

(define stages (list
  (lambda (x) (abs x))           ; stage 1: make positive
  (lambda (x) (min x 100))       ; stage 2: cap at 100
  (lambda (x) (/ x 10))))        ; stage 3: normalize

(define goals (list
  (lambda (x) (>= x 0))          ; post-stage-1: non-negative
  (lambda (x) (<= x 100))        ; post-stage-2: bounded
  (lambda (x) (<= x 10))))       ; post-stage-3: normalized

(check-pipeline stages goals -57)

; Goals compose: local goals + compatible interfaces => global goal
; Same structure as Hoare COMP

(define (check-pipeline stages goals input)
  (let loop ((val input) (ss stages) (gs goals) (i 1))
    (if (null? ss) (begin (display "All goals satisfied.") (newline))
        (let* ((stage (car ss))
               (goal (car gs))
               (output (stage val))
               (ok (goal output)))
          (display "Stage ") (display i)
          (display ": ") (display val)
          (display " -> ") (display output)
          (display (if ok " [goal met]" " [FAILED]"))
          (newline)
          (if ok (loop output (cdr ss) (cdr gs) (+ i 1))
                 (display "Pipeline goal violated."))))))

(define stages (list
  (lambda (x) (abs x))           ; stage 1: make positive
  (lambda (x) (min x 100))       ; stage 2: cap at 100
  (lambda (x) (/ x 10))))        ; stage 3: normalize

(define goals (list
  (lambda (x) (>= x 0))          ; post-stage-1: non-negative
  (lambda (x) (<= x 100))        ; post-stage-2: bounded
  (lambda (x) (<= x 10))))       ; post-stage-3: normalized

(check-pipeline stages goals -57)

Confidence: Editorial analogy. The Hoare triple parallel is mine, not the paper's. The paper composes goals via the Nash product (ε ⊠ δ). The sequential-postcondition framing comes from Staton 2025.

Notation reference

Paper	Scheme	Meaning
Optic(S,A; S',A')	(make-optic name fwd bwd)	Forward + backward pair
Para(C)	(make-para-optic ...)	Parametrised optic
ε ⊆ X × (X → R)	(satisfies? goal action ctx)	Selection relation — goal as (choice, context) predicate
G₁ ; G₂	(compose-optics o1 o2)	Sequential composition
argmax_X	(lambda (x k) (max? x k))	Canonical selection relation: x maximizes k
ε ⊠ δ	# Nash product	Composed goal: both agents satisfied given each other's choice

Neighbors

Other paper pages

🍞 Hedges 2018 — compositional game theory (the predecessor)
🍞 Staton 2025 — goals as postconditions = Hoare triples
🍞 Fritz 2020 — the Markov category where stochastic agents live

Related foundations

∫ Calculus Ch.5 Chain Rule — the chain rule that lens composition categorifies
🧠 Lovelace Ch.4 Neural Networks — backpropagation as the application of lens composition

Foundations (Wikipedia)

Translation notes

All examples use plain functions for optics and simple predicates for goals. The paper works with parametrised optics in a symmetric monoidal category, selection relations as profunctors, and a formal composition theorem for goals over mixed optics. For example: the agent composition on this page wires two functions sequentially. In the paper, the same construction works over a monoidal category of parametrised optics where the forward and backward channels live in different categories (the "mixed" in mixed optics), enabling agents whose learning substrate differs from their action space. The composition pattern is identical. The categorical scaffolding is not.

Ready for the real thing? arxiv

Read the paper. Start at §3 for parametrised optics, §4 for selection relations and goals.

Framework connection: The Natural Framework pipeline is a composed cybernetic system: agent composition via parametrised optics is its core structural pattern. (The Handshake, The Natural Framework)

← Hedges 2018 · 6 of 21 by june.kim Baez, Fritz 2011 · 8 of 21 →