Why can Reduce solve for Integers but not for Reals?

I’m showing as an image, since the question is generic. If we remove mm from the inequality we get both solutions. Why doesn’t the first inequality work for both domains?

Edit here is the code per request:

Clear[m, n, c, d];
c = (m == 1 &&
n >= 0 && ((-1 + 3^n m)/(-1 + 2^n m) – (3^n) /(2^
n) ) > ((-1 + 3^(n + 1) m)/(-1 + 2^(n + 1) m) – (3^(n + 1)) /(
2^(n + 1)) ));
d = (n >=
0 && ((-1 + (3^n) )/(-1 + (2^n) ) – (3^n) /(2^
n) ) > ((-1 + (3^(n + 1)) )/(-1 + (2^(n + 1)) ) – (
3^(n + 1)) /(2^(n + 1)) ));
Reduce[c, {n}, Integers]
Reduce[c, {n}]
Reduce[d, {n}, Integers]
Reduce[d, {n}]

=================

4

 

The default domain for Reduce is not Reals, it’s Complexes. Try Reduce[c, {n}, Reals].
– Chip Hurst
May 18 ’15 at 21:35

1

 

@ChipHurst, I didn’t know the default domain, however using Reals also doesn’t work.
– Fred Kline
May 18 ’15 at 21:39

  

 

Fred, would you mind posting the code anyway? I figure things out by tinkering, and I’d really rather not have to retype your equations.
– MarcoB
May 18 ’15 at 22:36

=================

1 Answer
1

=================

Clear[m, n, c, d];

c = (m == 1 &&
n >= 0 && ((-1 + 3^n m)/(-1 + 2^n m) – (3^n)/(2^n)) > ((-1 +
3^(n + 1) m)/(-1 +
2^(n + 1) m) – (3^(n + 1))/(2^(n + 1))));

d = (n >=
0 && ((-1 + (3^n))/(-1 + (2^n)) – (3^n)/(2^
n)) > ((-1 + (3^(n + 1)))/(-1 + (2^(n + 1))) – (3^(n +
1))/(2^(n + 1))));

Reduce[c, {n}, Integers]

Element[n, Integers] && m == 1 && n >= 1

Reduce[c // FullSimplify, {n}, Reals]

m == 1 && n > 0

Reduce[d, {n}, Integers]

Element[n, Integers] && n >= 1

Reduce[d, {n}, Reals]

n > 0

  

 

+1, FullSimplify is just the ticket!
– Fred Kline
May 19 ’15 at 1:47

  

 

Any thoughts on why FullSimplify is needed here? Shouldn’t Reduce manage this by itself? (+1 nevertheless)
– Mr.Wizard♦
May 19 ’15 at 6:27

  

 

@Mr.Wizard, I wondered that too. I usually use FullSimplify after the Reduce to use the code elsewhere.
– Fred Kline
May 19 ’15 at 7:33

2

 

@Mr.Wizard – @FredKline – It has been my (albeit limited) experience that when you hit a limit of the capabilities of a function’s algorithm that changing (e.g., simplifying) the input can sometimes assist the algorithm. I assume that the reason that the functions algorithms do not do this on their own is that the performance cost of FullSimplify can be very high and it is best left to the user to apply as needed.
– Bob Hanlon
May 19 ’15 at 14:06