Fused parallel composition for Trace when the feedback tensor matches.

Two yanks in parallel superpose into one yank over a paired channel, satisfying the superposing axiom of traced monoidal categories:

superpose (trace f) (trace g) = trace (pre . tensor f g . post)

where pre and post rearrange the paired channel via associators and braiding. This preserves sharing for recursive circuits; the lawful Tensor instance falls back to independent evaluation.

>>> let k1 = yank (base (\(ns, _) -> (1 : ns, take 3 ns))) :: Trace (,) (->) [Int] [Int]
>>> let k2 = yank (base (\(ns, _) -> (2 : ns, take 3 ns)))
>>> eval (superpose k1 k2) ([], [])
([1,1,1],[2,2,2])

The same fusion works for K, preserving sharing across the recursive channels under MonadFix.

>>> let k1 = yank (base (K $ \(ns, _) -> pure (1 : ns, take 3 ns))) :: Trace (,) (K Identity) [Int] [Int]
>>> let k2 = yank (base (K $ \(ns, _) -> pure (2 : ns, take 3 ns)))
>>> runK (eval (superpose k1 k2)) ([], [])
Identity ([1,1,1],[2,2,2])

Bias for ordered choice in scheduling and additive disjunction.

LeftFirst and RightFirst are used by shared-medium fusion in Circuit.Shared and by additive disjunction in Circuit.Poles.

The unit object for a tensor t.

t is an object-level bifunctor (Either, (,), type-level (+), …) with kind k -> k -> k, not a morphism tensor.

The unit object structure of a tensor t on a category arr.

unitl and unitr witness that the tensor has a unit object. This is the planar fragment without the morphism-level tensor product: arrows that are merely unital can introduce and eliminate the unit, but cannot parallel-compose two arbitrary morphisms.

Splitting this out from Tensor matters for premonoidal arrows such as Circuit.Prob: the unitors are deterministic and embed cleanly, while the general tensor product tensor is not canonical.

Kind-polymorphic: t and arr share object kind (inferred via PolyKinds).

The tensor action of t on a category arr, without braiding.

tensor is the tensor product of morphisms (parallel composition on disjoint wires). The unitors live in the Unital superclass.

Kind-polymorphic: t and arr share object kind (inferred via PolyKinds).

The action of a tensor t on a category arr, extended with a symmetric braiding.

This is the self-action of a symmetric monoidal category: t acts on arr by taking morphisms to morphisms over paired objects, and braid provides the symmetry.

Value-level pairing for a tensor t.

Tensor gives the action of t on morphisms; TensorSeed names the canonical way to combine two values into a value of type t a b. It is needed by constructions (such as SomeBody) that store a concrete channel value alongside a body.

Not every tensor has a canonical pairing: (,) has the pair constructor, but Either has no unbiased way to combine a and b into Either a b. Consequently TensorSeed is a separate class.

Distributivity of a multiplicative tensor d over an additive tensor t.

In a distributive monoidal category the product distributes over the sum: d a (t b c) ≅ t (d a b) (d a c) and d (t a b) c ≅ t (d a c) (d b c), and the additive unit is annihilated: d a (Unit t) ≅ Unit t.

For d = (,) and t = Either this is the ordinary distributivity of cartesian product over coproduct, with (a, Void) ≅ Void.

Leftward associator: (a, (b, c)) -> ((a, b), c).

Rightward associator: ((a, b), c) -> (a, (b, c)).

Coassociator for sums.

>>> coassoc (Left 1 :: Either Int (Either Bool Char))
Left (Left 1)

Inverse coassociator.

>>> coassoc' (Left (Left 1) :: Either (Either Int Bool) Char)
Left 1

Tag a channel value onto whichever branch of the sum is active.

>>> coseed "st" (Left 42 :: Either Int Char)
Left ("st",42)

If the left branch is taken, move a value from the payload into the channel wire.

>>> coabsorbL (+) (Left (10, (3, 7)) :: Either (Int, (Int, Int)) Bool)
Left (13,7)

If the right branch is taken, move a value from the payload into the channel wire.

>>> coabsorbR (+) (Right (10, (3, 7)) :: Either Bool (Int, (Int, Int)))
Right (13,7)

If the left branch is taken, move a value from the channel wire into the payload.

>>> coreleaseL (\s -> (s+1, s*2)) (Left (5, 99) :: Either (Int, Int) Char)
Left (6,(10,99))

If the right branch is taken, move a value from the channel wire into the payload.

>>> coreleaseR (\s -> (s+1, s*2)) (Right (5, 99) :: Either Char (Int, Int))
Right (6,(10,99))