Primes:

Randomness and Prime Twin Proof

Martin C. Winer

Index

# Referring sites:

I’m greatly appreciative of sites that have found my work interesting and have linked to me:  Most Notably, I appreciate:

 Google Directory DMOZ Open Directory Project H. Peter Aleff @ recoveredscience.com

# Introduction

## Overview

"It is evident that the primes are randomly distributed, we just don’t know what 'random' means."

-- R.C. Vaughan

Determinism cross Recursive Self Complication equals randomness.

n      M. C. Winer

## Need a simpler/shorter version?

http://www.rankyouragent.com/primes/primes_simple.htm

## Code Samples

Some java code has been provided to illustrate some of the concepts on this website.  It can be found here:

http://www.rankyouragent.com/primes/patn.java.htm

and the output can be viewed here:

http://www.rankyouragent.com/primes/patn.java.output.txt

A ‘C’ version for those who just can’t tolerate Java :)

http://www.rankyouragent.com/primes/patn.c.htm

http://www.rankyouragent.com/primes/patn.c.output.txt

The following uses Java’s BigInteger and BigDecimal classes to run the #Prime, #Twins, #Triplets, #Quadruplets between P(n) and P(n)^2 for larger n.

http://www.rankyouragent.com/primes/twins.html

http://www.rankyouragent.com/primes/twins.RawResults.txt

http://www.rankyouragent.com/primes/twins.xls  (note the different worksheets)

## Definition Random

A random process or event is one where for every suspected (macro or micro) pattern (other than the pattern of the event or process itself), there exists a change such that the suspected pattern no longer holds.

### Corollary:

A random process or event is one with an infinite supply of complexity (neither redundant nor reducible changes).

### Macro/Micro Pattern

Take for example the pattern

1010111110101111

****^^^^****^^^^

For every region *= 1010 there exists a change such (to ^=1111) such that the suspected pattern never holds.  HOWEVER, there a macro pattern of *^*^ (1010, then 1111, then 1010, then 1111 and so on).

## Overall Purpose

The purpose of this work is to look into some long pondered questions.  First, is the distribution of primes across the number line random?  Next, what is random anyway?  Finally the theories and axioms derived are used to solve the long discussed “Prime Twin Problem” to show possible applications of the understanding of what it means to be random.

## Summary

Pat(n) is the fundamental building block by which composite and prime numbers are laid down along the number line.  Pat(n) is a recursive algorithm which merges (algorithm described below) in the pattern 1 followed by (P(n)-1) 0’s with Pat(n-1).

Whenever a 0 occurs in Pat(n) between P(n) and P(n)^2 a prime occurs.  Whenever a 00 occurs similarly, a prime twin occurs.

The probability of either a 0 or a 00 between Pat(n) (in general) approaches zero, but never reaches it.

Even though there are relatively small numbers of 0 and 00's (single and prime twin candidates respectively) in Pat(N) with large N, you can't rule out their existing between P(n) and P(n)^2 by virtue of the fact that Pat(n)'s complexity grows without bound with increasing N.  That is Pat(n) grows as random as you care to make it with increasing N.  (Random subsumes randomly distributed.)

Hence, there is a non-zero probability (although decreasing) that there will be a 0 or 00 for in Pat(n) between P(n) and P(n)^2 for for any large N.

Any non-zero probability (even a decreasing one) event given enough chances will eventually occur.  Since we can take as many chances as we want (the number line is of infinite size), we will eventually get another prime twin or prime singleton.  Thus the set of prime twins (and primes) is infinite because for any prime twin (or prime singleton) we can get the next one.

Even though the set of primes and prime twins is infinite, they are also effectively finite.  That is, for increasing n, they become so sparse, so distant between instances that they are effectively finite, however strictly infinite.

All these observations are true for any allowable constellation of primes.  That is any allowable constellation of primes will likewise be infinite, however, will ‘fizzle’ to near finiteness.

## Summary 2

Pat(n) is random across Pat(n)'s for increasing n relative to the floor(P(n)/2)’th position.

"WHAT?!"

Let's break this one down:

What is P(n)?

P(n) is the nth prime starting at 3.  P(1) =3, P(2) = 5, and so on.

What is Pat(n)?

Pat(1) = 100…  (… means repeat everything to the left over and over again, hence 100100100 and so on)

Pat(2) =

Pat(2) =

P(1) 100100100100100

AND  010000100001000  ß this is 1 and P(2)-1 0’s shifted to

align the first 1 with the first

0 in Pat(1)

=    110100100101100 ß length = P(2)*P(1) = Primorial(n+1)/2

What is Random?

Random: A bit string (1’s and 0’s) is defined to be random IFF for every detected pattern in the bit string (other than the pattern of the bitstring itself) there exists a change in the bit string such that it no longer follows that pattern.

Most notably:

10100100010000… (… means and so on here, not repeat everything left) is NOT random.

Why because it follows the pattern 1 and n 0’s for an increasing n.  The pattern never changes.

How can bit strings be random?

I’ve detected two ways in which bit strings can be random.

First, they can be ‘random run’ bit strings, or they can be ‘recursive periodicity’ bit strings?

A random run bit string is: step =  [ a random number of 0’s concatenated to a random number of 1’s ]; for an infinite number of steps.

Ie. [00011][011111]… = 00011011111…; where … means and so on, not repeat everything to the left

A recursive periodicity bit string is defined by a list of prime factors.  For every prime factor in this list, every prime factor’s entry will be a 1, otherwise 0.  So if 3 is in this list, then every 3rd entry will be a 1.  If 3 and 5 are in the list then every 3rd and 5th entry will be a 1, all others will be a

Recursive Periodicity bitstrings and Random Run bitstrings are synonomous!  That is, they’re different ways of looking at the same thing.

Construct several large Pat(n)’s for yourself.  Then look at a subsequence of them.

Eg: 101100… (… means and so on)  Is this an excerpt of a random run bitstring or a recursive periodicity bit string?  Can you tell?

What is a cross section?

A cross section is the string of 1’s and 0’s produced by examining an certain entry in Pat(n) relative to a certain offset.  Let’s take the first cross section relative to ‘0’ in Pat(n).  The first entry in any Pat(n) is always ‘1’.  Thus the first cross section in Pat(n) relative to ‘0’ is 11111… .

What is random across?

Random across means that if you examine a certain position of Pat(n) for increasing n, you’ll not only see change, you’ll see a random change.  Pat(n) is random across increasing n, relative to the floor(P(n)/2) position.  Pat(n) is NOT random across, say the first position, because they are all 1’s.

Pat(1) = 100…

^^ the floor(P(n)/2) location +1 *

^ the first position in Pat(n) ***

Pat(2) = 110100100101100…

^ ^ the floor(P(n)/2) location +1 *

Pat(3) = 111100100 (truncated)

Pat(4) = 111110100 (truncated)

* The floor(P(n)/2) +1 location can contain either a zero or a 1.

** The bold underlined elements represent the first cross section relative to floor(P(n)/2), ie. 0010 and so on

*** The italicized entries represent the first cross section relative to 0.  This cross section is NOT random across n (and is equal to 1…)

How do we know that Pat(n) is random at all, by any measure?

Recall the definition of random bit strings:  for any suspected pattern, a change occurs such that the suspected pattern no longer holds.  Pat(n) is a recursive periodicity bit string (by construction).  As a result, we can introduce a measure of randomness which is the number of prime factors because these determine the number of changes that occur for any suspected pattern.  Thus the limit(n=1->+inf) Pat(n) = random bit string.  What this means is that Pat(n) becomes as random as you want it to become.  Thus Pat(n) is as random relative to the n you choose.  However, the first cross section relative to floor(P(n)/2) is absolutely random.  Why?  It is the tail of an ever changing pattern.  ‘Ever changing pattern’ doesn’t mean a fixed pattern whose output changes.  An ever changing pattern is a pattern which changes itself forever.

