Tea-Leaf Fingerprints

Circuits is an experiment in bundling very simple functions. Three constructors — Lift a plain function, Compose two circuits, Knot a feedback loop — and the whole thing stays open. You can rearrange, measure, annotate, or run it backwards before it ever executes. Version 0.2 adds Net, the piece we were missing for contravariant tracking: a value that flows backwards through the computation, letting us run circuits in reverse.

This post is a visual audit of what happens when you compile those bundled functions through MicroHs and stare at the shapes.

The contravariant channel

Net is the fourth structural row of Circuit.Net, completing the bimonoid:

These four operations form a bimonoid: they satisfy the laws of a commutative monoid and comonoid, interacting through the usual bialgebra axioms. The dagger — transpose — swaps fan-in and fan-out. copy becomes add, discard becomes zero. This is the one-line reveal of circuits-ad: backpropagation is just the dagger of forward evaluation, and the contravariant channel is what makes the swap structural rather than a hand-rolled reversal.

Here’s what these look like after MicroHs compiles them to combinators, then through the iota reducer into a single-combinator encoding:

The iota mandalas are radial tree diagrams. The root sits at center, edges encode application (0) or the iota combinator (1), and depth is colour-coded. Every pure function collapses to a single fingerprint — a measurable structural checksum. Change the algorithm, and the mandala shifts.

Fan-in is structurally expensive. Fan-out is trivial. This is as fundamental as it gets: addition requires recursion; copying is just pairing. The dagger tells you that reverse-mode differentiation is structurally the same cost — the expensive forward pass becomes the cheap backward one, and vice versa.

Sharing and the tensor

Circuits’ Knot with the (,) tensor ties a lazy self-referential binding. This is Haskell’s let knot, exposed as a first-class constructor:

let y = add x x in (y, y)

Computes add once and reuses the result. Without sharing, add is inlined twice:

The lazy knot is 44% cheaper at the combinator level. This is the structural analogue of common subexpression elimination, but visible in the type system — Knot with the (,) tensor is the sharing mechanism. No compiler pass, no optimization flag. It’s a constructor.

Iteration and the Either channel

The Either tensor gives you iteration. Left continues, Right exits. A counting loop that tests with Peano le:

Algorithmic complexity is invariant to input size. le is 39 nodes whether the threshold is 10 or 10,000. Only the Peano literal grows — linearly, 2 nodes per S. The comparison structure is fixed.

The Circuit GADT overhead

The GADT itself — Lift, Compose, Knot — compiles to opaque boxes around the computation:

reify adds dictionary passing — about 6 more nodes. encode via Hyper is tighter but opaque to the combinator dumper. The GADT overhead is 2–4 nodes: negligible for the structural inspection it enables.

What this shows

1. Every pure function has an iota fingerprint — a measurable structural checksum. Change the algorithm and the mandala shifts. This is a visual hash of what your program is, not what it claims to be.

2. Fan-in is structurally expensive; fan-out is trivial. Addition costs 7.8× what copying costs. Under the dagger, they swap — the circuits-ad reveal, visible at the combinator level.

3. Sharing has measurable structural cost. 44% fewer nodes for let vs inline duplication. Circuits’ (,) tensor trace achieves this via lazy knot-tying, embedded as a constructor.

4. The Circuit GADT is 2–4 nodes of overhead. reify adds dictionary passing. encode via Hyper avoids it but hides the structure. You pay for inspection, not much.

5. Algorithmic complexity is invariant to input size. le is the same 39 nodes at any threshold. Only literals grow, linearly.

---

Generated by circuits-iota · MicroHs (augustss) · iota-render (Tritlo) · circuits (tonyday567) · June 2026