The trouble with your method is that you repeatedly add elements to existing lists or sets. Unfortunately, that operation is very inefficient in Maple. It is so natural to approach this problem recursively; however, I can't think of any way to efficiently do it recursively in Maple, even after thinking about it for hours.

Here is a way to do it using seq. This method is faster than Iterator. (In fairness, I must say that I learned this technique from a post by Joe Riel where he applied it to Cartesian products.) I also show a better way to do your indexing procedure TkSubSetList. And I also compare with VV's recursive method.

Download AllCombinations.mw

Indices, which are formed with square brackets, and different from subscripts, which are formed with double underscore. The two forms display pretty much the same in the GUI. However, a subscript is an integral part of the name to which it is attached, and hence it can't be substituted for an integer or anything else. A subscript is intended for display purposes, not programmatic purposes.

Additionally, you'll achieve better results with mul rather than product (lowercase p). Here's your worksheet, modified:

Download WhatHappensHere.mw

Here's a much-simplified version of your code:

funcs := [x, 3*x, x^2, 5*x];
for i to nops(funcs) do listM[i] := diff(funcs, [x $ (i-1)]) end do;
M := convert(convert(listM, list), matrix);
linalg:-det(M);

P.S. Here's a more-direct way:

M:= matrix([seq(diff(funcs, [x$(i-1)]), i= 1..nops(funcs))]);

You think that D[3](y)(L) refers to the 3rd derivative with respect to the first variable. That's incorrect: Rather, it refers to the 1st derivative with respect to the 3rd variable (regardless of the fact that y is a univariate function). There are several ways to represent the 3rd derivative with respect to the first (and only) variable:

(D@@3)(y)(L)
D[1,1,1](y)(L)
D[1$3](y)(L)

Likewise for the 2nd or any other order of derivative.

You need to spell out Heaviside and use exp(...) instead of e^.... The command is

inttrans:-laplace(Heaviside(t-1)*exp(3*t-3), t, s);

The Wronskian command is predefined. See ?Wronskian.

The linalg package has long been deprecated. It's functionality has been replaced by the packages VectorCalculus and LinearAlgebra.

The internal reference to h must be stored as z5:-h because h is in z5, so it needs to know where to look up h on re-evaluation of the expression. But you don't need to see the z5:- if you use a `print/h` procedure. Change z5 to this:

z5:= module()
option package;
export
     h:= F-> expand(evalindets(D(F)/F, specfunc(D), d-> op(d)*'h'(op(d))))
;
local
     ModuleLoad:= proc() :-`print/h`:= ()-> ':-h'(args) end proc,
     ModuleUnload:= ()-> unassign(':-`print/h`')
;
     ModuleLoad();
end module:

Of course, you can include any other locals or exports that you want in the module.

The key thing is that you can get any function f to prettyprint differently by defining a global procedure `print/f`. Since the procedure needs to be global, it needs to be assigned in a ModuleLoad procedure.

Symbolic antiderivatives in Maple are allowed to be discontinuous. This especially happens with complex functions. You can see this discontinuity in this plot (the red line is the real part):

F:= I*arctan(sqrt(exp(2*I*t)-1))-I*sqrt(exp(2*I*t)-1):
plot(([Re,Im])~(F), t= 0..Pi, discont);

The int command correctly adjusts for the discontinuity when it's a definite integral.

In the line that defines vNN, you have

vNN= ....

That needs to be

vNN:= ....

In the next line, use eval instead of algsubs:

pressure:= eval(nMom, vNN);

Do you mean something like this?

Download Powers_of_2.mw

The variable cape very likely has an unassigned variable in it, so it can't be evaluated to a number. If you give the command print(cape), you'll very likely see what that unassigned variable is. If cape is too long to find that variable, the command indets(cape, name) will help you find it.

If you need further help, please use the green up arrow on the toolbar in the MaplePrimes editor to upload your worksheet. It's very difficult to make an accurate diagnosis based on simply reading the code "by eye".

I see what you're trying to do. It's a very common model for iterative numerical algorithms: You want to limit the number of iterations so that you don't have an infinite loop if the method is not converging. You need to use a for-while-do loop.

Download PointFixe.mw

Note that the given answer is not correct. The algorithm converged because the step size got too small. So, you'll need to add a check for that. You should have abs(u) being close to 0 to return without error.

You need more square brackets in the plot commands to indicate a parametric plot:

InertiaAxis1 := t->plot([x, V1(t)[2]*x/V1(t)[1], x = -2 .. 2]);
InertiaAxis2 := t->plot([x, V2(t)[2]*x/V2(t)[1], x = -2 .. 2]);

There's a command specifically for this equation. See ?LinearAlgebra,LyapunovSolve.

Here's a one-line procedure that tests whether your lists are valid:

valid:= (L::list(algebraic), V::list(name))->
     not `or`(seq(type(L[k], freeof({V[]} minus {V[k]})), k= 1..nops(V)))
:

See ?type,freeof.

You mentioned monomials. This Question is about polynomials, not monomials.