There's something goofy going on witheven the u[1] and u[0]. I can look later this evening.

The change from exp to sin,cos happens because of your evalc call. It's easy to amend that.

But the key will be to fix the appriach so that even the first a[1] comes out as you expect...

@salim-barzani Why didn't you show the expected result when you posted this Question thread!?

Or, were the additional details in one of your earlier Question threads that you've deleted?

@Geoff That's a regression in behaviour; Maple 2024.2 gets it in one call to simplify.

You can report bugs at this link, btw.

@emendes It returns the expression with the subexpression (addend) z*x becoming x*z, which is what you asked for if I'm not misunderstanding.

See the comments (after # symbols) in the latter code. See also the 3rd paragraph in my previous Reply. By sorting z*x into x*z anywhere -- including on its own -- it becomes thus sorted everywhere it appears structurally. Instances where it appears structurally merely point at the unique stored item. The sort command can actually change that stored item, in-place.

If the stored item is x*z and you type in, say, cos(z*x) then that automatically becomes cos(x*z) because z*x is uniquified (automatically simplified) to the stored x*z. And case of the opposite order being the one that happens to be store would also hold. For this example, it's one order of the product, or the other, that happens to be stored.

So the nature of the sole stored representation of the symbolic product of (only) x and z then rules over previously created as well as new expressions that contain it structurally. NB. p*x*z doesn't contain x*z structurally (even though it may, mathematically).

Download uniquification.mw

The mechanism for centrally storing items helps Maple performance. See also "The Simplification Table" in Appendix 1 of the Programming Guide.

The background knowledge and explanation is advanced Maple. But usage (like we're doing here) can be quite practical.

@nm I deleted the other Question thread.

If you are going to post multiple examples involving recursion errors during odetest (including while using Physics 'assumingusesAssume'=true), and if you also suspect that they might be related, and if you also are going to reference any of those from another in words, then they are closely related.

I have asked before, politely, to please either cross-reference such queries with links added manually, or to get such links automatically added by using the Branch button on a Question, or to simply group them together in the same Question thread. It's a reasonable request, because otherwise it's unjustifiably difficult for people to properly follow all what you are saying (especially at some future date) on this topic.

Ideally everyone here would be respectful, and honest, and helpful, whenever possible. In the absence of that, maybe I ought to stay away.

@rlewis You've changed the example I gave from using the plottools:-polygon command to using the plots:-polygonplot3d command, and kept all the other syntax corrections. The result is essentially the same, here.

It's good that you have it working.

@emendes Is this the kind of fix-up you're after? That is changing z*x back to x*z.

I added it as a late step in the Alt_monomialsGB procedure, but at the end of this worksheet I also show how you can apply it to an arbitrary list of expressions (of type polynom in your list of names). You could even make that a new small procedure.

The basic idea is that it simply forces re-ordering of the multiplicands in (only) the subexpressions of type `*`. Maple stores a single instance of such terms, in a special internal structure, and sort acts in-place on those; the sorted instance then appears (automatically) in any expression containing those terms.

Download more_sort_fun2.mw

@emendes Yes, that's an artefact of some of the forced sorting orders.

As I mentioned in the initial text of my original Answer, that (somewhat cosmetic) effect can be adjusted by an additional `sort` applied separately to the individual terms. I can add that, maybe tonight.

Do you always want the individual product terms alwats to have their multiplicands in usual alphabetic/lexicographic order?

It is a bug; a regression introduced in Maple 2023.

The syntax a(1) and a[1] are only interchangeable for some flavours of rtable indexing.

@emendes Does this cover your flavours?

(Choices of ordering are plex,tdeg,grlex, with plex the default. And reverse=true/false, defaulting to false.)

tdeg, reversed, is what I did for your original examples in this Question.

Download more_sort_fun.mw

@emendes Please give a brief but characteristic example of input and output for that procedure (which has Carl's "fist"), and a description of what it does, and how you want that changed.

@Andiguys I've updated my previous Reply, to cover your followup case involving
   c ≤ a and a ≤ b

I don't understand why you would wait so long to inform us that all the variables are positive. How does it help, to hold that back originally?

And now you've got some further, new variant example? Am I reading that rightly?

Is there some good reason that you couldn't give use all three different examples at the beginning?

@Andiguys The 2D Math display that looks like c ≤ a ≤ b is simply a conjunction of two inequalities, a ≤ b and c ≤ a . You might try dealing with those one at a time.

Does the following make sense,

Download Q_isolate_acc_2.mw

@emendes With repeats,

Download sort_lex_fun2.mw

Here I put the plex sorting (of multiplicands in each separate monomial) as an inside rather than outside job. That aspect might not even be of interest/use to you; and I can only guess at what order you might prefer for them.) Without that touch it can come out like this:

@emendes Would you rather see the original z,z,z,z in the output list, or 4*z? (both are easy to accomodate)