The pre-subscript and pre-superscript have no overall predefined meaning in Maple, although they may be given meaning by some packages. I suspect that even in these cases, this notation is only used for the display of the results and has no meaning computationally. For example, a pre-subscript is used in the prettyprinted display of hypergeometric functions when typesetting is set to extended:

interface(typesetting= extended);
hypergeom([a], [b], x);

You are free to assign to them any meaning that you want.

Here are procedures for extracting them:

PreSub:= (x::{name, name^anything})->
     if x::`^` then thisproc(op(1,x))
     elif x::indexed then thisproc(op(0,x))
     else parse(op([6,1], parse(substring(x, 2..))))
     end if
:
PreSuper:= (x::{name, name^anything})->
     if x::`^` then thisproc(op(1,x))
     elif x::indexed then thisproc(op(0,x))
     else parse(op([7,1], parse(substring(x, 2..))))
     end if
:

Please let me know if that gives you what you want. If you want them returned with their color intact, that's slightly different.

Use D:

g:= D(f);
g(2);

In the function f(x,t), x is the first variable, so the second derivative with respect to x is D[1,1](f). You have D[2](f), which means the first derivative with respect to the second variable. After correcting for this, you still have the problem that you have no initial conditions; you only have boundary conditions. One usually specifies that something special happens when t=0.

Functional iteration is done with @@, so you can make your plot with

plot([seq([k, nops((Y@@k)({}))], k= 1..20)], style= point, symbolsize= 24);

The speed of Y can be improved with a remember table. See ?remember.

Real programmers don't use untypeable variable names with silly hats on them.

I think that the point of the error message is that dsolve can't solve ODEs of arbitrary, unspecified differential order, although that point is sometimes made more explicit as in

dsolve(diff(y(x), [x$n]) = y(x), y(x));
Error, (in dsolve) unable to handle ODEs of undefined differential order

geom3d:-point~([A,B,C], [[4,5,5], [-9,4,7], [-3,-3,3]]):
geom3d:-line(L1, [A,B]):
geom3d:-line(L2, [C, [5,7,-4]]):
geom3d:-distance(L1,L2);

     (289/2315)*sqrt(2315)

Here's a conversion procedure:

IndicesToSubscripts:= e-> subsindets(
     e,
     'indexed',
     n-> cat(
          `if`(op(0,n)::'indexed', IndicesToSubscripts(op(0,n)), op(0,n)),
          __,
          `if`(hastype([op(n)], 'indexed'), IndicesToSubscripts~([op(n)]), [op(n)])[]
     )
):

Example use:

e:= x[1] + y[a][b[c]]:
IndicesToSubscripts(e);

(output suppressed)

lprint(%);

x__1+y__a__b__c

Ordinarily indets, subsindets, and evalindets (without the flat option) are inherently recursive, working their way through the expression tree, but indets doesn't seem to extract indices, so the recursion needs to be made explicit in my procedure above.

The command lprint will reveal the underlying structure of almost anything in Maple. So, use lprint(A).

Let TD represent t/d. Then t = d*TD, so you can use eval:

eval(Wr_over_p, t= d*TD);

If you want to plot this, you'll need to change pi to Pi. The lowercase version is just a meaningless symbol in Maple.

interface(prompt= "> ");

It is done by scaling the function by .4, using scaling= constrained, and scaling the tickmarks on axis[3] by .4:

T0:= (x,y,m)-> 20/Pi*sum((-1)^(n+1)/n*exp( n*Pi/10*y)*sin(n*Pi/10*x), n=1..m);
plot3d(
     .4*T0(x,y,50), x= 0..10, y= 0..10,
     scaling= constrained, axis[3]= [tickmarks= [2=5, 4=10]]
);

The procedure below handles, with the greatest possible generality, all cases of multivariate functional iteration. It uses a combination of unapply and eval, and can be used as a replacement for eval or `@@`. It is often far more efficient than `@@` because it uses a repeated squaring algorithm. As far as I can determine, this is the only usage of a repeated squaring algorithm for functional iteration.

Download MultivarIterate.mw

The function IsSubspace that you want isn't predefined in Maple, but it can be built as a one-liner from LinearAlgebra:-IntersectionBasis like this:

IsSubspace:= (U::set(Vector), V::set(Vector))->
     andmap(u-> LinearAlgebra:-IntersectionBasis([u, V]) <> {}, U)
:

And it's used like this:

IsSubspace({<0,1,0>, <0,0,1>}, {<1,0,0>, <0,1,0>, <0,0,1>});

     true

An approach that would be more computationally efficient would be based on examining the row-echelon form of the matrix formed by the columns of V on the left augmented by the columns of U on the right. I don't feel like coding that right now, but I suspect that it could be done also as a one-liner using LinearAlgebra:-LinearSolve. I'll do it tomorrow, if someone else doesn't do it first.

The output of both procedures is now 0, 0, 1, 1. That's because assign is now built-in, and thus it can alter an environment variable. In earlier Maple, assign was written in Maple, so it any change that it made to an environment variable would revert as soon as assign exited.

If you want to see any output in a simple form, use lprint.

int(1/(x-a)/(x-b), x= -infinity..infinity);
lprint(%);

piecewise(And(a = RootOf(Im(_Z)), b = RootOf(Im(_Z))), undefined, Im(a) = 0, undefined, Im(b) = 0, undefined, I*Pi*(signum(0, Im(a), 1)-signum(0, Im(b), 1))/(a-b))

I suspect that the symbol that you were having trouble undetstanding is the script I that Maple uses to prettyprint Im.