[QUOTE=Uncwilly;246921]Happenstance. The number of new factored exponents in the lower range is not large. So, the ability to catch it at 60;000 is not as hard as the leading edge of TF.

BTW, the numbers in that range are being ECM'ed, not TF'ed.[/QUOTE]

I do need a pointer to a refresher on TF versus ECM versus LL, but let me
simplify my question: are there three separate P95 programs, or does
P95 call TF and then ECM, or what? What's the upper level structure of P95?

[QUOTE=davar55;247409]I do need a pointer to a refresher on TF versus ECM versus LL, but let me
simplify my question: are there three separate P95 programs, or does
P95 call TF and then ECM, or what? What's the upper level structure of P95?[/QUOTE]
The assignment types:
TF = Trial Factoring (a deterministic, exhaustive method of checking for factors of numbers up to a certain bit level.) Most effect method for low bit levels. Finds only prime factors.
P-1 = P minus 1 factor finding, a method of finding factors over a range, more effect at higher bit levels. May find a factor that is composite.
LL = The primality test. Does not find factors.
DC = Double check, same as LL
ECM = Elliptic Curve Method best method for finding larger factors (beyond what P-1 may find). Small chunks can be run on different machines, no large quantity of data transfer need. Only normally assigned to find factors of known composites.

[url]http://www.mersennewiki.org/index.php/Factorization[/url]

[QUOTE=Uncwilly;246921]Happenstance. The number of new factored exponents in the lower range is not large. So, the ability to catch it at 60;000 is not as hard as the leading edge of TF.

BTW, the numbers in that range are being ECM'ed, not TF'ed.[/QUOTE]

And some of the first factors has been found by P-1. Few by SNFS/QS/CFRAC, and maybe some of them by P+1.

[QUOTE=R. Gerbicz;247573]And some of the first factors has been found by P-1. Few by SNFS/QS/CFRAC, and maybe some of them by P+1.[/QUOTE]

Could you lay out these sieves a bit?

I've a bit of catching uo to do.

SNFS = Something New Factor Sieve ?
QS = Quantitative Sieve ?
CFRAC = Compute Factors Running And Counting ?
P - 1 versus P + 1 = Test Near a Known Prime ?

As I said, I could use a bit of pointing.

[QUOTE=davar55;247714]SNFS = Something New Factor Sieve ?
QS = Quantitative Sieve ?
CFRAC = Compute Factors Running And Counting ?
P - 1 versus P + 1 = Test Near a Known Prime ?[/QUOTE]

SNFS - [URL="http://en.wikipedia.org/wiki/Special_number_field_sieve"]Special number field sieve[/URL] - the fastest way to deterministically (i.e. it always results in factors, unlike TF or ECM which may or may not produce a factor) factor numbers of the form r^e+s where r and s are small (s can be negative) for numbers over about 85 digits.
QS - [URL="http://en.wikipedia.org/wiki/Quadratic_sieve"]Quadratic sieve[/URL] - the fastest way to deterministically factor numbers from about 30 to 85 or 90 digits.
CFRAC - [URL="http://en.wikipedia.org/wiki/Continued_fraction_factorization"]Continued fraction factorization[/URL] - I'm not familiar with this one. It seems to be related to QS due to their common link to Dixon's.
[URL="http://en.wikipedia.org/wiki/Pollard%27s_p_%E2%88%92_1_algorithm"]P-1[/URL] and [URL="http://en.wikipedia.org/wiki/Williams%27_p_%2B_1_algorithm"]P+1[/URL] can find a factor P of a number N when P-1 or P+1 is smooth to certain bounds.

[QUOTE=davar55;247409]are there three separate P95 programs, or does P95 call TF and then ECM, or what? What's the upper level structure of P95?[/QUOTE]It's all in one program. There's a top-level procedure (written in C) in one source module that reads the worktodo file and interprets the line commands. It calls procedures in other modules, depending on the type of operation.

There are separate procedures for P-1 and ECM, but together in the same source module because they share some things in common. TF is processed in a procedure in another module.

