>>> :{
 differentiableSin_ :: RevDiff t Float Float -> RevDiff t Float Float
 differentiableSin_ (MkRevDiff v bp) = MkRevDiff (sin v) (bp . (cos v *))
:}

>>> value $ differentiableSin_ (MkRevDiff 0.0 id)
0.0

>>> backprop (differentiableSin_ (MkRevDiff 0.0 id)) 1.0
1.0

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import GHC.Integer (Integer)

>>> x = variable "x"

Using numeric literals in automatic differentiation

This instance allows RevDiff values to be created directly from integer literals, eliminating the need for explicit conversion functions.

Consider computing the partial derivative:

\[ \left.\frac{\partial}{\partial y} (x \cdot y)\right|_{y=2} \]

Without the Num instance, we would need explicit conversion:

>>> simplify $ twoArgsDerivativeOverY (*) x (stopDiff $ number 2) :: SE
x

With the Num instance for RevDiff, this simplifies to:

>>> simplify $ twoArgsDerivativeOverY (*) x (number 2) :: SE
x

And combined with the Num instance for SE, we achieve the most concise form:

>>> simplify $ twoArgsDerivativeOverY (*) x 2
x

This progression shows how the typeclass instances work together to enable increasingly natural mathematical notation.

Power function differentiation

The instance enables natural exponentiation syntax with automatic differentiation:

>>> x ** 3 :: SE
x^3
>>> simplify $ simpleDerivative (** 3) x :: SE
3*(x^2)
>>> simplify $ simpleDerivative (simpleDerivative (** 3)) x :: SE
(2*x)*3

Absolute value and signum functions

The instance provides symbolic differentiation for absolute value and signum:

>>> simplify $ simpleDerivative GHCN.abs (variable "x") :: SE
sign(x)

>>> simplify $ simpleDerivative GHCN.signum (variable "x") :: SE
0

For numeric evaluation, the second derivative of absolute value at a point gives the expected result:

>>> (simpleDerivative (simpleDerivative GHCN.abs)) (1 :: Float) :: Float
0.0

Notice that the signum function returns zero for all values, including zero.

>>> simpleDerivative GHCN.signum (0 :: Float) :: Float
0.0

>>> simplify $ (simpleDerivative (simpleDerivative GHCN.abs)) (variable "x") :: SE
0

>>> import GHC.Float (Float)
>>> import Debug.SimpleExpr (variable, SE, simplify)

>>> f x = 8 / x
>>> simpleDerivative f (2.0 :: Float)
-2.0
>>> simplify $ simpleDerivative f (variable "x") :: SE
-((8/x)/x)

>>> :{
 differentiableCos_ :: DifferentiableFunc Float Float
 differentiableCos_ (MkRevDiff x bpc) = MkRevDiff (cos x) (bpc . ((negate $ sin x) *))
:}

>>> call differentiableCos_ 0.0
1.0

>>> simpleDerivative differentiableCos_ 0.0
-0.0

>>> :{
  differentiableCos_ :: RevDiff t Float Float -> RevDiff t Float Float
  differentiableCos_ (MkRevDiff v bp) = MkRevDiff (cos v) (bp . negate . (sin v *))
:}

>>> value $ differentiableCos_ (initDiff 0.0)
1.0

>>> backprop (differentiableCos_ (initDiff 0.0)) 1.0
-0.0

>>> import Debug.SimpleExpr (variable)
>>> import Debug.DiffExpr (unarySymbolicFunc)

>>> :{
 differentiableCos_ :: RevDiff t Float Float -> RevDiff t Float Float
 differentiableCos_ (MkRevDiff v bp) = MkRevDiff (cos v) (bp . negate . (sin v *))
:}

>>> call differentiableCos_ 0.0
1.0

>>> x = variable "x"
>>> f = unarySymbolicFunc "f"
>>> f x
f(x)

>>> call f x
f(x)

>>> import Debug.SimpleExpr (variable)
>>> import Debug.DiffExpr (unarySymbolicFunc)

