Are any Mersenne factors 1 mod p^2?

[alpertron]

I have not seen the links to the files sorted by exponent because it is linked at the bottom of the exports page. I only saw the links to the files ordered by date, which are not useful for us.

Maybe in the future I will perform a double check.

[alpertron]

I changed the program to use the data from https://www.mersenne.ca/export/

#!/usr/bin/perl
use Math::BigInt lib => 'GMP';

$solutionsFound = 0;
$candidates = 0;
$sumInverses = 0;
$fh = 0;
# Use Gray codes to generate all composite factors.
sub generateFactors
{
  my $expon = $_[0];
  my @factors = @{$_[1]};
  my $factorLen = @factors;
  my $square = $expon * $expon;
  my $currReducedFactor = 0;
  my $currFactor;
  my $factorNbr = 0;
  my $grayCode = 0;
  my $factor;
  my @reducedFactors = ();
  for (my $index = 0; $index < $factorLen; $index++)
  {
    @reducedFactors[$index] = @factors[$index] -> copy() -> bmod($expon) -> numify();
    if ($index < $factorLen - 1)
    {
      @reducedFactors[$index] *= 2;
    }
  }
  $sumInverses += (2 ** $factorLen - 1)/ $expon;
  do
  {
    $factorNbr++;
    #Get lowest non-zero bit number.
    my $currBit = 1;
    my $bitNbr = 0;
    my $temp = $factorNbr;
    my $output;
    while ($temp % 2 == 0)
    {
      $temp = $temp / 2;
      $bitNbr++;
      $currBit *= 2;
    }
    return if ($bitNbr == $factorLen);
    $candidates++;
    $grayCode = $grayCode ^ $currBit;
    if ($grayCode & $currBit)
    {
      $currReducedFactor += @reducedFactors[$bitNbr];
    }
    else
    {
      $currReducedFactor -= @reducedFactors[$bitNbr];
    }
    if (($currReducedFactor % $expon) == 0)
    {   # Solution found. Find factor for solution.
      $currFactor = Math::BigInt->bone();   ## One.
      $currBit = 1;
      if ($grayCode & (2 ** ($factorLen-1)))
      {         ## Using cofactor.
        for ($bitNbr = 0; $bitNbr < $factorLen - 1; $bitNbr++)
        {
          if (($grayCode & $currBit) == 0)
          {
            $factor = @factors[$bitNbr] -> copy() -> bmul(2*$expon) -> binc();
            $currFactor -> bmul($factor);
          }
          $currBit *= 2;
        }
        if ($expon > 2000)
        {
          if ($currFactor == 1)
          {
            print "$expon, 2^$expon-1\n";
            print $fh "$expon, 2^$expon-1\n";
          }
          else
          {
            $output = $currFactor -> bstr();
            print "$expon, (2^$expon-1)/$output\n";
            print $fh "$expon, (2^$expon-1)/$output\n";
          }
        }
        else
        {
          # Compute $currFactor = (2**$expon - 1)/$currFactor.
          my $temp = Math::BigInt->new(2);
          $temp -> bpow($expon) -> bdec() -> bdiv($currFactor);
          $currFactor = $temp;
          $output = $currFactor -> bstr();
          print "$expon, $output\n";
          print $fh "$expon, $output\n";
        }          
      }
      else
      {
        for ($bitNbr = 0; $bitNbr < $factorLen; $bitNbr++)
        {
          if ($grayCode & $currBit)
          {
            $factor = @factors[$bitNbr] -> copy() -> bmul(2*$expon) -> binc();
            $currFactor -> bmul($factor);
          }
          $currBit *= 2;
        }
        print "$expon, $currFactor\n";
        print $fh "$expon, $currFactor\n";
      }
      $solutionsFound++;
      select()->flush();
    }
  } while (1);
}

