Not quite sure what you mean by invertible, or why you want it - it does not seem necessary for your accumulator definition. So ignoring that for now ....
How about min, max ?
Or count ?
If you admit composite accumulators with additional state, then you can have average (mean), because you can store { count, mean } and update:
count' = count + 1
mean' = (count*mean + n) / count'
or perhaps store { count, sum, mean } where
count' = count + 1
sum' = sum + n
mean' = sum' / count'
It seems like you want a monoid: an associative binary operator with an identity.
The identity value is the starting value of your accumulator.
The associative property means the order of application is irrelevant.
For more information see An Introduction to the Bird-Meertens Formalism, by Jeremy Gibbons.
In functional programming, your problem is equivalent to finding list homomorphisms, which are functions of lists (f) that can be expressed with a monoid (#) and the list concatenation operator (++), such that:
f (a ++ b) = (f a) # (f b)
i.e. applying a function to the whole list can be decomposed into applying the function to 2 sublists and combining the 2 results with a new binary operator. The Third Homomorphism Theorem (see another paper by Gibbons) states that if you can find two implementations for the function f, one accumulating from the left (foldl) and one accumulating from the right (foldr) then you can find the monoid operator and the function can be calculated in any order, or in parallel. An excellent paper on the subject is Automatic Inversion Generates Divide-and-Conquer Parallel Programs.
Mik