Just execute a shell script like:

maple a.mpl
maple b.mpl
maple c.mpl

and the three CLI processes will be executed simultaneously (replace maple with cmaple.exe on Windows).

Actually there is no ready facility implemented in Maple for this calculation or similar ones in the area of abstract/formal linear algebra. See, e.g. this thread and the ones linked therein (one of them is about the same question as yours).

See e.g. this thread.

It depends. The Standard GUI is implemented in Java, and the messages issued by this Java code become visible when launched from a Unix-like console. Sometimes they are just "warnings" about mild issues, so not of much concern, as in your case, it seems. Some other times they are error messages that tell about more serious issues.

A way, as you would do by hand, is:

> convert(e,sincos);
                                          2
                            (3 + 2 sinh(x) ) cosh(x)
                            ------------------------
                                           3
                                    sinh(x)
> subs(3=3*(cosh(x)^2-sinh(x)^2),%);
                                  2          2
                        (3 cosh(x)  - sinh(x) ) cosh(x)
                        -------------------------------
                                          3
                                   sinh(x)
> expand(%);  
                                       3
                              3 cosh(x)    cosh(x)
                              ---------- - -------
                                      3    sinh(x)
                               sinh(x)

> convert(%,coth);  
                                       3
                              3 coth(x)  - coth(x)

Yes, just redefine the `print/ODESolStruct` procedure, like:

> interface(prettyprint=0):
> `print/ODESolStruc`:=()->():
> ode:=diff(y(x),x$2)+a*exp(x)*sqrt(y(x)):
> sol:=dsolve(ode,y(x));
sol := y(x) = ODESolStruc(_a/exp(-2*Int(_b(_a),_a)-2*_C1),[{diff(_b(_a),_a) = (
_a^(1/2)*a+4*_a)*_b(_a)^3+4*_b(_a)^2}, {_a = y(x)*exp(-2*x), _b(_a) = 1/exp(-2*
x)/(diff(y(x),x)-2*y(x))}, {x = Int(_b(_a),_a)+_C1, y(x) = _a/exp(-2*Int(_b(_a)
,_a)-2*_C1)}])

Yes, printing assumed variables with a trailing tilde is an output phenomenon, see ?interface , entry showassumed. Its available values are 0, 1 and 2. Tilde is setting of 1. Try your example with 0 or 2. Indeed, this instability of assumptions under copy&paste is one of the weaknesses of the assume facility. Actually a patch on the original design of the Maple system. But it is better than nothing...

@Muhammad Ali 

One observation is that the command gc performs garbage collection on the C sector of the Maple system (the historical C kernel). The Java sector of the system, running over a virtual machine and most important if you are using the Standard GUI, has its own (separated) garbage collection mechanism. Meaning that under some usage circumstances executing gc may have little effect on returning memory back to the OS. And I think that there is no "standard" programmatic way to force garbage collection on the Java sector.

So, if you are at this situation, the most efficient usage of your RAM resources is using the CLI as much as possible.

If you do not need GUI features in the output (plots, typeset results), it would be much more straightforward and efficient for batch processing to use the CLI and text files for input and output.

It seems possible by elementwise substraction:

> seq1:=seq(i,i=1..5);
                             seq1 := 1, 2, 3, 4, 5
> seq2:=seq(i,i=1..5);
                             seq2 := 1, 2, 3, 4, 5
> seq2-seq1;
                                       0
> seq2 -~ seq1;
                                 0, 0, 0, 0, 0

Collapsing 0's is, I think, undocumented behavior. In such case, it is, at least, a documentation bug, and possibly a code bug also.

Albert Rich has communicated me the Rubi solution for this indefinite integral. It checks fine (on all the complex plane), it is continuous on the real axis and it is reasonably simple:

> G:=2*I*x*arctan(exp(I*x)) + x*ln(sec(x)+tan(x)) - I*polylog(2, -I*exp(I*x)) +
> I*polylog(2, I*exp(I*x)):
> f0:=ln(sec(x) + tan(x)):
> diff(G,x):
> convert(%,ln):
> simplify(% -f0);
                     (exp(2 I x) - 2 exp(x I) cos(x) + 1) x
                     --------------------------------------
                            (exp(2 I x) + 1) cos(x)
> convert(%,exp);
                                       0

> plot([Re,Im](G),x=0..10,color=[red,blue]);

Hence, the OP's definite integral can be computed right away:

> limit(G,x=10,left)-limit(G,x=0,right);
                  10                              10
20 I arctan(exp(I)  ) + 10 I Pi - dilog(1 + exp(I)   I) I
                       10
     + dilog(1 - exp(I)   I) I + 10 ln(1 + sin(10)) - 10 ln(-cos(10))
     + 2 Catalan
> evalf(%);
                          3.493589066 + 16.61151993 I

If a composed TypeMK name is wanted, I think that the correct way is creating it following the "standard" mrow construct. An auxiliary procedure may help as in this toy example:

compose:=proc(x,y)
nprintf("#mrow(mi(%A),mi(%A))", x,y);
end proc:

De:=compose(Delta,epsilon);
                  #mrow(mi(Delta),mi(epsilon))

De(T,z);
               #mrow(mi(Delta),mi(epsilon))(T, z)

type(De,symbol);
                              true

Download compose.mw

Not only the primitive function is discontinuous because of its branch cuts, but also it is wrong as its derivative is different from the integrand. See the plot of the real and imaginary parts of the difference. It is nonvanishing in some sectors of the complex plane :

F:=int(ln(sec(x)+ tan(x)),x):
f:=diff(F,x):
f0:=ln(sec(x) + tan(x)):
d:=f-f0;
PlotExpression(d,x=-10*I..10+10*I,title="",labels=[Re(x),Im(x),"d"]);

(here I am using the procedure PlotExpression).

This thread had a discussion on this design and alternatives, but it has been wiped out (I keep a copy).

Try remove:

> remove(has,R,t);
                                3             2
                        -1/16 C2  - 1/16 C2 C4  + 1/2 C2