But Wait?!  The probability of getting a ‘0’ decreases for increasing n.  Won’t it fizzle to nothingness?

Anyone who’s read my section on demographics below, or constructed a few Pat(n)’s for themselves, will quickly read that the number of 0’s relative to the number of 1’s in Pat(n) decreases for larger n.  Thus the probability is always decreasing of getting a 0 in the first cross section (in fact the probability of getting a 0 anywhere decreases).  However, the probability is always 1/ some large number.  There is always a 0 somewhere in Pat(n) and there are a large finite number of entries.

So examine the 0’s in the first cross section from above:

0010… (… = means an so on, not repeat everything to the left)  If you continue to grow this cross section you’ll see that the number of 0’s fizzles to near non existence.  However, you’ll never see it fizzle to an infinite string of 1’s (meaning no more 0’s)

Proof:

Suppose you play a slot machine with ever decreasing odds of winning:  That is on the first play you have 1 in 2 odds, then 1 in 3 odds, 1 in 4 odds… and so on.  You will never reach your last win.  Why?  We all should agree that a 1/million event CAN happen (can is not the same thing as likely).  We should also agree that things either can or cannot happen, never both nor neither.

Suppose that there was a last win.  That would mean that for all the infinite plays thereafter where you had a 1/someLargeNumber chance of winning, you actually couldn’t win.  So for those plays you both could and couldn’t win.  This is a contradiction which shows that you can’t have a finite number of wins.

But wait?!  How do we know that we can always get a 0 in the first cross section?

We know that we can always get a 0 in the first cross section because no matter how improbable a 0 is in Pat(n), the measure of randomness is increases as much as we like.  We can increase the randomness in Pat(n) as much as we care to until it is as random (ly distributed) as we like.  At such a time, even if there was only one 0’ in the entire Pat(n), random distribution will eventually guarantee that it is in the first cross section.

Putting all the pieces together

So what?  So there is now this thing called a cross section which is truly random, where the 0’s fizzle but never disappear.  So what there is something called Pat(n)?  What does it all mean?

Pat(n) is an examination of the number line for all odd entries.  The floor(P(n)/2) entry represents some prime.  Ie, 3 is represented by the first entry, 5 is represented by the second entry, 11 is represented by the 5th entry.

The first cross section of Pat(n) relative to floor(P(n)/2) is thus a prime number + 2.  Whenever a zero occurs in such a cross section, a prime twin will occur (any 0 in Pat(n) between P(n) and P(n)^2 will be prime, proof elsewhere in this paper).  Moreover, we have that number of 0’s in this sequence is unbounded.  Hence we have an unbounded number of prime twins.  QED.  Swoosh is the sound of the basketball as it makes the hoop.

## Summary 3

The following is taken from a newsgroup where I’ve been arguing the merits of my theory.  It’s a different expression of the summary, however I’ve learned that different expressions often help because the more there are, the more likely it is that one will register:  (I’ve removed any names)

Someone wrote:

>I did not say Winer proved anything (yet) but he's got my attention.

I proved it over 4 years ago.  Now I'm partaking in the unbounded process of convincing people I'm right.

Ok, here's the proof written another way.  Maybe this one will register.

Pat(n) is random across Pat(n)'s for increasing n relative to the floor(P(n)/2)’th position.

"WHAT?!"

Let's break this one down:

First what does 'random across' mean?

Ok, you'll note that the first entry in Pat(n) for all n>=1, is 1.  It never changes.  It's always 1.  Take a look at the first entry past the floor(P(n)/2) location in all Pat(n)'s and you'll notice that sometimes it's 0, often it's 1.  So the first position of Pat(n) is not random across Pat(n)'s for increasing n.  However the entries past the floor(P(n)/2) entry in Pat(n) do change ACROSS iterations.

Eg

Pat(1) = 100…

^ the floor(P(n)/2) location +1 *

Pat(2) = 110100100101100…

^ ^ the floor(P(n)/2) location +1 *

^ the 1st entry is always 1 for any Pat(n)

Pat(3) = 111100100 (truncated)

Pat(4) = 111110100 (truncated)

* The floor(P(n)/2) +1 location can contain either a zero or a 1.

** The bold underlined elements represent the first cross section relative to floor(P(n)/2), ie. 0010 and so on

Next you'll note I said RANDOM across, not pseduo random, or increasingly random.  I said absolutely random.  How can I say this?  Based on my definition of random (for any suspected pattern, there exists a change such that that pattern is broken), whenever you think you've detected a pattern in the cross section, the pattern generating the cross section will have changed to break that candidate pattern.  In other words, when tailing a pseudo random function, you can generate a truly random function PROVIDED that the pseudo random function you are tailing constantly changes (that is changes function (pattern), not just output).

"Cross section, what is a cross section?"

A cross section is a binary pattern produced by taking some integer i, i>0 and i< the length of any given Pat(n) (length = Primoridal(n)/2) and examining that position relative to the floor(P(n)/2) position for all Pat(n) of increasing n.

(Aside: the denser regions of these cross sections would make great fodder for encryption enthusiasts)

"What in the hell is this guy talking about?!"  Examples always help.

Let's take the first cross section (i=1) for all Pat(n)'s with increasing n.  So look at Pat(1) = 100... .  The first entry past n=1 (i.e. position 2).  It's a 0.  Write it down.

Look at Pat(2) = 110100100101100… Examine the position at n+1 = 3 and you see another zero.  Append it to the previous 0 to give 00.

Look at Pat(3).  Look at position 3+1 = 4... in this case it's 1 (position 3+1 = 4 represents the integer 9).  Append it to the previous string to produce 001.

I hope you get my point by now, so let me iterate and produce a longer string.

00101011011101... (... means and so on, not repeat)

But wait, what is this string?!  Why it's nothing other than a randomly distributed string of 1's and 0's where the 0's are becoming more and more sparse.  We 'win' and get a prime twin every time we get a zero in this sequence.

Someone on this forum said that if my definition of random holds, then there will never be a tail in such a pattern of unbounded 1's (losses, and 0's from the original example of the decreasing probability slot machine never experiencing it's last win, 1's and 0's are inverted here).  He also said this had nothing to do with probability.  I couldn’t disagree more strongly, but nevertheless, we have an admission that such a sequence never reduces to an unbounded string of 1's.

If you’d like another proof:  Suppose that a slot machine with decreasing odds of winning had a finite number of wins.  We should all agree that something with 1 in a million odds CAN happen (CAN != likely).  If however, there are a finite number of wins, then there exist some non zero probabilities that CAN”T happen.  Now either things can or can’t happen in the universe.  Hence , we have a contradiction and there can’t be a finite number of wins.

Thus we have an unbounded number of 0's in this tail of Pat(n) which corresponds to an unbounded number of prime twins because this tail is always in the region of P(n)..P(n)^2.  The set of prime twins is infinite.

Swoosh... hear the basketball make the hoop.  Thank you all for your attention; you've been a lovely audience.

## Summary 4

This is another summary from a newsgroup.  The exercise of reading these before reading the rest of my work is a good one, in that you will be able to see where I’m going with all of it.  I’ve removed any names:

>…but other than that, almost nothing in it was clear to me.

>As I understand it you are encoding Pat(n) by a finite sequence of

>0's and 1's, and using your definition of random to assert that

>Pat(oo),

>i.e. the infinite case, does not end in all zeroes.

Regrettably, that's not what I'm saying at all.  Pat(n) is an

increasingly random sequence of 1's and 0's true.

Using my definition of random, let's see if I can explain this to you.

Consider Pat(x) for some finite x> 1.

Let's try to define this pattern.

1) every 3rd  position (starting at offset 0) has a one, there that's

the pattern

damn... wait,

2) also every 5th position starting at offset 1 has a 1, there that's

the pattern

damn... wait

3) also every 7th position starting at offset 2 has a 1, there that's

the pattern...

and so on and so on up to x

Meaning, every time I think I've nailed down the pattern, there is a

