for this pattern i need explain prime numbers from beginning, so let start with simple things about prime numbers.

smallest prime numbers is “2” , if we divide all numbers by number “2” then what do we got as “ remainder” ? it a series of numbers:

0,1,0,1,0,1,0,1,0…..

its just a repetitive of “{0,1}”

what about for number “3”? its repetitive of “{0,1,2}”

if our Plan is finding more prime numbers? all we need is that this remainders of smaller primes must not be “0”.

the repetitive “remainder string” of each number acting like a ring i mean for example for number “3” we got

{0,1,2} if we start divide all numbers by number 3, start from number 3

{1,2,0} if we start divide all numbers by number 3, start from number 4

{2,0,1} if we start divide all numbers by number 3, start from number 5

so actually we can look at prime numbers as planets going around sun! and at {zero degree} they have remain of “0”, and “0” degree is a place where they started to move at first time.

and only “remainder=0” is important for us and there is no difference between “remainder=1 or remainder=2”

New remainder string

so we can make this new string and call it “New remainder string”

{0,1,1} if we start divide all numbers by number 3, start from number 3

{1,1,0} if we start divide all numbers by number 3, start from number 4

{1,0,1} if we start divide all numbers by number 3, start from number 5

so for each “Prime P” the New remainder string have “P” different shape depend on where is planet P right now, for example for planet 3 if we are at 4th second the New remainder string={1,1,0}.

Rule of System

each step of moving is 1second and the pattern start with number “2” which added at “2nd second”, and it moving around sun “1 time” each “two second” ,at third second, number “2” is not at {zero degree} so we find our new planet! its third second so numbers 3 is prime because there is no planet at {zero degree}!

number 3 will move like this: “1 time” each “3 second”

(prime “number P” moving “1 time” each “P second” and it added at “P’th second”)

this “two planet” have “2x3=6” different conditions to each others and after each “6 second” they will be at same place which they are at it right now, for example at:

“at 3 second”: Position of planet number “2” = {1} , and number “3”= {0}

“at 3+6 second” Position of planet number “2” = {1}, and number “3”={0}

so lets continue moving! at 4th second? planet number “2” is at {zero degree} so number 4 is NOT Prime! and for 5th second? no planet is at {zero degree} so 5 is prime!

so lets start again and see the pattern!!

when we are at number 2, this number is prime and the “new remainder string” for this number is:

{0,1} (no difference with old string cause its number 2)

we moving one step forward,now the “New remainder string” of number 2 is:

{1,0}

because number 2 is at “remainder=1” right now,number 3 coming as new prime with pattern of:

{0,1,1}

we know this 2 planet have 6 different condition together

so if we expand both strings to the length=6?

for number “2”

{1,0,1,0,1,0}

for number “3”

{0,1,1,0,1,1}

we want make new string out of this 2 string(because this are repetitive string, if we expand them like 1000x bigger, still its a repetitive pattern, like for number 3 there is no different between {011} or {011011} or {011011011} its all a repetitive pattern)

for 1st element, number 3 saying my new remainder is “0”, number 2 saying my new remainder is “1” and if even one new remainder is “0” then the result is “0” so 1st element is :

{ 0 , — , — , — , — , — }

what about second element? its 0 again

{ 0 , 0 , — , — , — , — }

its just like this:

Universal string= U ={ a0* b0, a1*b1 , a2*b2 , a3*b3 , a4*b4 , a5*b5 }

both a[i] and b[i] need to be “1” so result will be “1”

the new repetitive string of this two planet is:

U = {0,0,1,0,1,0}

we are currently at number 3,and in position of U[0]

nearest “element = 1” in this string is at U[2]

so 2 step forward we have a new prime!

current number 3 + 2 step forward = 5

the universal string moving ahead too, number 5 generated and universal string is:

U={1,0,1,0,0,0}

number 5 new remainder string is:

{0,1,1,1,1}

we want update our universal string to new one

which include 3 planet

new Universal String must have length = length of current “U” * length of new remainder string of number 5

length of new U= 6*5 = 30

this 3 planet have 30 different condition to each others.

so we repeating current U, five times to have length=30

{101000,101000,101000,101000,101000}

and also we repeating new version remainder of number 5, six times to have length=30:

{01111,01111,01111,01111,01111,01111}

and new U={001000101000101000100000101000}

as u can see 2 step later number 7 is next prime while 4 step later number 9 is not.

implement this for Computers

this Universal string growing really fast

like even for prime numbers less than 100 we will need huge hard drives to keep this strings.

so we need stop growing of this string depend on our hard drives, and just after finding new prime just update current string and with each new prime we finding the string will becoming smaller.

as an example:

we have just 6 bit hard drive

starting with number “2

{0,1}

then number 3 coming and and U is

U{0,0,1,0,1,0}

number 5 coming but we dont have more than 6 bits

so number 5 string is:

{0,1,1,1,1}

and U after moving forward is:

{1,0,1,0,0,0}

we repeating string of number 5 two time

{0,1,1,1,1,0,1,1,1,1}

we dont have more than 6 bits so we can have only 6 bits of it

{0,1,1,1,1,0}

the new update of U is:

U={0,0,1,0,0}

the next prime is 7 but after moving new U will be

U={1,0,0}

cause its not a pattern anymore

so when we have like 10¹⁸ bits maybe it look huge but actually it can show all prime numbers from “current number x”+10¹⁸

and if we stop expanding it, each new prime numbers can show up faster than the current one

and it can show all prime numbers near 10¹⁸ really fast but at the middle its slower cause too many bits to calculate

its not the best implement

we can use “AND” gate instead of multiple each bits of two strings

cause elements of both strings are always “0” and “1”

we can also use bubble idea?

compare to all numbers only few numbers are prime

so when we have 10¹⁸ bits, we know there is too many “0” in the string

so we can count each bubble of “0” and instead of saving:

00000000 in the hard this we can save “8” which means we have 8x“0” before next “1”. but then its need a hard programming!!!!