How can I enter a larger exponent?
 

When I try to enter a larger exponent under Advanced>Test

I am limited to 560,000,000 I believe, from what I read in the .txt files.
however, I see under recent results that people are capable of running higher exponents. How can I do this? I would like to run a random/shot in the dark/swingforthefences exponent of my own... a 1Billion digit exponent..

I would like to enter my own exponent once one of my workers finishes its current task.

thanks

[QUOTE=evanh;474650]I would like to enter my own exponent once one of my workers finishes its current task.[/QUOTE]

Stop worker.

Take head and insert into your own ass.

Start worker.

Please be kind.

[QUOTE=evanh;474650]a 1Billion digit exponent..[/QUOTE]
Why don't you start with a 100M digit one? It is also eligible for the EFF prize, and takes only 1/100th the time for a billion digit one. It is also 10 times likelier to be prime that a billion digit one! Talk about win-win. Once you've finished one of those, we'll talk about running a multi-decade test, ok?

[QUOTE=evanh;474650] my own... a 1Billion digit exponent..[/QUOTE]You might not live long enough to see it finish unless you have a very fast machine.

[size=1]Plus the limit is there for a good reason; P95 can't test numbers that large. You'll need different software for a number of that size.[/size]

[QUOTE=evanh;474650]When I try to enter a larger exponent under Advanced>Test

I am limited to 560,000,000
(...)
I would like to run a random/shot in the dark/swingforthefences exponent of my own... a 1Billion digit exponent..
[/QUOTE]

That is a large overshoot, do you really want that? The largest known Mersenne prime has only 8 digits long in exponent (in base ten).

:smile:[QUOTE=R. Gerbicz;474660]That is a large overshoot, do you really want that? The largest known Mersenne prime has only 8 digits long in exponent (in base ten).[/QUOTE]

:smile:

[QUOTE=CRGreathouse;474653]Please be kind.[/QUOTE]

thanks

:smile:[QUOTE=chalsall;474652]Stop worker.

Take head and insert into your own ass.

Start worker.[/QUOTE]

thats pretty ineffiicient. There is no need to stop my current workers to do that... I have a big head it may take a while to insert, thats time wasted on my current exponents:smile:

[QUOTE=evanh;474650]When I try to enter a larger exponent under Advanced>Test

I am limited to 560,000,000 I believe, from what I read in the .txt files.
however, I see under recent results that people are capable of running higher exponents. How can I do this? I would like to run a random/shot in the dark/swingforthefences exponent of my own... a 1Billion digit exponent..

I would like to enter my own exponent once one of my workers finishes its current task.

thanks[/QUOTE]

Prime95 is limited to 560M.
Results you see for larger exponents are using different software of which I have no experience. As well I believe those who are trying are using LL testing software on their GPUs.

But as several have said; you truly may not live to see it complete unless you have a super computer or very fast GPU.

Check out any of these that have LL as the Work Type and that have a completion date.
[url]https://www.mersenne.org/assignments/?exp_lo=560000000&exp_hi=999999999&exp1=1&extf=1[/url]

Since I am not sure what you mean by "fast" here are my specs. No I do not have a supercomputer or anything of that nature. just a couple of Macs.

[B]desktop:[/B]
iMac: 4 GHz Intel Core i7, 32 GB 1600 MHz DDR3, AMD Radeon R9 M295X 4 GB

[B]laptop: [/B]
MacBook Pro: 3.1 GHz Intel Core i7,16 GB 2133 MHz LPDDR3, Intel HD Graphics 630 1536

To be quite honest I found a way to land on a prime number relatively quickly(at least for numbers with a number of digits that I can test personally), however, it is not in the form [TEX]2^P-1[/TEX] ..... which means I could very likely land on a prime that is 100,000,000 digits long NOT in the form [TEX]2^P-1[/TEX] with ridiculously fewer computations .....<100 computations perhaps... while something like Prime95 keeps chugging along.

I thought I was good to go but then I ran into any issue with the computational mathematics software I use, Maplesoft's Maple. I am not actually coding in Maple's language(yet) just inputing my commands into worksheet mode.... symbolically? << right word :confused:

Its not an error on their part its just how their program is written. They have 2 prime functions of interest.

The first is [B]isprime(integer)[/B] and it returns true or false. Maplesoft's help pages state that this is a probabilistic primality testing routine that does a "strong pseudo-primality test" and a one Lucas test.

The second is [B]type(expr, prime)[/B] which apparently just checks to see if an integer is inputed and runs a "true" primality test up until you input a certain length of digit, then it defaults back to i[B]sprime(integer)[/B]

before I could even enter an exponent of my own I would have to find such a number that could be put in the form [TEX]2^P-1[/TEX] which is my first problem because my number would not initially be in such a form. it would be more like [TEX]2^x-C[/TEX] where x a specific number(likely not prime) and C is a constant chosen from the method I would employ.

There is nothing wrong with Prime95 as it has obviously proven itself. However, upon reading the rules of the EFF for the 100,000,000+ & 1,000,000,000+ digit awards I do not recall anything stating that the prime must be in the form of a Mersenne Prime

It would be great if I knew how to code and could write my own program where I could input one of these numbers and check to see if its prime but I am just now working on this aspect of my personal portfolio. My first programming class is "Intro to C-Programming" and it starts in about 3 weeks:big grin:

The problem with Maplesoft's program, again for my purposes not a flaw on their product, is that it doesn't provide any time references for completion, doesn't save progress, and just simply states "evaluating" .... I managed to get it to spit out a 600,000,000 digit long number but above that it appears that it doesn't like me lol


I almost forgot.. when I check my method through Maplesoft using smaller digit primes I always return a "true" for the prime check within 100 computations, most of the checks involve less than 40 computations...

