>>13

Understandable anon.

This is a Good thing.

The delivery will still take some time as it is important to step through.

This is for everyone, it is bigger than me.

The potential of Virtual Quantum Computers and unlocking the potential of P=NP is vast.

These VQCs exist as mathematical objects.

Note that these can be thought of as part of a Higher Power, since mathematics is Invariant and pre-dates our existence.

Others may want to walk this path so I appreciate your patience.

I have commitments but I begin to have free time towards the end of this week.

As long as this space is maintained as free, it would be Good to complete this beginning by Christmas.

The first Virtual Quantum Computer is the grid that you have seen already.

The second VQC is related but will begin to show why mathematics as a language is not fit for purpose. And also why it took so long to prove Fermat's Last Theorem.

The third VQC we will cover here is related to the Mandelbrot Set.

Questions are important and shall feature heavily.

Again, thanks for your support and patience.

>>14

The important point here is that only the ability to add and multiply are required as well as understanding what squares look like.

Finding square roots is also a feature.

Once we move to large numbers, we will let computers do the hard work but we will only use the large numbers to show examples once needed.

First I will repost the original C# code and walkthrough it.

using System;

using System.Collections.Generic;

using System.IO;

namespace IntegerFactorisation

{

public class TheEnd

{

public static string path = "";//PUT YOUR FILE PATH HERE

public static Dictionary<int, Dictionary<int, List<string>>theend = new Dictionary<int, Dictionary<int, List<string>>>();

public static void CreateTheEnd(int i_max = 512, int x_min = 0, int y_min = 0, int x_max = 64, int y_max = 64)

{

for (int i = 0; i < i_max; i++)

{

for (int j = 0; j < i; j++)

{

int a = i - j;

int b = i + j;

int c = a * b;

bool odd = c % 2 == 1;

int d = (int)Math.Sqrt(c);

int e = c - (d * d);

int f = e - ((2 * d) + 1);

int n = i - d;

int x = d - a;

if (!theend.ContainsKey(e)) theend[e] = new Dictionary<int, List<string>>();

if (!theend[e].ContainsKey(n))

{

theend[e][n] = new List<string>();

}

if (!theend.ContainsKey(f)) theend[f] = new Dictionary<int, List<string>>();

if (!theend[f].ContainsKey(n - 1)) theend[f][n - 1] = new List<string>();

string text = "{" + string.Format("{0}:{1}:{2}:{3}:{4}:{5}", e, n, d, x, a, b) + "}";

theend[e][n].Add(text);

text = "{" + string.Format("{0}:{1}:{2}:{3}:{4}:{5}", f, n - 1, d + 1, x + 1, a, b) + "}";

theend[f][n - 1].Add(text);

}

}

}

public static void Output(int i_max = 256, int x_min = -64, int y_min = 0, int x_max = 64, int y_max = 64, int set_size = 12)

{

TextWriter tw = File.CreateText(path + "output.csv");

for (int y = 0; y < y_max; y++)

{

for (int z = 0; z < set_size; z++)

{

for (int x = x_min; x < x_max; x++)

{

if (theend.ContainsKey(x) && theend[x].ContainsKey(y) && theend[x][y].Count z)

{

tw.Write(theend[x][y][z] + ",");

}

else

{

tw.Write(",");

}

}

tw.WriteLine("");

}

}

tw.Close();

}

}

}

The first three lines are below:

using System;

using System.Collections.Generic;

using System.IO;

These three lines state the C# libraries required to run the code.

>using System;

Almost all programs in C# use this library.

>using System.Collections.Generic;

This library is used for the Dictionary object.

The dictionary object stores the grid and each element in each cell of the grid.

>using System.IO;

The System.IO library is used for printing the output of the grid to a file.

The line that has 'namespace' in it is simply a way to group similar classes together.

>namespace IntegerFactorisation

The { and } after the namespace and after the code just act as a holder for the class code.

>public class TheEnd

The class is the definition of an object to hold any code we want related to this project.

The name TheEnd is a name given to our code class. Since the first three letters we use are e, n, and d, it seemed to work. It is also a pun on the importance of 'n'.

I know some of you are already way past this, thanks for bearing with me.

> public static string path = "";//PUT YOUR FILE PATH HERE

This is the definition of a variable used to store the name of the output file. E.g. c:\Somefolder\output.txt

> public static Dictionary<int, Dictionary<int, List<string>>> theend = new Dictionary<int, Dictionary<int, List<string>>>();

The dictionary can be thought of a store like a spreadsheet or grid.

The rest of the code produces The Grid.

The Grid contains cells.

Each cell contains zero or non-zero elements.

We use a list of letters now.

a,b,c,d,e,n,x

There are seven letters.

All represent integers, whole numbers.

All revolve or are central to a whole number or integer c, from one to infinity.

The only values of c we are interested in are the numbers (integers) that are the difference of two squares.

Which numbers are the difference of two squares?

All odd numbers and all even number divisible by four.

What about numbers even numbers that are odd when divided by two?

These numbers are not the difference of two squares. If we divide those numbers by two or multiply them by two, they become numbers that are the difference of two squares.

Why is that important?

All odd numbers are the difference of two squares. This includes all prime numbers and all numbers that are the products of two prime numbers. The products of two prime numbers is at the heart of RSA encryption.

