Mersenne Prime Puns

M(57885161) was discovered eight and half years ago. Now, thanks to the largely unheralded and dedicated efforts of thousands of GIMPS volunteers, every smaller Mersenne number has been successfully double-checked. Thus, M(57885161) officially becomes the 48th Mersenne prime. This is a significant milestone for the GIMPS project.

https://www.mersenne.org/

Link to the article: https://drive.google.com/file/d/1CmdSESs1whAdew6saz5eCrHlLAcqqw96/view?usp=sharing

I'm also putting 100$ (CAD) bounties on each hash function if someone finds a collision! I created the subreddit /r/falkush to share your solution. I'd really like to know what you think about it and if you think this could be published in a small journal. I wrote a Java implementation that you can download here: https://drive.google.com/file/d/1EQDbjunNIW5nhTT5qEkfUddvJgp2mocz/view

Thanks!!

As a little fun side project I wrote a very small program that is able to calculate mersenne primes. My current speed is about 26000 ms until M18 (2^3217 - 1) is calculated starting from the first one.

Here is the C# code:

using System;
using System.Numerics;
using System.Diagnostics;
namespace MersenneCalc128
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Mersenne Prime Calculator v3.1 by Thomas\nCalulcates Mersenne Prime of the form Mn = 2ⁿ - 1\nUses the Lucas–Lehmer primality test\n\n[PRESS ENTER TO START]\n");
            Console.ReadKey();
            BigInteger number = new BigInteger();
            BigInteger s = new BigInteger();
            BigInteger twoton = new BigInteger();
            Stopwatch sw = new Stopwatch();
            sw.Start(); //TIME START
            Console.WriteLine("The number 2^2 - 1 (3) is prime. \nTime Elapsed: {0} ms", sw.ElapsedMilliseconds);
            int p = 2;
            int x;
            bool primefound = false;
            while (true == true)
            {
                while (primefound == false)
                {
                    for (x = 2; x < p; x++)
                    {
                        int mod = p % x;
                        if (mod == 0)
                        {
                            p++;
                            break;
                        }
                    }
                    if (x == p)
                    {
                        primefound = true;
                    }
                }
                s = 4;
                twoton = 1;
                int count = p - 2;
                for (int y = 0; y < p; y++)
                {
                    twoton = twoton * 2;
                }
                number = twoton - 1;
                for (int y = 0; y < count; y++)
                {
                    s = ((s * s) - 2) % number;
                    if (s == 0)
                    {
                        Console.WriteLine("The number 2^{0} - 1 ({1}) is prime. \nTime Elapsed: {2} ms", p, number, sw.ElapsedMilliseconds);
                        break;
                    }
                }
                p++;
                primefound = false;

So kinda a newbie to Python, decided to try my hand at printing out math sequences, going well so far till I decided to try Mersenne primes. Here's how my code looks like:

choice_sequence = input("""please choose a sequence:
* factorials [0]
* Fibonacci [1]
* Tribonacci [2]
* Primes [3]
* Mersenne primes [4]
""")
def prime_checker(n):
    if n > 1:
        for i in range(2, int(n/2) + 1):
            if (n % i) == 0:
                return ""
                break
        else:
            return n
    else:
        return ""
while True:
    try:
        length_input = int(input("please enter the amount of digits in the sequence: "))
    except ValueError:
        print("the amount of digits has to be an integer")
    else:
        if length_input > 0:
            break
        else:
            print("the amount of digits can't be zero or less")
# some other code here, doesn't matter
elif choice_sequence == "4":
    to_print = ""
    i = 0
    count = 0
    while True:
        if prime_checker(2 ** i - 1) == 2 ** i - 1:
            to_print = to_print + str(2 ** i - 1) + ", "
            count = count + 1
            i = i + 1
        else:
            i = i + 1
        if count == length_input:
            print(to_print[:-2])
            break

Up to seven Mersenne primes are printed in a blink of an eye, eight take three-four minutes, and I've not been patient enough to wait for nine or ten. My question is: is it a normal behavior granted that they get harder and harder to find, or is it the issue in my code?

List of Mersenne primes: https://oeis.org/A000668

I saw a numberphile video on Mersenne primes, and I found out that sometimes 2 to the N - 1 is sometimes a prime. So I was wondering if there is a relationship between the Exponents, N, in Mersennes. Please explain in simple terms.

https://github.com/Ubuntu19019/learnruby/blob/master/Mersenne_Prime A mersenne prime is a prime number where the prime number plus one is a power of two. The code is working, but I suspect my power_of_two? helper method is preventing the code from running at a realistic speed. I've been trying to figure out a different way to approach that method. If I think of it as a folder that always divides by 2 I was thinking maybe it would work better recursively, but making a boolean recursive helper function is way over my head at the moment.

This post is a generalization of this post.

Edit: p is an odd prime*

I have $100 of AWS credits and wanted to use them for GIMPS, can anyone recommend what would be my best option for contributing as much as possible with this many credits?

Mersenne Primes are 1 less than a power of 2, for instance, 2^2 -1=3. I want to type all the Mersenne Primes we have found up to 2^74,207,281 -1, the largest Mersenne Prime ever found. If the numbers get too big, just put it in the scientific notation (2^74,207,281 -1)

However, reciting 77,232,917 1's does get tiring really fast.