I am currently a double major working towards a B.S. in Mathematics & Physics with about 2 years left.I will pursue a graduate degree in either: Mathematical Physics or Applied Physics concentrated in Applied Mathematics & Computational Physics... which is why I am learning with Maplesoft :)

Again, almost forgot.... I am one of the recipients at my university of our NSF-STEM Scholarship and I must do at least one research project and I was considering doing research into my method of locating primes... I guess the big question that I must answer before I go down this road is what benefit could my method have over any other method...

[QUOTE=petrw1;474698]Prime95 is limited to 560M.
Results you see for larger exponents are using different software of which I have no experience. As well I believe those who are trying are using LL testing software on their GPUs.

But as several have said; you truly may not live to see it complete unless you have a super computer or very fast GPU.

Check out any of these that have LL as the Work Type and that have a completion date.
[url]https://www.mersenne.org/assignments/?exp_lo=560000000&exp_hi=999999999&exp1=1&extf=1[/url][/QUOTE]

I have come across these but I am curious what their benchmarks are... here are mine below..

I get it Prime95 has a tried and true method so why stray from it right? Have you ever seen the video on youtube of Richard Feynman discussing the difference between Mathematicians and Physicists? the whole video is good but the part I am referring to startes at about 5:40. [URL="https://www.youtube.com/watch?v=obCjODeoLVw"]https://www.youtube.com/watch?v=obCjODeoLVw[/URL] He basically goes on to say that guessing the equation seems to be a good way to discover new things... essentially I would like to apply my personal method to finding prime numbers and testing those... I just have no way to test... womp womp womp .... guess I need to really learn programming now... :)

[QUOTE=evanh;474705]I have come across these but I am curious what their benchmarks are... here are mine below..[/QUOTE]Those results don't apply to 1 billion digit exponents. There is no software in existence that can test such an enormous number. There is no computer in existence that can even [i]store[/i] such an enormous number. Do you really know what you are asking for? Even in the best possible case of a base-2 one-billion-digit-exponent that is still something like 10[sup]332...<skip ~999,999,993 digits>...xxx[/sup].

[QUOTE=retina;474707]Those results don't apply to 1 billion digit exponents. There is no software in existence that can test such an enormous number. There is no computer in existence that can even [i]store[/i] such an enormous number. Do you really know what you are asking for? Even in the best possible case of a base-2 one-billion-digit-exponent that is still something like 10[sup]332...<skip ~999,999,993 digits>...xxx[/sup].[/QUOTE]

I think there is a miscommunication I am not referring to a billion digit exponent.... but a billion digit result

[QUOTE=evanh;474708]I think there is a miscommunication I am not referring to a billion digit exponent.... but a billion digit result[/QUOTE]

That's still over 3 GB to store the number.

That is pretty cool, how did you come up with that storage size?

Also, is this a reason that the calculation could not be done? I have storage space, RAM.. and more importantly... time :)

Evan,
Have you looked into Pari-Gp.
It's isprime function is deterministic and one of the fastest off the shelf functions for primality testing. For general form primes you can use primo it has limited (but large) parallel processing capability. It can only run on 64 bit Linux machine and will require a few lifetimes to come up with certificates for very large numbers.
IMHO your best chance of proving your 1G dd integer prime is writing your own code using Lucas primally test and not LL test. You will have to write your own code make your own hardware (a PC won't do) and find all the prime factors of n-1 where n is your prime candidate. This could be trivial and virtually instantaneous (relatively speaking) if the C in your formula can be -1.
If you see a discussion about the number of atoms in the universe, you can just ignore them

[QUOTE=evanh;474711]That is pretty cool, how did you come up with that storage size?

Also, is this a reason that the calculation could not be done? I have storage space, RAM.. and more importantly... time :)[/QUOTE] okay my math is bit off,. It's all to do with logarithms. Also look up computational complexity.

[QUOTE=evanh;474711]That is pretty cool, how did you come up with that storage size?

Also, is this a reason that the calculation could not be done? I have storage space, RAM.. and more importantly... time :)[/QUOTE]

You are Majoring in math and Physics... Consider learning a bit about computational complexity :smile: Such subject is all about how "hard" a calculation is, based on simple atomic operations. It also explain things like logarithmic, linear, polynomial and exponential time to reach a result (you should have learnt about asymptotics while studying Calculus I). Using such tools it becomes quite easy to define how long a computation will take, and how many bytes it will need to accomplish its goal.

And, yes, the answer to your last qustion lies on it. Unless you have petabytes of RAM and at least 85 years' time, you won't succeed.

[QUOTE=ET_;474714]You are Majoring in math and Physics... Consider learning a bit about computational complexity :smile: Such subject is all about how "hard" a calculation is, based on simple atomic operations. It also explain things like logarithmic, linear, polynomial and exponential time to reach a result (you should have learnt about asymptotics while studying Calculus I). Using such tools it becomes quite easy to define how long a computation will take, and how many bytes it will need to accomplish its goal.

And, yes, the answer to your last qustion lies on it. Unless you have petabytes of RAM and at least 85 years' time, you won't succeed.[/QUOTE]

Yes I am familiar with asymptotics. I am basically a newborn in the world of computational anything... however, I am very capable of learning just about anything. I see your, and everyone else's, point regarding the amount of time it would take.

Perhaps I will try my method on 100,000,000 digit primes and if my probabilistic test within Maple comes up "true" then I can move forward from there.

Also, I guess I can start here>> [url]https://en.wikipedia.org/wiki/Computational_complexity_theory[/url]
then move on to the textbooks referenced on that site.

currently working on a number close to this one, Maplesoft.. The only problem is that I do not have an estimated time to completion and no way to save my progress.

usually if the number is "false" it returns fairly quickly.. this one is taking its time so we shall see.

[QUOTE=evanh;474721]
Perhaps I will try my method on 100,000,000 digit primes and if my probabilistic test within Maple comes up "true" then I can move forward from there.
[/QUOTE]

