Repository: sympy/sympy

Issue:
zeta(2 + I).is_finite returns None
Atleast `zeta(x)` for `Re(x) > 1` and `Im(x)` being finite it should return `True`.

Discussion:
mvnnn: @gxyd please check the changes.
gxyd: In your branch
```
>>> a = Symbol('a', real=True)
>>> zeta(a).is_finite
True        # this should return None
```
mvnnn: @gxyd thanks. i will fix that
mvnnn: @gxyd please check the changes.
jksuom: The test function could be reorganized. It is not necessary to define a separate negative variable ``c`` as ``-b`` could be used instead (``zeta(-b).is_finite``). There could also be tests for e.g. ``a + I``, ``b + 1`` and ``s + 1`` for a non-zero ``s``.
mvnnn: @jksuom please review.
jksuom: It seems that the branch is in conflict with the previous version. (I get this when attempting to pull:
`` ! [rejected]        refs/pull/10543/head -> pr-10543  (non-fast-forward)``)
It is possible to add new commits without removing the old ones. That will make it easier to review.

Was there some problem with the tests I suggested?

mvnnn: @jksuom done.please Review.
jksuom: I don't see new tests or the difference to the previous commit. Was there a problem?
mvnnn: done
mvnnn: @jksuom done. should we need to add more test cases ?
jksuom: I was expecting to see the cases I did give earlier.
mvnnn: @jksuom done.
jksuom: Thanks! I think these tests should suffice. But there are still a couple of ways to simplify the code to avoid new imports.

It is not necessary to import ``Eq`` for ``Eq(self.args[0], 1)``. It is enough to form ``self.args[0] - 1``.

``solve`` need not be called either. We can use ``(self.args[0] - 1).is_zero`` instead. That can be the first thing to do, and then the code could become something like this:
```
        arg_is_one = (self.args[0] - 1).is_zero
        if arg_is_one is not None:
            return not arg_is_one
```
mvnnn: ```
>>> b = Symbol('b', positive=True)
>>>zeta(b).is_finite 
None
``` 
because it's domain contain ```b = 1``` also.
now we take this
```
>>> b = Symbol('b', positive=True)
>>>zeta(b + 1).is_finite 
True
>>>zeta(b - 1).is_finite
None 
>>>zeta(b**2  - 2*b + 1).is_finite
None
``` 
because ```(b+1)>1``` so it's finite but -1<(b-1)<00 is include ```1``` so ans is ```None```.
in case of ```(b**2  - 2*b + 1)``` .if we take ```b=2``` then this eqn value is ```1``` so it's return ```None```
overall, we can put any ```args```  and check it's possible solution is ```1``` then it's output is ```None``` otherwise output is ```True```

jksuom: I think the tests are ok. But I don't think that it should be necessary to call ``solve`` to find out that ``f = b**2 - 2*b + 1`` would take the value 1 for some positive ``b``. ``(f - 1).is_zero`` should also show that. (There is no need for the actual solution ``b = 2``.)
mvnnn: i will fix that.

Patch:
diff --git a/sympy/functions/special/zeta_functions.py b/sympy/functions/special/zeta_functions.py
index a78d9e7171..561c3e0cab 100644
--- a/sympy/functions/special/zeta_functions.py
+++ b/sympy/functions/special/zeta_functions.py
@@ -463,6 +463,11 @@ def _eval_rewrite_as_dirichlet_eta(self, s, a=1):
     def _eval_rewrite_as_lerchphi(self, s, a=1):
         return lerchphi(1, s, a)
 
+    def _eval_is_finite(self):
+        arg_is_one = (self.args[0] - 1).is_zero
+        if arg_is_one is not None:
+            return not arg_is_one
+
     def fdiff(self, argindex=1):
         if len(self.args) == 2:
             s, a = self.args


Test patch:
diff --git a/sympy/functions/special/tests/test_zeta_functions.py b/sympy/functions/special/tests/test_zeta_functions.py
index d3a5b4c3c1..de2007fe16 100644
--- a/sympy/functions/special/tests/test_zeta_functions.py
+++ b/sympy/functions/special/tests/test_zeta_functions.py
@@ -178,3 +178,21 @@ def test_stieltjes_evalf():
     assert abs(stieltjes(0).evalf() - 0.577215664) < 1E-9
     assert abs(stieltjes(0, 0.5).evalf() - 1.963510026) < 1E-9
     assert abs(stieltjes(1, 2).evalf() + 0.072815845 ) < 1E-9
+
+
+def test_issue_10475():
+    a = Symbol('a', real=True)
+    b = Symbol('b', positive=True)
+    s = Symbol('s', zero=False)
+
+    assert zeta(2 + I).is_finite
+    assert zeta(1).is_finite is False
+    assert zeta(x).is_finite is None
+    assert zeta(x + I).is_finite is None
+    assert zeta(a).is_finite is None
+    assert zeta(b).is_finite is None
+    assert zeta(-b).is_finite is True
+    assert zeta(b**2 - 2*b + 1).is_finite is None
+    assert zeta(a + I).is_finite is True
+    assert zeta(b + 1).is_finite is True
+    assert zeta(s + 1).is_finite is True