Here's an easy way that I think corresponds to what you were asking for. We sort the points returned by LagrangeMultipliers based on the function value, lowest to highest. Then we pair each point with its function value. This requires Maple 18 or later. If you have an earlier Maple, let me know---it can still be made to work.

F:= (x,y,z)-> x*y*z:
Sols:= Student:-MultivariateCalculus:-LagrangeMultipliers(
     F(x,y,z), [x^2+4*y^2+4*z^2-4], [x,y,z]
):
Sols:= sort([Sols], key= evalf@F@op):
map(s-> [F(s[]), s], Sols);

Any data structure can be stored in a Vector. But I think that in your situation storing them in a list would work better. I'm not sure about your situation, and I'd like to see more details.

Here's a procedure that does the job with simply three sorts and a reindexing. It doesn't use any conversion to disjoint cycle form; it works strictly with the permlist form.

Perm1to2_D:= (L1::list, L2::list)->
     sort(L1, 'output'= 'permutation')
          [sort(sort(L2, 'output'= 'permutation'), 'output'= 'permutation')]
:

Here's how it works. Given a permutation in permlist form, its inverse can be obtained by sorting it with output= permutation. Given two permutations P1 and P2 in permlist form, the product or composition of P2 applied to P1 can be obtained by simply indexing: P1[P2]. 

Here's a time test of the four procedures so far presented for this problem.

Download permL1toL2.mw

The first argument to animate shouldn't be a plotting command; rather, it should be just the procedure name of a plotting command. The second argument should be a list of arguments for the procedure in the first argument parametrized by the animation parameter. The third argument should be the animation parameter and its range. So, your command should be

plots:-animate(
     plots:-dualaxisplot,
     [sin(x+A), cos(x+A), x=0..5, style = line, gridlines = false],
     A = 0 .. 5
);

In the call to odeplot, change [x,U(x)] to [[x,U(x)], [x,S(x)]]. In the call to animate, change the range from -2..0 to -2..-0.1 to avoid the singularity at x=0.

If you have an existing proc procedure to which you want to give the property of being distributive over the first argument, then you can include the following statement before the main computation:

if args[1]::`+` then return map(thisproc, args) end if;

The simplest example---a procedure that does nothing other than distribute itself over its first argument---is

d:= proc(a,b)
     if args[1]::`+` then return map(thisproc, args) end if;
     'procname'(args)
end proc:

d(a+b, c);

Is r*t-m also negative? If yes, then you can solve the imaginary number problem by

combine(v(t), symbolic);

If no, then the imaginary numbers are "really" part of your problem, and you need to figure out their significance. Just making the ln "disappear" isn't an adequate solution.

The command that you tried to post as an "Inline image" didn't show up. In the future, just copy-and-paste plaintext of your command.

I'm going to guess that your command was something close to

plot(x/x, x= -1..1, discont= [showremovable]);

The reason why the hollow point doesn't appear in this case is something called automatic simplification : Certain expressions are automatically simplified before being passed. In this case, x/x is automatically simplified to 1 beforeit's passed to plot. There's nothing that you can do to prevent this.

However, if you want to test the showremovable option, the following works:

plot((x^2-x)/x, x= -1..1, discont= [showremovable]);

Change the line

MM:= Minimize(J, {seq(CC1[i]=0 and CC2[i]=0, i=1..numelems(CC1))});

to

MM:= Minimize(J, {seq([CC1[i]=0, CC2[i]=0][], i=1..numelems(CC1))});

The commands in Optimization don't accept constraints with Boolean operators, such as and.

A very often-discussed topic here on MaplePrimes is a better alternative for the awkward and slow combinat:-cartprod. 

L:= [ [ [1,2], [2,1] ], [ [3,4], [4,3] ], [ [5] ] ]:

CartProd:= proc(L::list(list))
local S, _i, V:= _i||(1..nops(L));
     [eval(subs(S= seq, foldl(S, [V], (V=~ L)[])))]
end proc:

(op~)~(CartProd(L));

Between the two inner loops you have two statements. The second of those statements needs a semicolon at its end.

Yes, there's a three-argument operator form of if: `if`. It's very similiar to the (...?...:...) operator in C. For example:

seq(`if`(k::prime, 1, 0), k= 1..10);

     0, 1, 1, 0, 1, 0, 1, 0, 0, 0

What's a little more difficult in Maple is an embedded assign-and-increment statement such as your idx+= 1. This can be implemented like this:

`&+=`:= proc(x::evaln, inc::algebraic)
     assign(x, eval(x)+inc);
     eval(x)
end proc:

idx:= 1:
seq(`if`(i > 2, idx &+= i, idx+i), i= 1..10);

    2, 3, 4, 8, 13, 19, 26, 34, 43, 53

It's fairly easy. Here's a worksheet for it.

Download permL1toL2.mw

Use the command Elements:

Elements(P2);

lprint(%);

{Perm([]), Perm([[1, 3, 5]]), Perm([[1, 5, 3]])}

Using the example that you provided, and automating the process of making the assumptions:

B:= [a-1, b+2, b-c, a*c-1]:
f:= a^2*c-a*c-a+1:
is(f <> 0) assuming (B <>~ 0)[];

     true

Unlike assume, assumptions made with assuming only last for duration of one command.