I've discovered a method of finding primes which blows Mersenne away.

In under 3 minutes produced these 2 primes, ON PAPER:

7,420,703,724,769

7,420,703,724,851

Currently putting this into a python script and hopefully find a way of using long numbers. And of course, putting it in TI-Basic

I'm writing a paper to establish the method as my own, as research shows it hasn't been done yet. Wish me luck.

$150k to 1st with over 100M digits.

$250k to 1st with over 1B digits.

https://www.eff.org/awards/coop
Using a TI for such enormous workloads isn't viable, but does involve the community.

Besides, I don't think it'd feel right to publish anywhere else

Wow that is really impressive. Good luck with your paper!

Since this presumably requires lots of number crunching, and you need speed, you should consider doing this in C or another compiled language. You don't want to have a technically faster algorithm but lose to someone because they're using a faster language.

Using CUDA or OpenCL would be a good idea if your method allows for multithreading just so you can go through a lot of math quickly.

When you say "discovered", what is the number-theoretical basis for this discovery? I would be absolutely shocked if you found a factoring algorithm that beats GNFS, or a testing algorithm that beats AKS.

Python seems powerful enough.

My testing method needs considerable improvement. I'm factoring by known primes for speed, and not going further than the square root of the number being tested. As for large numbers, using a string. and rotating through with standard long division. Absolutely ridiculous process really. However, proud to announce the results are getting larger.

It's the method of generating potential numbers that is far superior and each new number is many times larger than the last. Not every number generated is prime, but MOST are. I will refrain from releasing the details until the script is much faster in testing primality.

That, and of course I'd like a billion digit number to send to Guinness LOL

This is super exciting. You'll have to upload a PDF of your research to our

Archives! When you are complete of course.

Okay, so not to be a buzzkill, but....I'm going to just say this now, and then leave the thread.

**seklorean wrote:**

Python seems powerful enough.

Python is going to be 30-100 times slower than doing the same thing in C.

**seklorean wrote:**

My testing method needs considerable improvement. I'm factoring by known primes for speed, and not going further than the square root of the number being tested. As for large numbers, using a string. and rotating through with standard long division. Absolutely ridiculous process really. However, proud to announce the results are getting larger.

If you're serious about fast testing, implement AKS or similar heavy-weight algorithm. And switch to C and use a real big-num library (like libgmp).

**Quote:**

It's the method of generating potential numbers that is far superior and each new number is many times larger than the last. Not every number generated is prime, but MOST are. I will refrain from releasing the details until the script is much faster in testing primality.

I'm just going to warn you that this is a field which has been studied by number theorists for a good 2300 years. It is exceedingly unlikely that you have accidentally and with no formal training stumbled upon a breakthrough which revolutionizes the field of mathematics.

**Quote:**

That, and of course I'd like a billion digit number to send to Guinness 0x5

Just as an FYI, the current largest known prime is on the order of 17,000,000-digits. Yours will need to have 57 times more digits (which is to say, it will have around 100,000,000,000,000,000,000,000,000,000 more possible factors). It will take more than 3 Gigabits, just to write down.
Your advice will be fully implemented.

Python has indeed proven sluggish and rotating strings are a sad way of doing business.

The libgmp will be used. Thank you for the guidance. This process I stumbled on by randomly playing with numbers, like I do frequently, is very interesting yet simple.

Doubt me not, old friend. This task I take not lightly, nor tread as a fool.

Turns out my "method" was discovered by a guy in 1987.

I found it without help and have written the software which employs libgmp.

So, although it's not "my" method, I will push forward and seek the billion digit prime.

http://en.wikipedia.org/wiki/Primorial
The equation is simplified as Primorial +- Next Prime

Which turns out is ALSO already being done by Japanese students

Mutha @$%^$@# Back to formula I guess

**seklorean wrote:**

Turns out my "method" was discovered by a guy in 1987.

I found it without help and have written the software which employs libgmp.

So, although it's not "my" method, I will push forward and seek the billion digit prime.

http://en.wikipedia.org/wiki/Primorial
The equation is simplified as Primorial +- Next Prime

Which turns out is ALSO already being done by Japanese students

Mutha @$%^$@# Back to formula I guess

Though I'm not at all surprised that you're not the first person to come up with any particular method, there being a lot of very smart people working on these problems, I'm still sorry to hear it. Best of luck.
Thank you, buddy

Just disheatened - thought it was something special until today

Software still beating the japanese though

They haven't passed 500k digits but I have with AKS primality check.

Still not past 1.1M digits though

With the primorials, I could have told you some neat things I found out. For example, it is obvious that they have the most factors of any number less than or equal to it (otherwise, it would imply some smaller prime between consecutive primes which would be a contradiction). If you line the numbers up to a primorial, then wrap the second half of the list underneath like this:

123

543

Since 6 is divisible by 2 and 3, 6-2 is divisible by 2 and 6-3 is divisible by 3, but now you have 6-1, which is prime

123

543

And now 30:

**Code:** ```
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
```

29 28 27 26 25 24 23 22 21 20 19 18 17 16 15

remove 30-2, 30-3, 30-5, as those are composite

**Code:** ```
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
```

29 26 24 23 22 21 20 19 18 17 16 15