Try 10,000 digits. Then try 100,000. Then consider how much longer the second case takes, extrapolate. Perhaps once you have a concept of how many lifetimes your goal will take, you can then explore the limits of the software you have available to you.

[QUOTE=VBCurtis;474725]Try 10,000 digits. Then try 100,000. Then consider how much
longer the second case takes, extrapolate. [/QUOTE]This is wise. Also, you should test your machine to ensure that it is stable. Doing some double checks is useful. Also testing known primes and known composites with your software is a useful check.

@OP:
Your best computer can do one iteration in ~16ms, according with the benchmark you posted. To test a number with 100 million digits with the known best algorithm and program (that is LL test, and P95) you will need to do about 350 million iterations. Because your exponent is in the range of 350 million. That is, it will take [U]that particular[/U] computer, 350 000 000 * 0.016 = 5 600 000 million seconds. Or, about 1600 hours. Or, about 65 days.

To test a billion digits number, your exponent is 10 times larger, that is in the range of 3.4 gigs. Your number has [U]ten times[/U] a hundred million digits. A single iteration for such a monster would take more than 20 times longer, but say for the sake of the calculus that you can improve the algorithm, and get a faster computer, such that the iteration time grows only ten times. That is 160 milliseconds per iteration. In that case, you will need to do ~3.4 billion iterations, and that makes 3 400 000 000 * 0.16 = 544 million seconds, or about 156 thousand hours, or about 6300 days, or about 17 years.

If my calculus is right, that is the time you will need with a computer much faster than you have (but still in reasonable limits to buy in a specialized shop) to test a billion digit number with current known math.

Mind that the 160ms per iteration is exaggeratedly optimistic. That is because multiplication algorithm is not linear. Think about like that: with the school grade algorithm, when you double the number of digits, you need to do four times more multiplications. To multiply 3 time 5 you do a single multiplication, but to multiply 37 * 54 you do four multiplications (4*7, 4*3, 5*7, 5*3) and then add the stuff shifted respectively. Now, if you have 10 times more digits, you will have to do (school grade) 100 times more multiplications. Now, well, we do not make school grade multiplications here, that would be so slow that we would not be able to test even numbers with a single million digits. We do some tricks called Fast Fourier Transformation (FFT) to speed up the multiplications. But yet, when your numbers grows 10 times in size (like from 10 digits to 100 digits), the speed goes more than 10 times slower. Not 100 times slower, like it would be with school-grade (try to do a 100 digits multiplication by hand!), but yet, more than 10 times slower. Depending on the size of the numbers, it can be anything between 20 and 50 times slower.

Therefore, my calculus with 160 ms per iteration is extremely optimistic, you can better count on something like 30 years, instead of 17.

And that is for a single test. You don't need PhD in physics and math to make all this calculus.

Therefore, don't get upset if people here start making fun of you. We are kinda tough community here, and what you claim is really funny. :razz:

[QUOTE=evanh;474708]I think there is a miscommunication I am [b]not[/b] referring to [b]a billion digit exponent[/b]....[/QUOTE][QUOTE=evanh;474650]... a [b]1Billion digit exponent[/b]...[/QUOTE]Hence the confusion.

[QUOTE=LaurV;474771]@OP:
Your best computer can do one iteration in ~16ms, according with the benchmark you posted. To test a number with 100 million digits with the known best algorithm and program (that is LL test, and P95) you will need to do about 350 million iterations. Because your exponent is in the range of 350 million. That is, it will take [U]that particular[/U] computer, 350 000 000 * 0.016 = 5 600 000 million seconds. Or, about 1600 hours. Or, about 65 days.

To test a billion digits number, your exponent is 10 times larger, that is in the range of 3.4 gigs. Your number has [U]ten times[/U] a hundred million digits. A single iteration for such a monster would take more than 20 times longer, but say for the sake of the calculus that you can improve the algorithm, and get a faster computer, such that the iteration time grows only ten times. That is 160 milliseconds per iteration. In that case, you will need to do ~3.4 billion iterations, and that makes 3 400 000 000 * 0.16 = 544 million seconds, or about 156 thousand hours, or about 6300 days, or about 17 years.

If my calculus is right, that is the time you will need with a computer much faster than you have (but still in reasonable limits to buy in a specialized shop) to test a billion digit number with current known math.

Mind that the 160ms per iteration is exaggeratedly optimistic. That is because multiplication algorithm is not linear. Think about like that: with the school grade algorithm, when you double the number of digits, you need to do four times more multiplications. To multiply 3 time 5 you do a single multiplication, but to multiply 37 * 54 you do four multiplications (4*7, 4*3, 5*7, 5*3) and then add the stuff shifted respectively. Now, if you have 10 times more digits, you will have to do (school grade) 100 times more multiplications. Now, well, we do not make school grade multiplications here, that would be so slow that we would not be able to test even numbers with a single million digits. We do some tricks called Fast Fourier Transformation (FFT) to speed up the multiplications. But yet, when your numbers grows 10 times in size (like from 10 digits to 100 digits), the speed goes more than 10 times slower. Not 100 times slower, like it would be with school-grade (try to do a 100 digits multiplication by hand!), but yet, more than 10 times slower. Depending on the size of the numbers, it can be anything between 20 and 50 times slower.

Therefore, my calculus with 160 ms per iteration is extremely optimistic, you can better count on something like 30 years, instead of 17.

And that is for a single test. You don't need PhD in physics and math to make all this calculus.

Therefore, don't get upset if people here start making fun of you. We are kinda tough community here, and what you claim is really funny. :razz:[/QUOTE]

Also consider that what Laurv just wrote is valid using prime95 on a candidate of the form 2^p - 1. If, as you just said, your number is not of that form (2^p - C, C != 1), your timings would grow another 30% (if using a LLR test).

Luigi

[QUOTE=retina;474772]Hence the confusion.[/QUOTE]


