On Class Group Computations Using the Number Field Sieve

The best practical algorithm for class group computations in imaginary quadratic number fields (such as group structure, class number, discrete logarithm computations) is a variant of the quadratic sieve factoring algorithm. Paradoxical as it sounds, the principles of the number field sieve, in a strict sense, could not be applied to number field computations, yet. In this article we give an indication of the obstructions. In particular, we first present fundamental core elements of a number field sieve for number field computations of which it is absolutely unknown how to design them in a useful way. Finally, we show that the existence of a number field sieve for number field computations with a running time asymptotics similar to that of the genuine number field sieve likely implies the existence of an algorithm for elliptic curve related computational problems with subexponential running time

Integer Factorization with a Neuromorphic Sieve

The bound to factor large integers is dominated by the computational effort to discover numbers that are smooth, typically performed by sieving a polynomial sequence. On a von Neumann architecture, sieving has log-log amortized time complexity to check each value for smoothness. This work presents a neuromorphic sieve that achieves a constant time check for smoothness by exploiting two characteristic properties of neuromorphic architectures: constant time synaptic integration and massively parallel computation. The approach is validated by modifying msieve, one of the fastest publicly available integer factorization implementations, to use the IBM Neurosynaptic System (NS1e) as a coprocessor for the sieving stage.Comment: Fixed typos in equation for modular roots (Section II, par. 6; Section III, par. 2) and phase calculation (Section IV, par 2

Sharp Transitions in Making Squares

In many integer factoring algorithms, one produces a sequence of integers (created in a pseudo-random way), and wishes to rapidly determine a subsequence whose product is a square (which we call a square product). In his lecture at the 1994 International Congress of Mathematicians, Pomerance observed that the following problem encapsulates all of the key issues: Select integers a_1, a_2, >... at random from the interval [1,x], until some (non-empty) subsequence has product equal to a square. Find good estimate for the expected stopping time of this process. A good solution to this problem should help one to determine the optimal choice of parameters for one's factoring algorithm, and therefore this is a central question. Pomerance (1994), using an idea of Schroeppel (1985), showed that with probability 1-o(1) the first subsequence whose product equals a square occurs after at least J_0^{1-o(1)} integers have been selected, but no more than J_0, for an appropriate (explicitly determined) J_0=J_0(x). Herein we determine this expected stopping time up to a constant factor, tightening Pomerance's interval to $$[ (\pi/4)(e^{-\gamma} - o(1))J_0, (e^{-\gamma} + o(1)) J_0],$$ where $\gamma = 0.577...$ is the Euler-Mascheroni constant. We will also confirm the well established belief that, typically, none of the integers in the square product have large prime factors. We believe the upper of the two bounds to be asymptotically sharp

Integer Factorisation, Fermat & Machine Learning on a Classical Computer

In this paper we describe a deep learning--based probabilistic algorithm for integer factorisation. We use Lawrence's extension of Fermat's factorisation algorithm to reduce the integer factorisation problem to a binary classification problem. To address the classification problem, based on the ease of generating large pseudo--random primes, a corpus of training data, as large as needed, is synthetically generated. We will introduce the algorithm, summarise some experiments, analyse where these experiments fall short, and finally put out a call to others to reproduce, verify and see if this approach can be improved to a point where it becomes a practical, scalable factorisation algorithm

Factoring Integers above 100 Digits using Hypercube MPQS

In this paper we report on further progress with the factorisation of integers using the MPQS algorithm on hypercubes and a MIMD parallel computer with 1024 T-805 processors. We were able to factorise a 101 digit number from the Cunningham list using only about 65 hours computing time. We give new details about the hypercube sieve initialisation procedure and describe the structure of the factor graph that saves a significant amount of computing time. At March 3rd, we finished the factorisation of a 104 digit composite

Block Sieving Algorithms

Quite similiar to the Sieve of Erastosthenes, the best-known general algorithms for factoring large numbers today are memory-bounded processes. We develop three variations of the sieving phase and discuss them in detail. The fastest modification is tailored to RISC processors and therefore especially suited for modern workstations and massively parallel supercomputers. For a 116 decimal digit composite number we achieved a speedup greater than two on an IBM RS/6000 250 workstation