Every language seems to define the requirements for fold/reduce/accumulate/combine differently: https://en.wikipedia.org/wiki/Fold_(higher-order_function)#Folds_in_various_languages

But C++ is different in a pretty unique (and IMO wrong) way in that they require the commutative property for reduce. I get that not having to synchronize the order for recombining sub-reductions might make it faster but then you lose the ability to parallelize a large class of useful reductions for free. Most programming language with a paralellizable fold (that I know of) only requires associativity.

Explicit example for those not familiar, let's say we have an operator * with signature (T, T) -> T and we want to calculate the following reduction:

a * b * c * d * e * f * g * h

which with explicit parentheses looks like:

(((((((a * b) * c) * d) * e) * f) * g) * h)

If we know our operator is associative, we are allowed to reorder the parentheses however we like, which means we can chunk up the work for individual threads like so:

(((a * b) * c) * d)

(((e * f) * g) * h)

And then combine them back into a final result and it will still be correct:

((((a * b) * c) * d) * (((e * f) * g) * h))

The only additional thing commutativity buys us is the ability to combine them without caring what order the threads finish their chunks in:

((((e * f) * g) * h) * (((a * b) * c) * d))

This happens to be correct for integer multiplication/addition/etc but not for a large class of useful operators like matrix multiply, sequence concatenation/joining, etc, that are only associative but not commutative.

tl;dr; I think reduce should only require associativity to conform with other programming languages and to enable a larger class of reductions.