Vtgyjfy

Does there exist positive rational $s$ for which the Riemann Zeta function $zeta(s) in N$ or equivalently, does there exist finite positive integers $ell,m$ and $n$ such that $$zetaleft(1+dfrac{ell}{m}right) = n$$

My progress: Using the method described in my answer below, I am running a computer program, I have been able to show that if there is a solution then $l > 2.2*10^4$.

I misread $l$ as $1$, but in any case, as a partial result, here's a resolution for the case $l=1$.

Fix $sinmathbb{R}$, with $s > 1$.

On the interval $(0,infty)$, let
$f(x)={small{{displaystyle{frac{1}{x^{large{s}}}}}}}$.

It's easily verified that
$
{displaystyle{
int_{1}^infty !f(x),dx
=
{small{frac{1}{s-1}}}
}}
$.

Consider the infinite series
$
{displaystyle{
sum_{k=1}^infty frac{1}{k^s}
}}
$.

Since $f$ is positive, continuous, and strictly decreasing, we get
begin{align*}
int_{1}^infty !f(x),dx < ;&sum_{k=1}^infty frac{1}{k^s} < 1+int_{1}^infty !f(x),dx\[4pt]
implies;{small{frac{1}{s-1}}} < ;&sum_{k=1}^infty frac{1}{k^s} < 1+{small{frac{1}{s-1}}}\[4pt]
end{align*}
If $m$ is a positive integer, then letting $s=1+{large{frac{1}{m}}}$, we have ${large{frac{1}{s-1}}}=m$, hence
begin{align*}
{small{frac{1}{s-1}}} < ;&sum_{k=1}^infty frac{1}{k^s} < ;1+{small{frac{1}{s-1}}}\[4pt]
implies;m < ;,&zetabigl(1+{small{frac{1}{m}}}bigr) < ;m + 1\[4pt]
end{align*}
so $zetabigl(1+{large{frac{1}{m}}}bigr)$ is not an integer.

Can you resolve the problem for any other value of l, other than l=1?
For example, can you resolve the case l=2?

Yes and in fact I can show that $l ge 2.2*10^4$. Here is the outline of my approach which I am posting as an answer since it is too long to be a comment.

Step 1: The first step was to derive the following result

For every integer $n ge 2$ there exists a positive real $c_n$ such
that ${displaystyle{ zetaBig(1+frac{1}{n-1+c_n}Big) = n. }}$

The first few terms of the asymptotic expansion of $c_n$ in terms of $n$ and the Stieltjes constants $gamma_i$ are

$$ c_n = 1-gamma_0 + frac{gamma_1}{n-1}
+ frac{gamma_2 + gamma_1 - gamma_0 gamma_1}{(n-1)^2} + OBig(frac{1}{n^3}Big) $$

Step 2: I computed the first few values of $c_n$ but I did not use the above result. Instead I used the following recurrence formula.

Let $alpha_0$ be any positive real and ${displaystyle{ alpha_{r+1} = n +
alpha_r - zetaBig(1+frac{1}{n -1 + alpha_r}Big); }}$ then ${displaystyle{ lim_{r to infty}alpha_r = c_n}}$.

Using this we obtained
$$
c_2 approx 0.3724062
$$
$$
c_3 approx 0.3932265
$$
$$
ldots
$$
$$
c_{12} approx 0.4164435
$$

Step 3: Show that $l ge 5$

Let ${displaystyle{ zetaBig(1+frac{l}{m}Big) in N}}$ and let $m = lk+d$ where $gcd(l,d) = 1$ and $1 le d < l$.

Clearly, $c_2 le c_n < 1-gamma_0$ or $0.3724062 le c_n < 0.422785$.
Hence we must have ${displaystyle{ 0.3724062 le frac{d}{l} < 0.422785}}$. The fraction with the smallest value of $l$ satisfying this condition is ${displaystyle{frac{2}{5} }}$ hence $l ge 5$.

Extending the same approach I am able to show that $l > 2.2*10^4$.

Problems with this approach:

With this approach and with powerful computing, we can prove results like if ${displaystyle{ zetaBig(1+frac{l}{m}Big) in N }}$ then $l$ must be greater than some large positive integer but I don't see how this approach will solve the general problem.

Source code:

# Program with maximum n

from time import time

from mpmath import mp



start_time = time()

a = 1

a_end = 10^5

n_max = 2267

# Maximum n is at:', 4468, 1889, 2267



while(a < a_end + 1):

    b = 1 + floor(0.372406215900714*a)

    while(b <= floor((1 - euler_gamma)*a)):

        if(gcd(b,a) == 1):

            n = 2

            found = 1

            while (found == 1):

                i = 1

                r = 50

                c_n = c_n1 = N((1 - euler_gamma), digits = 100)

                while (i <= r):

                    c_n  = N(n + c_n - zeta(1 + 1/(n - 1 + c_n)), digits = 10)

                    c_n1 = N(n + 1 + c_n1 - zeta(1 + 1/(n + 1 - 1 + c_n1)), digits = 10)

                    i = i + 1

                test = N(b/a, digits = 100)

                if(c_n < test):

                    if(test < c_n1):

                        found = found - 1

                        # print(b, a, n, c_n, b/a.n(), c_n1)

                        if (n > n_max):

                            n_max = n

                            print("Maximum n is at:", a, b, n_max)

                        b = b + 1

                        if(b > floor((1 - euler_gamma)*a)):

                            found = found - 1

                        else:

                            n = n + 1

                    n = n + 1

                else:

                    n = n + 1

            if(found == 1):

                found = found - 1

                print("Solutions may be found for", a, b/a, c_n, b/a.n(), c_n1)

                b = b + 1

        else:

            b = b + 1

    if(a%10^1 == 0):

        print("Checked till", a, "Duration", floor(time() - start_time))

    a = a + 1