Maple is using SimplifySteps (number 8 in FSimp procedure) here and shows that numerator and denominater are 0 
So, its [0/0]  
But nothing happens further and it should be interesting if L'Hopital is applied and a new limit is calculated 
Limit(-2*x^2*ln(x)^2, x = 0, right), but this is the same situation as for the startlimit 
Another trick is needed.
Perhaps with RuleSteps i get a new( but useless) limit  for the [0,0] ?
------------------------------------
Concerns me if Maple wants to be educational and show in steps of a solution , then also all the steps can be seen in a solution
--------------------------------------

In my FSimp procedure i did SimplifySteps on a limit and in my textbook example l'hopital
Seems to be not clear what l'hopital version is used by Maple ( there are two versions [0/0],[infinity/infinity] )


voorbeeld_Mprimesforum_limiet_lhopital.mw

@vv 
Thanks, In the most right limit you can recognize some standardlimits 
But how do you know when to use l'hopital ?

With this little investigation ...
But x.ln x for x->0  gives [ 0, infinity ]  = lim x<- 0  x/ 1/ln x = [0/0] (=l'hopital)

lim x<- 0  1/ (- 1/ ln^2.x). 1/x (l'hopital applied, but it seems to go to limit x<--0  gives   x ln x^2 
Its not going better now with this limit

So we need to rewrite  x.ln x again on a second way...

Tried to add limit rules, but don't know how to handle the Calculus1 infolevel 1 and assigning exactly Calculus 1 package with the Uses cmmand  

FSimp-integration-assuming_Mprimes_26-7-2024.mw

Can now handle a sequence of assumptions

FSimp-integration-assuming_Mprimes_21-7-2024.mw

I solved it for integration : undefined or defined integrals are recognised in FSimp procedure 
A integral with  a assumption  can also be used too

"Now, do you understand that the expression
   u::nonnegint
is not itself an integer? Do you understand that the expression u::nonnegint is not itself of type nonnegint?"
yes, if it not is working

FSimp-integration-assuming_Mprimes_20-7-2024.mw

Simplify with assuming is working, but not working is Definite integral with assumption method yet.
( using the definite integral method instead  of it)
Funny enough method 14 seems to be working with a assumption, while it has no definition for it 
The variable of u in the integral is defined in FSimp procedure
Chanced also the FSimp input names for easier handling and  a assumption message 

FSimp-integration-assuming_Mprimes_19-7-2024.mw

@acer 

Seems not be solving this assuming problem by  using assumption as keyword  : example : assumption=(0 <= u) on 6 th position

e3 := Int(exp(-u*x)*x^(1/3), x = 0 .. infinity);
assumption:= (0 <= u);

FSimp(e3, 15,true,2,false, assumption); # zie het Maple-voorbeeld in de help

FSimp(Int(exp(-u*x)*x^(1/3), x = 0 .. infinity), 15, true, 2, false, 0 <= u)

@acer 
Thanks

Version FSimp 17-7-2024 has difficulties with assuming ....

FSimp-integration-assuming_Mprimes_17-7-2024.mw

To solve this, you must do it  interactively and follow the proof steps and then construct a method sequenze?

Final FSimp command to do simplifications on a expression
Easy to use 

FSimp_met_method_category_en_t_en_f_en_all_invoer_DEF4-7-2024.mw
Now the procedure must handle this ?

For simplifications as start as a procedure :FSimplify
Cannot be more simple ...
Next stap to do is categorising the methodlist in FSimplify  for applying the best/right methods

EXAMPLES

e:=(*2*sin(beta)^2*) +4*cos(alpha+beta)*sin(beta)+cos(2*(alpha+beta));# another strategy to simplify this answer:s cos(2alpha) 
                       2                                
       e := 2 sin(beta)  + 4 cos(alpha + beta) sin(beta)

          + cos(2 alpha + 2 beta)


e2:=cos(x)^2-sin(x)^2;
                                2         2
                    e2 := cos(x)  - sin(x) 

e1:=sin(x)^2+cos(x)^2;
                                2         2
                    e1 := sin(x)  + cos(x) 

FSimplify(expr, method ( 1, 1..10  as number or range) , metlist( 1..1, 1...10 ,for set false on methods) , methodlist on/off (true or false, default on true) 
#FSimplify(e,10);
FSimplify(e,10..20);
e3 := int(1-(sum(p[i]*(1-exp(-((t-xi)/tau[i]))), i=1..n)), xi=0..t);
                                     /    /
                                     |    |
                                     |    |
e3 := Typesetting:-msubsup(int, 0, t)\1 - \

                                                             / 
                                                             | 
                                                             | 
  Typesetting:-munderover(sum, iequals1, n)ApplyFunctionp[i] \1

                        t - ξ\\\                  
                 uminus0--------|||                  
                        τ[i]|||                  
   - ExponentialE               /// DifferentialDξ


#FSimplify(e3,7); # FSimplify(e3,7,false)no methodlist to see 
#c# try out method 13 
e4:= r^n;
                                   n
                            e4 := r 

FSimplify(e4,13);
------------------
Methods list:
------------------
1: CompleteSquareSteps(e)
2: ExpandSteps(e)
3: FactorSteps(e)
4: ODESteps(e)
5: PartialFractionSteps(e)
6: PowerSteps(e)
7: ReplaceIntSum(e)
8: SimplifySteps(e)
9: SummationSteps(e)
10: TrigSteps(e)
11: Sum(e, n=0..k)
12: sum(e, n=0..k)
13: SumMethods(e, n=0..k)
14: `assuming`([convert(simplify(combine(simplify(convert(e, trig)))), exp)])
15: collect(e, exp(x))
16: collect(e, ln(x))
17: combine(convert(e, trig))
18: combine(e)
19: convert(e, exp)
20: convert(e, rational)
21: convert(e, trig)
22: evala(factor(e))
23: evalc(e)
24: evalindets(e, `+`, simplify)
25: evalindets(e, radical, u->map(simplify, u))
26: factor(simplify(expand(combine(e, trig))))
27: normal(e)
28: radnormal(combine(e))
29: radnormal(evala(combine(e)))
30: rationalize(e)
31: simplify(combine(e))
32: simplify(combine(e, size))
33: simplify(combine(expand(simplify(e)), trig), trig)
34: simplify(convert(e, exp))
35: simplify(convert(e, trig))
36: simplify(e assuming complex)
37: simplify(e assuming rational)
38: simplify(e assuming real)
39: simplify(e)
40: simplify(e, Ei)
41: simplify(e, RootOf)
42: simplify(e, factorial)
43: simplify(e, hypergeom)
44: simplify(e, ln)
45: simplify(e, polar)
46: simplify(e, power)
47: simplify(e, size)
48: simplify(e, sqrt)
49: simplify(e, symbolic)
50: simplify(e, symbolic, power)
51: simplify(e, symbolic, trig)
52: simplify(e, trig)
53: simplify(radnormal(combine(convert(e, trig))))
54: simplify(radnormal(combine(e)))
55: simplify(simplify(convert(e, 'sincos'), constant, sqrt), trig)
********************************************************
Original expression: lc = 3, l = 5

                                n
                               r 

********************************************************
All simplifications:
********************************************************
M13 (SumMethods(e, n=0..k))(lc = 29, l = 74):

                    k                        
                  -----                      
                   \          (k + 1)        
                    )    n   r            1  
                   /    r  = -------- - -----
                  -----       r - 1     r - 1
                  n = 0                      

******************************************************
Sorting by complexity of simplified expressions:
M13 (SumMethods(e, n=0..k))(lc = 29, l = 74):

                    k                        
                  -----                      
                   \          (k + 1)        
                    )    n   r            1  
                   /    r  = -------- - -----
                  -----       r - 1     r - 1
                  n = 0                      

FSimplify_proc_vaste_methodenlijst_DEF_Mprimes.mw

@Scot Gould 

Thanks for the response, 
I like the idea of using a procedure instead of a module ( the with( ) construct) , which is the case now.

The simpler it can be programming, the better, but ease of use comes first.
 I would give it the name FSimplify, because Simplify already exists in Maple and is a protected name

FSimplify( method, metlist , ?,?, options) as a procedure
The method becomes a number and which method to choose from a method list: metlist something like that ?

Can see if I can make a setup of this and look at the ease of use. 

It has actually become a flop programming a Simplify module to go simplify expressions..
Easily adding a method to go simplify an expression failed in the module code.
To keep it simple for a user of the module and not make changes in the code programming itself, that has not been possible, too bad.

@acer 
Thanks for your help.
If this Method added: combine(e, trig) is working and it is possible to add more methods with the command AddMet ,save them, then it could be useful this module programming.

I think i earlier realized the same output, but could not give meaning to it 
Command ShowMet( ) , shows the all added methods , working or disabled ( true or false)