如何在 JavaScript 中准确地找到极大的 BigInt 素数？

Question

tl;dr你如何得到一个非常大的 80 位 BigInt 精确素数，而不是“可能”素数？看来我找到并附在下面的代码只会给你一个“可能的”质数。现在的问题是如何确定它是否是“精确”素数（即不是可能的，而是实际的）？

---

我被引导到this BigInt "random value between" code 用于生成介于最小值和最大值之间的随机 BigInt，以及 this BigInt prime number test code，我已将其粘贴在下面。然后我添加了一个简单的while 循环来生成一定量级的bigint，并检查素数（在我的情况下，素数也是p ≡ 3 mod 4（prime % 4 === 3）：

let i = 0n

while (i < 1000000000n) {
  let n = randomBigIntBetween(
    1000000000100000000010000000001000000000100000000010000000001000000000n,
    10000000001000000000100000000010000000001000000000100000000010000000001000000000n
  )
  if (isPrime(n) && n % 4n === 3n) {
    console.log(String(n))
  }

  i++
}

function randomBigIntBetween(minInclusive, maxExclusive) {
  var maxInclusive = (maxExclusive - minInclusive) - BigInt(1)
  var x = BigInt(1)
  var y = BigInt(0)
  while(true) {
     x = x * BigInt(2)
     var randomBit = BigInt(Math.random()<0.5 ? 1 : 0)
     y = y * BigInt(2) + randomBit
     if(x > maxInclusive) {
       if (y <= maxInclusive) { return y + minInclusive }
       // Rejection
       x = x - maxInclusive - BigInt(1)
       y = y - maxInclusive - BigInt(1)
     }
  }
}

// Javascript program Miller-Rabin primality test
// based on JavaScript code found at https://www.geeksforgeeks.org/primality-test-set-3-miller-rabin/

// Utility function to do
// modular exponentiation.
// It returns (x^y) % p
function power(x, y, p)
{

    // Initialize result
    // (JML- all literal integers converted to use n suffix denoting BigInt)
    let res = 1n;

    // Update x if it is more than or
    // equal to p
    x = x % p;
    while (y > 0n)
    {

        // If y is odd, multiply
        // x with result
        if (y & 1n)
            res = (res*x) % p;

        // y must be even now
        y = y/2n; // (JML- original code used a shift operator, but division is clearer)
        x = (x*x) % p;
    }
    return res;
}


// This function is called
// for all k trials. It returns
// false if n is composite and
// returns false if n is
// probably prime. d is an odd
// number such that d*2<sup>r</sup> = n-1
// for some r >= 1
function millerTest(d, n)
{
    // (JML- all literal integers converted to use n suffix denoting BigInt)

    // Pick a random number in [2..n-2]
    // Corner cases make sure that n > 4
    /*
        JML- I can't mix the Number returned by Math.random with
        operations involving BigInt. The workaround is to create a random integer
        with precision 6 and convert it to a BigInt.
    */
    const r = BigInt(Math.floor(Math.random() * 100_000))
    // JML- now I have to divide by the multiplier used above (BigInt version)
    const y = r*(n-2n)/100_000n
    let a = 2n + y % (n - 4n);

    // Compute a^d % n
    let x = power(a, d, n);

    if (x == 1n || x == n-1n)
        return true;

    // Keep squaring x while one
    // of the following doesn't
    // happen
    // (i) d does not reach n-1
    // (ii) (x^2) % n is not 1
    // (iii) (x^2) % n is not n-1
    while (d != n-1n)
    {
        x = (x * x) % n;
        d *= 2n;

        if (x == 1n)
            return false;
        if (x == n-1n)
            return true;
    }

    // Return composite
    return false;
}

// It returns false if n is
// composite and returns true if n
// is probably prime. k is an
// input parameter that determines
// accuracy level. Higher value of
// k indicates more accuracy.
function isPrime( n, k=40)
{
    // (JML- all literal integers converted to use n suffix denoting BigInt)
    // Corner cases
    if (n <= 1n || n == 4n) return false;
    if (n <= 3n) return true;

    // Find r such that n =
    // 2^d * r + 1 for some r >= 1
    let d = n - 1n;
    while (d % 2n == 0n)
        d /= 2n;

    // Iterate given nber of 'k' times
    for (let i = 0; i < k; i++)
        if (!millerTest(d, n))
            return false;

    return true;
}

到目前为止，它为我打印了该范围内的几个素数，或者我认为应该是素数，对吗？我对所涉及的数学或素数的“miller test”知之甚少，无法知道该算法是否真的找到了一个精确的素数，或者正在找到可能的东西是素数。

corresponding blog post 的作者开口说：

米勒-拉宾素数检验是对素数的可靠检验，尽管它只能确定一个数为素数的概率。

（加了重音）

据我所知，这个算法似乎只能让我们走上一段路？我们必须做什么才能建立一个保证是素数的列表？假设我们想要非常大的 BigInt 素数......

实际上，对于我当前的用例，我需要找到 70 到 80 位之间的素数，但我想知道如何找到任意大小数字的素数，如果可能的话，最多 65536 位。

知道“素数正好有两个因数——1 和数本身”，我认为，意味着我们需要以某种方式找到 BigInt 的因数。这导致我here 和this function：

function primeFactors(n){
  const factors = []

  let divisor = 2n
  let i = 0

  while (n > 2n) {
    if (n % divisor == 0n) {
      factors.push(divisor)
      n = n / divisor
    } else{
      divisor++
    }

    i++

    if (i % 100 === 0) {
      console.log(i)
    }
  }

  console.log(i)

  return factors
}

然后我将它添加到我原来的 while 循环中：

while (true) {
  let n = rbigint(
    1000000000100000000010000000001000000000100000000010000000001000000000n,
    10000000001000000000100000000010000000001000000000100000000010000000001000000000n
  )
  if (isPrime(n) && n % 4n === 3n) {
    const factors = primeFactors(n)
    console.log(factors)
    console.log(String(n))
  }
}

如您所见，我还添加了那些 console.log 语句以调试正在进行的迭代次数，因为调用 primeFactor 被挂起。几秒钟后，我取消了记录22481400 迭代的过程，但似乎没有接近完成，我不确定需要多长时间。试图只记录每 1000 万次迭代，它只是突然消失，永远不会完成。我在300000000 迭代后取消以计算isPrime(n) && n % 4n === 3n 为真的第一个数字的因子。看来我们至少需要 300000000300000000300000000300000000300000000300000000 或一些疯狂的迭代次数才能完成分解......我不知道如何计算这部分，但想知道如何得到素数。

所以问题是，在 JavaScript 中，当定位这些极大的 BigInt 值时，如何获得“精确”质数，而不是“可能”质数？

Answer 1

您不需要检查数字是否正好是质数。例如，由于恒星辐射，您的计算机中有可能发生翻转。这是非常不可能的，但只要它比 Rabin-Miller 测试标记非素数的可能性更大，因为素数低于你应该没问题。

因此，硬件故障比数字不是质数更有可能，您不能从质数测试中要求更多。