So a simple encoding of the basic AD rules leaves your Dual class, just one level up.

data D f g a = D (f a) (g a)

type family (:+>) (f :: * -> *) (g :: * -> *) :: * -> *
type family (:*>) (f :: * -> *) (g :: * -> *) :: * -> *
type family DLift (f :: (* -> *) -> * -> *) (f’ :: (* -> *) -> * -> *) (g :: * -> *) :: * -> *
type instance (D x a :+> D y b) = D (x :+: y) (a :+: b)
type instance (D x a :*> D y b) = D (x :*: y) (x :*: b :+: a :*: y)
type instance DLift f f’ (D x a) = D (f x) (a :+: f’ x)

dConst :: a -> D Identity Zero a
dConst z = D (Identity z) zero

dVar :: a -> D Identity One a
dVar z = D (Identity z) (suck zero)

I think the general AD case requires polymorphic kinds, so yeah something like Omega is probably better suited. Alas.

I left the fixed point cases off because I was still trying to get the finite cases to terminate and once I ran up against the wall of type-ability I didn’t check that what I had so far was what I thought I had so far.

It has been a while since I did anything with classical analysis. Hrmm. Back to the drawing board I guess until I figure out how to do what I really want.

a^n / n! = Bag n a

i.e. the multiset (bag) with n elements of type a. So, the power series expansion for a data type just counts how many different sets of elements it may contain. So, a :*: a contains two bags of two a (one for each permutation in the tuple).

Btw, as the differential equation for the list type suggests, we have the power series expansion
[a] = 1 + a + a^2 + a^3 + ...
which “is” 1/(1-a).

AD f a ~~ (f a, AD (D f) a)

With (Derivable f) => Functor (AD f) you only need (Derivable (D f)) to justify using bimap (fmap f) (fmap f). So, it seems like what you’d really want is:

class (Functor f, Derivable (D f)) => Derivable f where
type D f :: * -> *

instance (Derivable f) => Functor (AD f) where …

Where the context on Derivable enforces that all such functors are arbitrarily differentiable. But, of course, GHC complains about a cycle there (in 6.8, at least. I don’t have 6.9 handy).

Simplification should, I think, be possible with total type families once they go into 6.9. For instance:

type family (f :: * -> *) :+: (g :: * -> *) :: * -> * where
Zero :+: g = g
f :+: Zero = f
f :+: g = Lift Either f g

You’re allowed to overlap instances for total type families, because they’re closed.

instance Derivable [] where
type D [] = [] :*: []

I also would like to find out a way to include a simplification step in the type function to go through and do the Zero :*: x = Zero step, etc to make the encoding a little less naive.

And yeah, without a notion of type division (maybe using species?), I don’t see how to get from this form of AD to a power series.

And concerning the power series, I think what you really want is

newtype Power f a = Power (f () :+: (a :*: Power (D f) a))

but that’s wrong too, because you would have to divide by $latex \frac1{n!}$ somewhere. Power series are different from (but related to) automatic differentiation! Most likely, the impossible division can be included by using bags of n elements instead of powers a :*: a :*: ... (= ordered pairs) of n elements. In any case, the functor instance for power series is no problem, since a is used explicitly.

Not sure in the case of automatic differentiation; the main problem here is indeed to somehow tell the compiler that
instance Functor f => Functor (D f)
But since type families are open, I guess that’s not possible. I mean, a “mischievous” person could add a new case for this type family which violates this condition. So, the problem is not that the compiler doesn’t grok it, the problem is that there is a good reason that the compiler doesn’t accept it.