I met a last difficulty I didnt solve. I didnt see it 4 hours ago because of the sample limitation at dimension 2.

If I work on :

Inner[dwproduct, ( {
   {1, On, 0, 0},
   {On, 1, On, On},
   {0, On, 1, 0},
   {0, On, 0, 1}
  } ), ( { {V},{N},{N},{N} } ), wsum]

The given result is

{
 {wsum[V, N, 0, 0]},
 {wsum[V, N, N, N]},
 {wsum[0, N, N, 0]},
 {wsum[0, N, 0, N]}
}

So, how to define wsum a general/generic way to avoid specialize for each tuple ? (i probably will compute samples with matrices at dimension 600 and more)

Could I imagine something recursive (or not) that will transfer "evaluation capability" to binary operation ?

Let's say wsum[x1,x2,x3,...,xn]= ((((x1)+x2)+x3)+...)+xn

This might also be interesting: Operators without Built In Meanings

In[1]:= CirclePlus[a, b] = b

Out[1]= b

In[2]:= a \[CirclePlus] b

Out[2]= b

(Note that [CirclePlus] can be entered as esc c+ esc and looks like a CirclePlus symbol in an actual notebook.)

To use pattern matching to turn an enumeration into a function, define your "plus" function as follows:

plus[a,a]=a
plus[a,b]=b
plus[b,a]=b
...

When the left hand side matches, the right hand side replaces it. Note that a and b are not named function arguments (that would be a_ and b_), but literal symbols that must match the symbols in those slots for the definition to take effect.

Write your own add and multiply functions. Combine them using Inner to make your matrix product function.

What you are looking for probably already exists: matrix operations and vector + matrices

but you can define your own as well