We consider an odd perfect number (OPN for short) N, its total number Ω(N) of prime factors (counting multiplicities), and its number ω(N) of distinct prime factors.

Michael Rao wrote a program producing a tree similar to the one in [Brent, Cohen, te Riele] that proves that N > 10300.
We use it to prove that:
(1) N > 101500 (since then, we have pushed the computation to N > 102200),
(2) Ω(N) >= 101 (since then, we have pushed the computation to Ω(N) >= 115),
(3) the largest component (i.e. factor pa with p prime) of an OPN is > 1062.
(4) Ω(N) >= 2ω(N)+51.
(5) If we consider the Euler form N=pe*m2 where p is prime and e = 1 (mod 4), then m > 101000.

We obtain (1), (2), and (3) in this paper and (4) in this paper.
Using (2), (4), and the result in [Clayton, Hansen], we get Ω(N) >= max(115, 2ω(N)+51, (99ω(N)-187)/37).
The bound (5) is unpublished. It is tailor-made to boost Carl Pomerance's heuristic argument, since we can replace m > 1075 by m > 101000.

The proof tree looks like this (26Mb for the bound N > 10540).
The slides of a talk in Montpellier (2014).

### Differences with [BCR]:

- We forbid the factors 127,19,7,11,331,31,97,61,13,398581,1093,3,5,307,17 instead of 127,19,7,11,31,13,3,5.
- We branch on the overall largest available prime factor instead of branching on the largest available prime factor "from the previous line".
- We do not use the arguments of the B25 and B30 bounds described in [BCR].
- We use instead a method to circumvent the roadblocks similar to the one used in [Hare] to show Ω(N) >= 75. It is described below.
- In the end, we have to conclude that an odd perfect number not divisible by any of the forbidden factors must be greater than the target bound. To do this, we use an improved version of the argument in [BCR] that is described below.

### Composites

t570 (1/2024) t600 (1/2024) t800 (1/2024) t1000 (1/2024) t1200 (1/2024) t1600 (1/2024) t2200 (1/2024)
tXXXX contains composite numbers encountered when targetting the lower bound 10XXXX.
The format is "p q c" where c is a composite factor of σ(pq).
There are all and only the composites that appear firstly on their respective branch:
If you factor one of them, then the proof tree will be reduced, and this factorization will not become useless because of the factorization of some other number.

A list of the most difficult composites for the proof of N > 102100.
A new list of the most difficult composites for the proof of N > 102200.
The format for pq-1 is "p q-1 composite weight", where "weight" is the number of roadblocks involving the composite.
The list and the weights are not updated very often but every (partialy) factored composite is removed within a few days.

### Known factors

The format for prime factors in checkfacts.txt (12/2022, 2.5 Gb) is the same as in Brent's tables:
"p q+1 f" where f is a factor of σ(pq). p, q+1, and f are prime.
The compressed file checkfacts.txt.gz (12/2022) is 660 Mb.

### If you want to help us finding factors

Look at the threads about OPNs at the Mersenne forum.

Given a roadblock, we compute an upper bound on the smallest not-yet-considered factor of the OPN.
Then we branch on all prime factors below this bound (except the forbidden or already considered ones).

Example: Consider the roadblock σ(1118) = 6115909044841454629, σ(611590904484145462916) = C301.
To ensure that the unknown factors of C301 have a negligible contribution to the abundancy, we check that C301 has no factor less than 109.
Thus, there are at most 301/9=33 such prime factors and each of them contributes at most 1+10-9 to the abundancy.
So the abundancy of the factors 1118, 611590904484145462916, and C301 is at most (1+1/10)*(1+1/6115909044841454628)*(1+10-9)33 < 1.10000004.
Suppose our target bound is 102100 and p is the smallest prime factor of the OPN distinct from 11.
Suppose p=853. We must have at least 511 other prime factors >= 853 because 1.10000004*(1+1/853)510 < 2.
But then 1118*611590904484145462916*C301*853511 > 102117.
So we have to rule out every prime factor smaller than 853 except 19, 127, 7 (forbidden) and 11 (already considered).

When branching on a prime in order to circumvent a roadblock, we might encounter a new roadblock, so we have to apply this method recursively.

NB: I should eventually change this example since the factors of the C301 are known now.

### End game

Once enough small primes are forbidden, [BCR] considers the contribution (multiplicative increasing) of each prime p to both the abundancy that has to reach the value 2 and the OPN that should remain smaller than 10300.
Smaller primes p are prefered since their contribution to the abundancy (less than p/(p-1)) is higher and their contribution to the OPN (at least p2, except for the special prime) is lower.
With these rules, the best thing to do is to take every allowed prime in order. Then, the OPN gets bigger than 10300 before that the abundancy reaches 2.

As the target bound increases, we forbid more small primes so that this argument still works.
We also refine the argument. We consider the component (i.e., the prime together with its exponent) rather than the prime alone, and we use a bit more the fact that some factors are forbidden.
The efficiency of the component pa is defined as eff(p,a) = ln(σ(pa)/pa)/ln(pa).
We deal with multiplicative increasings, which expains the logarithms, and then make the ratio between the contribution of the component pa to the abundancy and to the OPN.
Remarks:
a < b implies eff(p,a) > eff(p,b)
p < q implies eff(p,a) > eff(q,a)

Then:
- for each allowed prime p, we find the smallest a such that σ(pa) is not divisible by 4 or some forbidden factor.
Example: Consider p=23. σ(231), σ(232), σ(233), are respectively divisible by 4, 7, 4. So the exponent of 23 is at least 4.
- we sort these components pa by decreasing efficiency.
- we compute the product of such components as long as the abundancy of the product remains smaller than 2.

This product is greater than 101735, as shown by this maple code.

### Older stuff (not used in this work):

abundant.txt is an idea to reduce a little the proof tree.
E_q_k.c is a C/GMP code to compute the set E(q,k) in [BCR].