Order of Terms in Algebraic Expression

Question

When I write an algebraic expression of the following form,

B*OverBar[A]*C^3 + A*OverBar[C]*B
    
B C^3 Overscript[A, _]+A B Overscript[C, _]

the order of the terms in the output and inside the terms change. How to keep the order as it is in the input. I used "..." for this purpose, which works only on the factors of the individual terms. The issue is that I can't copy the "..." expression in the input form. And I need it to copy as input to use later. Thanks!

Edited:

I have found a simple solution. See the following. When I use the quotation "...". The order does not change which is good. But the problem is that I cannot properly copy the "Output" as an "Input". For all copying options, I get the following mess given in the output.

Input:

"B \!\(\*SuperscriptBox[\(X\), \(3\)]\) \!\(\*OverscriptBox[\(C\), \
\(_\)]\)" + "A B \!\(\*OverscriptBox[\(C\), \(_\)]\)"

Output:

"A B \!\(\*OverscriptBox[\(C\), \(_\)]\)" + "B \
\!\(\*SuperscriptBox[\(X\), \(3\)]\) \!\(\*OverscriptBox[\(C\), \
\(_\)]\)"

Answer 1

Let us introduce the following function:

rearrange[expr_, finalPositions_List] := Module[{lst, newlst},
   lst = List @@ expr;
   newlst = 
    Table[lst[[Position[finalPositions, i][[1, 1]]]], {i, 1, 
      Length[lst]}];
   HoldForm[Evaluate[expr]] /. MapThread[Rule, {lst, newlst}]
   ];

The function rearrange[expr,listOfFinalPositions] rewrites an expression (a sum or a product) in the order prescribed by the list entitled "listOfFinalPositions."

Arguments: expr is the expression with the head Plus or Times.

listOfFinalPositions is a list. Its length must be equal to the length of the expression. It indicates the positions the terms of the sum or product must take in the end.

For example, for the expression a+b+c, the listOfFinalPositions {2,3,1} means that a must go to the second position, b - to the third, and c - to the first one resulting in c+a+b

Example in your case:

expr = B*OverBar[A]*C^3

One can see that here B has the first position. It must stay there. C^3 has the second one; it must go to position 3. A_bar must go to position 2. Finally, listOfFinalPositions={1,3,2}

rearrange[B*OverBar[A]*C^3, {1, 3, 2}]

Have fun!

Answer 2

It really depends on how you want to use the result. For example, you say

I need it to copy as input to use later

This makes any of the Hold* wrappers a bit problematic (you'll probably have to use ReleaseHold to be able to use it how you want).

As it happens there is the Defer wrapper, and to me that sounds like what you want (@DanielLichtblau already suggested this in the comments). So, this

Defer[B*OverBar[A]*C^3 + A*OverBar[C]*B]

will display without rearranging anything, but if you copy-pasted the result to somewhere else, the Defer wrapper will automatically get stripped.

On the other hand, if you're primarily concerned with just the display (and not with subsequent evaluation), my goto construct is a template. This gives you fine grained control of what you want to the parameters to be. So, let's say that your A, B, and C were really your objects of interest that you want to sit nicely in a structure expression. You could do this:

TemplateApply[
  TemplateExpression[
    TemplateSlot[2]*OverBar[TemplateSlot[1]]*TemplateSlot[3]^3 + TemplateSlot[1]*OverBar[TemplateSlot[3]]*TemplateSlot[2]],
  {A, B, C},
  InsertionFunction -> HoldForm]

Of course, you can pull out that TemplateExpression into a variable for re-use.

Or maybe you just care that the sum appear in the right order. Then you could use

mySum = TemplateExpression[TemplateSlot[1] + TemplateSlot[2]]
TemplateApply[mySum, {y x, 5}, InsertionFunction -> HoldForm]

x y + 5

(I used a simpler example for clarity.) Notice that since the product was part of the argument to TemplateApply, it was evaluated and ordered per Mathematica's preference, but the sum was held in its original order.

Or maybe your specific case falls somewhere between these two examples. Just be aware that since the InsertionFunction wrapped the result in HoldForm, you'll need to ReleaseHold this if you want to do further computeations.