I have a vague feeling that I may be missing something important in this discussion (especially since I would've expected Acer to come up with this also), but doesn't the following simple code, which uses no unapply and no quotes, do what you want?

G:= [seq(subs(_u= u, theta-> x-> _u*theta*x), u in [v1,v2])];

Many commands (perhaps most) don't automatically map themselves over container objects such as Vectors, lists, and sets. This can often be achieved by appending ~ to the command name, making it into an elementwise command. In your case, this works:

A:= Vector([1, 2, 3]):
solve~(2*A =~ 5+x);

Note also the use of the ~ in =~. See ?elementwise.

If you're willing to change Matrix A itself, you can perform the operation in place, which saves time, memory, and typing:

A[.., 1]:= b;

Matrix, in addition to being a type, is also a procedure. It's the constructor procedure for matrices that you just used. When you use print, it forces the expansion of the name Matrix into its underlying procedure. You'd get the same thing if you'd executed print(Matrix) at the top level (i.e., outside a procedure). The solution to your problem is to simply not use print. A procedure's return value is simply the result of its last executed statement; there's no need to use print to see a procedure's result. Indeed, it is a bad practice to use print in this way. It should only be used to display supplementary information, not the procedure's return value.

Set new initial conditions after the singularity, and plot on the range after the singularity. Then combine the plots. For your case, I set n(14) = 1.1, T(14) = 1.1, then plotted on 14..30. It reaches the next singularity at t = 27.....

To convert a table T into a list in the order implied by its indices, use 

[entries(T, 'indexorder', 'nolist')];

instead of

convert(T, 'list');

Also, the plot and Statistics commands accept lists as well as Vectors. With these changes, your code simplifies to

restart:

Atot:= 0:
PtotFkt:= ii-> ii^2: #Keep function definition outside loop.

for ii from 0 by 0.01 to 2 do
     (Atot, A[ii], t[ii]):= (Atot + 0.01*PtotFkt(ii), Atot, ii)
end do:

#Conversion from tables to lists.
#Reuse names A and t to encourage garbage collection.
(A,t):= [entries]~([A,t], 'indexorder', 'nolist')[]:

plot(t, A, style= point, symbol= asterisk, color= blue);
regress:= Statistics:-PolynomialFit(10, A, t, time);
plot(regress, time= 0..2);

In the future, please use plaintext for your posted Maple code, or upload a worksheet. Then we won't need to retype your commands.

The solve your problem, go to the Maple Application Center and download the package DirectSearch. The worksheet below shows how to use it. You can see that the package stumbles around a bit before coming up with a solution, but the solution that it finally produces is accurate.

Download Temp_Power.mw

Why not simply use solve:

solve((z^2-1)/(z^2+1) = c, z);

Simple: Use a local declaration:

lisse:= proc(...)
local AzIII;
...
end proc:

It's not built-in (AFAIK), but it can be written as a trivial one-liner. However, you do need to specify the maximum number of bits to allow for the numerator.

`convert/dyadic`:= (x::nonnegative, b::posint)-> ``(trunc(x))+round(2^b*frac(x))/2^b:

convert(1.74, dyadic, 5);

     (1)+3/4

convert(1.74, dyadic, 6);

     (1)+47/64

The pochhammers can be converted to summations by following the differentiation command with

convert(%, Sum);

The best simplifier that I've found for explicit algebraic numbers (meaning those specified without RootOf) is evala@evalc. In this case, this combo will quickly reduce a, b, and c to a form from which it's obvious that no further simplification is possible. Then I do two independent verifications--one numeric and one symbolic---that these simplifications are correct. The numeric is evalf[10]@evalf[999]; the symbolic is evala@Normal.

Download evala_evalc.mw

Square brackets can't be used as a higher level of parentheses. Only round parentheses may be used for algebraic grouping.

After you correct that, it'll require many function evaluations and several minutes for it to integrate out to 20. You need to include the option maxfun= 0 in the dsolve command so that it doesn't try to limit the number of function evaluations.

I doubt that in the general case that it's possible to do any better than this brute force method:

Ker:= (H, g1::Group)->  select(g-> H(g)=Perm([]), GroupTheory:-Elements(g1));

where H is the homomorphism. Certainly nothing to this end is already implemented in Maple 18.

As far as I'm concerned, the correct way to do it is now, and always (at least since Maple Vr4) has been, 

t:= (a/b)^2*x*y:
fprintf(outfile, "%A:= %A;\n", 't', t);

Your usage of cat doesn't seem to be supported by the documentation at ?cat, which clearly states (in Maple 18) that cat may return an object of type `||`. Also, it's been ages since strings and names were considered the same thing. You're using names; you'd be better off using true strings.