Math Is Fun Forum

So I started off drawing curves between the primes on a number line

I then drew curves between all the other numbers using the following rules:
1) Draw a upwards curve to a number that is not already taken
2) If the next number is also available, skip until you find a number that is taken, and then draw a downwards curve to the number before it
Repeat

So I did this for a while in geogebra..

(That's all the primes smaller than 200)

..until I finally got bored and decided to write a program to do it for me.
This is the first 600 primes:

There is a few interesting things to note here. A circle usually have between 1 and 3 smaller circles inside it:
1) They are next to each other on the number line
2) The two child circles will be of the same size
3) You often get one child circle in the middle with two circles of the same size at either side

There are examples of circles with both 4 and 5 children, but they are rare.

First 1200 primes:

First 2400 primes:

Notice how all the big circles has bumps under their legs? Here's a zoomed in picture of the biggest lump from the 2400 picture:

It appears as if all big circles are born from these black holes of primality (it's actually the opposite, it's a huge prime gap). Over to the right in the picture you'll see a black hole that hasn't even finished rendering (I only asked for the first 2400 primes, so there was no gap large enough for the remaining curves to go to.
Also interesting to note is that the three curves that outlines the rightmost circle, is the two other big circles and a new one.

Now I am sure that you are sitting at the edge of your chair, shivering in anticipation for how that un-rendered black hole from 2400 is going to turn out. There is already 4 circles for the up and coming mega circle to hold, will it have more than 4? Well, shiver no more, for we need not go further than 2600 to find out:

The black hole is actually not fully sated until 6000:


(Is it just me, or does all the circles appear to "point" in the same angle?)

I'm leaving you with this svg (infinitely zoomable vector image) of the first 10k primes:

Suppose you have a number n, and that you write a list of n modulo x, where x is all numbers between n and 1. Do this for all integers greater than 0.

1: 0         
2: 0 0      
3: 0 1 0   
4: 0 1 0 0
...

1 is divisible by 1.
2 is divisible by 1 and 2.
3 is divisible by 1 and 3, and has a remainder of 1 when divided by 2.
4 is divisible by 1, 2 and 4, and has a remainder of 1 when divided by 3.
..

Notice that the modulos are in the reverse order, such that the first number on a line is n modulo n, and the next is n modulo (n-1).

This is a screenshot of a text editor with the pattern for the first 300 numbers or so, with 0 highlighted.

You get a bunch of lines! The leftmost line is the n%n line. All numbers are divisible by themselves. The next line is n%(n/2), all numbers that are divisible by 2, are also divisible by themselves divided by two. The pattern continues like this, the next line being n%(n/3).

..
18: 000 001 002 003 004 005 006 007 008 000 002 004 000 003 002 000 000 000
19: 000 001 002 003 004 005 006 007 008 009 001 003 005 001 004 003 001 001 000
20: 000 001 002 003 004 005 006 007 008 009 000 002 004 006 002 000 000 002 000 000
21: 000 001 002 003 004 005 006 007 008 009 010 001 003 005 000 003 001 001 000 001 000
..

Notice that between the 1 and 2 line, the modulos are incrementing by one up to ceiling(n/2-1). After the 2 line, everything increments by 2.
You also see a example of diagonal incrementation lines, that is, you can pick any of the modulo numbers, go one down and one to the right, and that number is going to be one greater than the number that you came from, unless it is zero.

Consider 6:

06: 000 001 002 000 000 000
07:                         000
08:                         000
09:                         000
10:                         002
11:                         001
12:                         000
13:                         006
14:                         006
15:                         006
...

If you flip this sequence 90 degrees, it is going to replicate:
6 is divisible by 1, therefor 7 is divisible by 1.
6 is divisible by 2, therefor 8 is divisible by 2.
6 is divisible by 3, therefor 9 is divisible by 3.
6 has a remainder of 2 when divided by 4, therefor 10 has a remainder of 2 when divided by 4.
6 has a remainder of 1 when divided by 5, therefor 11 has a remainder of 1 when divided by 5.
6 is divisible by 6, therefor 12 is divisible by 6.

after this point, 6 is just going to repeat infinitely downwards. This pattern is true for all numbers, and primes are just the unlucky numbers that didn't get any zeroes.
I am sure that there are a lot more patterns that I didn't cover, so I'm gonna leave that to the comment section

Haskell program that generates the first 1000 lines in case anyone want it:

mods x = map (mod x) [1..x]
mods'  = map  mods [1..]

show' x = replicate 3 - length (show x) '0' ++ show x

main = putStrLn . unlines . map (unwords.map show'.reverse) $ take 1000 mods'

Many cryptography algorithms - notable RSA - rely on the difficulty of factorizing semiprimes. Essentially, the server multiplies two gigantic primes and send you the result, you use that number to encrypt your message, and the only way to decrypt it is to know the two original primes.

So the server sends you a number n. n = p*q, where p and q are primes.
You can consider p and q to be the length of the short sides on a right angled triangle, and if we where to know the angle of either A or B we could figure out p and q.

p = sqrt (n * tan(((pi*A)/180)))
q = sqrt (n / tan(((pi*B)/180)))

If you plot those functions you'll get this:

The point where the two curves crosses is sqrt(n). At either side of x=45, the only point where the two curves travel trough a integer value on the y-axis at same place on the x-axis, is at the two original factors p and q.

Now this is where I need help. It looks as if I where to invert either of the curves, they would intersect at the point of the factors. I made this mockup to illustrate this:

How do I invert the curves, and do they actually intersect at the factors?