A convert and a correct assumption are needed.

simplify(convert(exp(I*t)^q, exp)) assuming t > -Pi, t <= Pi, q > 0, q < 1;

Why don't you use the monomial order lexdeg([x,y,z], [u,v,w]) ; it is used exactly to eliminate x,y,z.

Your monomial order can be obtained:

t2:=plex(u,v,w);  t1:=wdeg([1,1,1,0,0,0],[x,y,z,u,v,w]);

t:=prod(t1, t2);  # your order

sat:=a -> satisfies(u -> (op([0,0,0],u)=D and op([0,1],u)=a)):
difford:= (e,a) -> max(nops~(map2([op],[0,0,..],indets(e,sat(a))))):

# Example
expr:=(diff(a(x, y), x, y))*x*y+(diff(a(x, y), x, x, y))*x+diff(b(x, y), x, x)-sin(z):
expr:=convert(expr,D):
has(expr,a); # depends on a?
                              true
has(expr,c); # depends on c?
                             false
difford(expr,a);
                               3
difford(expr,b);
                               2

For example, the principal branch with ~ 3 digits accuracy, for x>0:

W = 1.45869*ln(1.2*x/(ln(2.4*x/(ln(1+2.4*x))))) - 0.45869*ln(2*x/ln(1+2*x))

You probably know that  f(n) = O(g(n))  means  limsup( f(n)/g(n), n=infinity) < infinity

provided that f,g>0  and  n -->oo.

Now, Maple does not have limsup; we shall use limit instead (in most cases it's OK).
So, your "equation" is equivalent to

limit( (n^2/2 + 2*n - 1)/n^2, n=infinity ) < infinity;
        1/2 < oo
It is true. What do you want to solve here? Do you mean prove?

LinearAlgebra works fine. You must know that it uses Matrix and Vector (capital M and V) instead of the old matrix and vector.
I suspect that you have used matrix. If this is not the case, please post your example.

The equation is equivalent to

x ln(x) = ln(4) + 2n Pi I <==>  ln(x) exp(ln(x)) = ln(4) + 2n Pi I <==>

ln(x) = W(m, ln(4) + 2n Pi I)   and  Im( W(m, ln(4) + 2n Pi I) )  in (-Pi , Pi].

Here m,n are integers.

But  Im( W(m, ln(4) + 2n Pi I) )  in (-Pi , Pi]   iff  m=0  (for n in Z).

Note that m is an arbitrary integer if all the branches of the logarithm (or equivalently of x^x) are considered.

BIN:=module()
export ModuleApply, Fac, Fac1;
local pmax:=trunc(2^((kernelopts(wordsize)-1)/2));

Fac:=proc(n,m,p)
  local r:=1,k;
  for k from n to m do r := irem(r*k,p) od
end:

Fac1:=proc(n::integer,m::integer,p::integer)::integer;
  option autocompile;
  local r::integer:=1, k::integer;
  for k from n to m do r := irem(r*k,p) od
end:

ModuleApply := proc(N::nonnegint, K::nonnegint, p::prime)  # combined with Carl's
local r:=1, n:=N, k:=min(K, N-K), Bin, fac:=`if`(p<pmax,Fac1,Fac);

Bin:=proc(N,K)  # 0 <=K < p, 0 <= N
local k:=min(K,N-K);
if k<0 then return 0 fi;
fac(N-k+1,N,p)/fac(1,k,p) mod p
end;

if k<0 then return 0 fi;
while k > 0 and r > 0 do 
   r:= irem(r*Bin(irem(n,p,'n'), irem(k,p,'k')), p) 
od;
r
end:

end module:

p:=nextprime(8*10^7): n:=p*2-1:  k:=floor(p/2):
CodeTools:-Usage(BIN(n,k,p));
memory used=2.97MiB, alloc change=0 bytes, cpu time=1.89s, real time=1.88s, gc time=0ns
                            80000022

p:=nextprime(9*10^8): n:=p*2-1:  k:=floor(p/2):
CodeTools:-Usage(BIN(n,k,p));
memory used=2.11KiB, alloc change=0 bytes, cpu time=20.78s, real time=20.78s, gc time=0ns
                           900000010

NOTE. The compiler works for p < 3.037*10^9. For p greater than that, BIN uses the non-compiled Fac but then k should be smaller (or at least the reductions via Lucas' theorem) to have reasonable execution time. The magnitude of N is not important.
 

macro(ff=2*a*b-3*a-2*b-c):
f:=(a,b,c)-> `if`(ff<=30 and ff>=15,ff,0):
A:=Array(0..10,1..5,0..1,f, storage=sparse):
indices(A,pairs); # or simply inspect the Array using the matrix browser

(10, 3, 1) = 23, (7, 4, 1) = 26, (5, 4, 0) = 17, (4, 5, 1) = 17, (9, 3, 0) = 21, (8, 3, 1) = 17, (4, 5, 0) = 18, (6, 4, 0) = 22, (5, 4, 1) = 16, (8, 3, 0) = 18, (10, 3, 0) = 24, (5, 5, 0) = 25, (7, 4, 0) = 27, (5, 5, 1) = 24, (9, 3, 1) = 20, (7, 3, 0) = 15, (6, 4, 1) = 21

Vector needs a procedure (with 1 argument) as initializer.
fenq  is such a procedure but  fsenq(2.1, j)   (actually you mean fseqn) is not; it's an expression.
So, use

psf := Vector(5, j->fseqn(2.1, j));

or maybe the more "sophisticated"

psf := Vector(5, curry(fseqn, 2.1));

The roots of integer numbers are not automatically simplified. Not even 4^(1/2). It is by design.
Unfortunately it is hard to find in the help pages "automatic simplification",  even if the Programming Guide contains information about this important aspect.

plots:-animate(plot3d,
[[y, x, (1/3)*Pi], x = 0 .. 2*Pi*a, y = 0 .. 5*a, coords = spherical, scaling = constrained,axes=none], a = 0 .. 1);

using spherical coordinates.

d1:=3: d2:=3: d3:=5:    x0:=0: y0:=0: z0:=0:
eq:=[x^2+y^2+z^2-d1^2, (x-3)^2+y^2+z^2-d2^2, x^2+y^2+(z-4)^2-d3^2]:
sph:=[x=x0+r*sin(v)*cos(u), y=y0+r*sin(v)*sin(u), z=z0+r*cos(v)]:
Eq:=simplify(eval(eq,sph)):
R:=min(seq(max(solve(e,r)),e=Eq)) assuming real:
plot3d(rhs~(eval(sph,r=R)), u=0..2*Pi, v=0..Pi, color=green);

int( R^3*sin(v)/3, u=0..2*Pi, v=0..Pi, numeric, epsilon=1e-5); #volume
                          23.55847110
# The integral can be computed symbolically but the result is ugly.

Edit: the code is now a bit more general.

Note first that you are using incorrectly the 2D input. You have a space after assume which is interpreted as multiplication; so all the assume stuff is ignored (actually it is anyway useless in your case).

Maple is not smart enough to obtain such bounds. It does not know Grönwall's inequality (see wiki).

Edit. You should also avoid gamma which is a Maple constant (unless this is what you want).