>>> :{
  differentiableSin_ :: RevDiff t Float Float -> RevDiff t Float Float
  differentiableSin_ (MkRevDiff v bp) = MkRevDiff (sin v) (bp . (cos v *))
:}

>>> (derivativeOp differentiableSin_ 0.0) 1.0
1.0

>>> c = variable "c"
>>> x = variable "x"
>>> f = unarySymbolicFunc "f"
>>> f x
f(x)
>>> (derivativeOp f x) c
f'(x)*c

>>> value (constDiff 42.0 :: RevDiff' Float Float)
42.0

>>> backprop (constDiff 42.0 :: RevDiff' Float Float) 1.0
0.0

>>> :{
   simpleDerivative
     (\x -> x * twoArgsDerivativeOverY (+) x (stopDiff (1 :: Float)))
     (2024 :: Float)
:}
1.0

>>> :{
 differentiableCos_ :: RevDiff t Float Float -> RevDiff t Float Float
 differentiableCos_ = simpleDifferentiableFunc cos (negate . sin)
:}

>>> call differentiableCos_ 0.0
1.0

>>> simpleDerivative differentiableCos_ 0.0
-0.0

>>> import Optics (Lens', lens, view, set, getting, (%))
>>> import Debug.SimpleExpr (variable, SE)

>>> sinLens = toLens sin :: Lens' SE SE
>>> x = variable "x"
>>> c = variable "c"
>>> (view . getting) sinLens x
sin(x)
>>> set sinLens c x
cos(x)*c
>>> squareLens = toLens (^2) :: Lens' SE SE
>>> (view . getting) (squareLens % sinLens) x
sin(x^2)

>>> import Optics (lens)
>>> import Debug.SimpleExpr (variable, SE, simplify)

>>> sinV2 = fromLens $ lens sin (\x -> (cos x *))
>>> x = variable "x"
>>> c = variable "c"
>>> call sinV2 x
sin(x)
>>> simplify $ simpleDerivative sinV2 x :: SE
cos(x)

>>> :{
 sphericToVector :: (TrigField a) =>
   (a, a) -> BoxedVector 3 a
 sphericToVector (theta, phi) =
   DVGS.fromTuple (cos theta * cos phi, cos theta * sin phi, sin theta)
:}

>>> sphericToVector' = customArgValDerivative autoArg boxedVectorVal sphericToVector
>>> sphericToVector' (0 :: Float, 0 :: Float)
Vector [(0.0,0.0),(0.0,1.0),(1.0,0.0)]

>>> :{
   sphericToVector :: (TrigField a) =>
     (a, a) -> BoxedVector 3 a
   sphericToVector (theta, phi) = DVGS.fromTuple (cos theta * cos phi, cos theta * sin phi, sin theta)
:}

>>> sphericToVector' = customArgValDerivative tupleArg autoVal sphericToVector
>>> sphericToVector' (0 :: Float, 0 :: Float)
Vector [(0.0,0.0),(0.0,1.0),(1.0,0.0)]

>>> f = sin :: TrigField a => a -> a
>>> f' = sameTypeDerivative f :: Float -> Float

>>> f' 0.0
1.0

>>> import Debug.SimpleExpr (variable, simplify, SimpleExpr)
>>> import Debug.DiffExpr (unarySymbolicFunc)

>>> simpleDerivative sin (0.0 :: Float)
1.0

>>> x = variable "x"

>>> simplify $ simpleDerivative (^ 2) x
2*x

>>> f = unarySymbolicFunc "f"

>>> simplify $ simpleDerivative f x :: SimpleExpr
f'(x)

>>> import Debug.SimpleExpr (variable, simplify, SimpleExpr)
>>> import Debug.DiffExpr (unarySymbolicFunc)

>>> simpleValueAndDerivative sin (0.0 :: Float)
(0.0,1.0)

>>> x = variable "x"
>>> f = unarySymbolicFunc "f"

>>> simplify $ simpleValueAndDerivative f x :: (SimpleExpr, SimpleExpr)
(f(x),f'(x))

>>> :{
   sphericToVec :: (TrigField a) =>
     (a, a) -> BoxedVector 3 a
   sphericToVec (theta, phi) = DVGS.fromTuple (cos theta * cos phi, cos theta * sin phi, sin theta)
:}

>>> sphericToVec' = customArgDerivative tupleArg sphericToVec

Here tupleArg indicates that the argument type is a tuple.

>>> sphericToVec' (0 :: Float, 0 :: Float)
Vector [(0.0,0.0),(0.0,1.0),(1.0,0.0)]

>>> :{
   sphericToVector :: (TrigField a) =>
     (a, a) -> BoxedVector 3 a
   sphericToVector (theta, phi) = DVGS.fromTuple (cos theta * cos phi, cos theta * sin phi, sin theta)
:}

>>> sphericToVector' = customValDerivative boxedVectorVal sphericToVector

The term boxedVectorVal specifies that the output value type is a boxed vector.

>>> sphericToVector' (0 :: Float, 0 :: Float)
Vector [(0.0,0.0),(0.0,1.0),(1.0,0.0)]

>>> :{
   sphericToVec :: (TrigField a) =>
     (a, a) -> BoxedVector 3 a
   sphericToVec (theta, phi) = DVGS.fromTuple (cos theta * cos phi, cos theta * sin phi, sin theta)
:}

>>> sphericToVec' = customArgValDerivative tupleArg boxedVectorVal sphericToVec

Here tupleArg manifests that the argument type is a tuple. The second term boxedVectorVal specifies that the output value type is a boxed vector.

>>> sphericToVec' (0 :: Float, 0 :: Float)
Vector [(0.0,0.0),(0.0,1.0),(1.0,0.0)]

>>> import Debug.SimpleExpr (variable, SE, simplify)

>>> simplify $ simpleDerivative differentiableLog (variable "x") :: SE
1/x

>>> call differentiableSin 0.0 :: Float
0.0
>>> simpleDerivative differentiableSin 0.0 :: Float
1.0

>>> call differentiableCos 0.0 :: Float
1.0
>>> simpleDerivative differentiableCos 0.0 :: Float
-0.0

>>> call differentiableTan 0.0 :: Float
0.0
>>> simpleDerivative differentiableTan 0.0 :: Float
1.0

>>> call differentiableSinh 0.0 :: Float
0.0
>>> simpleDerivative differentiableSinh 0.0 :: Float
1.0

>>> call differentiableCosh 0.0 :: Float
1.0
>>> simpleDerivative differentiableCosh 0.0 :: Float
0.0

>>> call differentiableTanh 0.0 :: Float
0.0
>>> simpleDerivative differentiableTanh 0.0 :: Float
1.0

>>> call differentiableAsin 0.0 :: Float
0.0
>>> simpleDerivative differentiableAsin 0.0 :: Float
1.0

>>> call differentiableAcos 0.0 :: Float
1.5707964
>>> simpleDerivative differentiableAcos 0.0 :: Float
-1.0

>>> call differentiableAtan 0.0 :: Float
0.0
>>> simpleDerivative differentiableAtan 0.0 :: Float
1.0

>>> call differentiableAsinh 0.0 :: Float
0.0
>>> simpleDerivative differentiableAsinh 0.0 :: Float
1.0

>>> call differentiableAtanh 0.0 :: Float
0.0
>>> simpleDerivative differentiableAtanh 0.0 :: Float
1.0

>>> import Debug.DiffExpr (unarySymbolicFunc, SymbolicFunc)
>>> import Debug.SimpleExpr (variable, SimpleExpr, simplify, SE)

>>> scalarArgDerivative = customArgDerivative scalarArg

>>> t = variable "t"
>>> :{
  v :: SymbolicFunc  a => a -> BoxedVector 3 a
  v t = DVGS.fromTuple (
     unarySymbolicFunc "v_x" t,
     unarySymbolicFunc "v_y" t,
     unarySymbolicFunc "v_z" t
   )
:}

>>> v t
Vector [v_x(t),v_y(t),v_z(t)]

>>> v' = simplify . scalarArgDerivative v :: SE -> BoxedVector 3 SE
>>> v' t
Vector [v_x'(t),v_y'(t),v_z'(t)]

>>> :{
   product :: (Multiplicative a) => (a, a) -> a
   product (x, y) = x * y
:}

>>> product' = customArgValDerivative tupleArg scalarVal product

>>> product' (2 :: Float, 3 :: Float)
(3.0,2.0)

>>> import Debug.SimpleExpr (variable, simplify, SimpleExpr)
>>> x = variable "x"
>>> y = variable "y"
>>> simplify $ product' (x, y) :: (SimpleExpr, SimpleExpr)
(y,x)

>>> import Debug.SimpleExpr (variable, simplify, SE)

>>> :{
  f :: TrigField a => a -> (a, a)
  f t = (cos t, sin t)
:}

>>> f' = scalarArgDerivative f

>>> f (0 :: Float)
(1.0,0.0)
>>> f' (0 :: Float)
(-0.0,1.0)

>>> t = variable "t"
>>> f t
(cos(t),sin(t))
>>> simplify $ scalarArgDerivative f t :: (SE, SE)
(-(sin(t)),cos(t))

>>> import Debug.SimpleExpr (variable, simplify, SE)

>>> :{
  f :: Additive a => (a, a) -> a
  f (x, y) = x + y
:}

>>> f (2 :: Float, 3 :: Float)
5.0
>>> x = variable "x"
>>> y = variable "y"
>>> f (x, y)
x+y

>>> :{
  f' :: (Additive a, Distributive (CT a)) => (a, a) -> (CT a, CT a)
  f' = scalarValDerivative f
:}

>>> f' (2 :: Float, 3 :: Float)
(1.0,1.0)
>>> simplify $ f' (x, y) :: (SE, SE)
(1,1)

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import Debug.DiffExpr (SymbolicFunc, unarySymbolicFunc)

>>> :{
  f :: Multiplicative a => (a, a) -> a
  f (x, y) = x * y
:}

>>> :{
  f' :: (Distributive a, CT a ~ a) => (a, a) -> (a, a)
  f' = customArgDerivative tupleArg f
:}

>>> simplify $ f' (variable "x", variable "y")
(y,x)

>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.DiffExpr (SymbolicFunc, unarySymbolicFunc)

>>> :{
  x = variable "x"
  y = variable "y"
  f :: SymbolicFunc a => a -> a
  f = unarySymbolicFunc "f"
  g :: SymbolicFunc a => a -> a
  g = unarySymbolicFunc "g"
  h :: (SymbolicFunc a, Multiplicative a) => (a, a) -> a
  h (x, y) = f x * g y
:}

>>> f(x)*g(y)
f(x)*g(y)

>>> :{
 h' :: (SE, SE) -> (SE, SE)
 h' = simplify . tupleArgDerivative h
:}

>>> h' (x, y)
(f'(x)*g(y),g'(y)*f(x))

>>> :{
 h'' :: (SE, SE) -> ((SE, SE), (SE, SE))
 h'' = simplify . tupleArgDerivative (tupleArgDerivative h)
:}

>>> h'' (x, y)
((f''(x)*g(y),g'(y)*f'(x)),(f'(x)*g'(y),g''(y)*f(x)))

>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.DiffExpr (SymbolicFunc, unarySymbolicFunc)

>>> :{
  x = variable "x"
  y = variable "y"
  f :: SymbolicFunc a => a -> a
  f = unarySymbolicFunc "f"
  g :: SymbolicFunc a => a -> a
  g = unarySymbolicFunc "g"
  h :: (SymbolicFunc a, Multiplicative a) => (a, a) -> a
  h (x, y) = f x * g y
:}

>>> f(x)*g(y)
f(x)*g(y)

>>> :{
 h' :: (SE, SE) -> SE
 h' = simplify . tupleDerivativeOverX h
:}

>>> h' (x, y)
f'(x)*g(y)

>>> :{
 h'' :: (SE, SE) -> SE
 h'' = simplify . tupleDerivativeOverX (tupleDerivativeOverX h)
:}

>>> h'' (x, y)
f''(x)*g(y)

>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.DiffExpr (SymbolicFunc, unarySymbolicFunc)

>>> :{
  x = variable "x"
  y = variable "y"
  f :: SymbolicFunc a => a -> a
  f = unarySymbolicFunc "f"
  g :: SymbolicFunc a => a -> a
  g = unarySymbolicFunc "g"
  h :: (SymbolicFunc a, Multiplicative a) => (a, a) -> a
  h (x, y) = f x * g y
:}

>>> f(x)*g(y)
f(x)*g(y)

>>> :{
 h' :: (SE, SE) -> SE
 h' = simplify . tupleDerivativeOverY h
:}

>>> h' (x, y)
g'(y)*f(x)

>>> :{
 h'' :: (SE, SE) -> SE
 h'' = simplify . tupleDerivativeOverY (tupleDerivativeOverY h)
:}

>>> h'' (x, y)
g''(y)*f(x)

>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.DiffExpr (SymbolicFunc, unarySymbolicFunc)

>>> :{
  x = variable "x"
  y = variable "y"
  f :: SymbolicFunc a => a -> a
  f = unarySymbolicFunc "f"
  g :: SymbolicFunc a => a -> a
  g = unarySymbolicFunc "g"
  h :: (SymbolicFunc a, Multiplicative a) => a -> a -> a
  h x y = f x * g y
:}

>>> f(x)*g(y)
f(x)*g(y)

>>> :{
 h' :: SE -> SE -> (SE, SE)
 h' = simplify . twoArgsDerivative h
:}

>>> h' x y
(f'(x)*g(y),g'(y)*f(x))

>>> :{
 h'' :: SE -> SE -> ((SE, SE), (SE, SE))
 h'' = simplify . twoArgsDerivative (twoArgsDerivative h)
:}

>>> h'' x y
((f''(x)*g(y),g'(y)*f'(x)),(f'(x)*g'(y),g''(y)*f(x)))

>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.DiffExpr (SymbolicFunc, unarySymbolicFunc)

>>> :{
  x = variable "x"
  y = variable "y"
  f :: SymbolicFunc a => a -> a
  f = unarySymbolicFunc "f"
  g :: SymbolicFunc a => a -> a
  g = unarySymbolicFunc "g"
  h :: (SymbolicFunc a, Multiplicative a) => a -> a -> a
  h x y = f x * g y
:}

>>> f(x)*g(y)
f(x)*g(y)

>>> :{
 h' :: SE -> SE -> SE
 h' = simplify . twoArgsDerivativeOverX h
:}

>>> h' x y
f'(x)*g(y)

>>> :{
 h'' :: SE -> SE -> SE
 h'' = simplify . twoArgsDerivativeOverX (twoArgsDerivativeOverX h)
:}

>>> h'' x y
f''(x)*g(y)

>>> import Debug.SimpleExpr (variable, simplify, SE)

>>> :{
 f :: TrigField a => a -> (a, a)
 f x = (sin x, cos x)
:}

>>> f (variable "x")
(sin(x),cos(x))

>>> :{
 f' :: SE -> (SE, SE)
 f' = simplify . tupleValDerivative f
:}

>>> f' (variable "x")
(cos(x),-(sin(x)))

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import Debug.DiffExpr (SymbolicFunc, unarySymbolicFunc)

>>> :{
  f :: Multiplicative a => (a, a, a) -> a
  f (x, y, z) = x * y * z
:}

>>> :{
  f' :: (Distributive a, CT a ~ a) => (a, a, a) -> (a, a, a)
  f' = customArgDerivative tripleArg f
:}

>>> simplify $ f' (variable "x", variable "y", variable "z")
(y*z,x*z,x*y)

>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.SimpleExpr.Utils.Algebra (AlgebraicPower, square, MultiplicativeAction)
>>> import Debug.DiffExpr (SymbolicFunc)

>>> :{
  x = variable "x"
  y = variable "y"
  z = variable "z"
  norm :: (AlgebraicPower Integer a, Additive a) => (a, a, a) -> a
  norm (x, y, z) = square x + square y + square z
:}

>>> norm (x, y, z)
((x^2)+(y^2))+(z^2)

>>> :{
 norm' :: (SE, SE, SE) -> (SE, SE, SE)
 norm' = simplify . tripleArgDerivative norm
:}

>>> simplify $ norm' (x, y, z)
(2*x,2*y,2*z)

>>> :{
 norm'' :: (SE, SE, SE) -> ((SE, SE, SE), (SE, SE, SE), (SE, SE, SE))
 norm'' = simplify . tripleArgDerivative (tripleArgDerivative norm)
:}

>>> norm'' (x, y, z)
((2,0,0),(0,2,0),(0,0,2))

>>> import Debug.SimpleExpr (variable, simplify, SE)

>>> :{
 f :: (Multiplicative a, IntegerPower a) => a -> (a, a, a)
 f x = (one, x^1, x^2)
:}

>>> f (variable "x")
(1,x^1,x^2)

>>> :{
 f' :: SE -> (SE, SE, SE)
 f' = simplify . tripleValDerivative f
:}

>>> f' (variable "x")
(0,1,2*x)

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import Debug.DiffExpr (SymbolicFunc, unarySymbolicFunc)

>>> :{
  f :: Additive a => BoxedVector 3 a -> a
  f = boxedVectorSum
:}

>>> :{
  f' :: (Distributive a, CT a ~ a) => BoxedVector 3 a -> BoxedVector 3 a
  f' = customArgDerivative boxedVectorArg f
:}

>>> simplify $ f' (DVGS.fromTuple (variable "x", variable "y", variable "z"))
Vector [1,1,1]

>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.DiffExpr (SymbolicFunc)
>>> import Numeric.InfBackprop.Utils.SizedVector (BoxedVector, boxedVectorSum)
>>> import Debug.SimpleExpr.Utils.Algebra (AlgebraicPower, (^))

>>> :{
  x = variable "x"
  y = variable "y"
  z = variable "z"
  r = DVGS.fromTuple (x, y, z) :: BoxedVector 3 SE
  norm2 :: (AlgebraicPower Integer a, Additive a) => BoxedVector 3 a -> a
  norm2 v = boxedVectorSum (v^2)
:}

>>> simplify $ norm2 r
((x^2)+(y^2))+(z^2)

>>> :{
 norm2' :: BoxedVector 3 SE -> BoxedVector 3 SE
 norm2' = simplify . boxedVectorArgDerivative norm2
:}

>>> norm2' r
Vector [2*x,2*y,2*z]

>>> :{
 norm2'' :: BoxedVector 3 SE -> BoxedVector 3 (BoxedVector 3 SE)
 norm2'' = simplify . boxedVectorArgDerivative (boxedVectorArgDerivative norm2)
:}

>>> norm2'' r
Vector [Vector [2,0,0],Vector [0,2,0],Vector [0,0,2]]

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import Debug.DiffExpr (unarySymbolicFunc, SymbolicFunc)

>>> :{
  v :: SymbolicFunc a => a -> BoxedVector 3 a
  v t = DVGS.fromTuple (
     unarySymbolicFunc "v_x" t,
     unarySymbolicFunc "v_y" t,
     unarySymbolicFunc "v_z" t
   )
:}

>>> t = variable "t"
>>> v t
Vector [v_x(t),v_y(t),v_z(t)]

>>> v' = simplify . customValDerivative boxedVectorVal v :: SE -> BoxedVector 3 SE
>>> v' t
Vector [v_x'(t),v_y'(t),v_z'(t)]

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import Debug.DiffExpr (unarySymbolicFunc, SymbolicFunc)

>>> :{
  v :: SymbolicFunc a => a -> BoxedVector 3 a
  v t = DVGS.fromTuple (
     unarySymbolicFunc "v_x" t,
     unarySymbolicFunc "v_y" t,
     unarySymbolicFunc "v_z" t
   )
:}

>>> t = variable "t"
>>> v t
Vector [v_x(t),v_y(t),v_z(t)]

>>> v' = simplify . boxedVectorValDerivative v :: SE -> BoxedVector 3 SE
>>> v' t
Vector [v_x'(t),v_y'(t),v_z'(t)]

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import GHC.Base ((<>))

>>> :{
  f :: Additive a => Stream a -> a
  f = NumHask.sum . Data.Stream.take 4 :: Additive a => Data.Stream.Stream a -> a
:}

>>> :{
  f' :: (Distributive a, CT a ~ a) => Stream a -> FiniteSupportStream a
  f' = customArgDerivative streamArg f
:}

>>> s = Data.Stream.fromList [variable ("s_" <> show n) | n <- [0 :: Int ..]] :: Data.Stream.Stream SE
>>> simplify $ f' s
[1,1,1,1,0,0,0,...

>>> import GHC.Base ((<>))
>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.DiffExpr (SymbolicFunc)
>>> import Data.Stream (Stream, fromList, take)

>>> s = fromList [variable ("s_" <> show n) | n <- [0 :: Int ..]] :: Stream SE

>>> take4Sum = NumHask.sum . take 4 :: Additive a => Stream a -> a
>>> simplify $ take4Sum s :: SE
s_0+(s_1+(s_2+s_3))

>>> :{
 take4Sum' :: (Distributive a, CT a ~ a) =>
   Stream a -> FiniteSupportStream (CT a)
 take4Sum' = streamArgDerivative take4Sum
:}

>>> simplify $ take4Sum' s
[1,1,1,1,0,0,0,...

>>> :{
 take4Sum'' :: (Distributive a, CT a ~ a) =>
   Stream a -> FiniteSupportStream (FiniteSupportStream (CT a))
 take4Sum'' = streamArgDerivative (streamArgDerivative take4Sum)
:}

>>> simplify $ take4Sum'' s
[[0,0,0,...,[0,0,0,...,[0,0,0,...,...

>>> import GHC.Base ((<>))
>>> import Data.Stream (Stream, fromList, take)
>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import Debug.DiffExpr (unarySymbolicFunc, SymbolicFunc)

>>> :{
  s :: SymbolicFunc a => a -> Stream a
  s t = fromList [unarySymbolicFunc ("s_" <> show n) t | n <- [0..]]
:}

>>> t = variable "t"
>>> take 5 (s t)
[s_0(t),s_1(t),s_2(t),s_3(t),s_4(t)]

>>> :{
  s' :: SE -> Stream SE
  s' = simplify . customValDerivative streamVal s
:}

>>> take 5 (s' t)
[s_0'(t),s_1'(t),s_2'(t),s_3'(t),s_4'(t)]

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import Data.FiniteSupportStream (unsafeFromList, toVector)

>>> :{
  f :: Additive a => FiniteSupportStream a -> a
  f = NumHask.sum . toVector
:}

>>> f (unsafeFromList [1, 2, 3])
6

>>> :{
  f' :: (Distributive a, CT a ~ a) => FiniteSupportStream a -> Stream a
  f' = customArgDerivative finiteSupportStreamArg f
:}

>>> Data.Stream.take 5 $ f' (unsafeFromList [1, 2, 3])
[1,1,1,0,0]

>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.DiffExpr (SymbolicFunc)
>>> import Data.Stream (Stream, take)
>>> import Data.FiniteSupportStream (FiniteSupportStream, unsafeFromList, toVector)
>>> import NumHask (sum)

Define a finite support stream with support length 4 containing 4 symbolic variables.

>>> s = unsafeFromList [variable "s_0", variable "s_1", variable "s_2", variable "s_3"] :: FiniteSupportStream SE
>>> s
[s_0,s_1,s_2,s_3,0,0,0,...

Now we'll define a function that sums all elements of a finite support stream.

>>> finiteSupportStreamSum = sum . toVector :: Additive a => FiniteSupportStream a -> a
>>> simplify $ finiteSupportStreamSum s :: SE
s_0+(s_1+(s_2+s_3))

We compute the gradient of this function.

>>> :{
 finiteSupportStreamSum' :: (Distributive a, CT a ~ a) =>
   FiniteSupportStream a -> Stream (CT a)
 finiteSupportStreamSum' = finiteSupportStreamArgDerivative finiteSupportStreamSum
:}

Let's compute the gradient at point s. It is an infinite stream and we take first 7 elements:

>>> take 7 $ simplify $ finiteSupportStreamSum' s
[1,1,1,1,0,0,0]

As expected, the gradient is a stream with 1's in the first four positions (corresponding to our four variables and the fixed support length 4) and 0's elsewhere:

We can compute the second derivative (Hessian matrix) that is stream of streams in our case.

>>> :{
 finiteSupportStreamSum'' :: (Distributive a, CT a ~ a) =>
   FiniteSupportStream a -> Stream (Stream (CT a))
 finiteSupportStreamSum'' = finiteSupportStreamArgDerivative (finiteSupportStreamArgDerivative finiteSupportStreamSum)
:}

All second derivatives should all be zero. We take first 7 rows and 4 columns of the inifinite Hessian matrix:

>>> take 7 $ fmap (take 4) $ simplify $ finiteSupportStreamSum'' s
[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import Debug.DiffExpr (unarySymbolicFunc, SymbolicFunc)
>>> import Data.FiniteSupportStream (unsafeFromList, FiniteSupportStream)

>>> :{
 fss :: (Multiplicative a, IntegerPower a) =>
   a -> FiniteSupportStream a
 fss t = unsafeFromList [t^3, t^2, t, one]
:}

>>> t = variable "t"
>>> fss t
[t^3,t^2,t,1,0,0,0,...

>>> :{
  fss' :: SE -> FiniteSupportStream SE
  fss' = simplify . customValDerivative finiteSupportStreamVal fss
:}

>>> (fss' t)
[3*(t^2),2*t,1,0,0,0,...

>>> import Debug.SimpleExpr (variable, SE, simplify)
>>> import Debug.DiffExpr (unarySymbolicFunc, SymbolicFunc)
>>> import Data.FiniteSupportStream (unsafeFromList, FiniteSupportStream)

>>> :{
 fss :: (Multiplicative a, IntegerPower a) =>
   a -> FiniteSupportStream a
 fss t = unsafeFromList [t^3, t^2, t, one]
:}

>>> t = variable "t"
>>> fss t
[t^3,t^2,t,1,0,0,0,...

>>> :{
  fss' :: SE -> FiniteSupportStream SE
  fss' = simplify . finiteSupportStreamValDerivative fss
:}

>>> fss' t
[3*(t^2),2*t,1,0,0,0,...

>>> :{
 f :: Additive a => Maybe a -> a
 f (Just x) = x
 f Nothing = zero
:}

>>> customArgDerivative maybeArg f (Just 3 :: Maybe Float) :: Maybe Float
Just 1.0

>>> import Debug.SimpleExpr (variable, simplify, SE)
>>> import Debug.DiffExpr (SymbolicFunc)
>>> import qualified GHC.Num as GHCN

>>> :{
 maybeF :: TrigField a => Maybe a -> a
 maybeF (Just x) = sin x
 maybeF Nothing = zero
:}

>>> maybeF (Just 0.0 :: Maybe Float)
0.0

>>> maybeF (Nothing :: Maybe Float)
0.0

>>> maybeArgDerivative maybeF (Just 0.0 :: Maybe Float)
Just 1.0

>>> maybeArgDerivative maybeF (Nothing :: Maybe Float)
Just 0.0