change in the pattern which breaks that assumption.  For any finite n

in Pat(n) there exists a finite number of these descriptions.  Hence

it's as complicated as you care to make it but finite (pseudo random).

> But you've waved

>your hands through a required step, that of showing that Pat(oo)

>conforms to your definition of random.

I hope you can now see that as n increases without bound, Pat(n)

approaches (gets as close as you desire to) my definition of random.

> I cannot see anything resembling

>a proof of this step either in your website or your posts.  Listing a

>bunch

>of examples of Pat(n) for low n is not a proof.

Let's say someone sells you a random number generator.  It has a dial

with which you can set the probability of a 1 occuring.  You set it to

0.5 and you decide to test this machine for a bit.  It spits out

10101010101010101010101010.  You become suspicious.  You continue the

test and you get 1010101010101010101010.  The probability of getting a

large region of 1's and 0's which conforms to some pattern (in this

case 10...) in a pseudo random sequence is inversely proportional to

the randomness of the generator cross the length of the sequence.  So

the fact that the machine spit out a bunch of 10...'s suggests that

it's a lower probability that this is a complicated random number

generator (relative to another machine that spits out a less patterned

sequence of equal length).

So where am I going with this?  We know that the probability of getting

a '0' in Pat(n) decreases with larger n.  However the randomness

increases with larger n;  thus so does the randomness of the

distribution.

Next I changed gears and looked at a particular entry in Pat(n),

specifically the nth + 1 entry (right next to the recently fixed

prime).  I examined this entry with respect to increasing n and Pat(n).

Because I can make Pat(n) ('s distribution) as random as I care to, I

can always guarantee that I can get a '0' in this position as I iterate

over Pat(n)'s for increasing n.

Now the kicker.  I observed the 1's and 0's in Pat(n) at the n+1th

position and wrote them down to produce a new string of 1's and 0's.

The odds of getting a 1 or a 0 in this position are dependent on the

odds of getting a 1 or 0 for that given n, Pat(n).  How do I know that

there CAN be a zero at the n+1th position?  Again, because I can let n

grow unbounded and let Pat(n) become as close to random (ly

distributed) as desired.

So we get a string of 0's and 1's where the 0's are initially more

dense than later... and the odds of getting a zero decrease as we

progress left to right across the string.  The string is RANDOM because

it is the tail of an ever changing pattern (Pat(n) for ever increasing

n).  Because it is random, and because the probability is decreasing

asymptotically towards 0 (never equal), we never hit a point where

there will never be another 0.  Any 0 between P(n) and P(n)^2 for any

Pat(n) is guaranteed to be prime.  Moreover, the immediate left

neigbour of such a zero is also prime (P(n)) so we have an infinite

supply of prime twins.

QED, swoosh, 2 points.

## Sieves and Patterns

Consider all odd numbers starting at 3.

### “Hey! What did 2 ever do to you man?”

Ok, I’ve been getting lots of questions about what I have against the number 2.  Nothing.  I love it, in fact if all primes were as well behaved as 2 there would be no uncertainty about primes at all.  2 is the only prime to predictably have multiples of the form x2,x4,x5,x8,x0 where x is a natural number digit.  If all primes were like this, well there wouldn’t be any questions about primes, prime twins, randomness of primes etc.  Since all of the ‘problems’ (=uncertainty) of primes come from the odd primes and hence odd multiples, I remove 2 to clarify the picture… if only for myself.  True, 5 also predictably has multiples of the form x5,x0, but if I was to remove 2 and 5 I’d confuse so many people that only I could read my own work… which is self-defeatist.

Continuing, with the construction of the sieves (patterns), start with the number 3…

Mark a 1 on the number line where the number is a product of 3, (including 3x1), 0 otherwise.  We get a pattern (sieve) such as:

1 0 0 1 0  0

3 5 7 9 11 13

1)The pattern is 100...

2)Note that the numbers corresponding to the zeros between 3 and 3^2=9 are also prime (5 and 7).

3)The length of the pattern is 3

Consider the pattern formed by 3 and 5:

1) the pattern is 110100100101100...

2) Note that the numbers that correspond to zeros between 5 and 5^2=25 are also prime (7,11,13,17,19,23)

3) The length of the pattern is 3x5=15

## Definition of P(x) [The Xth Prime]

In general

If we let P(x) be the xth prime starting from 3 such that

P(1)=3, P(2)=5, P(3)=7 and so on, we can consider the patterns on a larger scale.

## Definition of Pat(n)

Suppose we define a function Pat(n) which will produce the string of ones and zeros in patterns (sieves) as described above from P(1) to P(n).

I.e. Pat(1) = 100…

Pat(2) = 110100100101100…  (That’s the pattern or sieve of 3 and 5)

In such a case,

(1) The pattern will consist of ones and zeros corresponding to the products and non-products of the n composing prime factors,

(2) The numbers corresponding to zeros between P(n) and P(n)^2 are guaranteed to be prime

[Why? because a number is either a prime or a product of primes.  A zero means that it's not the product of any prime below it.  The first unique contribution a prime factor gives to the number line occurs at P(n)^2 = P(n)xP(n) because below that at say P(n)xP(n-1) can be rewritten as P(n-1)xP(n) and thus is already accounted for in the number line.  Thus a zero between P(n) and P(n)^2 is not a product of primes and must therefore be prime.]

(3) The length of the pattern will be:

P(n) x P(n-1) x P(n-2) x ... x P(1)

[Note to mathematicians:  This is just the primorial(n+1) / 2, P(n+1)# / 2]

## Unique Contributions of P(x)

### Description

As we build iteratively build Pat(n)’s over time, each successive prime adds to our knowledge of which numbers are prime and which numbers are not.  In the case of the prime number 3, we know that 3 is prime and that all (other) multiples of 3 are not prime.  However, when we come to the prime number 5, 5 does not ADD to our knowledge that all multiples of 5 are not prime.  For example 15 is a multiple of 5, but we already knew that this number was not prime because of the prime number 3.  Therefore, the unique contribution to our knowledge as we build Pat(n)’s that a given prime (P(x)) provides us is given below:

### Definition uniqueContribution(P(x))

For any prime, P(x), define

UniqueContribution(P(x))  = {P(x)*k; k is odd, k>=P(x), primeFactorization(P(x)*k) contains no primes < P(x)}

### In English…

The unique contribution, to the knowledge of which numbers are prime or not, a prime number (P(x)) gives us while building successive Pat(n)’s is the set of all odd multiples of P(x) such that the odd multiples have no primes less than P(x) in their prime factorizations

### Examples:

Consider the prime 5.

5*5 = 25 is a unique contribution of 5

5* 15 = 5*3*5 = 75 is NOT a unique contribution because it has 3 in its prime factorization.  Ie, we already knew that 75 was not prime thanks to the prime number 3.

5*7 = 35 is a unique contribution of 5 because the prime factorization contains no primes less than 5.

5*5*5 = 125 is a unique contribution.

### Powers of a prime

It turns out that powers of primes (greater than the first power) are  unique contributions.

### Important Notes on uniqueContribution(P(x))

For larger P(x), uniqueContribution(P(x)) becomes increasingly difficult to calculate and more complicated.  The unique contribution becomes more random as P(x) increases.

## Merging Patterns

### Introduction

It’s been briefly mentioned before that Pat(n) is the merging of 100… merge 10000… merge … merge 10000(n)… .  However, it’s important to take a closer look at how merging is done because there is much that can be learned by observing how Pat(n)’s are merged

### Merging Algorithm

Let’s merge the pattern formed by 3 with the pattern formed by 5.

1)

To do this you write out the left hand side (LHS) pattern the length of the right hand side RHS pattern times as follows

(ie write out ‘100’ for the length of the pattern formed by 5 [10000] = 5 times)

1:100

2:100

3:100

4:100

5:100

2)

Next you mark an x on the first ‘0’ and then mark an x every length(RHS pattern) (reading left to right, top to bottom) spaces as follows:

(ie, starting at the first 0, place an x and then place an x every 5th spot afterwards

1:1x0

2:100

3:x00

4:10x

5:100

3)

Finally, read out the resulting pattern from left to right, top to bottom and write it out.

1x0100x0010x100

4)

Change the x’s to 1’s and you have the resulting pattern, length  = length(LHS pattern) x length(RHS pattern) = 15

110100100101100

This is none other than our beloved Pat(2).

### Time Out:  Who Cares?  My Grandmother could do this?!

Some may be thinking that this is all trivial and mundane.  Well it is, but thinking of merging in this way allowed me to develop make some significant observations on the way patterns evolved.  Specifically, I was able to derive formulae for the growth of prime twin candidates vs singleton prime candidates.  Lend me your patience, and I’ll show you what can be done with this presently.

### Demographic changes in Pat(n) over time

Using this method of merging, some trends can be described by formulae.  An example will make things clearer.  Let’s merge Pat(2) with 7 (10000000…).  Following the algorithm, we write out Pat(2) 7 times, marking an x on the first 7 and every 7th entry thereafter.

357913579135791

1:11x100100x01100  31

2:1x010010x101100  61

3:x101001x010110x  91

4:110100x001011x0  121

5:11010x100101x00  151

6:1101x010010x100  181

7:110x001001x1100  211

#### Notes

1) There is always a string of 1’s at the beginning of a Pat(n).  Those 1’s are either prime or composite.  Any 1 after those initial 1’s are composite, NEVER prime.

2) Note the diagonal patterns on the x’s.

3) For every 1 in the LHS pattern, we get length(RHS pattern) 1’s  AND we get two new 1’s for every …1001… in the LHS pattern.

4) For every …1001… in the LHS pattern, we get length (RHS pattern) -2 …1001…’s in the RHS pattern

5) Intuitively you may be able to detect that we’re going to get successively more …101…’s in the pattern compared to …1001…’s.

…1001…’s represent prime twin candidates.  That means if a …1001… falls between P(n) and P(n)^2 of a Pat(n), then we have a prime twin.

…101..’s represent a singleton prime candidate.  Again, if a …101… falls between P(n) and P(n)^2 of a Pat(n), then we’ll have a singleton prime.

Finally Pat(n) is simply Pat(n-1) merge pattern (1 and n-1 zeros).

Combining all this knowledge, we come up with the following table of demographic values for Pat(n)

### Demographic Values For Pat(n)

 Pat(i) Single Candidates Twin Candidates Number of 0’s Number of 1’s Number of 1’s / Number of 0’s Single Candidates/ Twin Candidates Pat(1) 0 1 2 1 0.5 0 Pat(2) 2 3 8 7 0.875 0.666 Pat(3) 18 15 48 57 1.1875 1.2 Pat(4) 210 135 480 675 1.40625 1.555 Pat(5) 2790 1485 5760 9225 1.6015625 1.8787 Pat(i) Singles(i-1) * [P(i)-1] + twins(i-1)*2 Twins(i-1)* [P(i)-2] Zeros(i-1) * [P(i)-1] Ones(i-1)*P(i) + zeros(i-1)

### Observations about Demographic Values for Pat(n)

The most telling figures from the table above are the final two, the number of 1’s to number of 0’s and the single candidates to the twin candidates.  You’ll note that they increase with increasing n in Pat(n).   What does that tell us?

It’s common knowledge that the primes are infinite.  It’s almost as common knowledge that they are denser initially than they are later.  These increasing figures suggest why.

It’s been said elsewhere in this work, but repetition is a good method for internalizing knowledge, that any prime candidate (a 0) between P(n) and P(n)^2 in Pat(n) will be prime.  This is because the first unique contribution made by P(n) occurs at P(n)^2.  What the increasing ratios suggest is that the odds of a prime candidate falling between P(n) and P(n)^2 decreases with larger n.

This is also true, and more so, with prime twin candidates.  Even a cursory examination of the number line shows that prime twins are denser initially than later.  However the drop off is more sharply pronounced for prime twins.  That is they ‘fizzle’ to less and less abundance more quickly than the singleton primes.

#### Formula for calculating the number of primes between P(n) and P(n)^2

From the above it is possible to derive a formula for the number of primes that exist between P(n) and P(n)^2.  In this interval, Pat(f(n), n-1) is in effect, as the first unique contribution of P(n) occurs at P(n)^2.

In English, the number of primes in this interval will be the number of zeros in the previous pattern over the size of the previous pattern, giving us the probablility of zeros in the previous pattern.  Next we multiply through by the number of odd numbers in the interval between P(n) and P(n)^2 and we get the approximate number of primes in the interval

#P[P(n)->P(n)^2] = [zeros(n-1)*((P(n)^2-P(n))/2)] / (P(n-1)#/2)

Multiply by 2/2 to simplify

#P[P(n)->P(n)^2] = [zeros(n-1)*(P(n)^2-P(n))] / P(n-1)#

Recall (from table above),

Zeros(n) = Zeros(n-1) * [P(n)-1]

and

Zeros(1) = 2

Recall P(1) = 3 (not 2)

P(n)# = 2 * P(1) * P(2) * P(3) * … * P(n)

(note the primorial includes 2)

##### Accounting For Skew

Empirically, at least for low values, the skew seems to be a function similar to nlog10(n)a for some constant a.  We can adjust our previous function as follows:

#P_Corrected[P(n)->P(n)^2] = {[zeros(n-1)*(P(n)^2-P(n))] / P(n-1)#} – n*log10(n)* 0.145348

Note: the skew function was determined empirically, still a work in progress

The source code for the empiric data can be found here:

And the output of the program can be found here (under this section: “EXAMINING THE #P[P(n)->P(n)^2] AND #P_Corrected[P(n)->P(n)^2] FORMULAE”):

There is also source code and output for larger iterations:

http://www.rankyouragent.com/primes/twins.xls  (note the different worksheets)

#### Formula for calculating the number of prime twins between P(n) and P(n)^2

#Twins[P(n)->P(n)^2] = [twins(n-1)*(P(n)^2-P(n))] / P(n-1)#

#Twins_Corrected[P(n)->P(n)^2] =

{[twins(n-1)*(P(n)^2-P(n))] / P(n-1)#} + - (n*log10(n)* 0.058652)^2

Recall twins(n) = twins(n-1) * (P(n)-2);

See the code output for examples.

#### General method for calculating a constellation function

We have made much use of the twins(n) and zeros(n) functions in the previous section.  Let us term these constellation functions as they determine the number of their respective constellations in Pat(n).  In general the way to derive these is as follows.  Refer to the first Pat(n) where a constellation occurs.  (zeros and twins occur in Pat(1), triplets and quadruplets occur in Pat(2), triplets are p,p+2, p+6, quadruplets are p,p+2,p+6,p+8)

Let x be the number of times the constellation occurs in the first Pat(n) it appears in

Let y be the number of zeros in the constellation

Then

constellation(n) =

P(n)*constellation(n-1) – y*constellation(n-1)

factor out constellation(n-1) to produce

constellation(n) = constellation(n-1)(P(n) – y)

and

constellation(firstN) = x;

where firstN is the first n where Pat(n) has the constellation

In general

constellation(n) = constellation(n-1)(P(n)-y) = (P(1)-y) * (P(2)-y) * (P(3)-y) * ... * (P(n)-y) ;

such that (P(z)-y) > 0

Recall P(1) = 3 (NOT 2)

##### Explanation:

Why does this work?  X determines the number of the constellations in the first pattern.  When we merge, we will get P(n) * constellation(n-1) of them in the new pattern.  However, some will be destroyed.  The one of the elemental will meet every 0 of the previous pattern and turn it into a 1 (the ‘y’ parameter).  Hence every constellation will be destroyed when a one intersects with it.  This will occur for the number of zeros that comprise the constellation.

##### Using constellation(n) to predict constellation occurrences

Observe the term: (P(1)-y) * (P(2)-y) * (P(3)-y) * ... * (P(n)-y).  Note that you can use this term to a priori determine where a constellation may occur.  If the constellation has y zeros, you find the first (P(x)-y) sub term such that (P(x)-y) >0.  P(x) then is the earliest you can expect to find your constellation, if it’s allowable.  If it is allowable, you can also expect to find (P(x)-y) occurrences of your constellation in Pat(x).

We can now derive expressions for triplets(n) and quadruplets(n)

The first triplet occurs in Pat(2) = 110100100101100

There are two of them, one bolded the other underlined so we have x=2

There are 3 0’s in the constellation hence y=3

Thus:

triplets(n) = triplets(n-1)(P(n)-3)

triplets(2) = 2

The first quadruplet occurs in Pat(2) = 110100100101100

There is only one, bolded, hence x=1

There are 4 0’s in the constellation hence y=4

Thus:

#### Primes and Prime Twins become effectively finite when considering larger numbers.

What this reveals is that primes and prime twins (indeed all prime constellations) fizzle to near finiteness.  That means that for any method you care to measure their infiniteness, you’ll nearly fail with larger n.  For example, suppose you examine the number of primes in successive decades (11-20,21-30,31-40,…).  This means that the number of primes and prime twins you find will drop to to as close to zero as you like, with the larger decades.  This effectively means, for all intents and purposes, primes and prime twins ARE NOT infinite for the more you try to find them.  They ARE infinite if you have an infinite amount of time, space, computing power, whatever to find them.

With the counting numbers 1,2,3… the ‘cost’ of finding the next one is always fixed.  That, just add 1 to whatever number you have, and you’ll find the next.  The cost of finding the next prime or prime twin however is not fixed.  It grows in complexity, and the numbers of them respectively decrease with larger numbers over time.

# General Notes on Randomness

## Definition Random Bit String

A random bit pattern is an unbounded string of 1’s and 0’s where for every region which follows a certain pattern, there exists a change in the bit string which violates that regions’s pattern

## Axioms of Randomness

1) All truly random patterns must be infinite length

2) A pattern is said to be random if there is an infinite supply of complexity