LL and DC are processed in a different set of modules. For the Test= and DoubleCheck= line commands, there first is a check on whether sufficient TF and P-1 have already been done. If one or both haven't, this LL/DC procedure calls the TF and/or P-1 procedures mentioned above.

FFTs (for P-1, ECM, LL and DC) are performed in a procedure, in another module, that is called by the other procedures doing P-1/ECM and DC/LL. This procedure, in turn, calls subroutines written in assembler language (all others mentioned above are in C) to do the well-optimized calculation loops that keep the FPU so busy.

[QUOTE=cheesehead;247790]It's all in one program. There's a top-level procedure (written in C) in one source module that reads the worktodo file and interprets the line commands. It calls procedures in other modules, depending on the type of operation.

There are separate procedures for P-1 and ECM, but together in the same source module because they share some things in common. TF is processed in a procedure in another module.

LL and DC are processed in a different set of modules. For the Test= and DoubleCheck= line commands, there first is a check on whether sufficient TF and P-1 have already been done. If one or both haven't, this LL/DC procedure calls the TF and/or P-1 procedures mentioned above.

FFTs (for P-1, ECM, LL and DC) are performed in a procedure, in another module, that is called by the other procedures doing P-1/ECM and DC/LL. This procedure, in turn, calls subroutines written in assembler language (all others mentioned above are in C) to do the well-optimized calculation loops that keep the FPU so busy.[/QUOTE]

I knew most of that, but is the entire program (P95) provably correct?

[QUOTE=davar55;247958] is the entire program (P95) provably correct?[/QUOTE]

Absolutely not.

[QUOTE=Prime95;247963]Absolutely not.[/QUOTE]

I realized that. But when you put all your baskets in one egg,
you're liable to require a lot of redundancy to get completeness.

Perhaps the author of P95 could write a short overview of
what calls what when in P95 with what parameters
(e.g. cutoffs for bit levels, how high TF goes for each bit range, etc)
in a software framework design language we can all read,
rather than in the C/asm not-provable form?

Would help the overall GIMPS proof schema.

[FONT=Courier New][SIZE=2]Some data from the status report:

[code]
19000000 59557 | 37557 22000 | 1 | |
20000000 59336 1 | 37304 22031 | 3 | |
21000000 59318 | 37281 22018 19 | 20 | |
22000000 58960 | 37212 21640 108 | 108 | |
23000000 58901 | 37297 21427 177 | 1 177 | |
24000000 58805 1 | 36962 14521 7321 | 7190 | 138 |
25000000 58600 1 | 36894 9198 12507 | 3 12341 | 194 |
26000000 58538 | 36574 4113 17851 | 4 17036 | 814 |
[/code]So GIMPS is [/SIZE][/FONT]1 + 3 + 20 + 108 + 1 + 177 = 310 LL tests,
either FT or DC, from proving
all mersenne prime exponents < 24000000 have been found,
and are 40 in number.

Then the same kind of laborious calculations give us
the number of tests to proving M41, M42, etc.

By ... I think I've got some of it.

...

Oh h*ll I can't split my screen to do the arithmetic for the rest.

That will have to wait.

[QUOTE=davar55;248572][FONT=Courier New][SIZE=2]Some data from the status report:

[code]
19000000 59557 | 37557 22000 | 1 | |
20000000 59336 1 | 37304 22031 | 3 | |
21000000 59318 | 37281 22018 19 | 20 | |
22000000 58960 | 37212 21640 108 | 108 | |
23000000 58901 | 37297 21427 177 | 1 177 | |
24000000 58805 1 | 36962 14521 7321 | 7190 | 138 |
25000000 58600 1 | 36894 9198 12507 | 3 12341 | 194 |
26000000 58538 | 36574 4113 17851 | 4 17036 | 814 |
[/code]So GIMPS is [/SIZE][/FONT]1 + 3 + 20 + 108 + 1 + 177 = 310 LL tests, either FT or DC, from proving all mersenne prime exponents < 24000000 have been found, and are 40 in number.
[/QUOTE]

No. By that data, GIMPS is 19 + 108 + 177 = 304 LL tests, all DC, from proving all mersenne primes < 24000000 have been found, and are 40 in number. :smile: