@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)

@salim-barzani It's not clear what you might be trying to say about conjugates.

I really do suggest that you try to understand how the code parts work. How else would you be able to tell that parts of some AI-generated code is trash? (I don't mean mmcdara's and dharr's code...)

@mmcdara Yes, I saw that too. And simplify doesn't reduce the contradiction, as well (in M2024.2 at least). I'll check M2025 and submit a report (against both solve and simplify).

@mmcdara In the member's Maple 2019 the conditions in that piecewise result from that solve call are awkward (and weird).

Download Q_solve_oof_M2019.mw

That first Error message in your worksheet (in magenta) is a URL that can take you to this webpage.

Not all (few) Error messages link to useful information, but this one does.

I had to tell it how to find my web-browser, the first time I clicked on such a link.

@emendes I don't think that you've explicitly clarified whether an entry in any given inner list/set has to have all its own member lists/sets have the same depth of nesting as each other. Ie, you haven't (as yet, explicitly, AFAICS) disallowed, say,
   [  [1, 2], [ [4,5], [[6,7],[a,b]] ] ]
or,
   [ [1, 2], [ [4,5], [[[[[6,7]]]]] ] ]
where it's unclear whether the "depth" rating of [ [4,5], [[6,7],[a,b]] ] ought to return as 2 or 3 (or error).

But perhaps you don't expect such a case. So far, that was my guess.

Or perhaps you mean to convey instead that you wanted the maximal nesting depth for the members of parent L.  So here's another guess for the depth (though I don't know always what you might mean by "flatten" in some examples),

Download some_list_set_stuff_2.mw

@emendes To start with, your claim, "After the first outer list, entries are either lists or sets." is not true of the examples you've shown. Some entries are integers.

Moreover, even if you complete your characterization to allow lists or sets or scalars(or integers), it could still not be specified whether the entries of any sublist list have to all be all-integers, or all-sets or all-lists, or all sets-or-lists, or possibly a mix. If a mix of integers and lists/sets, then it's not explicitly clear what you might mean by "flatten", and you haven't clarified that case through example -- or prevented it (so far) with words.

It may be that an natural interpretation is obvious to you (or others). But, based purely on what you have written, the problem is (literally, indeed) under-specified.