A length-indexed array used as the AD parameter for a scan.

The array stores one cotangent slot per input element. Addition and subtraction are pointwise over the underlying Array.

A single input variable: the i-th element of an n-element input.

Turn a list of inputs into a list of differentiable variables.

Each variable selects one array element in the forward pass and scatters a cotangent back to that same position in the backward pass.

A Process machine with explicit state and differentiable inject step extract functions.

The pullbacks are captured during the forward pass and then replayed by a single backward walk, so the cost of a scan gradient is linear in the input length (no closure-chain blow-up).

State for a differentiable standard deviation: a moving average together with a squared moving average.

Fold a list through a DiffProcess and return the final output together with a pullback through the entire fold.

>>> let (y, g) = diffFold (maDiffProcess 0) [1,2,3] in (y, g 1)
(3.0,[0.0,0.0,1.0])

Scan a list through a DiffProcess and return the per-step outputs together with a pullback that maps output cotangents to input cotangents.

>>> let (ys, g) = diffScan (maDiffProcess 0) [1,2,3] in (ys, g [1,1,1])
([1.0,2.0,3.0],[1.0,1.0,1.0])

A System-packaged differentiable Moore machine: state is external.

Same dynamics as DiffProcess, without inject. Matches System s (Mono i o) packaging (i = output, o = input):

dsExtract :: Diff' s i     -- output from state
dsStep    :: Diff' (s, o) s  -- next state from state and input

Pair with an initial state via diffSystemAsDiffProcess to reuse diffScan / diffFold. Agents that are Systems sit here for Diff without pretending to be Process first.

Bake in s0: inject is one step from that state (same as systemAsProcess).

diffSystemAsDiffProcess sys s0 :: DiffProcess s o i

Drop inject: keep extract and step. Initial state must be supplied again when scanning (via diffSystemAsDiffProcess or diffSystemScan).

Scan a DiffSystem from external s0 (via diffSystemAsDiffProcess).

>>> let sys = diffProcessAsDiffSystem (maDiffProcess 0)
>>> let (ys, g) = diffSystemScan sys (PS.A 0 0) [1,2,3] in (ys, g [1,1,1])
([1.0,2.0,3.0],[1.0,1.0,1.0])

Fold a DiffSystem from external s0.

Fold a list through a differentiable mealy and return the final output together with a pullback through the entire fold.

>>> let m = PS.asum :: PS.Process (Diff' (GradInputs Double) Double) (Diff' (GradInputs Double) Double); (y, g) = gradFold m [1,2,3] in (y, g 1)
(6.0,[1.0,1.0,1.0])

Scan a list through a differentiable mealy and return the per-step outputs together with a pullback that maps a list of output cotangents (one per step) to input cotangents.

>>> let m = PS.asum :: PS.Process (Diff' (GradInputs Double) Double) (Diff' (GradInputs Double) Double) in snd (gradScan m [1,2,3]) [1,1,1]
[3.0,2.0,1.0]

Lift a plain input value into the parameter space of a network mealy.

The value is treated as a constant: its pullback is always zero.

Fold a network mealy and return the final output together with a pullback through the parameters.

Scan a network mealy and return the per-step outputs together with a pullback that maps output cotangents to parameter cotangents.

online with a Diff carrier.

The inject and step functions now operate on differentiable values, so the resulting mealy can be placed inside netFold / netScan and the parameters inside the carrier are learned by ordinary reverse-mode AD.

Differentiable moving average with a learnable decay parameter.

Differentiable squared moving average with a learnable decay parameter.

Differentiable standard deviation with a learnable decay parameter.

online as a reverse-step DiffProcess.

Differentiable moving average as a reverse-step DiffProcess.

Differentiable squared moving average as a reverse-step DiffProcess.

>>> let (ys, g) = diffScan (sqmaDiffProcess 0) [1,2,3] in (ys, g [1,1,1])
([1.0,4.0,9.0],[2.0,4.0,6.0])

Differentiable standard deviation as a reverse-step DiffProcess.

The gradient is taken to be zero when the standard deviation is itself zero (for example, after a single sample), because the usual sqrt derivative is undefined at zero.

>>> let (ys, g) = diffScan (stdDiffProcess 0) [1,2,3] in (ys, g [1,1,1])
([0.0,0.0,0.0],[0.0,0.0,0.0])

A one-step delay as a reverse-step DiffProcess.

The initial output is a0; after that the machine emits the previous input.

>>> let (ys, g) = diffScan (delay1Diff 0) [1,2,3] in (ys, g [1,1,1])
([0,1,2],[1,1,0])

diff as a reverse-step DiffProcess.

The first output uses the supplied initial previous value a0 instead of undefined, which makes the machine differentiable. This is exactly the log-return pattern used in Anal.Returns.ret.

>>> let f = Diff $ \(p, p') -> (log (p' / p), \dy -> (negate (dy / p), dy / p'))
>>> let (ys, g) = diffScan (diffDiff 1 f) [1,2,4]
>>> (ys, g [1,1,1])
([0.0,0.6931471805599453,0.6931471805599453],[0.0,0.0,0.25])