@cmcjas 
|T(z)|=1 iff |z-I|=|z+I|, meaning indeed that z has the same distance from I as from -I since z+I = z-(-I).
If L is the set of points with that property, then L must be the set of points on the real axis.

An illustration:
plots:-implicitplot(abs(T(x+I*y))=1,x=-5..5,y=-1..1,thickness=3,view=-1..1,gridrefine=1);

@IanLisle I just tried the eval trick and using mul again. It worked as I said above on my machine. Then after a restart I tried again. Then it crashed.
I got successes and failures in a few more attempts after closing the program or pasting the code into a new worksheet. So there is obviously some randomness in this.

interface(version);
Standard Worksheet Interface, Maple 17.02, Windows 7, September 5 2013 Build ID 872941
kernelopts(version);
     Maple 17.02, IBM INTEL NT, Sep 5 2013, Build ID 872941

@Carl Love Yes, you are right. So one might try

seq(simplify(T((N@@k)(z))-(T(z))^(2^k)),k=1..9);

Just a couple of observations:
Replacing add with sum doesn't help.
Replacing add with mul works (but of course produces something entirely different).
The following artificial construction works:

restart;
BlahObject := module()
    option object;
    export BlahMethod := proc()
    local C, d, i,f;
      eval(f(C[i]*d[i] + C[i], i=1..4),f=add);
    end proc;
  end module;

B := Object(BlahObject);
B:-BlahMethod();

@Kitonum I suggest replacing the print statement print(convert(.....)) with a return statement:
return convert(...);

The reason being that a print statement just does that: prints. There is no output to save to a variable as in
res:=Basises({x^2+x+4,  x+3,  2*x^2-x-5,  5*x^2+x-7});

@ecterrab I agree that these changes are welcome.

Let me use the opportunity to ask if there is any good reason why dsolve/SERIES and dsolve/INTTRANS need the indeterminate function(s) as the second argument unlike dsolve and dsolve/numeric?
Simple example:
restart;
ivp:={diff(x(t),t)=x(t),x(0)=1};
dsolve(ivp);
dsolve(ivp,numeric);
dsolve(ivp,x(t),series); #Unknown function needed
dsolve(ivp,x(t),method=laplace);#Unknown function needed

@bunmipopoola The manuals found these days in Maple itself are not bad at all.
In Maple look under the menu item Help/Manuals, Resources, and more/Manuals.

The manuals can also be downloaded from
http://www.maplesoft.com/documentation_center/

It used to be possible to subscribe to a post or question. This was useful when you didn't answer or comment yourself, but still wanted to follow the discussion. That feature seems left out.

Well, maybe it is just put under Comments feed. Haven't tried that.

@traiannp It appears to me that L1 appears in all the equations. Also if you remove the first 4 equations, then you still have 9 unknowns, viz.
{L1d, L1q, Ladssec, Laqssec, Lfd, Ll, R1d, R1q, Rfd}

I deleted my initial response as I realized that Carl had already said the same thing.

@bunmipopoola You can do like this
PrF; #Just recalling what PrF is
odeplot(sol,[t,rhs(PrF)],0..0.00431,labels=[t,Pr]);
#Analogously
odeplot(sol,[t,rhs(OF)],0..0.00431,labels=[t,O]);
#To plot D(P) we need to express it in terms of P, F, and T.
#Notice that in sys2 we have D(P) expressed in terms of D(T).
sys2;
#Thus we need to isolate the derivatives:
sys3:=solve(sys2,{D(F)(t),D(P)(t),D(T)(t)});
#(We might as well have done that earlier.)
#Thus D(P)(t) is given by
DP:=eval(D(P)(t),sys3);
odeplot(sol,[t,DP],0..0.00431,labels=[t,D(P)]);

Notice that double brackets in odeplot are not necessary if you have only one pair as we have.
If you have several, then you need them as in
odeplot(sol,[[t,log10(P(t))],[t,log10(T(t))]],0..0.00431,labels=[t,"log(P), log(T)"]);

@danlun If you set p to be what you have above (where multiplication signs are missing), you can correct that by using the following device:

indets(p,function);
nops(%); #6 multiplication signs are missing
q:=evalindets(p,function,s->op(0,s)*op(1,s)); #Correcting that
indets(q,function); #Output {}
factor(q);
nops(%);
type(q,`*`);

@Carl Love Here is a version which doesn't need unevaluation quotes, but is requires the sequence of variable names surrounded by a pair of double quotes:

restart;
a:=6: b:=7: c:=8:
p:=proc(s::string) unassign(parse(s)) end proc;
p("a,b,c");
a,b,c;
%;


One could even overload the existing unassign:

Unassign:=overload([
                    proc(s::string) option overload; unassign(parse(s)) end proc,
                    subsop(3=overload,eval(unassign))]
):
a:=6: b:=7: c:=8:
Unassign("a,b,c");
a,b,c;
%;
a:=6: b:=7: c:=8:
Unassign('a','b','c');
a,b,c;
%;

@Carl Love Would it be possible in Maple to make unassign not evaluate its arguments, so that uevaluation quotes were not necessary?
If you restrict unassign to a fixed number of arguments it is easy enough by just using the existing unassign:
p:=proc(x::evaln) unassign(x) end proc;
a:=7:
p(a);
a;
An attempt to extend this to a sequence of arguments using the seq-modifier:
q:=proc(x::seq(evaln)) unassign(x) end proc;
Error, `evaln` cannot be used within `seq` modifier for parameter `x` in procedure q

@acer My guess is that there is no (significant) difference between a Danish keybord and a Norwegian.
Ctrl+Alt+=  works in Maple 17.02 on a Danish keyboard.

@wzelik

Using that the matrix A is symmetric and has an LU-decomposition with no switching of rows, i.e. A = L.U, A can also be written as A = L.D1.L^T, where D1 is the diagonal matrix having the diagonal of U as its diagonal.
A will be negative definite iff all diagonal elements of U are negative. Since all your constants are positive all the elements but the last one U[n,n] are always negative. 
The last element U[n,n] is
((n-1)*hext*hint*`δx`+hext*lambda-hint*lambda)/(`δx`*((n-1)*hint*`δx`+lambda)*rho*cp);

Since `δx` = L/(n-1) this can be written

(L*hext*hint+hext*lambda-hint*lambda)*(n-1)/(L*(L*hint+lambda)*rho*cp)

and this is negative iff

L*hext*hint+hext*lambda-hint*lambda < 0.

Notice that this inequality does not contain n, thus it doesn't help to increase n.
The inequality can be rewritten as
L < lambda*(1/hext-1/hint)
For your values of the constants L, lambda, hext, and hint this inequality is not satisfied.