Is it possible to get the order of inputs when "overloading" an orderless function?

Question

When working with symbolic matrix operations or other objects which don't have commutative multiplication, it would be nice to not have to constantly switch out times for NonCommutativeMultiply (**). So I was wondering if there is a way to do something like

matrix /: Times[pre___, a_matrix, post___] :=  NonCommutativeMultiply[pre, a, post]
a = matrix["a"];
b = matrix["b"];

and then have it replaced automatically. However since Times is orderless, this doesn't preserve the order. In general, is it impossible to get the order of inputs when doing this kind of "overloading" though upvalues of an orderless function?

Answer 1

Well, you can sort of do this, by creating something like a continuation. This requires playing games with the Stack, and I don't claim that it is robust, but it may represent some theoretical interest, particularly to those of us looking for ways to implement continuations in Mathematica. Here is the code (edit please note that I had to add Update[matrix] to address some improper behavior noted in the comments end edit):

ClearAll[matrix, inMatrix];
matrix /: HoldPattern[Times[pre___, a_matrix, post___]] :=
  (
      Update[matrix];
      ReleaseHold[NonCommutativeMultiply @@@ $stack]
  );
matrix[args__] /; ! TrueQ[inMatrix] :=
  Block[{inMatrix = True},
    Update[matrix];
    $stack = Stack[_][[-5]];
    matrix[args]]

It combines UpValues, Villegas-Gayley trick to redefine a function, and manipuations with Stack. What happens is that first, of course, the attributes of Times are applied, I can't fight that. Then, the DownValues of matrix are applied, and at this point I record the relevant part of the Stack. Then, UpValues of matrix are applied, and at that point I communicate the recorded part of the stack, where the attributes of Times weren't yet applied, and Times gets replaced with NonCommutativeMultiply, after which I re-evaluate this, as if it was not evaluated before. The Update sommand is used to prevent caching the values for the $stack, as this is inappropriate here and resulted in some erroneous behavior noted in the comments.

Here are some examples:

a = matrix["a"];
b = matrix["b"];

a*c*b

matrix[a]**c**matrix[b]

f[g[1 + c*a*d*b*e]]

f[g[1 + c ** matrix["a"] ** d ** matrix["b"] ** e]]

I would not probably recommend such tricks for serious use, it is just interesting that you can use them to divert evaluation sequence in ways which seem to be impossible otherwise.

Answer 2

there is a package called NCAlgebra I used some time ago to handle non-commutative variables (not just in matrix representation but also quaternions etc) in a multitude of situations.

http://www.math.ucsd.edu/~ncalg/

I think it would solve your problem as it defines its own substitution and expansion rules. You get the option to define a variable as non-commutative and then "do stuff" to it. In your example, and using this package

SetNonCommutative[A, B]

would define A, B to be treated as non-commutative symbols and the order in multiplication will be preserved.

Answer 3

As far as I know this cannot be made to work in the manner you show so long as the Orderless property of Times remains, because this property is applied before pattern rules are applied.

You can of course do things such as Blocking Times but I cannot think of a way to get (automatically) the behavior you desire without bad side effects.

Answer 4

What you want to do is tricky. You are mixing two things:

1. You want noncommutative products based on upvalues of the symbols involved;
2. You want to be able to replace the symbols by matrices.

Both can be achieved with NCAlgebra. The latest distribution is available from:

https://github.com/NCAlgebra/NC

The example from one of your comments in NCAlgebra would look like this:

<< NC`
<< NCAlgebra`
f[a_, b_] := a + b - b^2 - b ** a

Because a and b are noncommutative by default,

f[a, b]

results in

a + b - b ** a - b ** b

whereas

f[A, b]

results in

A + b - A b - b ** b

The second ** gets downgraded to a regular Times because A is commutative. This accomplishes task 1.

The task 2. is more subtle. If you want to substitute a and b for matrices you can use NCMatrixReplaceAll. For example:

AA = {{1, 2}, {3, 4}}
BB = {{-1, 0}, {1, 2}}

and

NCMatrixReplaceAll[f[a, b], {a -> AA, b -> BB}]

would result in

{{0, 4}, {-4, -8}}

which is what you get out of AA + BB - BB.BB - BB.AA, as you might expect. Note that the regular RepleceAll (\.) will fail because of the way Mathematica mixes Lists with other expressions when Plus is involved. This is why f[AA,BB] would also fail.

NCMatrixReplaceAll also works with matrices that have noncommutative entries. For example:

AA = {{1, d}, {c, 4}}
BB = {{a, b}, {1, d}}
NCMatrixReplaceAll[f[a, b], {a -> AA, b -> BB}]

returns

{{1 - b - a ** a - b ** c, -3 b + d - a ** b - a ** d - b ** d}, {-a + c - d - d ** c, 4 - b - 4 d - d ** d}}

which is what you would obtain from AA + BB - NCDot[BB, BB] - NCDot[BB, AA].