@Carl Love I did it over the Reals, of course. But m and b enter as squares in the first combined integral, so one can assume them to be positive and finally replace them by their absolute values (for selecting the other sign).

Then the second integral follows as well. Though the poster may have meant to use f2 for it (then b has to be positive anyway) and f1 is a typo.

@Carl Love Thx.

I 'played' with your generic approach off the procedure, some thoughts.

1. It is not clear which domains are valid, but instead one can feed and may use "try .. catch", since that will be faster than finding domains.

2. I used complex inputs for the variables by RandomTools[Generate] and did it for rationals. One can modify for Reals, but it would be hell to cover all domains. Integers may not be enough for trig(x*Pi).

3. Assuming Reals may fail then, but as an option indets ---> Re(indets) may work. But again for Rationals, Integers etc that is not enough. And it is not clear over which ring or field it should work. Just secondaries.

4. I pondered about "is", because one can not expect it to prove all. In other tasks for me "signum" worked quite fine, so here "csgn" was helpfull for me ('0 or not 0'?)

5. For the task ln + ln = ln(prod) that command failed. But simplify after exp worked. That is luck and depends on the task. BTW evalf fails for a black box, because of rounding errors

6. For inputs of 'small magnitute' it works. Sometimes. So one way might be to increase after a 'FAIL'. But it is a matter of taste how much one would blow up such a thing.

It would be nice that in case of 'false' the according constellation is being reported. I am fine with your proc. May be 4) is helpfull.

@Carl Love so far it is correct, yes?

For me the integrand does not work: parantheses do not match and multiplication signs are missing

@Carl Love you are right, I was too hopefull

I (vaguely) remember Int( f(x), x ) ~ Int( f(x), x = `` .. x ) as sloppy notation and would read Int( f(x), x = 0 .. x ) as Int( f(z), z = 0 .. x ) [may be assuming that the FTOC ( ~ continuous anti-derivate ) can be used or similar]. But, yes, it is very unclear.

Also I ask myself, whether that can be 'reformulated' using some DE instead of using the above formulation. And whether (Digits=10 ?) the floats do have an actual meaning.

fnormal(ms): simplify(%, zero); convert(%, rational); #identify(%);
convert(%, StandardFunctions); simplify(%);
Int(%, x): Change(%, 7*x-10 = xi, xi): subs(xi= x, %); Expand(%); value(%);

That gives me a formal result, which should be investigated

@Carl Love 

While I (roughly) can imagine the 1-dim case through a zero-counting integral I would like to have a guess for higher dim. Are you aware what the approach is used by the the 'command'?

But may be you can recognize some more 'structure' in your task. In the very example I got it by looking at the degrees.

May be you post some more from your bundle, a hard one.

NB: That is the reason for the notion "radical of an ideal" (and decomposition into prime components, if possible)

Thx! Would you mind to post the proof?

observe a change of signs for -1 < x < 0 is needed if using a "simple" simplification

((x+1)/x)^(1/2) = (x+1)^(1/2)/x^(1/2)*piecewise(-1 <x and x <0, -1, 1); # for x in Reals

restart; y:=(a*x-b)/sqrt(1-x^2);

  (a*x-b)/(-x^2+1)^(1/2)

y:=sort(y,x,ascending);

  (-b+a*x)/(1-x^2)^(1/2)

One can treat such double integrals directly in a numerical way:

For your formulation one better writes f:= D(phi)^2, no variables occure.

Then note

  Int(F(x), x=0 .. r);
  ``=IntegrationTools:-Change(%, x= r*t, t): 
  subs(t=x, %): # just to have some x again
  combine(%, Int);
                                r
                               /
                              |
                              |   F(x) dx
                              |
                             /
                               0


                                1
                               /
                              |
                           =  |   r F(r x) dx
                              |
                             /
                               0

Then write down the double integral (one of the ways) and compute it: 

  'Int(r*f(r*x), [x = 0 .. 1,r=0..1])';
  ``=evalf(%);
                          1    1
                         /    /
                        |    |
                        |    |   r f(r x) dx dr
                        |    |
                       /    /
                         0    0


                           = 2.31448547892824

This is very quick and avoids the troubles seen above.

sinh(x); MultiSeries:-asympt(%,x); eval(%, O=0);

                              1/2 exp(x)

exp(-x)*(exp(-x)+1); MultiSeries:-asympt(%,x); eval(%, O=0); 

                                  1
                                ------
                                exp(x)

I get a correct result.

diff(phi(x),x)^2*diff(eta(t),t)^2+diff(phi(x),x)^2*eta(t)*diff(diff(eta(t),t),t)
 = diff(phi(x),x)^2 * (diff(eta(t),t)^2+eta(t)*diff(diff(eta(t),t),t))

phi := x -> 
  (.7163810771*sin(1.860598606*x)-
    1.422331524*cos(1.860598606*x)+
    .2024488624*exp(1.860598606*x)+
    .9188299398*exp(-1.860598606*x)) / (1+.2*x);

f:= x -> diff(phi(x),x)^2;

'Int(f(x), x=0 .. 1)'; evalf(%);

                           6.68031378969390


Int(f(x), x=0 .. r); 
V:=value(%) assuming 0 < r: # lengthy, complicated

eval(V, r=1);
                                                    -13
             6.68031378969388 - 0.324169140691086 10    I

discont(V, r);
                       {-5., -5.00000000000000}


The spurious imaginary part comes in through numerical evaluation
of the functions in V (like "Ei") and their representation.

Likewise you can use the command given by Carl Love.