I see, that is my fault, I apologize.

I think I may have confused myself during that post. I was looking for an exponent that would produce a billion digit number and I think I was finding that it would take an exponent over 1 billion, probably around 3 billion... as an exponent.. I was using Maple to find such an exponent that would produce a billion digit number but I could only find 999,xxx,xxx digits... I guess thats where Maple stops because when I increased the exponent every so slightly it stops giving me an answer there.

Thank you for pointing out my miscommunication, I appreciate it.

[QUOTE=Uncwilly;474735]This is wise. Also, you should test your machine to ensure that it is stable. Doing some double checks is useful. Also testing known primes and known composites with your software is a useful check.[/QUOTE]

So far my iMac has a Verified M45305383, Unverified M81540187, and a Mismatch M48025451 as result types. Not sure what Mismatch is I haven't been able to find any literature on it yet.

Is there a link that anyone can provide that explains what the "residue", "shift", "type", and "results" all mean on the "primenet exponent status" page?


When using my software for my personal prime search I have been checking against known primes and not-primes(composites?) before attempting to locate a prime. I really wish there was a way to save the progress and see a completion date in the Maple software... While Prime95 seems to be CPU heavy, Maple seems to be RAM heavy and spares the CPU, even when I ran Maple in terminal mode.

[QUOTE=LaurV;474771]@OP:
Your best computer can do one iteration in ~16ms, according with the benchmark you posted. To test a number with 100 million digits with the known best algorithm and program (that is LL test, and P95) you will need to do about 350 million iterations. Because your exponent is in the range of 350 million. That is, it will take [U]that particular[/U] computer, 350 000 000 * 0.016 = 5 600 000 million seconds. Or, about 1600 hours. Or, about 65 days.

To test a billion digits number, your exponent is 10 times larger, that is in the range of 3.4 gigs. Your number has [U]ten times[/U] a hundred million digits. A single iteration for such a monster would take more than 20 times longer, but say for the sake of the calculus that you can improve the algorithm, and get a faster computer, such that the iteration time grows only ten times. That is 160 milliseconds per iteration. In that case, you will need to do ~3.4 billion iterations, and that makes 3 400 000 000 * 0.16 = 544 million seconds, or about 156 thousand hours, or about 6300 days, or about 17 years.

If my calculus is right, that is the time you will need with a computer much faster than you have (but still in reasonable limits to buy in a specialized shop) to test a billion digit number with current known math.

Mind that the 160ms per iteration is exaggeratedly optimistic. That is because multiplication algorithm is not linear. Think about like that: with the school grade algorithm, when you double the number of digits, you need to do four times more multiplications. To multiply 3 time 5 you do a single multiplication, but to multiply 37 * 54 you do four multiplications (4*7, 4*3, 5*7, 5*3) and then add the stuff shifted respectively. Now, if you have 10 times more digits, you will have to do (school grade) 100 times more multiplications. Now, well, we do not make school grade multiplications here, that would be so slow that we would not be able to test even numbers with a single million digits. We do some tricks called Fast Fourier Transformation (FFT) to speed up the multiplications. But yet, when your numbers grows 10 times in size (like from 10 digits to 100 digits), the speed goes more than 10 times slower. Not 100 times slower, like it would be with school-grade (try to do a 100 digits multiplication by hand!), but yet, more than 10 times slower. Depending on the size of the numbers, it can be anything between 20 and 50 times slower.

Therefore, my calculus with 160 ms per iteration is extremely optimistic, you can better count on something like 30 years, instead of 17.

And that is for a single test. You don't need PhD in physics and math to make all this calculus.

Therefore, don't get upset if people here start making fun of you. We are kinda tough community here, and what you claim is really funny. :razz:[/QUOTE]

First of all, thank you for taking the time to type all of this up I really do appreciate it. I have read through it, and I am now going to drink my coffee while I read through it again making sure I completely understand each sentence.. :coffee:

I don't mind if people make fun of me.. I grew up with "[I]sticks and stones may break my bones but words shall never hurt me[/I]". I only ask that if people are going to make fun at least couple it with some constructive criticism so that I may learn something in the process:smile:

Again thank you for the write up.. I am going to take some notes on it and I'll get back to you.

[QUOTE=ET_;474778]Also consider that what Laurv just wrote is valid using prime95 on a candidate of the form 2^p - 1. If, as you just said, your number is not of that form (2^p - C, C != 1), your timings would grow another 30% (if using a LLR test).

Luigi[/QUOTE]

I understand.

You all have been very insightful. I am glad that you all have taken time out of your day to help me better understand.

My iMac is currently running M332xxxxxx on Prime95 as well as a 300M+ exponent in Maple. I did start the Maple calculation a few days after the Prime95 calculation but we'll see how it goes. I know there are a lot of variables that go into comparing the two computations, I just figured since Prime95 is CPU heavy and Maple is RAM heavy why not take advantage of the two programs since they don't hinder each other.

