Hmm... there are easy answers and hard answers. I think we should take Aaron's defense and just say that if there are free symbols then this means the expression "as written" has the symbols indicated, not whether the expression actually depends on them. Here is a really simple case:

```
>>> Add(x,-x,evaluate=0).is_number
False
>>> Add(x,-x,evaluate=0).is_constant()
True
>>> Add(x,-x,evaluate=0).free_symbols
set([x])
```

`free_symbols` and `is_number` agree: there is an x there; the more expensive `is_constant` routine can verify that the expression does not actually depend on `x` -- but that is a *much* more expensive test in general.

So although Integral's `free_symbols` method could be modified to look at the difference of the upper and lower bounds and get it right for the case that you gave, there will always be an expression which is *not* trivially zero. A routine that should get it right is `is_constant`...but this requires the following modifications:

```
+++ b/sympy/core/expr.py
@@ -480,10 +480,14 @@ def is_constant(self, *wrt, **flags):
             a = self.subs(list(zip(free, [0]*len(free))))
             if a is S.NaN:
                 a = self._random(None, 0, 0, 0, 0)
+            else:
+                a = a.n()
             if a is not None and a is not S.NaN:
                 b = self.subs(list(zip(free, [1]*len(free))))
                 if b is S.NaN:
                     b = self._random(None, 1, 0, 1, 0)
+                else:
+                    b = b.n()
                 if b is not None and b is not S.NaN:
                     if b.equals(a) is False:
                         return False
@@ -506,7 +510,7 @@ def is_constant(self, *wrt, **flags):
             deriv = self.diff(w)
             if simplify:
                 deriv = deriv.simplify()
-            if deriv != 0:
+            if not deriv.is_zero:
                 if not (deriv.is_Number or pure_complex(deriv)):
                     if flags.get('failing_number', False):
```

Then,

```
>>> from sympy import *;var('x y');i=Integral(1,(x,y-1,y));i.is_constant()
(x, y)
True
```