### Definition ‘Complexity’

Complexity is defined to be the number of (non-redundant) descriptions it takes to completely define a pattern.

It can only ever be said that an infinite length pattern follows a pattern for a certain finite length.  Suppose you have a machine that spits out 1’s and 0’s and it spits out 1010101010… for a certain number of times you make the ask the machine to produce a 1 or a 0.  You can only say that it follows the pattern 10… for the number of attempts you made because on the next attempt, the pattern may change.  Thus it is impossible to ever say that an infinite length pattern follows a certain pattern unless you are aware of the algorithm that generates it.

# On Randomness of Primes

## Measure of Randomness in a (Recursive Periodicity) Binary Pattern

Let’s define a measure of randomness (mr) for a binary pattern to be the number of smallest repeating units in the lowest reducible pattern.

## Definition of Lowest Reducibility:

A pattern is reducible if it can be rewritten in a simpler, shorter form, such as:

11111111… is reducible to 1…

10101010101010… is reducible to 10…

## Definition of Smallest Repeating Units

Take the pattern:

Pat(2) = 110100100101100…

This repeats every 3rd and every 5th.  Note it repeats every 9th as well but that’s not the smallest repeating unit because the every 3rd subsumes the every 9th.  Thus the mr of this pattern is 2.

## Some Examples for Clarity

So,

100000000… is no more or less random than

100…, or

100000000000000000000000…

(Because in all cases mr = 1)

However,

110100100101100… (every 3rd and 5th)  is more random than those above since mr=2.

Some other interesting examples for clarity:

110… has mr = 2 because it has two repeating units of size 3, (the second offset by 1)

101… has mr = 2 because it has two repeating units of size 3, (the second offset by 2)

111… has mr = 1 because this is a reducible pattern, reducing to 1…

The latter is an important example because one might be tempted to say this pattern repeats every 3rd, every 3rd offset by 1 and every 3rd offset by 2, but this pattern reduces to 1… therefore, the mr is calculated on the lowest reducible pattern.

## Great Argument: shouldn’t a random binary string have mr=0?

In a great retort to my work, a reader suggested that a truly random binary string would have mr=0.  Why? Because a truly random string would have no periodicities whatsoever, hence mr=0.  Great question.  It comes out of the fact that there are two ways of looking at the definition of random when it comes to a binary string.  This reader is thinking in terms of a random run binary string whereas I was previously discussing an recursive periodicity binary string.  I’ve always wanted to discuss this in my work, but felt it would be too confusing or diverting, but you know what?  It’s worth it.

### Random run Binary Strings

A random run binary string is a string of 1’s and 0’s where the length of substrings containing only 1’s and only 0’s (runs of 1’s and 0’s) is a random number.

Eg.  110000010110000101001010… (in this case the … means continue, not repeat)

Ie, 2 1’s, 5 0’s, 1 1, 1 0, 2 1’s, 4 0’s etc…

More generally random(x1) - (random(y1) mod 2)’s concatenated to random(x2) – (random(y2) mod 2) concatenated to…

For random(x1),random(x2),random(y1),random(y2)… where random(x) produces random numbers > 0.

### Recursive Periodicity Random Strings

Almost immediately, and intuitively, most will quickly point out that period and random are antithetical.  Try to abandon those previously conceived notions for just a moment and let me define it, then read the next section.

A recursive periodicity random binary string is one that takes a pattern and recursively merges those patterns with other patterns for an unbounded number of iterations.

Eg Pat(2) is a merging of Pat(1) with the Pattern of 1000…

Pat(1) 100100100100100…

Merge  010000100001000…

-------------------------------

Pat(2) 110100100101100…

In a more general example, you can merge 1001101100… and 1001010101010010… (two arbitrary patterns) and continue merging the resulting pattern with other arbitrary patterns indefinitely.

### Recursive Periodicity Random Binary Strings and Random run Binary Strings are the same thing

“What?! Are you nuts?!  Periodic and Random are the complete opposite?!”  Ok, wait, before you burn me in the mathematical π-re (that’s pyre), you need to tell me, what’s the difference between them?

Take Pat(1) = 100…  We should all agree that this is not random.  However, examine it in terms of a random run binary string and you get 1 1, and 2 0’s

Take Pat(2) = 110100100101100… and do the same analysis:

2 1’s, 1 0, 1 1, 2 0’s, 1 1, 2 0’s etc…

Couldn’t the above description also be the beginnings of a description of a random run binary string ?

You may be able to intuitively deduce that as we continue to produce larger n, Pat(n), we’ll get a random run string.  If you can’t see it intuitively, tell me what pattern you see in the runs of 1’s and 0’s? Note that pattern is not the same word as algorithm.  A pattern is a finite series of descriptions that define a pattern.  You will not be able to describe the ‘pattern’ in Pat(n) for unbounded n in a finite number of steps.  Hence, there is no pattern, it’s a random string of 1’s and 0’s.

In conclusion to this section random run binary patterns and recursive periodicity random run binary strings are actually superficially synonymous, differing only in their construction.

#### Finally an answer to the question why isn’t mr=0?

Well the mr of Pat(n) increases with higher n.  If you look at the resulting string of 1’s and 0’s as n increases without bound, you’ll approach an infinite mr.  If you think of the string as a recursive periodicity random string, the string will have mr increase without bound.  If you look at the string as a random run string, you’ll have mr approach 0.  It’s hard to grasp so for yourself, construct some Pat(n)’s.  Think of the Pat(n) as a collection of recursive periodicities an you’ll see mr as I’ve described it increase.  Then rerun the experiment looking at the runs of 0’s and 1’s.  You’ll see that the more you recursively combine periodicities, the less periodic the string (Pat(n)) becomes when you look at it as a random run string.  Cool huh?  It was a great question.