[QUOTE=a1call;474712]Evan,
Have you looked into Pari-Gp.
It's isprime function is deterministic and one of the fastest off the shelf functions for primality testing. For general form primes you can use primo it has limited (but large) parallel processing capability. It can only run on 64 bit Linux machine and will require a few lifetimes to come up with certificates for very large numbers.
IMHO your best chance of proving your 1G dd integer prime is writing your own code using Lucas primally test and not LL test. You will have to write your own code make your own hardware (a PC won't do) and find all the prime factors of n-1 where n is your prime candidate. This could be trivial and virtually instantaneous (relatively speaking) if the C in your formula can be -1.
If you see a discussion about the number of atoms in the universe, you can just ignore them[/QUOTE]

Thank you a1call. I am looking into your suggestions now.

I am new to code but better late than never. It seems like the general theme is a billion digit number will require either a supercomputer or a search to be passed down from generation to generation lol!

Thanks for the input, I will respond again when/if I have questions about Pari-GP

[QUOTE=LaurV;474771]@OP:
Your best computer can do one iteration in ~16ms, according with the benchmark you posted. [/QUOTE]That time is for 4M FFT only. For the required 1Gdigit check the FFT iteration time would be a lot more. Since P95 can't do tests that large the times will have to come from another application. Is there any program currently existing that [i]can[/i] handle numbers of 1Gdigit? A single iteration could take a few minutes. Multiply that by 1G iterations and you need to have the lifetime of a few Methuselahs to see it finish.

[QUOTE=evanh;474793]I understand.

You all have been very insightful. I am glad that you all have taken time out of your day to help me better understand.

My iMac is currently running M332xxxxxx on Prime95 as well as a 300M+ exponent in Maple. I did start the Maple calculation a few days after the Prime95 calculation but we'll see how it goes. I know there are a lot of variables that go into comparing the two computations, I just figured since Prime95 is CPU heavy and Maple is RAM heavy why not take advantage of the two programs since they don't hinder each other.[/QUOTE]

Let me add that

IF (prime-proving requires high-level CPU calculations)
AND (prime95 is CPU heavy)
THEN (prime95 will reach its result much faster than Maple)

and

IF (prime95 proves numbers of the form 2^p - 1)
AND (your number is not of the form 2^p - 1)
THEN (you cannot use prime95 to prove your numbers: the result will be wrong)

I beg your pardon if such syllogisms are already clear to you: having to do daily with students who do not know how computers work, I felt the urge to elaborate. :smile:

Luigi

[QUOTE=evanh;474789]Is there a link that anyone can provide that explains what the "residue", "shift", "type", and "results" all mean on the "primenet exponent status" page?[/QUOTE]

The LL-test residue, is like a remainder for the test. If two people perform the same test, we expect the same residue from both tests, unless one (or both) of the tests had errors.
[URL="http://www.mersennewiki.org/index.php/Residue"]http://www.mersennewiki.org/index.php/Residue[/URL]

The 'shift' is just part of the FFT (fast fourier transform) used in the test. It is expected to be different. The below link doesn't discuss the shift, but might give you a good starting point if you want to get more detail on the subject.
[URL="http://www.mersennewiki.org/index.php/Fast_Fourier_Transform"]http://www.mersennewiki.org/index.php/Fast_Fourier_Transform[/URL]

The result 'type' is what each test tells us. If someone performs partial factoring, "NF" tells us there was no factor for the factoring range. If an LL test indicates the candidate is composite, "C" is the result type.

The 'result' column just has some extra details about the test type, like the residue for an LL test, or the 'bit-range' that someone checked for factors.

[QUOTE=ET_;474796]Let me add that

IF (prime-proving requires high-level CPU calculations)
AND (prime95 is CPU heavy)
THEN (prime95 will reach its result much faster than Maple)

and

IF (prime95 proves numbers of the form 2^p - 1)
AND (your number is not of the form 2^p - 1)
THEN (you cannot use prime95 to prove your numbers: the result will be wrong)

I beg your pardon if such syllogisms are already clear to you: having to do daily with students who do not know how computers work, I felt the urge to elaborate. :smile:

Luigi[/QUOTE]

This is a very good point. I thought perhaps Maple might be more efficient with how it uses the Computers hardware but it looks like I am very wrong. I need to read up on how these types of computations utilize the computers hardware ...

I was thinking that Maple is using a code where it checks all integers 2 to n-1 to see if they factor into n but somehow stores each check in the RAM for efficiency so it doesn't have to compute factors it already computed but rather it just checks against previous calculations...

I could be making no sense here but I'm learning...

[QUOTE=potonono;474797]The LL-test residue, is like a remainder for the test. If two people perform the same test, we expect the same residue from both tests, unless one (or both) of the tests had errors.
[URL="http://www.mersennewiki.org/index.php/Residue"]http://www.mersennewiki.org/index.php/Residue[/URL]

The 'shift' is just part of the FFT (fast fourier transform) used in the test. It is expected to be different. The below link doesn't discuss the shift, but might give you a good starting point if you want to get more detail on the subject.
[URL="http://www.mersennewiki.org/index.php/Fast_Fourier_Transform"]http://www.mersennewiki.org/index.php/Fast_Fourier_Transform[/URL]

The result 'type' is what each test tells us. If someone performs partial factoring, "NF" tells us there was no factor for the factoring range. If an LL test indicates the candidate is composite, "C" is the result type.

The 'result' column just has some extra details about the test type, like the residue for an LL test, or the 'bit-range' that someone checked for factors.[/QUOTE]

I see. Thank you very much. So is it correct that a result of "C-Mismatch" means that the result is composite but did not match someone else result?

thank you for the links.

[QUOTE=ET_;474796]I beg your pardon if such syllogisms are already clear to you: having to do daily with students who do not know how computers work, I felt the urge to elaborate. :smile:[/QUOTE]

When I was going to UVic in the late '80's, a friend of mine was a support consultant in the Computing Services department.

A graduate student came in complaining that his program wasn't working on the IBM 360.

My friend looked at the code, and carefully and gently explained to him that he was trying to allocate a four dimensional complex number array which would consume more memory than existed on earth.

"Well", said the graduate student, "when are you going to upgrade your computer so it can run my program?

Believe it or not, this is a true story.

[QUOTE=evanh;474800]
I was thinking that Maple is using a code where it checks all integers 2 to n-1 to see if they factor into n[/QUOTE]
Testing a number for factors is much smaller you need only check up to sqrt n. This is because if n=pq with p and q both greater than sqrt you get n> n a contradiction.

[QUOTE=evanh;474800]
I was thinking that Maple is using a code where it checks all integers 2 to n-1 to see if they factor into n but somehow stores each check in the RAM for efficiency so it doesn't have to compute factors it already computed but rather it just checks against previous calculations...

I could be making no sense here but I'm learning...[/QUOTE]

If you are learning, then it makes sense.

First things first.
You don't have to test all integers from 2 to n-1 to see if they factor into n: you may well use only prime numbers (hence the explosion in RAM usage) up to the square root of n. Can you see why? Because every factor above the square root of n gives a second (co)factor that is less than the square root of n: if you start from 2 and go up the ladder of primes, then you have already checked such cofactor. Hence the reason to stop at the square root of n.

Second heuristic.
Division operations are quite slow on modern CPUs, referred to (integer) multiplication, so we can use modular arithmetic instead. As you may remember the modulus of an operation is the remainder from an integer division, i.e. 5 % 2 = 1.
Using modulus is quite efficient and lets you test numbers up to 4,200,000,000 using only a few modulo operations with primes in the very low range.

Interlude.
I guess Maple uses a symbolic engine to (try to) solve primality problems. Consider that the isprime() function used on Maple does not perform a primality test, it only performs a probabilistic test. So I hope you don't use that function to test your number...

[QUOTE=evanh;474794]Thank you a1call. I am looking into your suggestions now.

I am new to code but better late than never. It seems like the general theme is a billion digit number will require either a supercomputer or a search to be passed down from generation to generation lol!

Thanks for the input, I will respond again when/if I have questions about Pari-GP[/QUOTE]
Well if the search is parallel-able, distributed computing with a very large number of collaborators would divide the time required by the number of collaborators, at least in theory(individual computing power variations not withstanding).
Primo uses parallel computing for proving general form primes. But it is limited in threads by design, which makes it of limited use. It's a shame that the concept is not utilised as distributed computing.

Regarding primo, it is not the top SERP in Google for its name:
[url]http://www.ellipsa.eu/public/primo/primo.html#FAQ[/url]
Paul Underwood can correct me if I am wrong but going by memory it has a limit on 64 threads.

[QUOTE=evanh;474788]I was looking for an exponent that would produce a billion digit number and I think I was finding that it would take an exponent over 1 billion, probably around 3 billion... as an exponent..[/QUOTE]

You can easily find the smallest exponent:
1,000,000,000 / log[sub]10[/sub](2) = 3321928094,887

The smallest prime above this is: 3,321,928,097 but there is already known factors of 2[sup]3,321,928,097[/sup] - 1. The lowest prime exponent without known factors is:
3,321,928,171:

[url]http://home.earthlink.net/~elevensmooth/Billion.html[/url]

[QUOTE=ET_;474807]
Interlude.
I guess Maple uses a symbolic engine to (try to) solve primality problems. Consider that the isprime() function used on Maple does not perform a primality test, it only performs a probabilistic test. So I hope you don't use that function to test your number...[/QUOTE]

Unfortunately it is a probabilistic test with the following information regarding how it tests... [url]https://www.maplesoft.com/support/help/maple/view.aspx?path=isprime[/url]


[B][I]•
The isprime command is a probabilistic primality testing routine. (See prime number.)
•
It returns false if n is shown to be composite within one strong pseudo-primality test and one Lucas test. It returns true otherwise.
•
If isprime returns true, n is very probably prime - see References section. No counterexample is known and it has been conjectured that such a counter example must be hundreds of digits long.[/I][/B]

I suppose if a number I test comes back "true" I will have to seek help in performing a deterministic probability test... the good news is that usually it is quickly able to kick back a "false" output... right now the number I am testing has been "evaluating" for a few days now.. I know thats nothing considering with my hardware it could take a few months... with all of the numbers I have tested with my method up to... 1,000,000,000,000 I have been able to find a prime with this method... no I have not tested ALL of the numbers up to this and I know that just because it holds true for what I have shown that does not mean it holds true for ALL cases...

I still think it will be pretty cool to get a return of "true" on a 100,000,000+ digit number even if it is probabilistic.. anyone care to help out if that happens??? we can split the prize money :big grin:

[QUOTE=evanh;474832]Unfortunately it is a probabilistic test with the following information regarding how it tests... [url]https://www.maplesoft.com/support/help/maple/view.aspx?path=isprime[/url]


[B][I]•
The isprime command is a probabilistic primality testing routine. (See prime number.)
•
It returns false if n is shown to be composite within one strong pseudo-primality test and one Lucas test. It returns true otherwise.
•
If isprime returns true, n is very probably prime - see References section. No counterexample is known and it has been conjectured that such a counter example must be hundreds of digits long.[/I][/B]

I suppose if a number I test comes back "true" I will have to seek help in performing a deterministic probability test... the good news is that usually it is quickly able to kick back a "false" output... right now the number I am testing has been "evaluating" for a few days now.. I know thats nothing considering with my hardware it could take a few months... with all of the numbers I have tested with my method up to... 1,000,000,000,000 I have been able to find a prime with this method... no I have not tested ALL of the numbers up to this and I know that just because it holds true for what I have shown that does not mean it holds true for ALL cases...

I still think it will be pretty cool to get a return of "true" on a 100,000,000+ digit number even if it is probabilistic.. anyone care to help out if that happens??? we can split the prize money :big grin:[/QUOTE]Don't get your hopes up. You won't be able to simply use off-the-shelf code to test numbers of that size in a few days, or a few months, or a few years. If it was so easy someone else would have already done it by now. There is a very good reason that the prize has remained unclaimed, and it is not because no one else has thought about it before. You haven't discovered any new or interesting.

[QUOTE=evanh;474832] with all of the numbers I have tested with my method up to... 1,000,000,000,000 I have been able to find a prime with this method... no I have not tested ALL of the numbers up to this and I know that just because it holds true for what I have shown that does not mean it holds true for ALL cases...
[/QUOTE]
Waaaiiiit..... you've tested your "method" up to thirteen digits? 13? One-three? You've skipped from 13 to.... how big?

You didn't consider trying 20, or 100, or 300 digits first, to see how many tries (and how many seconds) your method takes to find a prime as the length increases?

If the current state-of-the-art software used to prove arbitrary forms prime could be extended to the length you're considering and still fit in memory (it can't, and it wouldn't), you're looking at something on the order of the age of the Earth to complete the proof.

[QUOTE=VBCurtis;474835]

If the current state-of-the-art software used to prove arbitrary forms prime could be extended to the length you're considering and still fit in memory (it can't, and it wouldn't), you're looking at something on the order of the age of the Earth to complete the proof.[/QUOTE]

Yes , even at 1 nanosecond I get roughly 278 million years for just the multiplies to do an LL test on the lowest exponents using the grade school multiply.

[QUOTE=evanh;474801]I see. Thank you very much. So is it correct that a result of "C-Mismatch" means that the result is composite but did not match someone else result? [/QUOTE]
A mismatch just means that two people ran the test and got different results. We don't know if the number is composite or not, until we get a "match". Up to now, all mismatches turned out to be composite, but that means statistically [U]nothing[/U] (as almost all tests turn out to be composite anyhow, and only 49 of them up to now turned out to be prime, ever...)

Until we get a match, we don't know.

[QUOTE=retina;474795]That time is for 4M FFT only. For the required 1Gdigit check the FFT iteration time would be a lot more. Since P95 can't do tests that large the times will have to come from another application. Is there any program currently existing that [I]can[/I] handle numbers of 1Gdigit? A single iteration could take a few minutes. Multiply that by 1G iterations and you need to have the lifetime of a few Methuselahs to see it finish.[/QUOTE]
Have you read my post? The one you quote...

Edit: a Titan (classic) tests M666666667 in 217 days. I know because I am working on it (see [URL="https://www.mersenne.org/report_exponent/?exp_lo=666666667&exp_hi=&full=1"]my reservation[/URL], already almost two years old - that is because I had big "gaps" in the work, due to fun adventures, hardware smoking, etc, haha). I never touched the new Big Pascal, and Big Volta, which Oliver plays with, but from his benchmarks, that looks about triple fast, so the "giga-digit test in a year" is not so far away. :razz:

You will live to see in each house the hardware able to do it, much sooner than you expect.

[QUOTE=LaurV;474857]Have you read my post? The one you quote...

Edit: a Titan (classic) tests M666666667 in 217 days. I know because I am working on it (see [URL="https://www.mersenne.org/report_exponent/?exp_lo=666666667&exp_hi=&full=1"]my reservation[/URL], already almost two years old - that is because I had big "gaps" in the work, due to fun adventures, hardware smoking, etc, haha). I never touched the new Big Pascal, and Big Volta, which Oliver plays with, but from his benchmarks, that looks about triple fast, so the "giga-digit test in a year" is not so far away. :razz:

You will live to see in each house the hardware able to do it, much sooner than you expect.[/QUOTE]

Yes I worked through the numbers you gave me and found the same you did. Now it is much easier to see why so many are laughing at me! lol I kind of laughed at myself once I did the math....

is this the Titan you are referring to? [url]https://www.olcf.ornl.gov/titan/[/url]

even if not this one but a different supercomputer type I have a question regarding languages.. Is Maple a language that is accepted by these types of computers? Maple does have a code generator that can convert the Maple code to others but I am just curious if these supercomputers accept Maple.

[QUOTE=LaurV;474857]Have you read my post? The one you quote...

Edit: a Titan (classic) tests M666666667 in 217 days. I know because I am working on it (see [URL="https://www.mersenne.org/report_exponent/?exp_lo=666666667&exp_hi=&full=1"]my reservation[/URL], already almost two years old - that is because I had big "gaps" in the work, due to fun adventures, hardware smoking, etc, haha). I never touched the new Big Pascal, and Big Volta, which Oliver plays with, but from his benchmarks, that looks about triple fast, so the "giga-digit test in a year" is not so far away. :razz:

You will live to see in each house the hardware able to do it, much sooner than you expect.[/QUOTE]Okay, the progress is better than I was aware of. I didn't consider the GPU side of things because the OP only showed two quite ordinary CPU boxes. But I wonder if the OP has enough patience to complete a "one billion [strike]dollars[/strike]" digit test?

[QUOTE=VBCurtis;474835]Waaaiiiit..... you've tested your "method" up to thirteen digits? 13? One-three? You've skipped from 13 to.... how big?

You didn't consider trying 20, or 100, or 300 digits first, to see how many tries (and how many seconds) your method takes to find a prime as the length increases?

If the current state-of-the-art software used to prove arbitrary forms prime could be extended to the length you're considering and still fit in memory (it can't, and it wouldn't), you're looking at something on the order of the age of the Earth to complete the proof.[/QUOTE]

Yes I am now trying longer digits and what not based off of the recommendations of others and yourself on this forum.

I am simply learning by trial and error, seeing what works and what doesn't work, but also understanding what works and does not work as well as why it does and does not work.

[QUOTE=LaurV;474771]@OP:
Your best computer can do one iteration in ~16ms, according with the benchmark you posted.[/QUOTE]

[QUOTE=retina;474795]That time is for 4M FFT only. For the required 1Gdigit check the FFT iteration time would be a lot more. Since P95 can't do tests that large the times will have to come from another application. Is there any program currently existing that [i]can[/i] handle numbers of 1Gdigit?[/QUOTE]

I believe Mlucas can. Does anyone have timings for large FFTs?

[QUOTE=CRGreathouse;474870]I believe Mlucas can. Does anyone have timings for large FFTs?[/QUOTE]

Toward the bottom of the [url=http://www.mersenneforum.org/mayer/README.html]Mlucas readme page[/url] I give some numbers for the smallest billion-digit Mersenne number - on a octocore Ryzen it needs ~550 msec/iter at the required 192Mdoubles FFT length.

On the close-to-the-limit-of-current-practicability front I am currently doing side-by-side primality tests of F30, a gibabit-plus-one number with a known small factor. Even though said number is known composite via the factor it's still useful to do such testing to push the current hardware and software, and the resulting residue will be used for fast cofactor-PRP testing. One run @60M FFT is getting ~52 msec/iter on a 32-core Xeon using an AVX2 build of the code; the other @64M is getting ~60 msec/iter (best timing, it ranges up to 68 msec for mysterious reasons) on the 64-core "GIMPS KNL" using an AVX512 build. I cross-check residues for highest-iteration-reached-by-both-runs roughly daily.

[QUOTE=ewmayer;474874]Toward the bottom of the [url=http://www.mersenneforum.org/mayer/README.html]Mlucas readme page[/url] I give some numbers for the smallest billion-digit Mersenne number - on a octocore Ryzen it needs ~550 msec/iter at the required 192Mdoubles FFT length.[/QUOTE]So about 58 years.

[QUOTE=retina;474875]So about 58 years.[/QUOTE]

That's a more-or-less "budget system" - perhaps ~20 years on the kind of systems I'm using for F30.

[QUOTE=ewmayer;474876]That's a more-or-less "budget system" - perhaps ~20 years on the kind of systems I'm using for F30.[/QUOTE]I wish my old Banias system had more RAM. I want to beat [url=http://mersenneforum.org/showpost.php?p=208980&postcount=7]my current record of 37.5 years[/url].

[QUOTE=retina;474878]I wish my old Banias system had more RAM. I want to beat [url=http://mersenneforum.org/showpost.php?p=208980&postcount=7]my current record of 37.5 years[/url].[/QUOTE]

That's a 100Mdigit number - my timings are for a 1Gdigit one. Or do you mean 'beating' in the sense of yielding an even more-ridiculously-long runtime?

[QUOTE=ewmayer;474879]That's a 100Mdigit number - my timings are for a 1Gdigit one. Or do you mean 'beating' in the sense of yielding an even more-ridiculously-long runtime?[/QUOTE]Bigger numbers are always better, or course. :showoff: I still hold the record, no one has beaten my time. :showoff:

[QUOTE=evanh;474865]is this the Titan you are referring to? [URL]https://www.olcf.ornl.gov/titan/[/URL][/QUOTE]
Haha, no, it is not that one, we totally wish to have access to such an alien monster, but our pockets are not so deep, and our job in on the other side of the world...
(we are still trying hard to determine if you are serious, or making fun of us, i.e. trolling)

[URL="http://www.nvidia.com/gtx-700-graphics-cards/gtx-titan-black/"]This is the titan[/URL] every body is talking about, on these particular math-related forums. Actually, not exactly that, but the one before it, without the "black" particle, but it seems to be phased out completely by NV, no links there. Note that this is quite an "old" card already, some new "gaming" cards can beat its performance per_watt, or even per_wall_clock_and_watt, but they are not so common (yet) in the prime-hunter's systems. On [URL="http://www.mersenne.ca/cudalucas.php?model=490"]this page[/URL] you can see some benchmarks, which you can translate in working days/weeks/months/years with a simple formula depending on your exponent. Or, if you are lazy to use the formula, you click [URL="http://www.mersenne.ca/credit.php?worktype=LL&exponent=3330000000&f_exponent=&b1=&b2=&numcurves=&factor=&frombits=&tobits=&submitbutton=Calculate"]here[/URL] and see you need about 92k GHzDays to do a 1G test, which divided by 80 (about the daily harvest of the Titan), you get about 3 years and a half. Again, this is quite optimistic. The big problem with this is that you will need two Titans in parallel to run the DC (double check) with a different shift, because the Titan does not have ECC memory, and one FFT error in the beginning of the test may render all the test useless, and just waste all the power and effort for the 3-4 years.

My (slightly overclocked) Titans have the bad habit to spit out a mismatch (I always run two in parallel) every 50-80-100 million iterations or so, for an 100M exponent. I assume that for 1G exponent (if you would have the right program, as CudaLucas can not go so high yet) you may have an error every 10? 20? million iterations...

But with a Tesla (say the top Pascal, harvesting about 200GHzDays per day), with ECC memory and all stuff, you may do your 1G test (again, if you have the program) in about 480 days, or an year and half.

Again, this calculus is very optimistic, and a lot of assumptions are wrong, like for example I assume that the test will go well and uninterrupted, day and night, and I also assume that the output performance of the card does not degrade with the growing of the FFT (which is false) - this paragraph added to avoid Retina coming here and taking me apart piece by piece, hehe...

etc...

[QUOTE=LaurV;475084][URL="http://www.nvidia.com/gtx-700-graphics-cards/gtx-titan-black/"]This is the titan[/URL] every body is talking about, on these particular math-related forums.[/quote]
[url]https://www.nvidia.com/en-us/titan/titan-v/[/url] is the new king.

[QUOTE=LaurV;475084]Or, if you are lazy to use the formula, you click [URL="http://www.mersenne.ca/credit.php?worktype=LL&exponent=3330000000&f_exponent=&b1=&b2=&numcurves=&factor=&frombits=&tobits=&submitbutton=Calculate"]here[/URL] and see you need about 92k GHzDays to do a 1G test, which divided by 80 (about the daily harvest of the Titan), you get about 3 years and a half.[/quote]
That calculator is wildly wrong. It will take about 0.5-1m GHz days to do a billion digit test.

[QUOTE=LaurV;475084]The big problem with this is that you will need two Titans in parallel to run the DC (double check) with a different shift, because the Titan does not have ECC memory, and one FFT error in the beginning of the test may render all the test useless, and just waste all the power and effort for the 3-4 years. [/quote]
Definitely need to use Gerbicz PRP check for these tests.