Trace over a vector feedback channel, backward pass solved by starMatrix.

The channel is a list [j] whose dimension is fixed by the seed. Forward iterates from the seed (no closed form for a nonlinear fixpoint). Backward:

1. probe backward with each basis cotangent e_i to read off column i of the channel self-coupling A (in cotangent space);
2. star A by Conway block recursion — starMatrix;
3. per cotangent dc: C·dc = fst (backward (0, dc)), then db = snd (backward (star A · C·dc, dc)).

A and star A are forced once (lazily, on first pullback) and shared across cotangents.

Proof obligation: probing assumes every primitive's pullback is a genuinely linear map — true for honestly-constructed 'Diff prims.

Solve a (,) feedback body whose channel is StarChannel in closed form.

The channel type stays exposed, so the dictionary is read directly from the StarChannel value carried on the feedback wire.

A self-coupled scalar body the lazy trace diverges on, solved exactly (dj = 0.3·dj + 2·dc, db = dj, so db/dc = 2/0.7):

>>> :{
let body (FieldStar dj, dc) = (FieldStar (0.3 * dj + 2.0 * dc), dj)
    b = Body (withStarChannel fieldStarChannel (Pullback body)) :: Body (,) (StarChannel FieldStar) Pullback Double Double
:}

>>> let solved = solveStarBody b
>>> abs (runPullback solved 1.0 - 2.0 / 0.7) < 1e-12
True

traceStarFrom for a bare Double channel, routed through FieldStar so star a = recip (1 − a) is the class method, not an ad-hoc formula.

Channel x' = 0.3x + b, output c = 2x. The fixpoint is x = b/0.7, so dc/db = 2/0.7 ≈ 2.857 — the same number the Neumann iteration approaches, computed here in closed form:

>>> :{
let body = Diff (\(x, b) ->
      ( (0.3 * x + b, 2.0 * x)
      , \(dx', dc) -> (0.3 * dx' + 2.0 * dc, dx') ))
:}

>>> let (y, pb) = runDiff (traceStarFromD 0 60 body) 1.0
>>> abs (y - 2.0 / 0.7) < 1e-12
True
>>> abs (pb 1.0 - 2.0 / 0.7) < 1e-12
True

traceStarMatrix for bare [Double] channels, routed through FieldStar so starMatrix performs honest (I − A)⁻¹.

A two-dimensional channel: x' = 0.5y + b, y' = 0.3x, output c = x + 2y. Solving the fixpoint by hand: x = b/0.85, y = 0.3b/0.85, c = 1.6b/0.85, so dc/db = 1.6/0.85.

>>> :{
let body2 = Diff (\([x, y], b) ->
      ( ([0.5 * y + b, 0.3 * x], x + 2.0 * y)
      , \([dx', dy'], dc) -> ([0.3 * dy' + dc, 0.5 * dx' + 2.0 * dc], dx') ))
:}

>>> let (y2, pb2) = runDiff (traceStarMatrixD [0, 0] 200 body2) 1.0
>>> abs (y2 - 1.6 / 0.85) < 1e-12
True
>>> abs (pb2 1.0 - 1.6 / 0.85) < 1e-12
True