## Examining Pat(n) re: Randomness with increasing n

So as we take higher n in Pat(n), the number of smallest repeating units increases.  In fact it exactly equals n.  For any given n, Pat(n) isn’t absolutely random, but P(n+1) is more random than Pat(n).

## Model of A Continued Fraction = π

Ever see this?

This is a continued fraction representation of π.  Pi is an irrational number, that is, to say, it can’t be represented by a (finite) fraction.  One can see that this is an iterative algorithm of sorts.  If we were to ‘stop’ this algorithm at any step, we’d get a rational number that is an approximation of pi. [How could you ‘stop’ the algorithm?  You could replace the recursive part with the number 1 because as we iterate, the recursive part approaches 1.]  The notation of this continued fraction is:

This notation involves the notion of a limit.  So for no k above is the result an irrational number, but for increasing k, the number of non repeating digits in the decimal grow, and for an unbounded k, we get as close to an irrational number (an infinite supply of non repeating digits) as one would like.  Interestingly, pi (the digits, taken one at a time), can pass any test for a random number test, if you don’t know that it’s Pi and the starting point.

Likewise, for no x is Pat(x) a random string of 1’s and 0’s however, for an unbounded x, Pat(x) is a random string of 1’s and 0’s.

## Model of Lim(x->inf) (1/x) = 0

Examine the model of:

let f(x) = 1/x

At no x, is f(x) = 0, however

closenesstozero(f(x+1))>closenesstozero(f(x))

and the

lim(x->inf)f(x) = 0

Likewise, for no x is Pat(x) a random pattern, however

The mr(Pat(n+1))>mr(Pat(n)), and then the

## Important Identities

(4a) lim(n->inf) mr(Pat(n)) = inf    (i.e. grows infinitely complex)

(4b) lim(n->inf) uniqueContribution(P(n)) = random set

(4c) lim(n->inf) Pat(n) = random binary pattern   (i.e. absolute random)

## Definition of Random in English

Pat(n) always produces patterns in the lowest reducible form (ask me for a proof if you like).  Pat(n) has n smallest repeating units (we know this because the units are prime).  Therefore as you create Pat(n) with greater and greater n, you produce lowest reducible patterns of greater and greater complexity (higher mr).  Each individual P(n) as n increases, has a more and more complicated uniqueContribution, leading to more complexity in the resulting Pat(n)’s, hence more randomness.  As you do this without bound, you create complexity based on previous complexity, resulting in infinite complexity = random.

So what can we do with this knowledge?

# Solution to prime twin, triple, quadruplet problem

Well it solves the prime twin, triplet, and quadruplet problems in a shot...

From 2 above, we know that the zero's in Pat(n) between P(n) and P(n)^2 are prime.  A prime twin will occur in this region whenever you see the pattern 00 (two adjacent prime candidates).  Can one predictably say that there exists a certain Prime P(K) after which, there will never be a 00 in the pattern between P(k+q) and P(k+q)^2?

An examination of pattern combinatorics reveals that there is a 00 in the base case P(1) (100..).  As we combine patterns, there will always be a 00 somewhere in the pattern Pat(n) (ask me for the proof if you like).  The trick is, will it be between P(n) and P(n)^2.

Now we know from the demographics tables above that the number of prime twin candidates to the number of singleton candidates DROPS with larger n.  That is, it becomes increasingly improbable that you’ll find a prime twin compared with a singleton prime.  Moreover, the probability that you’ll find a prime candidate at all between P(n) and P(n)^2 drops increasingly with larger n.  Just the same, the probability is never 0, it only gets as close to 0 as you like.

Well the pattern subtended by P(n) and P(n)^2 is a subset of the pattern Pat(n) and grows without bound as n does.

Pat(n) = 10110010101010100010101010101010010101101010101010101010101010…

^^---------------------^^

P(n)                        P(n)^2

So, for whatever prime twin candidates exist in Pat(n) you can’t reliably tell me that they won’t be in the region P(n)-P(n)^2 because Pat(n) becomes as random as you care to make it with larger n.  So even though we’re seeing less and less prime twin candidates with increasing Pat(n), you can’t tell me that there won’t be a prime twin candidate between P(n)-P(n)^2.  When there is, you’ll have another prime twin.  The set of prime twins is thus infinite because from any prime twin, you can find another.

The statement that the set of primes and prime twins is infinite however, misses some ‘magic’ about them.  In effect, if you’re hunting for prime twins and primes, they’re actually EFFECTIVELY FINITE.  That is for any metric you care to apply as to whether something is finite or infinite, the set of primes and prime twins will eventually meet that metric in an ‘as close as you care to get to it’ manner.  Note, and this is crucial, the set of primes and prime twins are ACTUALLY infinite, however they are EFFECTIVELY finite.  The difference is crucial and prevented me from solving this problem for many years.

What this means is that if the time remaining in the universe is finite (highly debatable, but lets assume that it is finite for a moment), then you will eventually arrive at a prime p(f) (final prime) where finding the next prime will take more time than you have left in the universe for any calculation method you propose.  This is equally true for prime twins, however the you will arrive at the final prime twin BEFORE you arrive at the final prime.

## Probabilities over infinite tries implying a certainty

In mathematics probabilities of 1 or 0 do not imply that an event is guaranteed to occur or guaranteed never to occur respectively.  An event which occurs with probability 1 is the most possible likeliness of something occurring however, this is not a guarantee.  Likewise an event with probability 0 is the most unlikely you can get, however it is not guaranteed to never occur.  However, given an unbounded number of attempts anything which can have a probability associated with it (there does not exist a certainty) will occur.

Take for example a slot machine with 1 in 2 odds of winning.  There is a catch to this machine… each time you play it, the odds decrease by 1.  That is 1 in 3, then 1 in 4 and so on.  The question is, will you ever reach a point where you don’t win ever again?

1) yes

2) no

The answer can be tricky.  If the machine uses a pseudo random generator there will be some point at which the pseudo random generator will not be able to generate a 1 in large number probability and will eventually generate 0’s ever after.  This is a space-time complexity type problem.  In short, if it’s a pseudo random generator, the answer is yes… eventually you will get all 0’s because you pass the abilities of the pseudo random generator to generate a 1 in large number distribution.

However, if the machine is truly random, then the answer is no.  The answer is no because were it yes, there would exist a pattern of some finite 1’s and 0’s followed by an unbounded string of 0’s.  This violates the random definition (region where the detected pattern holds ever after).  Hence such a machine wouldn’t be random, and we’re left with the no choice.  Don’t know isn’t possible because things must either happen or not happen.

## Dualities in Primes

Due to all the aforementioned observations of Pat(n) with larger n, we derive that the set of primes has a duality in the sense of being effectively random and being patterned at the same time.  We also have a duality in the set being infinite while at the same time being effectively finite at the same time.

Confused?  So was Xeno, a Greek Mathematician.  He asked, when someone throws, say a ball at someone else, that ball travels through half the distance to that person, then a quarter of the distance to that person, then to an eigth the distance, and so on 1/16th, 1/32nd, etc.  However, at no point of  1/2^n does the distance to your target = 0.  Thus, according to this, you should never be able to hit your target.  Everyone however, knows that a ball thrown (correctly) at a target will eventually hit it.  Xeno’s Problem?  He didn’t understand the notion of a limit and as it turns out, neither do most of my readers (some of whom in turn accuse me of the same J ).

### Why the word ‘limit’ is limiting

The choice of the word limit is unfortunate.  It correctly communicates one of the concepts surrounding a limit but not the other.  Look at the function 1/x.  For no positive x is 1/x = 0 but as x increases without bound, the function 1/x approaches but never reaches 0 – it is limited by 0.  The meaning that is correctly captures by the word ‘limit’ is that the function is limited or bounded by something (never passes or reaches).

