Do not use [...] for grouping in expressions; they are reserved for lists.
Do not use floats in symbolic computations.

restart;
f:=1/(exp((-1+(1-4*epsilon)^(0.5))/(2*epsilon))-exp((-1-(1-4*epsilon)^(0.5))/(2*epsilon)))*(exp((-1+(1-4*epsilon)^(0.5))/(2*epsilon)*t)-exp((-1-(1-4*epsilon)^(0.5))/(2*epsilon)*t))/(exp(1-t)-exp(1-t/(epsilon))):
g:=convert(f, rational);

simplify(limit(g, epsilon=0, right)) assuming t>0;
                               1
simplify(limit(g, epsilon=0, left)) assuming t>0;
                               0
simplify(limit(g, epsilon=0)) assuming t>0;
                           undefined

So, for t>0 your function has distinct side-limits. (For t=0 the function is not defined).

Download puiseux.mw

SymFun:=proc(f,x)
local s,a_,b_, g;
if is(simplify(diff(f,x))=0) then return 'ConstantFunction' fi;
s:=solve(identity(eval(f,x=a_+x)=eval(f,x=a_-x),x),[a_]);
if s<>[] then return 'VerticalSymmetry'=s[] fi;
s:=solve(identity(eval(f,x=a_-x)+eval(f,x=a_+x)=2*b_,x),[a_,b_]);
if s<>[] then return 'CentralSymmetry'=s[] fi;
# hack
g:=eval(f,x=a_+x)-eval(f,x=a_-x);
s:=solve(limit(g,x=infinity),[a_]);
if s<>[] and is(simplify(g,s[1])=0) then return 'VerticalSymmetry'=s[1] fi;
'NoSymmetry'
end:

eliminate({s = sum(n/2^k, k=0..p), n/2^p=1}, p):
simplify(solve(%[2],s))[];
              s = -1+2*n

A point on the unit sphere is determined by the spherical coordinates (th, ph). You can choose any color for this point. E.g.

c := ph+th/16:  # color (HUE)
plot3d(1, th=0..2*Pi, ph=0..Pi, coords=spherical, color=c);

If your vector field is V(r,th,ph), you can take c := LinearAlgebra:-Norm(V(1,th,ph), 2, conjugate=false);

Digits:=15:
par:=[lambda1 = 0.733e-1,lambda2 = 5.3344,alpha = 4.8492]:
f := (Z^(lambda2/lambda1))^2*ln(Z)^2/((Z-1+alpha)^2*(Z^(lambda2/lambda1)-1+alpha)^3):
J:=IntegrationTools:-Change(Int(f,Z=1..infinity), Z=z^(lambda1/lambda2)) assuming positive:
evalf(eval(J,par));

           1.15034205858649*10^(-7)  

Download modular-cp.mw

restart:
A:= <x1,y1,z1>:
B:= <x2,y2,z2>:
P :=<x3, y3, z3>:
H:=A+t*(B-A):
solve( (P-H)^+ . (B-A), t ):
'H'=eval(H, t=% );

If you set Digits:=15 at the beginning of the worksheet (which is always a good idea), the integral will be finite (6.32 ...). Even TP(3, 10^(-5)) will be finite (7.59...).

Explanation. For Digits=10, if you replace in TP int with Int, you will see that TP(3, 10^(-4)) is
const * int(1/sqrt(1.0 - cos(theta)) ,  theta = 0 .. const).
So, the integral is divergent.
Here 1.0 appears due to roundoff errors; the exact value is strictly > 1. For a larger Digits ==>  1/sqrt(1+eps - cos(theta)) and the integral is convergent.

By default, verify checks syntactically the equality (without any simplification).
We can use:
verify(2*cos(phi)^2-1, cos(2*phi), simplify);
or
verify(2*cos(phi)^2-1, cos(2*phi), expand);
to obtain the desired result (true).

So, you actually want

asympt( (2 * Pi * n) ^ (1/(2*n)), n, 2);
           

(the fact that taylor also works instead of asympt is strange; it should not).

You are expecting O(ln(n)^2/n^2) instead of O(1/n^2).
This would be true in terms of the standard Landau notation  O(...).  But Maple uses a modified version where the sub-polynomial functions are ignored; e.g. in this Maple notation O(ln(n)) = O(1).

Note that MultiSeries:-asympt  uses the true Landau notation. So,

MultiSeries:-asympt( (2 * Pi * n) ^ (1/(2*n)), n, 2);
will produce the expected result.

You cannot do much about this. The automatic simplification in Maple transforms 5*(x+1)+y into 5*x+5+y.
There are some tricks (such as Kitonum's) but they work only temporarily (i.e. the next evaluation reverses the transform) or can be used only for display purposes (and not for computations). It is more convenient to accept it.

Q:=proc(k::list(nonnegint))
local P,i;
P := combinat:-cartprod([seq([seq(0..i)],i=k)]);
while not P[finished] do 
  print( add(i, i = P[nextvalue]()) ) 
end do;
end:

Q([2,3]);
                               0
                               1
                               2
                               3
                               1
                               2
                               3
                               4
                               2
                               3
                               4
                               5

In more recent versions it is better to use Iterator:-CartesianProduct

P:=proc(k::list(nonnegint))
local M,i,v;
M := Iterator:-CartesianProduct(seq([seq(0..i)],i=k);
for v in M do print(add(v[])) od
end;