And now if n is composite, 30-n is composite, so remove the composites up to 15, and the ones directly underneath are 30-n:

**Code:** ```
1 2 3 5 7 11 13
```

29 23 19 17

And then the next is 210, then 2320, and so on. However, I feel like I was being tricky . After 30, there are some composites that show up in the second row, but maybe I need to take it to >2 dimensions?

As well, if you were interested in primes, take these observations (I first wrote them down in seventh grade):

lcm(1,2,3,...,n+1)/lcm(1,2,3,...,n) is 1 if n+1 is not a power of a prime, else it is p. For example, using n=80, n+1 is 3^{4}, so it returns 3, or if n=88, 89 is prime, so it returns 89. Essentially, it only returns non-composite values, but it is computationally very slow. It can also be defined by a product of p^{floor(logp(n+1))} where p is over all primes. That product can be rewritten in some interesting ways if you want to have fun
p#! +- (p#-1)! +- 1

[Primorial Factorial] plus/minus [(Primorial - 1) Factorial] +- 1

Some fast growing numbers. Normally number lass than 100k coming off a formula may seem unusually prime so there's alot of guess work. This seems to be hitting larger numbers with better-than-expected accuracy.

@Xeda - excellent observation. never saw it that way

Just as I was wrapping up the coding of my primorial program, I see a remarkable breakthrough and must nearly start over.

After a slight tweak of the formula above, what is a list of occasional primes became a matrix of mostly primes.... Mixed feelings here, but back to coding.

BTW: on my linux a longstanding issue with libgmp was finally fixed.

needed to [./configure --disable-assembly] prior to setup

All coding done in C, so the php project sent here can be deleted.

THREAD CAN BE DELETED.

A New Primes Formula in the /web archives can also be deleted

Project is a success in C and will be released in a few days once optimized.

Got a new formula up and running, however,

a new focus is writing code to apply a seive to

a given range of numbers without starting at 2, 3, 4...

Looks like the long primality test on the 1st number

while dropping the numbers in the range as each

early prime is modulused against the 1st may work

quickly to reduce the range to a list of possible primes.

I'll test this on "small" numbers and "short" ranges,

ie 8x10e8 to 10x10e8 and benchmarking the process.

2,881 digits.

285869134328839728854071799559613774325796517615365032497086800762669596241104998039375345020136114683366673864296564806659476141317682119815183804872854145600240035294360248247533861307322054779657036029918417724653

181864532480394379948833464095199898572840890737988242765932963055037993786519126391942723506137684367349379305343432955875610051560051063788333690542436198154157491176050210274765805753417318880165874162105216347325

121133532631993992900728873392832559184542076966411367299199414551925761622035263372506787828559446751433866441722714078443043573610775925265379712948665840472723181534791856840696635044916960139435732151653241174011

087037503105368634196064218387007980000969553925556718142376432293171861686191348286505377559431848556422619937109106121880144857687983357797932835027510224925085134864475585835357733728011947055772917909204697824571

061966692364925652049870840984976487297563644629704581001832591802096818419532693407626185700394101612688864516562732946099719836145307381847500173466494578687351786322038471838917782480411073580081786649232171546761

206151329264941623859174265530557801727707382988855012490767185531141875892166195675788893273560724602927007993366553954946328241506800400976019508897599649630880286781859513949181469512703888387881400565816039421678

224076677161790729409016202719796058366638668867366461931526210346712776737219603946771347397474859051837338676888870477202650952114045183888427141564224751727518234223090637503123303893686377520301248494774281900720

571380667003875577560864763745546947530856756875196432152806867405827003803391021536456872222593516775570746720601351807232349472413140753232649422487903156099507463922127228618076501681154408513291843120661831017247

445015870458350467122019142021862057721122097156329747665127364502484962927570293734833512395228673348781147381485597852565289800796788992739461540338100991140863938495173373019328226221688299151984578534092766310865

313939407073314775825015739350750479738861316879977903868950539880128952569989687867263460288099659712611321722611521683321558589831926370910441929739615187134825937282471547085783296783953987681645265939763793572216

249833560552203825947516529024034583898648956617204780246963668940899643524432409263358523861703858214400313556132909507146630417631238755394152219574565843858788080657508283729549449542596413068736337629599409426577

134077612422724269820608806960060802943557977732127859187506926050654944631552562838495779326021859558571438451946148753767643177084470352969674226696563377786924966858839098143177614629203396961358112545335419972379

734546595737694517120305487506959452445664157419556755198269161133522043831700829585607744768532357498842354642598777281688350624633257839548330687258819858099060584277644295727732666388364923335730230044341043199999

9999999999999999999999999999999999999999999999999999999999999999999999999

Been awhile

but not without progress.

I've realized through experimenting the most efficient place to start

a prime seive is at a primorial. It took my machine 13 hours to crank

out primorial(86,028,121), which came to 37,356,774 digits

After crossing out every composite that starts from exactly that point,

with a range of 86,028,121, I should be able to sift out irrefutable

prime numbers. Remember, a primorial is just the result of a product

series using the prime set. Primorial(5) is the product of all primes

less than or equal to 5, so 2*3*5 = 30. I used the first 5 million primes.