Should this generate an error?

restart;
r:=evalc(Im(1/ln(x)));
solve(r,{x});

This did not help. Same error as above.

restart;
r:=evalc(Im(1/ln(x))):
solve(r,{x}) assuming x::real;

This made Maple not give an error

restart;
r:=evalc(Im(1/ln(x))):
solve(r,{x}) assuming x::real, x>0;

       {x = x}

Also this worked, but NULL returned

restart;
r:=evalc(Im(1/ln(x))):
solve(r,{x}) assuming x::real, x<0;

Also this worked with NULL returned

restart;
r:=evalc(Im(1/ln(x))):
solve(r,{x}) assuming   x<0;

Is this how Maple generally works? i.e It generates an exception error when it is not able to solve something? Or does it normally echo back the input back if it can't solve something? Or at least return NULL if it can't solve it? I am havin hard time figuring which method to use to check if Maple is able to solve something or not, because each time it seems to do something different.

Should one then put a try/catch around each Maple call, and treat the try section as if Maple was not able to solve the equation whatever it was?

singular(ln(y^2+1),y);

        {y = -I}, {y = I}, {y = infinity}, {y = -infinity}.

But if "y" was real, then there are no finite singularities, since y^2 is always positive and hence y^2+1>0 always. Adding assumptions did not help

singular(ln(y^2+1),y) assuming y::real;

gives same result. RealDomain does not support singular.  But I am no longer using RealDomain as it seems bugy.

I know I could filter out these complex results using remove(), but it would be nice if there was a way to singular supports assumptions. Is there a way to do it?

Why are the following 2 commands produce different result?

restart;
RealDomain:-solve({y=y,y<>0},y);
solve({y=y,y<>0},y);

                            [y = 0]
                            {y <> 0}
 

Should not the result be the same?

solve({y=y,y<>0},y) assuming y::real;
                           {y <> 0}

Maple 2018.1. 

Are these errors to be expected? Why do they happen?

restart;
solve({x<>10, -infinity<x , x<infinity, -infinity<y , y<infinity},{x,y});

Error, (in solver) invalid input: SolveTools:-Inequality:-LinearUnivariateSystem expects its 1st argument, eqns, to be of type ({list, set})({`<`, `<=`, `=`}), but received {x <> -infinity, x < 10}

But it works when replacing x<>10 by y<>10

restart;
solve({y<>10,-infinity<x , x<infinity, -infinity<y , y<infinity},{x,y});
            {10 < y, x < infinity, y < infinity, -infinity < x}, {y <> -infinity, x < infinity, y < 10, -infinity < x}

What is the difference in the above two?

It also work when replacing x<>10 by x=10

solve({x=10, -infinity<x, x<infinity, -infinity<y , y<infinity},{x,y});
               {x = 10, y < infinity, -infinity < y}

It also works when removing the y parts by keeping x<>10

solve({x<>10, -infinity<x , x<infinity},{x,y});
           {y = y, 10 < x, x < infinity}, {y = y, x < 10, -infinity < x}

it also works when removing x<>10 and putting back the y stuff

solve({-infinity<x , x<infinity, -infinity<y , y<infinity},{x,y});
              {x < infinity, y < infinity, -infinity < x, -infinity < y}

Why Maple gives an error for some cases and not the others?

Maple 2018.1

I was trying the solution given in 

https://www.mapleprimes.com/questions/225083-Maple-Command-To-Find-Domain-Of-Function

Which works fine for some functions, but fail for some reason for other functions.

restart;
f:=x*ln(y);
solve(evalc(Im(f)), {x,y});

But fails on 

restart;
f:=sqrt(x)*ln(y);
solve(evalc(Im(f)), {x,y});

Using Maple 2018.1 with Physics 

`2018, July 3, 20:10 hours, version in the MapleCloud: 78, version installed in this computer: 74`

Why this error happen on some functions? Is there a way around it?

One way to workaround it I found, is to use solve for one variable at a time. Now Maple do not give an error

restart;
f:=sqrt(x)*ln(y);
solve(evalc(Im(f)), {x});
solve(evalc(Im(f)), {y});

Strange it failed when using {x,y} at same time on this one, but not on the first one. But the above answer is wrong. For "x", it should be x>=0 and not x=0. If I remove the "y" now it gives correct answer

restart;
f:=sqrt(x)*ln(y);
solve(evalc(Im(f)), {x});

f:=sqrt(x);
solve(evalc(Im(f)), {x});

This makes no sense to me.

I am finding too many bugs in Maple making it not useable and having to keep coming with workarounds. 

Maybe it should be tested more thoroughly before release.