The meaning the word ‘limit’ misses is the ‘equivalent to’ meaning.  In certain limits, such as the limit of 1/x for unbounded x, the limit is 0 meaning it’s bounded by zero but it is also equivalent to 0.  This part gets people to arguing. “ But for no x is 1/x =0!”. This is where it all gets sticky… for large n, 1/x is close enough to zero

Close enough?  Close enough?!  Math deals with things that either are or are not, there is no close enough.  I’m sorry to disappoint you kiddies but there is no Santa Claus, and there is no number 1.  It’s an abstract term that only has real world approximations to a certain threshold.  Take a look at a pen, one pen.  What if I took 2% of it’s atoms away from random locations.  Would it still be a pen.  Stupid question right?  It either writes or it doesn’t.  Well it’s not so stupid a question because if I remove 100% of the ink, the thing won’t write anymore… and it’s an empty pen.  I could hand it to you when you asked for a pen and you’d be upset or annoyed with me.  Why?  Because we had different thresholds for being satisfied of the ‘one pen’ property.  Ok, let’s agree that the pen must be working.  Now I hand you a 10 foot pen, 200 lbs which writes.  You say that I’m an idiot for giving you such a pen.  Pens must be a few grams and ‘small’.  Ok, now I hand you a small light pen and you start to write happily and it runs out after 3 seconds.  Now you’re super annoyed… and you specify that you want a small, few grams in weight pen that lasts for more than 20 days worth of writing.  I come back and say that I have such a pen but one that can only last 10 days.  Finally you say: “close enough!”.

This silly example illustrates a basic point: there has to be a notion of close enough in the world to have the world work.  The notion of a limit, is mathematics way of embracing this idea of ‘close enough’.  Look at an n-gon.  That is a triangle, a square, a pentagon, a hexagon… an n sided figure.  A square is decidedly non-circular… put a pentagon is more circular than a square.  Keep adding sides… the shape becomes more and more circular.  Suppose you say that any n-gon with more than 128 sides is a circle.  Then a 128-gon is a circle for you.

The limit does a bit more for us however.  Suppose for whatever threshold you specify, we’re able to meet or surpass that threshold.  Now you want a 256-gon to be happy enough that the shape is a circle.  Ok… away we go and we can produce this 256-gon and you’re happy again.  So if we can, for any arbitrarily large n you specify, produce an n-gon , you’ll always be happy that we’ve made a circle for you.  What this means is that the limit of an n-gon as n increases without bound IS a circle, not just close enough to a circle, it IS a circle. Even though for any arbitrary large n, you can zoom in and see lines meeting each other at angles, it is still a circle.  Why? Because no matter how picky you are in your definition, you can always be satisfied.  Thus the limit is mathematical way by which we can say, that there doesn’t exist a judge that can specify a threshold for a meeting a property whom we can’t satisfy.

In summation the limit of 1/x as x increases without bound = 0 has two meanings (only one of which obvious by the term ‘limit’).  1) There is no x for which 1/x will ever be 0.  The function is limited (bounded) by 0.  2) There is no 1/x where you can’t find a number larger than x, call it y, such that 1/y is closer to 0 than 1/y.  There is NO limit as to how close you can get to 0.  Further there is no threshold which you can set for being close-enough to 0 that can’t be satisfied.  Hence the limit of 1/x as x increases without bound is equivalent to 0.

# Mersenne Primes Also Infinite

A Mersenne prime is a number 2^n -1 such that 2^n-1 is also prime.  (Most modern users of the term restrict n to be a prime as well).  For example 31 is a Mersenne prime because 2^5-1 = 31 and 31 is a prime.  There is a long held question about whether these primes are infinite.

Elsewhere in this work we see the discussion of a cross section.  To review quickly, a cross section occurs when you look at Pat(n) with respect to some other function.  In the case of the prime twins, we looked at Pat(n) relative to the first entry past the entry corresponding to the given prime P(n).  So for Pat(1) = 100… we look at the first entry past the P(1)= 3 location (the first one) and we see we have a 0.  Hence we have a prime twin.  For Pat(3) = 1111 etc the entry relative to P(3) = 7 is the 3rd 1 and the one immediately past it is a 1, meaning that in this case we don’t have a prime twin.  Looking at the bit string we get for the prime twin cross section we get 00101011… which is as random as the primes themselves, hence we have an infinite number of prime twins.

For Mersenne primes this is just another form of cross section.  The cross section is easy to compose.  For any Pat(n) if there exists a 2^p-1 within P(n) and P(n)^2 then 1 or 0 for the corresponding entry in Pat(N).  If no such 2^p-1 exists in the range, output nothing.  Wherever we see a 0 we have a Mersenne Prime.  This cross section is as random as the primes themselves.

Some of the clever among you out there may say, well what about a cross section that after the first 1 finds the next 1 and outputs 1.  Hence we’d get 1111… which isn’t random at all.  Cross sections as I define them, can’t use any information from parent pattern in order to operate.  Hence you can’t create such a cross section.  Cross sections, must be, as is the case with the Mersenne cross section, agnostic of the parent pattern.

What about 3^p-1?  Are there 3-senne primes by this logic?  3^p-1 is always an even number which has no corresponding entry in Pat(n) by construction.  Hence the output of this cross section would be empty.

In summary, cross sections are sort of ‘pick a card, any card’ constructs which once can use to examine a random pattern.  If the pattern is truly random, picking any arbitrary element will also produce random results.  So in a 52 card deck, we can look at the order of the cards and get something random, or we can say, pick every 5th card every time we shuffle the deck and get an equally random (but slower to construct) sequence of cards.  What we can’t do is say, flip the cards, and look for a 2 and upon finding it, select that card.  If we’d do that we’d end up with a long series of 2’s.  The Mersenne Prime and the Prime Twin cross sections (and all allowable constellations) are just such arbitrary ‘pick a cards’ from the random sequence of primes.

# The Distribution of Primes along the Number Line

There is much discussion about the distribution of primes along the number line.  If the distribution is truly ‘random’, some would say, that we should see an even distribution over the number line with sufficient sample size.  However, according to this definition of ‘random’, primes should be as dense at the beginning of the number line as they are at the ‘end’ of it.  Primes are known to be more dense at the beginning of the number line than towards the ‘end’.  From this we either conclude that primes aren’t random, or they aren’t random in the way this first group of people define randomness.

A second group of people point to certain figures and calculations that would tend to suggest that primes are not randomly distributed.  Here too we must ask the question, do these figures and calculations suggest that primes aren’t randomly distributed or does it suggest that primes are just not random in the way these people (or their calculations) imply?

What I consider to be the unifying view on the matter occurs with the realization that primes are ‘recursively patterned random’.  That is, as you progress along the number line, you see distributions that result from increasing complexity, based on previous complexity.  This may explain why some tools and calculations appear to detect patterns in primes.

# Why do they keep finding patterns in primes?

This becomes evident knowing that we only have a finite list of primes in our knowledge.  The patterns produced by a finite list of prime factors are never absolutely random, just relatively random, or ‘sufficiently complex to avoid simple categorization’.  Statistical tools, depending on their power, will find a pattern in those patterns not produced by an infinite number of prime factors (the number line).

# Interesting tie-in to Quantum Mechanics

In my cursory study of Quantum Mechanics, I always hear people talking about probabilities of this and that, and the famous “Heisenberg Uncertainty Principle” which states that one can never be 100% sure of anything in Quantum Mechanics.

In an interesting analog (and I’m curious to know the usefulness to Quantum Mechanics if any) my work seems to relate.  For example

Suppose I ‘drop’ you on the number line and you’re unable to see the number but can only ask the question: “is this number prime or composite (not prime)?”   You may ask this question of the number you land on, or any of its odd neighbours to the right.  {If I let you ask to the left you could ask repeatedly until you get to the number 1 which is neither prime nor composite.  At such a time, the answer would come back indeterminate and you would know where you are on the number line by counting the number of iterations.}  Now consider the amount of information the answers give you as to what number you are on, on the number line.

