@acer 
Thanks for the comprehensive list of pointers.
After reading through the directions list, I still don't understand much of it
a?,b?,c?,d?,e,f?,g,h?,i,j,k,l,m,n,o,p,q
c: is the use of a module in which procedures can be called? 
Where(with ) to start: how is the setup ?

You can also have an expression and run an iteration of simplification commands on it.
That's a different approach than running down a list of simplification commands.

New method discovered: combined two methods

Expressions can be simplified with various combinations of commands.
It is also informative that an expression comes in different forms

Try some expressions your self ...

veeenvoudingings_proc-full_simplify5_Maple_primes.mw

@Carl Love 

Explain again what exactly is meant by your text :

"Your problem comes from using the default equality operator = to check the mathematical equality of algebraic expressions, but = only checks whether the expressions are syntactically identical in their unsimplified form. That's a much stronger form of equality than mathematical equality."

post : 

Use `is` for mathematical equality

Now doing alone simplication examples ...
vereenvoudigings_proc-versie_2_naaar_MPFORUM_DEF.mw

If you see this kind of generic solution, then in my opinion, Maple doesn't know either.
Checking then yields nothing. 

@mmcdara 
Thanks, I try this for expression T, it gives s8 : for  a := full_simplify(T); and with : print~(full_simplify~(T)) s7,s9 and s16 

a := full_simplify(T[2]):
b := convert(rhs~(a), set):
t := map(u -> lhs~(a[[ListTools:-SearchAll(u, rhs~(a))]]) = u, b):
print~(t):

Error, (in anonymous procedure) invalid input: lhs received (s8 = [(-12*cos(3*t)^2-228*cos(3*t)-54)/(-1169+72*cos(3*t)^3-124*cos(3*t)+388*cos(3*t)^2), 1/2*2^(1/2), 1/9*(ln(1+2^(1/2))+2^(1/2))^2, 1/2*exp(1/2*x)*(cosh(1/2*x)-cosh(3/2*x)+sinh(1/2*x)+sinh(3/2*x))])[[1]], which is not valid for its 1st argument, expr

"As several simplification methods lead to the same result, you could be interested in knowing those that give the same."
In other simplifications has this multiple same simplification some uses ?
Interesting question too is, find a simplification what simplified a expression the most .: the procdure must use this one.

@mmcdara 
Thanks, that's a great idea to add a numbering to the simplification commands.
 

I add two simpifications more for trigoniometry and exp 
simplify(combine(expand(simplify(expr)), trig), trig),# special for trigonimetry 
 convert(simplify(combine(simplify(convert(e, trig)))), exp) assuming real # special for exp(x) powers

later i will add some more simplifications for other expressions.
Try to get this simplification
[exp(-1)*exp(x)/sqrt(2 - exp(-2)*exp(x)^2), sqrt(2)/2, (ln(1 + sqrt(2)) + sqrt(2))^2/9, exp(x)/2 - exp(-x)/2]

Rotation cone around the x-axis as start

Download _8_kegels_met_random_kleur_maple_primes.mw

Thanks, in the meantime had also done something with tickmarks: 
 tickmarks = [[-2, -1, 0, 1, 2], [-2, -1, 0, 1, 2], [-2, -1, 0, 1, 2]],
The procedure also works with this, only it is static 

Going to modify it with view as well., that's easier for comparing the cones if they are equal.
Looks like the procedure now works well with a cone at an angle to the positive x-axis of 10 degrees and 45 degrees

How to debug this ? 

with(plots):
with(plottools):

plotCone := proc(phi_degrees, x_range::range, y_range::range, z_range::range)
    local R, param_cone, apply_rotation, kegel, phi;

    # Convert degrees to radians
    phi := phi_degrees * Pi / 180;

    # Define the rotation matrix
    R := Matrix([
        [1, 0, 0],
        [0, cos(phi), -sin(phi)],
        [0, sin(phi), cos(phi)]
    ]);

    # Define the parametric equation of the cone
    param_cone := (t, theta) -> [t, t*cos(theta), t*sin(theta)];

    # Define a function to apply the rotation matrix to a vector
    apply_rotation := (R, v) -> [
        R[1,1]*v[1] + R[1,2]*v[2] + R[1,3]*v[3],
        R[2,1]*v[1] + R[2,2]*v[2] + R[2,3]*v[3],
        R[3,1]*v[1] + R[3,2]*v[2] + R[3,3]*v[3]
    ];

    # Create a matrix for the cone
    kegel := (t, theta) -> apply_rotation(R, param_cone(t, theta));

    # Plot the cone with specified ranges for the axes
    plot3d(
        kegel(t, theta),
        t = 0 .. 2,
        theta = 0 .. 2*Pi,
        x = x_range,
        y = y_range,
        z = z_range,
        axes = boxed,
        scaling = constrained,  # Keep the scaling of the axes consistent
        labels = ["x", "y", "z"],
        title = cat("Cone around the positive x-axis (phi = ", phi_degrees, " degrees)")
    );
end proc:

# Call the procedure with a desired angle in degrees and specified ranges for x, y, and z axes
plotCone(10, -2 .. 2, -2 .. 2, -2 .. 2);  # Adjust the ranges as needed

Error, (in plot3d) unexpected options: [x = -2 .. 2, y = -2 .. 2, z = -2 .. 2]

Thanks, I did not know this plot command. 
There is also a 3d version of it, but let's see how to use it.
The idea of the procedure is to use a plane in various positions to create a intersection with solids.
Started with a cylinder.

@Carl Love 
Can determine from an existing procedure its "level", but what it's relation to a printlevel? 

 

myProcedure := proc()
    local currentDepth,  innerProcedure;
    currentDepth := kernelopts(level);
    printf("Current evaluation depth: %d\n", currentDepth);
    
    # Nested procedure to demonstrate depth change
    innerProcedure := proc()
        local innerDepth;
        innerDepth := kernelopts(level);
        printf("Inner procedure evaluation depth: %d\n", innerDepth);
    end proc;
    
    innerProcedure(); # Call the nested procedure
end proc:

# Call the main procedure
myProcedure();

Current evaluation depth: 23
Inner procedure evaluation depth: 44

Simple debugging handling for a procedure
trace ? for this example. 

Download vooorbeeld_voor_mapleprimes_post_debuhgging.mw

procedure 

@mmcdara 
Thanks, if the procedure contains : loop or if statement : printlevel : +1
For each procedure call : printlevel : +5, that is for recursion programming, so each iteration for that requires a procedure call. 

@janhardo 

The printlevel depends on the complexity of the procedure.