Skip to content

Commit 238281f

Browse files
TilmanNeumannTilmanNeumann
committed
two more variants by Dave McGuigan, and some cleanup
1 parent 721b5e3 commit 238281f

File tree

4 files changed

+246
-6
lines changed

4 files changed

+246
-6
lines changed

‎src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoBrent.java

+3-1
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
/*
22
* java-math-library is a Java library focused on number theory, but not necessarily limited to it. It is based on the PSIQS 4.0 factoring project.
3-
* Copyright (C) 2018-2024 Tilman Neumann - [email protected]
3+
* Copyright (C) 2018-2025 Tilman Neumann - [email protected]
44
*
55
* This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
66
* as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
@@ -76,12 +76,14 @@ public BigInteger findSingleFactor(BigInteger N) {
7676
}
7777
G = q.gcd(N);
7878
// if q==0 then G==N -> the loop will be left and restarted with new x0, c
79+
// after checking each diff separately in the loop below.
7980
k += m;
8081
if (DEBUG) LOG.debug("r = " + r + ", k = " + k);
8182
} while (k<r && G.equals(I_1));
8283
r <<= 1;
8384
if (DEBUG) LOG.debug("r = " + r + ", G = " + G);
8485
} while (G.equals(I_1));
86+
8587
if (G.equals(N)) {
8688
do {
8789
ys = squareAddModN(ys, c);

‎src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoBrentModBlock.java

+118
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,118 @@
1+
/*
2+
* java-math-library is a Java library focused on number theory, but not necessarily limited to it. It is based on the PSIQS 4.0 factoring project.
3+
* Copyright (C) 2018-2025 Tilman Neumann - [email protected]
4+
*
5+
* This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
6+
* as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
7+
*
8+
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
9+
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
10+
*
11+
* You should have received a copy of the GNU General Public License along with this program;
12+
* if not, see <http://www.gnu.org/licenses/>.
13+
*/
14+
package de.tilman_neumann.jml.factor.pollardRho;
15+
16+
import static de.tilman_neumann.jml.base.BigIntConstants.*;
17+
18+
import java.math.BigInteger;
19+
import java.security.SecureRandom;
20+
21+
import org.apache.logging.log4j.Logger;
22+
import org.apache.logging.log4j.LogManager;
23+
24+
import de.tilman_neumann.jml.factor.FactorAlgorithm;
25+
26+
/**
27+
* A variant of the Pollard-Rho-Brent algorithm by Dave McGuigan,
28+
* adding "mod-blocking", i.e. computing the mod() only every few rounds.
29+
*
30+
* @author Dave McGuigan
31+
*/
32+
public class PollardRhoBrentModBlock extends FactorAlgorithm {
33+
private static final Logger LOG = LogManager.getLogger(PollardRhoBrentModBlock.class);
34+
private static final boolean DEBUG = false;
35+
private static final SecureRandom RNG = new SecureRandom();
36+
37+
private BigInteger N;
38+
39+
@Override
40+
public String getName() {
41+
return "PollardRhoBrentModBlock";
42+
}
43+
44+
@Override
45+
public BigInteger findSingleFactor(BigInteger N) {
46+
this.N = N;
47+
int Nbits = N.bitLength();
48+
BigInteger G, x, ys;
49+
do {
50+
// start with random x0, c from [0, N-1]
51+
BigInteger c = new BigInteger(Nbits, RNG);
52+
if (c.compareTo(N)>=0) c = c.subtract(N);
53+
BigInteger x0 = new BigInteger(Nbits, RNG);
54+
if (x0.compareTo(N)>=0) x0 = x0.subtract(N);
55+
BigInteger y = x0;
56+
57+
// Brent: "The probability of the algorithm failing because q_i=0 increases, so it is best not to choose m (gcdBlock) too large"
58+
// DM: failing is a bit strong. q(i)=0 happens often when there are small powers of small factor (i.e.5*5)
59+
// This often occurs because multiple instances of the factor are found with larger blocks. The loop below
60+
// addresses that by re-doing the last block and checking each individual difference. The "failure" is
61+
// is that larger blocks have more to re-do. There are cases where a single difference = n, but this would happen even when m=1.
62+
// Empirical testing indicates 2*log(N) is better than a fixed choice for large N.
63+
// In 31 bit versions, is was determined just log(N) is best.
64+
final int logN = N.bitLength()-1;
65+
final int gcdBlock = Math.max(100, 2*logN);
66+
final int modBlock = 4; // DM: no real difference between 4 and 8. Conservatively choosing 4.
67+
68+
int r = 1;
69+
70+
do {
71+
x = y;
72+
for (int i = 1; i <= r; i++) {
73+
y = squareAddModN(y, c);
74+
}
75+
ys = y;
76+
BigInteger q = I_1;
77+
int k = 0;
78+
do {
79+
final int iMax = Math.min(gcdBlock, r - k);
80+
final int jMax = Math.min(modBlock, iMax);
81+
for (int i = 1; i <= iMax; i = i + jMax) {
82+
for (int j = 0; j < jMax; j++) {
83+
y = squareAddModN(y, c);
84+
q = q.multiply(x.subtract(y));
85+
}
86+
q = q.mod(N); // one mod for the block
87+
}
88+
G = q.gcd(N);
89+
// if q==0 then G==N -> the loop will be left and restarted with new x0, c
90+
// after checking each diff separately in the loop below.
91+
k += gcdBlock;
92+
if (DEBUG) LOG.debug("r = " + r + ", k = " + k);
93+
} while (k < r && G.equals(I_1));
94+
r <<= 1;
95+
} while (G.equals(I_1));
96+
97+
if (G.equals(N)) {
98+
do {
99+
ys = squareAddModN(ys, c);
100+
G = N.gcd(x.subtract(ys));
101+
} while (G.equals(I_1));
102+
if (DEBUG) LOG.debug("G = " + G);
103+
}
104+
} while (G.equals(N));
105+
if (DEBUG) LOG.debug("Found factor of " + N + " = " + G);
106+
return G;
107+
}
108+
109+
/**
110+
* Square and add modulo N, with <code>a, b < N</code>.
111+
* @param y
112+
* @param c
113+
* @return () mod N
114+
*/
115+
private BigInteger squareAddModN(BigInteger y, BigInteger c) {
116+
return y.multiply(y).add(c).mod(N);
117+
}
118+
}