Suppose you ask… did I land on a prime or composite number?  Suppose too that the answer comes back “composite” (not prime).  Well this is the least amount of information you can get in this scenario, because there are more composites than primes.  So that’s the worst answer you could get as to information as to where you are.

If the answer comes back “prime” well that’s a little better news because you at least have more information as to where you are on the number line compared with the composite answer (there are fewer primes, hence fewer possibilities as to where you can be).

Let’s be more investigative as to where we are on the number line.  Let’s ask, 1) is my current position prime and 2) is my next odd neigbour prime too?  Suppose we have terrific luck and the answer to both questions is prime.  Well we have a lot more information as to where we are on the number line compared with any of the other answers because a prime twin is far less common than any of the other possibilities.

## Letting the Cat out of the Bag, the above paragraph is false

Sorry, it was cruel but I had to have a way of discerning people who were dismissing me out of hand from those who had taken the time to read my work and understand it.  The above paragraph contains a mistake that I didn’t correct on purpose.  People who pointed it out to me all had read my work and at least partially understood it.  Other people were dismissing me out of hand as a neophyte know nothing.  The correct phrasing is:  Given a fixed and finite set of prime factors, landing at any number on the number line… you can ask “does one of the prime factors in the set divide me” of the number you’ve landed on and your next right neigbours.  You can’t go left because you’ll hit zero which doesn’t divide any number.  However, in this correct phrasing, you can’t tell me what number you’re on.

Suppose the set of prime numbers contains only 3 and 5.  Suppose you land on 15.  You’ll get the same answers as if you landed on 45 and likewise if you land on 75 and so on.

Guess what though?  You can actually determine the primes in the set provided I agree to use consecutive primes.  How… why don’t you tell me, it’s an interesting assignment.  Email me if you’d like the solution.

So here’s a good model of what I’m trying to get across in general.  How much do we know as to where we are on the number line?  Suppose stipulate that I will use consecutive primes in my set.  The amount you know about where you are on the number line is proportional to the number of primes I use in the set of factors and the number of questions you ask.  Hold on… the number of questions you ask, is proportional to the number of primes in the factor set  (the number of questions you ask before you hit a cycle is proportional to the primorial, that is P(n)*P(n-1)*…).  So that reduces to the number of prime factors in the set.

Mathematicians may read that and say: “You stupid neophyte idiot, you know nothing of where you are on the number line, there are an infinite number of possibilities as to where you are, for any given set, therefore you know nothing”.  Ok, so according to that line of reasoning, I have zero knowledge of where I am.  Suppose the set contains only ‘3’ and I land on a number divisible by 3.  There are infinitely many numbers that 3 divides, hence I know nothing.  So am I on number 58281958395?  No, I’m not there because that number is divisible by 5 which isn’t in the set.  So I obviously know something.  In fact the number 3 is miraculous, of all the odd possibilities on the number line, if we land on a number divisible by 3, we’ve eliminated 1/3 of the possibilities.

### Growth Rate of Infinities

Mathematicians will point out that infinity / any natural number is still infinity.  I strongly have and always will disagree, at least it’s highly misleading.  I look at infinity as a function (or process) growing without bound (as do many mathematicians).  Hence I look at its growth rate.  GrowthRate(infinity) > GrowthRate(infinity/any natural number).  The equal sign when applied to

infinity/any natural number = infinity

is NOT misleading in that both are processes growing without bound.  However it is misleading in that the rate of growth of the LHS is different from the RHS.

So this nonsense of infinity = infinity/3 is stupid… that is imprecise.  The notation should be adjusted to be:

infinitygrowthrate(x) = infinitygrowthrate(x)

Also: infinitygrowthrate(y) > infinitygrowthrate(x) , where y>x

Anything other than this is to say something as stupid as:

A car traveling at 40 kph and another traveling at 50 kph from Toronto to New York will both eventually arrive in New York AND the functions defining their motion from those two cities will be exactly the same.  Poppycock!

Moving on, with reference to our model, you know more of where you are if there is 3,5 in the prime factor set compared with the case of having only 3 in the set.  Even though there are infinitely many possibilities in either case, in one case, the growth rate of the infinity in the 3,5 case is less than the growth rate of the infinity of the 3 case.

### Why is the ‘Relationship To Uncertainty Principle’ paragraph wrong?

Land on any number as described in that paragraph.  Move right until you hit a prime number if you’re not already on one.  The pattern of primes and non primes will mark a unique constellation of primes.  There is a rigorous proof for this, but as you may have guessed, I like to think from 30,000 feet.  So from 30,000 feet, we know that primes are more dense at the beginning compared to later (larger) on the number line.  Thus intuitively, you could ‘measure’ the density of the primes to your right to get a good idea as to where you were on the number line.  For an exact idea, each prime and its neigbours forms a unique constellation of finite right hand primes which uniquely identifies it. For example, the prime ‘5’ has neighbours: p, p+2, p+6, p+8, p+14.  This is the only allowable constellation of this form.

### Why did I let the cat out of the bag?

People who did manage to read and understand my work, which is a small set to begin with, were so distracted with this mistake that they often missed the bigger picture.  So I’m removing the distraction.

# Interesting Patterns in Non-Primes

There are some interesting patterns in non-primes that emerge from this work.

Define:

LowMarker(n) = 3 + 2(P(1)xP(2)x…x(P(n)),

HighMarker(n) = 3 + 2(3x5x…xP(n)), and

Offset(n) = P(n) – 3

We can say conclusively, thanks to pattern combinatorics that numbers in the ranges:

LowRepeater(n) = [LowMarker(n),LowMarker(n)+Offset(n)] and

HighRepeater(n) = [HighMarker(n),HighMarker(n)+Offset(n)] are non-prime (product of primes)

Moreover they follow a similar pattern to the base pattern that spawned them.

## Example

Let’s work an example:

### Examine Pat(4) at the start of the pattern

Examine the numbers

{3,5,7,9,11}

3 is a product of 3,

5 is a product of 5,

7 is a product of 7,

9 is a product of both 9 and 3,

11 is a product of 11

Recall P(4) = 11

Let’s examine the numbers in the ranges, LowRepeater(4) and HighRepeater(4)

### Examine LowRepeater(4)

LowRepeater(4) = {2313,2315,2317,2319,2321}

2313 is a product of 3,

2315 is a product of 5,

2317 is a product of 7,

2319 is a product 3, and necessarily, not a product of 9 (this could only occur in HighRepeater)

2321 is a product of 11

### Examine HighRepeater(4)

HighRepeater(4) = {20793, 20795, 20797,20799, 20801}

20793 is a product of 3,

20795 is a product of 5,

20797 is a product of 7,

20799 is a product of both 9 and 3,

20801 is a product of 11

### LowRepeater(n,k) and HighRepeater(n,k)

LowRepeater and HighRepeater repeat over the number line

Adding a factor k to the previous functions we get:

LowMarker(n,k) = 3 + 2k(P(1)xP(2)x…x(P(n)),

HighMarker(n,k) = 3 + 2k(3x5x…xP(n)), and

Offset(n) = P(n) – 3

Then,

LowRepeater(n,k) = [LowMarker(n,k),LowMarker(n,k)+Offset(n)] and

HighRepeater(n,k) = [HighMarker(n,k),HighMarker(n,k)+Offset(n)] are non-prime (product of primes)

All, where k>=0 and k is an integer.

### Interesting observation about the difference between LowMarker(n,k) and HighMarker(n,1)

For a fixed n, and HighMarker’s k=1, LowMarker’s k = the product of the non-primes between P(1) and P(n).

The following table will clarify:

 LowMarker(3,1) = HighMarker(3,1) LowMarker(4,9) = HighMarker(4,1) LowMarker(5,9) = HighMarker(5,1) LowMarker(6,9*15) = HighMarker(6,1) LowMarker(7,9*15) = HighMarker(7,1) LowMarker(8,9*15*21) = HighMarker(8,1)