it took me hrs to find this as my solution was failing verification and I did not know why.

What logic do you think Maple used to simplify this:

expr:=sqrt(1 + sin(x))/x;
simplify(expr)

To this

How could the above be simpler than

?

Compare to Mathematica

And this is what I expected. I am now scared to use simplify in Maple as I do not know what I will get back.

Is there a way to tell Maple not to do such strange "simplification"? I am doing this in code, and the code does not know what the expression is.

To see an example of the side effect of this, here is one, where if solution to an ode is simplified first, it no longer verifies by odetest without adding extra assumptions:

One does not expect that simplified solution no longer verfiies the ode.

Sure, I can do

          odetest(simplify(sol),ode) assuming real;

and now it gives 0. But the point is that the first one did not need assumptions.

Download simplify_with_odetest.mw

Maple 2024 on windows 10.

THis ode looks complicated

ode := (2*x^(5/2) - 3*y(x)^(5/3))/(2*x^(5/2)*y(x)^(2/3)) + ((-2*x^(5/2) + 3*y(x)^(5/3))*diff(y(x), x))/(3*x^(3/2)*y(x)^(5/3)) = 0;

But is actually a simple first order linear ode:

RHS:=solve(ode,diff(y(x),x));
new_ode:=diff(y(x),x)=RHS;

Whose solution is 

But Maple gives this very complicated answer as shown below. When asking it to solve as linear ode, it now gives the much simpler solution.  

Maple complicated solutions are all verified OK. But the question is, why did it not give this simple solution?

Attached worksheet.  All on Maple 2024

Download why_missed_simple_solution_march_17_2024.mw

In Maple 2022

restart;

res := t^3 - 3*t^2*sqrt(t^2*(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(1/3))*ln(t)/(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(2/3) - 2*t^2*sqrt(t^2*(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(1/3))*sqrt(2)/(12*sqrt(2)*ln(t) + 9*ln(t)^2 + 8)^(2/3);
plot(res,t=-5..1)

gives

The same exact code in Maple 2024 gives

Worksheet is below. 

Both on same PC. Windows 10.

Will report to Maplesoft, but thought to check also here is others have seen such problem before.

Btw, Maple 2022 plot is the correct one.

Download wrong_plot_V_2024_march_15_2024.mw

Maple's coulditbe  is useful. But unfortunately it does not return back to the user the conditions under which the proposition was found true. This could make it much more useful. It seems in way similar to Mathematica' Reduce but Reduce returns the conditions.

Is there a way to find the conditions which makes it true? 

I use coulditbe alot. I use it to verify that the result of odetest (I call it the residue) is zero or not. Maytimes, odetest does not return zero. And using simplify, or evalb or is to check if the residue is zero, all fail. But many times, coulditbe returns true, meaning the residue is zero. But I do not know under what conditions. In Mathematica's Reduce, it tells me the conditions. 

Here is one of hundreds of examples I have

restart;
ode:=(t^3+y(t)^2*sqrt(t^2+y(t)^2))-(t*y(t)*sqrt(t^2+y(t)^2))*diff(y(t),t)=0;
ic:=y(1)=1;
sol:=dsolve([ode,ic]);
the_residue:=odetest(sol,[ode,ic]);

You see, odetest says it could not verify the solution (the first entry above) but it did verify the solution against the initial conditions. 

Using simplify, evalb and is all also could not verify it

simplify(the_residue[1]);
evalb(the_residue[1]=0);
is(the_residue[1]=0);

Now coulditbe does:

_EnvTry:='hard':
coulditbe(the_residue[1]=0);

So the solution is correct, but I do not know under what conditions. Using Mathematica's Reduce I can find this:

So now back in Maple, I can do this

simplify(the_residue[1]) assuming t>exp(-2*sqrt(2)/3);

                      0

Actually in this example, just using assume t>0 also gives zero. But I am using Mathematica's result for illustration.

You might ask, why do I need to know for what values of the independent variable is the residue zero?

Because in some cases, the residue is zero only at single point! So it does not make sense to say the solution is verified to be correct only at one single point of the domain, right?

it needs to be some finite range at least. Here is an example of an ode whose solution is correct only at x=0

ode:=diff(y(x),x)=3*x*(y(x)-1)^(1/3);
ic:=y(3)=-7;
sol:=dsolve([ode,ic]);
the_residue:=odetest(sol,[ode,ic]);

And simplify, evalb, is all fail to verifiy this, but coulditbe says true

simplify(the_residue[1]);
evalb(the_residue[1]=0);
is(the_residue[1]=0);
_EnvTry:='hard':
coulditbe(the_residue[1]=0);

So now, we ask, is this solution then correct or not? It turns out to be zero but only at origin x=0

plot(abs(the_residue[1]),x=-1..1)

If I knew that residue is zero only at single point, then I would say this solution is not correct, right?

And that is why I need to know under what conditions coulditbe retruned true.

I tried infolevel[coulditbe]:=5 but nothing more was displayed on the screen.

Mathematica's Reduce confirms that when x=0 the residue is zero.

So my question is simply this: Can one obtain the conditions used by coulditbe to determine when result is true?

It will be useful if Maple could in future version return the value/range which makes it true.

Maple does not have full_simplify() command like with Mathematica.

So I figured why not make one? 

Here is a basic implementation. All what it does is blindly tries different simplifications methods I know about and learned from this forum then at the end sorts the result by leaf count and returns to the user the one with smallest leaf count.

I tried it on few inputs.

Advantage of full_simplify() is that user does not have to keep trying themselves. One disadvantage is that this can take longer time. timelimit can be added to this to make it not hang.

Can you see and make more improvement to this function?

May be we all together can make a better full_simplify() in Maple to use. Feel free to edit and change.

#version 1.0  
#increment version number each time when making changes.

full_simplify:=proc(e::anything)
   local result::list;
   local f:=proc(a,b)
      RETURN(MmaTranslator:-Mma:-LeafCount(a)<MmaTranslator:-Mma:-LeafCount(b))
   end proc;

   #add more methods as needed

   result:=[simplify(e),
            simplify(e,size),
            simplify(combine(e)),
            simplify(combine(e),size),
            radnormal(evala( combine(e) )),
            simplify(evala( combine(e) )),
            evala(radnormal( combine(e) )),
            simplify(radnormal( combine(e) )),
            evala(factor(e)),
            simplify(e,ln),
            simplify(e,power),
            simplify(e,RootOf),
            simplify(e,sqrt),
            simplify(e,trig),
            simplify(convert(e,trig)),
            simplify(convert(e,exp)),
            combine(e)
   ];   
   RETURN( sort(result,f)[1]);   

end proc:

worksheet below

Download full_simplify.mw