open($fh, '>', "factors.txt") or die $!;
my $currExp = -1;
my @factors = ();
my $nbrElems = 0;
for ($fileNbr = 0; $fileNbr <= 9; $fileNbr++)
{
  open(my $inputFile, '<', "mersenneca_known_factors_${fileNbr}G.txt") or die $!;
  while (my $line = <$inputFile>)
  {
    if ($line =~ /^(\d+),(\d+)$/gm)
    {    ## $1 = Exponent, $2 = k.
      if ($1 != $currExp)
      {
        if (int($1/1000000) != int($currExp/1000000))
        {
          print "Exponent = $currExp, found: $solutionsFound, candidates: $candidates, sum inverses: $sumInverses\n";
          select()->flush();
        }
        if ($currExp > 1)
        {
          ## add (cofactor mod currExp^2) / currExp to array.
          my $bigExp = Math::BigInt->new($currExp);
          my $bigSquare = $bigExp -> copy() -> bmul($bigExp);
          my $base = Math::BigInt->new(2);
          my $cofactor = $base -> copy() -> bmodpow($currExp, $bigSquare);
            # cofactor = ((2^currExp - 1) mod currExp^2) / currExp
          $cofactor->bdec() -> bdiv($currExp) -> bmod($currExp);
          for (my $index = 0; $index < $nbrElems; $index++)
          {
            my $reducedFactor = @factors[$index] -> copy() -> bmod($currExp) -> bmul(2);
            $cofactor = $cofactor -> bsub($reducedFactor);
          }
          $factors[$nbrElems] = $cofactor -> copy();  ## Add cofactor to array.
          generateFactors($currExp, \@factors);
        }
        $currExp = $1;
        @factors = ();
        $nbrElems = 0;
      }
      $factors[$nbrElems] = Math::BigInt->new($2);    ## Save value of k = (factor-1)/2/exponent.
      $nbrElems++;
    }
  }
  close($inputFile);
}
close($fh);
print "Exponent = $currExp, found: $solutionsFound, candidates: $candidates, sum inverses: $sumInverses\n";
select()->flush();

After almost 20 hours I found the same 22 solutions in the range 0G - 1G and no solutions in the range 1G - 10G using the data updated on 5 Feb.

In the range 1G - 10G there were 873352250 candidates and the sum of inverses was 0.257388, so the probability of finding a solution with 10-digit exponent was a little higher than 25%.

[alpertron]

I'm running PRP for M281903623/known factors. It just passed the iteration #100 million.

[alpertron]

A few hours ago it passed iteration #200 million:

[alpertron]

As expected, the number M281903623 / known factors is composite.

It appears that the server does not accept the proof file.

The last iterations are:

[Dobri]

Originally Posted by alpertron

As expected, the number M281903623 / known factors is composite.

It appears that the server does not accept the proof file.
...

An alternative option is to try the PRP Proof Manual Upload at https://www.mersenne.org/proof_upload_manual/.

[alpertron]

PrimeNet rejects the proof file as shown below:

[Andrew Usher]

Congratulations!

But it's unfortunate that a bad proof might spoil it. That does not seem to be one of the stronger points of our system. Here Prime95 actually stated it generated a valid proof, but it is corrupt.

[alpertron]

At least the Gerbicz tests every million iterates were all OK.

[kriesel]

Originally Posted by Dobri

An alternative option is to try the PRP Proof Manual Upload at https://www.mersenne.org/proof_upload_manual/.

This seems to indicate it is for PRP tests (not also for PRP-CF). Probably worth a try once though, to try to save a PRP-CF-DC on such a large exponent.
"Here you can upload .proof files from PRP tests. Internet-connected Prime95/mprime machines should not need this (they will upload proof files automatically) but gpuowl users (for example) need to upload proof files manually. Prior to uploading a proof file you need to submit the JSON result for the PRP test. If you don't see your PRP test listed below your upload will not be accepted." (No version of Gpuowl to date does PRP-CF.)
There are several proof file uploader possibilities, listed at https://www.mersenneforum.org/showpo...0&postcount=26. Those are for PRP-test proof files too, but possibly one might work for PRP-CF proof. If the file is not flawed in some fatal way. Which it apparently is, since mprime / prime95 didn't work on it.

@alpertron: Save the proof file a while, in case Prime95 wants to examine a copy for what's wrong. Occasionally he's able to resolve such a problem for a high-effort file, uploading it successfully, and may even find a program bug or opportunity to reduce the occurrence of such issues.

[alpertron]

I was able to upload the proof file using the uploader.exe linked from https://mersenneforum.org/showpost.p...3&postcount=14