Whenever a symbol is redefined by a package, the original value of the symbol can be accessed by prefixing the symbol with :-. So in this case you'd use :-``.

with(Physics):
``(3)*``(2);
Error, (in GetDifferentiationVariables) differentiation variables for dAlembertian, d_ and D_ are not defined; either use Setup(differentiationvariables =  ...) to set them, or indicate the differentiation variables as a second argument to dAlembertian

:-``(3)*:-``(2);
                            (3) (2)

There is a policy stated in the 6th paragraph at ?name : 

Names that start with an underscore (with the exception of _Env) are used as global variable names by Maple and are effectively reserved for use by library code. Do not use a symbol beginning with an underscore. The empty name `` must never be assigned a value.

It seems that Physics violates this.

For the constraints to DirectSearch, you could generate all pairs of the variables like this:

map(`<>`@op, combinat:-choose({a,b,c,d}, 2));

You can use VolumeOfRevolution and exchange the roles of x and y:

Student:-Calculus1:-VolumeOfRevolution(
      2*t^3-t^4, t= 0..2,
      axis= vertical, distancefromaxis = -2,
      output= plot, labels= [y,x,z], caption= ``
);

I believe that this is the same surface as Preben plotted.

Is that what you were expecting?

You need to remove the definition of POWER.

restart:
ee:=u^2+v^2-w^2:
applyrule(a::algebraic^b::nonunit(algebraic) = POWER(a,b), ee);

            POWER(u, 2) + POWER(v, 2) - POWER(w, 2)

Note also the presence of the modifier nonunit. This is necessary to prevent an infinite loop (where it treats everything as itself to the power 1).

Another way:

subsindets(ee, `^`, x-> POWER(op(x)));

Download diff.mw

You simply need to use the two-argument eval command.

Download eval.mw

Assuming that you mean p is the conjugate of z, then

restart:
eq:= (2*z-3)*(-3*p+4) - (2*p-3)*(-3*z+4)=0:
solve(eval(eq, [z= x + I*y, p= x - I*y]));

Therefore z can be any real number.

Several pointers in general:

1. "e" means nothing on input to Maple.The correct name is exp. You had e in one place and exp in another.
2. Functions should be defined as f:= (x,y)-> ..., not as f(x,y):= ....
3. If you want numeric integration, use Int, not int. The latter will try symbolic integration first, potentially taking a long time.

Specifically for this problem: I got 6 digits of precision on the integral in mere seconds by passing the optional argument digits= 6 to Int. There seems to be a threshold effect: At 7 digits, it starts to take a very long time. Since you have constants in your problem with only 4 digits, 6 should be enough.

Here's your worksheet with my corrections:

Download 6_digits.mw

It's tricky because Maple automatically distributes integer factors over sums. You can do this:

Notice the special quote marks in my command. It's two single backquotes (the key under ESC on my keyboard) together with nothing in between them.

The expand command will put this back to its original form.

Download primpart.mw

By starting from the closed-form expression for the Fibonacci numbers, we can generate a one-line algebraic expression for "next Fibonacci".

Download next_fibonacci.mw

It isn't exactly an issue of global vs. local. The issue is that assuming doesn't work on variables in procedures, even if they are global; but assume does work on them. It seems as though assuming was designed this way--the documentation at ?assuming,details does mention this property:

The assuming command does not scan Maple programs regarding the potential presence of assumed variables. To compute taking into account assumptions on variables found in the bodies of programs, use assume....

Perhaps someone else can comment on why it was designed this way.

Example:

restart:
f:= proc() global a; a end proc:
is(f()>0) assuming a>0;
                             false
assume(a>0);
is(f()>0);
                              true

There is no nontrivial solution to your equation. Your A has first row all zero. Thus, for any P, the [1,1] entry of A.P + P.A^%T will be 0. Thus it cannot equal your C, unless the scale factor is 0.

There's atomicweight for elements and atomicmass for isotopes. They are presented in kg by default. You can convert to amu:

macro(SC= ScientificConstants):
convert(SC:-GetValue(SC:-Element(oxygen, atomicweight)), units, kg, amu);
                        15.9994000000000

IsPrime:= proc(n) option cache; isprime(n) end proc:
APSearch:= proc()
     local SP:= 2, AD:= 210, n:= 7, k, S;
     do
          SP:= nextprime(SP);
          S:= SP + k*AD $ k = 1..n-1;
          if andmap(IsPrime, [S]) then
               return [SP, S]
          end if
     end do
end proc:     
APSearch();
              [47, 257, 467, 677, 887, 1097, 1307]

I put your data into a Matrix M with three columns. Then I gave the plot command

plot(
     [M[.., [1,2]], M[.., [1,3]]],
     labels= [time, `error`], legend= [error1, error2]
);

This command indicates a plot of two curves, the first being column 1 vs column 2 and the second being column 1 vs. column 3.