Algorithm 研究人员是如何找到如此大的素数的？

当我试图找到一个更大的素数时，这引起了我的兴趣，但我很快意识到，我的编程语言的解释器在尝试插入一个2400万位数（2^82589933）的数字时很快出现了一个错误− 1） 一个变量。所以我想知道，研究人员是如何做到这一点的？当有明显的计算限制时，他们如何找到这么大的数字

65537的战力测试至少能让你得到梅森数，我不确定他们使用什么测试，因为我只能在几分钟后爬到2**4423-1：

for x in range(2,100000): 
   if pow(65537,2**x-2, 2**x-1) == 1: 
       print(f"2**{x}-1 is prime") 

2**2-1 is prime
2**3-1 is prime
2**5-1 is prime
2**7-1 is prime
2**13-1 is prime
2**17-1 is prime
2**19-1 is prime
2**31-1 is prime
2**61-1 is prime
2**89-1 is prime
2**107-1 is prime
2**127-1 is prime
2**521-1 is prime
2**607-1 is prime
2**1279-1 is prime
2**2203-1 is prime
2**2281-1 is prime
2**3217-1 is prime
2**4253-1 is prime
2**4423-1 is prime

根据詹姆斯·K·波尔克总统的评论，我编写了卢卡斯·莱默素性测试

def LucasLehmer(p):
   if p == 2:
     return True
   s = 4
   M = pow(2, p) - 1
   for x in range (1, (p-2)+1):
      s = ((s * s) - 2) % M
   if s == 0: return True
   else: return False


# 20th Mersenne Prime
In [401]: LucasLehmer(4423)                                                                                                                                                                                 
Out[401]: True

# 21st Mersenne Prime
In [402]: LucasLehmer(9689)                                                                                                                                                                                 
Out[402]: True

# Some non random test:
In [404]: LucasLehmer(2727)                                                                                                                                                                                 
Out[404]: False

# 24th Merseene Prime
In [409]: LucasLehmer(19937)                                                                                                                                                                                
Out[409]: True

我在LL测试中玩弄了一下数学，找到了一个很好的素数查找器。慢，不是突破性的，但也不错：

from sympy import isprime

def PrimeFinderLucasLehmer(N):
   p = 1<<N.bit_length()-1
   if p == 2:
     return True
   s = 4
   M = pow(p, 2) - 1
   for x in range (1, (p-2)+1):
     s = (((s * N) - 2  )) % M
     mgcd = math.gcd(s, N)
     if  mgcd != 1:
        print(s, mgcd)
        if isprime(mgcd) == True:
           break
        else: continue
   return mgcd

---

不管怎样，我觉得这很有趣，所以想和大家分享。这只是一个数学上的调整。

也许这个问题更适合于。如果问题是用什么算法来发现或测试大的（可能的）素数，那就属于数学。如果问题是他们（或任何人）如何编写程序来实现大量的这种算法，那么这是属于基本的：一些语言有像Python这样的BIG，有些在标准库中有java，有些需要像C++和C++这样的Advon库。请参阅标记[bignum]和。如果你有一个关于特定算法和实现的问题，那是可以回答的。正如你可以从大素数中验证的那样，有特殊的素数测试。大多数都是由科学家发现的。该搜索的数学解释见。我将LL测试转换为素数查找程序。我花了两分钟在这上面，所以觉得分享很酷，所以我在帖子上的最新评论看到它可以找到素数，即使不是很小的数字。不是突破性的或惊天动地的，只是很酷，因为我做了一个小小的改变，只是为了看看会发生什么，哇，它找到了素数。我修改了这个，以便更快地检查：看看围绕Lucas Lehmer素数测试构建的因式分解引擎。这不是惊天动地或开创性的，但它很酷，因为它可以在几秒钟内完成我发布的stackoverflow网站上的数字。我希望你喜欢，这是一个很好的发现，并对大小和以下的数字非常有效，当然，更大的数字，如代码注释所示

In [149]: PrimeFinderLucasLehmer(8114231289041741)                                                                                                             
15823901318551394674372071332152 1839221
Out[149]: 1839221

In [148]: PrimeFinderLucasLehmer(10142789312725007)                                                                                                            
36241961070961173943814389655700 100711423
Out[148]: 100711423

In [151]: PrimeFinderLucasLehmer(1009732533765203)                                                                                                             
157641275043535187903371634694 1823