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 predicates on optics. An agent is a parametrised optic (forward pass + backward pass) with a selection relation that says which actions are "good enough." 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 gets updated by learning.

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 predicates

In Hedges 2018, a selection function picks the best action. Capucci generalizes to a selection relation: a predicate that says which actions are acceptable. Not "the best action" but "any action that's good enough." This is the cybernetic goal — a predicate on the optic's choices.

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 are on parametrised optics in a monoidal category. Same 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 composition of goals is: the whole system satisfies the goal if each agent satisfies its local goal given the context provided by the other.

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 like postconditions

This is the bridge to Staton's Hoare logic. A goal on a composed system decomposes into goals on sub-agents — exactly like a Hoare postcondition decomposes via COMP. The "handshake" is the interface between agents. Cybernetic composition IS program composition, with the backward pass added for learning.

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: Analogy. The goal-composition pattern is the same. The paper works with parametrised optics in a monoidal category, not plain function chains.

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 × K^X	(satisfies? goal action ctx)	Selection relation
G₁ ; G₂	(compose-optics o1 o2)	Sequential composition
BestResp	# predicate on actions	Best response as goal predicate

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 →