‎src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoTwoLoops.java

+5-5
Original file line numberDiff line numberDiff line change
@@ -65,17 +65,17 @@ public BigInteger findSingleFactor(BigInteger N) {
6565
xxs = xx;
6666
for(int i=0; i<m; i++) {
6767
x = squareAddModN(x, c);
68-
xx = squareAddModN(xx, c);
69-
xx = squareAddModN(xx, c);
68+
xx = squareAddModN(xx, c);
69+
xx = squareAddModN(xx, c);
7070
prod = prod.multiply(x.subtract(xx)).mod(N);
7171
}
7272
gcd = prod.gcd(N);
73-
} while(gcd.equals(I_1));
73+
} while (gcd.equals(I_1));
7474
if (gcd.equals(N)) {
7575
do {
7676
xs = squareAddModN(xs, c);
77-
xxs = squareAddModN(xxs, c);
78-
xxs = squareAddModN(xxs, c);
77+
xxs = squareAddModN(xxs, c);
78+
xxs = squareAddModN(xxs, c);
7979
gcd = N.gcd(xs.subtract(xxs));
8080
} while (gcd.equals(I_1));
8181
}

‎src/main/java/de/tilman_neumann/jml/factor/pollardRho/PollardRhoTwoLoopsModBlock.java

+120
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,120 @@
1+
/*
2+
* java-math-library is a Java library focused on number theory, but not necessarily limited to it. It is based on the PSIQS 4.0 factoring project.
3+
* Copyright (C) 2018-2025 Tilman Neumann - [email protected]
4+
*
5+
* This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License
6+
* as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.
7+
*
8+
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
9+
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
10+
*
11+
* You should have received a copy of the GNU General Public License along with this program;
12+
* if not, see <http://www.gnu.org/licenses/>.
13+
*/
14+
package de.tilman_neumann.jml.factor.pollardRho;
15+
16+
import static de.tilman_neumann.jml.base.BigIntConstants.*;
17+
18+
import java.math.BigInteger;
19+
import java.security.SecureRandom;
20+
21+
import org.apache.logging.log4j.Logger;
22+
import org.apache.logging.log4j.LogManager;
23+
24+
import de.tilman_neumann.jml.factor.FactorAlgorithm;
25+
26+
/**
27+
* Another variant of the original Pollard-Rho method by Dave McGuigan,
28+
* using a second loop like in Pollard-Rho-Brent,
29+
* and "mod-blocking", i.e. computing the mod() only every few rounds.
30+
*
31+
* @author Dave McGuigan
32+
*/
33+
public class PollardRhoTwoLoopsModBlock extends FactorAlgorithm {
34+
private static final Logger LOG = LogManager.getLogger(PollardRhoTwoLoopsModBlock.class);
35+
private static final boolean DEBUG = false;
36+
private static final SecureRandom RNG = new SecureRandom();
37+
38+
private BigInteger N;
39+
40+
@Override
41+
public String getName() {
42+
return "PollardRhoTwoLoopsModBlock";
43+
}
44+
45+
@Override
46+
public BigInteger findSingleFactor(BigInteger N) {
47+
this.N = N;
48+
BigInteger gcd;
49+
int bitLength = N.bitLength();
50+
// get random x0 from [0, N-1]
51+
BigInteger x = new BigInteger(bitLength, RNG);
52+
if (x.compareTo(N)>=0) x=x.subtract(N);
53+
54+
// Brent: "The probability of the algorithm failing because q_i=0 increases, so it is best not to choose m (gcdBlockMax) too large"
55+
// DM: failing is a bit strong. q(i)=0 happens often when there are small powers of small factor (i.e.5*5)
56+
// This often occurs because multiple instances of the factor are found with larger blocks. The loop below
57+
// addresses that by re-doing the last block and checking each individual difference. The "failure" is
58+
// is that larger blocks have more to re-do. There are cases where a single difference = n, but this would happen even when m=1.
59+
// Empirical testing indicates 2*log(N) is better than a fixed choice for large N.
60+
// In 31 bit versions, is was determined just log(N) is best.
61+
final int logN = N.bitLength()-1;
62+
final int gcdBlockMax = Math.max(100, 2*logN);
63+
final int modBlock = 4;
64+
do {
65+
// get random c from [0, N-1]
66+
BigInteger c = new BigInteger(bitLength, RNG);
67+
if (c.compareTo(N)>=0) c=c.subtract(N);
68+
69+
70+
BigInteger xx = x;
71+
BigInteger xs;
72+
BigInteger xxs;
73+
int gcdBlock = 1;
74+
gcd = I_1;
75+
do {
76+
xs = x;
77+
xxs = xx;
78+
BigInteger prod = I_1;
79+
for (int i=0; i<gcdBlock; i = i+modBlock) {
80+
final int jMax = Math.min(modBlock, gcdBlock-i);
81+
for (int j=0; j<jMax; j++) {
82+
x = squareAddModN(x, c);
83+
xx = squareAddModN(xx, c);
84+
xx = squareAddModN(xx, c);
85+
prod = prod.multiply(x.subtract(xx));
86+
}
87+
prod = prod.mod(N);
88+
}
89+
gcd = prod.gcd(N);
90+
// grow the gdBlock like R in Brent
91+
if (gcdBlock<gcdBlockMax) {
92+
gcdBlock <<= 1;
93+
if (gcdBlock > gcdBlockMax) gcdBlock = gcdBlockMax;
94+
}
95+
} while (gcd.equals(I_1));
96+
97+
if (gcd.equals(N)) {
98+
do {
99+
xs = squareAddModN(xs, c);
100+
xxs = squareAddModN(xxs, c);
101+
xxs = squareAddModN(xxs, c);
102+
gcd = xs.subtract(xxs).gcd(N);
103+
} while (gcd.equals(I_1));
104+
}
105+
// leave loop if factor found; otherwise continue with a new random c
106+
} while (gcd.equals(N));
107+
if (DEBUG) LOG.debug("Found factor of " + N + " = " + gcd);
108+
return gcd;
109+
}
110+
111+
/**
112+
* Square and add modulo N, with <code>a, b < N</code>.
113+
* @param y
114+
* @param c
115+
* @return () mod N
116+
*/
117+
private BigInteger squareAddModN(BigInteger y, BigInteger c) {
118+
return y.multiply(y).add(c).mod(N);
119+
}
120+
}

0 commit comments

Comments
 (0)