The seven letters we start with are defined, remembering that c is the same in all the definitions and remembering that this applies to every c where c is the difference of two squares:

ab = c : a multiplied by b equals c

dd+e = c : the biggest square with side d you can make from c and the remainder e left over.

(d+n)(d+n)-(x+n)(x+n) = c : c is the difference of two squares

aa + 2ax + 2an = c : c is a square with four rectangles added to it

a+x = d : d is the sum of a and x

b = a + 2x + 2n : b is the sum of a and 2 lots of x and n

These definitions should align with the images at the top.

The program simply goes methodically through all the differences of two squares in order from the square of one minus the square of zero, then the square of two minus the square of zero, then the square of two minus the square of one and so on.

The program stores the results of every difference of two squares in a grid.

The grid has columns and it has rows.

The grid columns are defined by the remainder e. So to find e of any c, you can find the square root of c we call d. Then subtract the square of d from c to get the remainder. The remainder can be 0,1,2,..,etc. We call the remainder e and it is the column header, the remainder of any c goes in the column that is defined by it's remainder e.

The rows are defined by the number you add to d, the square root, to make the large square. Remember, each c is the difference of two squares? The number n is what you add to the square root of c if you were to make the square that is having a smaller square subtracted. This number added to d is called n. n decides which row a number c goes in.

We know that the remainder of any c will always be the same, e.

All numbers c that are the difference of two squares will have at least one number n. Some have more than one value n for a value c, those that have more than one value n for a value c appear in a column more than once but always the same column, since e is always the same.

Prime numbers such as 3,5,7,11,13,.. have only ever one value n.

Imagine any square with side d, then subtract a square with sides (d-1) from it and you will have an odd number. If that odd number is prime, this is the only way you can do this but all odd numbers have this representation.

The square 2 by 2 with one taken will be 3.

The square 3 by 3 with four taken will be 5.

And so on.

The number 15 (c=15) which is not prime plugs in like this:

ab = c

1x15=15 : a=1,b=15,c=15

3x5=15 : a=3, b=5, c=15

dd+e = 15 : d=3, e=6, c=15

(d+n)(d+n)-(x+n)(x+n) = c : d=5, n=1, x=0, n=1

aa + 2ax + 2an = c

9 + 0 + 6 = 15

a+x = d

3+0 = 3

b = a + 2x + 2n

5 = 3 + 0 + 2

The picture here is the output of The Grid.

We will go through examples of the cells and the elements of the cells.

This is a grid cell.

The highlighted one is (0,0)

The values in each element of that cell have the format:

(e,n,d,x,a,b)

The value of c for each cell can be calculated a number of ways but the simplest is to take the last two values, a and b and multiply them:

ab = c

Since the cell is at (0,0) all the values of c in that cell are perfect squares (remainder e is always zero) and there is nothing to a to d to make the largest square. In other words in the cell at (0,0) we have all the squares with a square of size zero subtracted.

(0,0) is a unique cell in some ways.

It is the ONLY cell in row 0. No positive value of e has a cell in row zero.

Highlighted in this image is cell (0,1)

Again, perfect squares because the remainder after taking the largest square is zero.

So, these values of c ALL appear in (0,0) but they also ALL have more than one way to arrange their factors.

E.g. the first element in (0,1):

{0:1:4:2:2:8}

{e:n:d:x:a:b}

This is square with sides of 4.

4x4 = 16 can be arranged as 2x8 = 16

If you take a square 3x3 from a square 5x5, you get this difference of two squares.

The square at (0,1) is the basis of the patterns of all cells on row one.

Notice that the values of b for the first element is the value of a for the next element, the value of b for the second element, is the value of a for the third element.

This pattern exists in every cell in the first row.

All the values of a in this cell, include as a set, all the values of b by the same logic.

So, we can focus on the values of a if we want.

Notice that all the values of a in this cell are also each twice the value of a perfect square.

1+1 = 2

4+4 = 8

9+9 = 18

And so on.

Notice that all the values of d for this cell also follow a pattern:

2x(1x2) = 4

2x(2x3) = 12

2x(3x4) = 24

The image here is cell (1,1)

These values of c that are the elements of this cell share a pattern with (0,1).

Note that all the values of d for (1,1) are identical to the values of a for (0,1)

This cell (1,1) contains as values for a and b the values of two consecutive squares added together.

0+1 = 1

1+4 = 5

4+9 = 13

9+16 = 25

When two of these are multiplied together, the result is a twice a perfect square plus one as a remainder.

Each value of a in cell (1,1) is also the long side of an integer right angled triangle.

Notice that all the values of a at (1,1) are the values of d in (0,1) with one added.

4+1 = 5

12+1 = 13

24+1 = 25

The cell at (2,1) is identical to the cell at (0,1) with one added to each value a,b,d while the values of n and x remain the same.

The cell at (3,1) is identical to the cell at (1,1) with one added to each value a,b,d while the values of n and x remain the same.

In the row n=1 which is also written (e,1), the cell elements repeat this pattern every two cells or 2xn = 2x1.

We will explore that for any row n, the values of a,b and d will increase by one in a cell that is twice n to the right.

If a cell has values at (e,n) then there will be values in a cell at (e+2n,n)

Please explore that pattern.

Let me know if there are any questions at this stage.

Next we will explore the reason that answer the following question:

Why are there gaps?

Why do the values in row one determine all the values in the columns below them?