Ratios on bounds of sum of divisors of $8n+5$ and $2n+1$

Question

I am trying to understand if it can be shown that $\frac{S(8n+5)}{S(2n+1)}<1$ is not possible, where $S(n)$ is the sum of divisors of $n$. There seems to be no example that's available till $100$ million (that's no proof of course) In general is there any known lower bound on $\frac{S(m n+p)}{S(k n +p')}$ where $m,k$ are integers and $p,p'$ are coprime and $k<m$.

Answer 1

Throughout the post I will use $N=2n+1$ and also the standard notation $\sigma(N)$ instead of $S(N)$, so we want $\sigma(N)>\sigma(4N+1)$ for odd $N$ (we aim to show the inequality indeed has a solution).

Edit: The smallest example is $$N=5446904314821287278479203823071273715375,$$ see the end of the post how it was found.

Original post (larger example): It is possible but the examples are large, one such is $$ N=32210113769945735764350959616774191410125. $$

It can be shown that \begin{align} \sigma(N)=128927467633230067174384644875354112000000\\ \sigma(4N+1)=128857229253996150977269189749996751275200 \end{align} (first one is easier as $N$ is product of very small primes, for the second one a CAS system might be useful for factorization of $4N+1$). Then we can see that $$ \sigma(4N+1) < \sigma(N). $$

The example here was constructed using values from https://oeis.org/A134716 for $N$ after dividing by powers of $2$ and few odd prime factors.

Some quick Maple code:

with(NumberTheory):
N:=32210113769945735764350959616774191410125;
A:=sigma(N);
B:=sigma(4*N+1);
is(B<A);

Why such large example is needed? Here are some elementary bounds which help to understand. Clearly $\sigma(4N+1)>4N$, so it is necessary to have $\sigma(N)/N>4$. Let $N=\prod p_i^{e_i}$ be the unique prime factorization of $N$, then notice $$ \sigma(N)=\prod \sigma(p_i^{e_i})=\prod (1+p_i+\dots +p_i^{e_i})=\prod \frac{p_i^{e_i+1}-1}{p_i-1}. $$ Since $p_i^{e_i+1}-1<p_i^{e_i+1}$, we get $$ \sigma(N)<\prod \frac{p_i^{e_i+1}}{p_i-1}=\prod p_i^{e_i}\prod \frac{p_i}{p_i-1}=N\prod\frac{p_i}{p_i-1} . $$ Put this together with wanted $\sigma(N)/N>4$ and get $$ \prod\frac{p_i}{p_i-1}>4. $$ This last condition is still very strong, if we check product of consecutive smallest (odd) primes, we achieve this inequality only after reaching $p_{22}=79$ (we have used that $x/(x-1)$ is decreasing for $x > 1$). This implies that $N$ will have at least $21$ distinct prime factors (which also implies that $N$ will have at least $2^{21}=2097152$ divisors) and as a result $$ N \geq 3\cdot 5\cdot 7 \cdots 73 \cdot 79=1608822383670336453949542277065. $$

You can compare it with the example above for which $$N=3^5 \cdot 5^3 \cdot 7^3 \cdot 11^2 \cdot 13^2 \cdot 17^2 \cdot 19 \cdot 23 \cdot 29 \cdot 31 \cdot 37 \cdot 41 \cdot 43 \cdot 47\\ \cdot 53 \cdot 59 \cdot 61 \cdot 67 \cdot 71 \cdot 73 \cdot 79 \cdot 83$$ and see that all primes between $3$ and $83$ are included.

Note: This inequality only holds for $N$ odd. For $N$ even, having $p=2$ involved in the product makes the inequality hold for much smaller number of primes, already primes up to $7$ are enough. And indeed, if we search for smallest even $N$ such that $\sigma(N)/N>4$, we find $N=27720=2^3\cdot 3^2 \cdot 5 \cdot 7\cdot 11$ works.

Searching for smaller examples: We can in fact find ALL odd $N$ such that $\sigma(N)/N>4$ and $N \leq L$ where is $L$ is some search bound (in our case where the search bound is the above example, so we find all the examples below). The following algorithm written in Python 3 uses recursive search through feasible prime factorizations (this way we also get sigma calculated along the way for free), where most of the speedup is gained by pruning the search space whenever remaining primes would fail to satisfy the given conditions.

primes = [3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107,
          109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
          233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
          367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491,
          499, 503, 509, 521, 523, 541]
L = 32210113769945735764350959616774191410125

min_primes_count = 22
max_primes_count = 24

# precompute conditions for checking whether to continue
# product of p/(p-1) of following k primes, used to rule out case where prod p/(p-1) > 4 cannot be reached
p_over_pm1_prod = [None] * (len(primes) - max_primes_count)
# product of p fo of following k primes, used to rule out case where prod p <= N cannot be reached
p_prod = [None] * (len(primes) - max_primes_count)
for idx in range(len(primes) - max_primes_count):
    p_over_pm1_prod[idx] = list()
    p_prod[idx] = list()

    prod = 1
    prod_p = 1
    for k in range(max_primes_count + 1):
        p_over_pm1_prod[idx].append(prod)
        p_prod[idx].append(prod_p)

        prod *= primes[idx + k] / (primes[idx + k] - 1)
        prod_p *= primes[idx + k]

total = []
for primes_count in range(min_primes_count, max_primes_count + 1):

    all = []

    # from_idx - from which index we want to continue recursion and evaluate additional powers
    # curr_prod - product of previous primes including their exponents, overall product <= N
    def check(from_idx, curr_prod, curr_sigma, remaining):
        if remaining == 0:
            if curr_sigma > 4 * curr_prod:  # necessary sigma(N)/N > 4
                all.append(curr_prod)
            return

        # prune if prod p/(p-1) > 4 is not possible
        if curr_sigma * p_over_pm1_prod[from_idx][remaining] < 4 * curr_prod:
            return

        # prune if prod p <= L is not possible
        if curr_prod * p_prod[from_idx][remaining] > L:
            return

        p = primes[from_idx]

        # e = 0
        check(from_idx + 1, curr_prod, curr_sigma, remaining)

        e = 1
        pe = p
        while curr_prod * pe <= L:
            check(from_idx + 1, curr_prod * pe, curr_sigma * (p * pe - 1) // (p - 1), remaining - 1)
            e += 1
            pe *= p

    check(0, 1, 1, primes_count)
    total += all

print(sorted(total))
print(len(total))

It searches between 22 and 24 distinct prime divisors due to the fact that there are none with 21 prime factors or more than 24 (can be checked by the same algorithm).

On my PC it ran for about 100ms and got $143$ candidates with $\sigma(N)/N > 4$, first few of them being \begin{equation} 1853070540093840001956842537745897243375,\\ 4323831260218960004565965921407093567875,\\ 5446904314821287278479203823071273715375,\\ 5559211620281520005870527613237691730125,\\ 5671518925741752733261851403404109744875,\\ \dots \end{equation}

Checking all these (we could still use Python and sympy perhaps, but I just put the list into Maple and checked there), finally, we find that $87$ values out of the $143$ candidates satisfy the given condition $\sigma(N)>\sigma(4N+1)$, the smallest $10$ are: \begin{equation} 5446904314821287278479203823071273715375,\\ 5671518925741752733261851403404109744875,\\ 6308768243240826074077789763337155783625,\\ 6433694347067377085445666788353733125875,\\ 8029972340406640008479650996898888054625,\\ 9112665240236748773667918547042558354125,\\ 9265352700469200009784212688729486216875,\\ 9293114056875100234532629805399836737375,\\ 9384425506258362419548507791556531822875,\\ 9654011690151803156262052322114393503875,\\ \dots \end{equation}

(The previously found example is thus the $87$-th smallest).