First - collect, then - exp:

restart;

a0:=I*(m*x+mp*x-omega[m]*t-omega[mp]*t);

a1:=exp(collect(a0, [x,t]));

     # or

a2:=exp(a0);

applyop(collect, 1, a2, [x, t]); 

Or use  a more powerful  algsubs  command:

w:=x+2+sin(x+2);

algsubs(x+2=u, w);

          w := x+2+sin(x+2)
                  u+sin(u)

PP:=proc(S::set)

local It, Sp, s;

if S={} then return {{}} fi;

It:=proc(Sp, s)

{op(Sp), seq(Sp[i] union {s}, i=1..nops(Sp))}

end;

Sp:={{}};

   for s in S do

   Sp:=It(Sp, s)

   od;

Sp;

end;

Example:

PP({a,b,c,d,e});

{{}, {a}, {b}, {c}, {d}, {e}, {a, b}, {a, c}, {a, d}, {a, e}, {b, c}, {b, d}, {b, e}, {c, d}, {c, e}, {d, e}, {a, b, c}, {a, b, d}, {a, b, e}, {a, c, d}, {a, c, e}, {a, d, e}, {b, c, d}, {b, c, e}, {b, d, e}, {c, d, e}, {a, b, c, d}, {a, b, c, e}, {a, b, d, e}, {a, c, d, e}, {b, c, d, e}, {a, b, c, d, e}}

X:=Array([seq([x, x^2, 8-4*x], x=0..2.9, 0.1)]);

plot([seq(X[i,2],i=1..30)], [seq(X[i,1],i=1..30)]);

             # or

plot([seq(X[i,3],i=1..30)], [seq(X[i,1],i=1..30)]);

See  http://www.physics.arizona.edu/~restrepo/475A/Notes/sourcea-/node23.html

I have reduced the equation by  x^2  removing the trivial root  x=0.

plots[implicitplot](x+omega^2*x^3-omega=0, omega=-2..10, x=-1..1, thickness=2, numpoints=20000);

It is easy to guess the rule: if  n  is even then  F(n)=F(n-1)*3  else  F(n)=F(n-1)+9  so

F:=proc(n)

option remember;

if n=1 then 3 else

((-1)^n+1)/2*3*F(n-1)+(1-(-1)^n)/2*(F(n-1)+9) fi;

end:

seq(F(n), n=1..15);

                3, 9, 18, 54, 63, 189, 198, 594, 603, 1809, 1818, 5454, 5463, 16389, 16398

Enequality  n^2<=2^n  is true for all integer  n>=4 .

Two variants:

restart:

is(n^2<=2^n) assuming n::integer, n>=4;

restart:

assume(n::integer, n>=4):

is(n^2<=2^n);

                       true

                       true

l := 89: h := 49: d:= 55: beta1 := 11.5*Pi/180:

A := l*sin(beta1): B := l*cos(beta1): C := (h + 0.5*d)*sin(beta1) - 0.5*d*tan(beta1):

E := (h + 0.5*d)*cos(beta1) - 0.5*d:

RootFinding[Analytic](A*sin(alpha)*cos(alpha) + B*sin(2*alpha) - C*cos(alpha) - E*sin(alpha) = 0, alpha, re=0..2*Pi, im=-1..1);

evalf(map(convert,[%], degrees));

There is no  33 degrees or  22 degrees  in this list .

Your formula for the width of the wall of the players can be simplified since

sqrt(6400*x^4+12800*x^2*y^2+6400*y^4) = 80*(x^2+y^2)

and needs some refinement. This formula is true if it is assumed that the width of a football goal is 8 meters, and the distance from the point  (x, y)  to the wall is 10 meters. In fact, the gate width should be equal to 7.32 meters, and the distance to the wall  9 meters. 

With these adjustments more accurate formula:

z = (65.88*(x^2+y^2))*y/abs((x^2+y^2-3.66*x)*(3.66*x+x^2+y^2))

We construct a plot of this function, taking into account that the domain is a football field minus the penalty area:

restart;

z := unapply(piecewise(abs(x)<20.15 and y>0 and y<16.5, undefined, (65.88*(x^2+y^2)*y)/abs((x^2+y^2-3.66*x)*(3.66*x+x^2+y^2))), x, y):

plot3d(z, -34..34, 0..40, view=[-34..34, 0..40, 0..4.5], style=surface, axes=normal, numpoints=10000, orientation=[-40, 75], lightmodel=light4, labels=[x, y, z]);

plot3d([27*(t-sin(t)), sqrt((27*(1-cos(t)))^2)*cos(s), sqrt((27*(1-cos(t)))^2)*sin(s)], t=0..2*Pi, s=0..2*Pi);

ListTools[Reverse]([[1,4],[2,3],[3,2],[4,1],[6,5],[6,1]]);

                         [[6, 1], [6, 5], [4, 1], [3, 2], [2, 3], [1, 4]]

a[1], a[2], a[3]:=3, -1, 2:

for n from 3 to 89 do

a[n+1]:=a[n]-3*a[n-1]+a[n-2]:

od:

a[90];

                   58692136618345153331

A:=-9-60*s1/(60*s1-1)+500*s1^2/(10*s1-1)/(60*s1^2/(10*s1-1)-1):

solve({A>=2.5, A<5});

            {0.01531863559 <= s1, s1 < 0.01554503851}, {0.1400885995 <= s1, s1 <= 0.3572594316}

Procedure  Rename  solves your problem. If solutions of the system depend on a single parameter, it is denoted by  t , and if solutions depend on  r  parameters, they are denoted by  t[1], t[2], ... , t[r] .

Rename:=proc(sys)

local Ind, S, L, n, r;

Ind:=indets(sys);

n:=nops(Ind);

solve(sys);

L:=[seq(rhs(%[i]), i=1..n)];

S:=indets({op(L)});

r:=nops(S);

if r=1 then {seq(Ind[i]=eval(L[i],{op(S)=t}), i=1..n)} else

{seq(Ind[i]=eval(L[i],{seq(S[j]=t[j], j=1..r)}), i=1..n)} fi;

end proc;

Example:

sys:={x[1]-x[2]=1, x[1]+x[2]-x[3]-x[4]=5};

solve(sys);

Rename(sys);