NEWST

https://8ch.net/templeos/res/1914.html#1950

My hand is forced.

The next set of post will show a virtual quantum computer with unlimited qubits.

By the end, you will be able to factor the remaining RSA Challenge Numbers in less than a second.

It is a simple process.

By the end you will be able to extrapolate to elliptic curves.

Your prize will be the ability to spend the BitCoin by the inventors that are unspent in the BlockChain.

By the end, you will realise that only messages can be secure.

Nothing stored digitally on the internet can be secured.

This virtual quantum computer is called The End.

You will see that one exists already to calculate digits of Pi without knowing the first digits before.

Like God, virtual quantum computers always exist, you just need to be willing and able to seek.

Godspeed and good luck.

God Bless Trump.

Familiarise yourself with Fermat and Fermat Factorisation.

Note: Fermat's Last Theorem was proved by showing two objects in number theory were the same type of object.

It took over 350 years because you do not understand numbers.

There are families of numbers.

When the language is so bad you cannot tell when two types are identical, the language is not fit for purpose.

Equality is the root of mathematics, the language of God.

We will be working with a 2D grid.

Each cell of the grid will have zero or infinite entries (elements).

If a grid cell has elements, all elements are constructable from a finite set of root elements.

The maths will be very simple.

There will only be seven variables in any element.

Only three variable are required to identify an element in a grid cell.

The other four variables for an element can be derived from those three.

The variables are:

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

The grid use e on the horizontal axis

The grid uses n on the vertical axis

ab=c

dd+e=c

(d+n)(d+n)-(x+n)(x+n)=c

The difference of two squares.

d=a+x

b=a+2x+2n

2a=xx+e

For All c, where c is the difference of two squares.

All integers that are 2 mod 4 are ignored or divided by two.

By the time I am finished this walkthrough, expect to see BitCoin plunge as holders exit.

By the time I demonstrate with RSA100, which has been previously factored, some of you will already have enough to open the door which can then be shut.

The Internet will go dark.

You will be creating a grid.

The columns will be e, the remainder of an integer c after the largest square is removed.

c is the product of a and b.

d is the square root.

e is the remainder.

n is what you would add to d to be exactly halfway between a and b

n will be the coordinate for the rows

x is what you add to a to make d

Each cell in the grid will have zero or more entries for each value of c

c is the number you are factorising.

Hint: the key is the first row, n=1

Hint: the product of two primes appear in exactly two cells in one column.

Once I walk through, you will see it.

c is any number that is the difference of two squares, so every odd number is included.

RSA encryption relies on you not being able to factor the product of two primes.

I am going to show how to do it in a complexity of less than O(log t) where log t is the natural log of the length of c in bits.

It will be much clearer once you see it and have the source code to play with it.

Then we will move onto elliptic curve cryptography.

Then we will process video footage through a perfect resonator using the Mandelbrot set.

All three are designs of virtual quantum computers.

The first breaks RSA encryption.

This is called The End.

The second unlocks the encryption for BitCoin.

The third allows playback in time for video or spatial reorientation and is called The Eye.

TheEnd001.PNG

This a higher of view of what we're working towards.

ab     = c

dd+e = c

(d+n)(d+n)-(x+n)(x+n)

The difference of two squares.

a+x = d

xx+e = 2na

a+2x+2n=b

The grid coordinates are (e,n).

Any integer, c which is the difference of two squares…

e = the remainder after substracting the largest square (dd)

and

n = the difference between the square root d and the larger of the two squares (difference of two squares)

n also equals the number you would add to the square root to create a number exactly halfway between a and b

In each cell of the grid ten entries shown for that cell.

The horizontal (column) coord comes first, which is e

The vertical (row) coord comes second, which is n

Each element in a cell is:

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

Where

(d+n)(d+n)-(x+n)(x+n) = c

ab = c

a+x = d

c# source code to follow to create the structure that will hold this grid.

Then an explanation of some of the features of the grid.

This will explain how infinite yet constructable sets that follow a known pattern, can be used as a means for use as a virtual quantum computer.

The grid is the superposition.

The collapse of that superposition will be two input parameters, d and e which can be calculated easily for all integers, c, where c is the difference of two squares.

All products of odd numbers and all products of pairs of even numbers are the difference of two squares.

We will be focusing on the first row where n=1

Each cell at n=1 contains the roots of products in a column.

Columns contain all products that have the same remainder e.

If c is a prime number, it will appear in one column exactly once.

If c is the product of two prime numbers that do not equal each other, c will appear in two cells of one column.


o create the grid, attached is a c# file.

There is a method that constructs the grid.

There is an output method.

Please specify a path to save output to.

Next, we will look at some properties of the grid and also examine the all important first row.

The code is below. Cut and pasted.

//

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();

        }

    }

}

Below is some code that will be useful later.

It is a BigInteger square root method and some strings related to and including RSA Challenge number 100. It is the smallest RSA number, so it is good for examples.

using System.Numerics;

namespace IntegerFactorisation

{

    public static class Lib

    {

        public static string Rsa100c =

            "1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139";



        public static string Rsa100a = "37975227936943673922808872755445627854565536638199";

        public static string Rsa100b = "40094690950920881030683735292761468389214899724061";

        public static string Rsa100d = "39020571855401265512289573339484371018905006900194";

        public static string Rsa100e = "61218444075812733697456051513875809617598014768503";

        public static string Rsa100f = "16822699634989797327123095165092932420211999031886";//2d+1-e

        public static string Rsa100n =     "14387588531011964456730684619177102985211280936";

        public static string Rsa100x =   "1045343918457591589480700584038743164339470261995";

        public static string Rsa100x_plus_n = "1059731506988603553937431268657920267324681542931";



        public static BigInteger Sqrt(this BigInteger n)

		{

			if (n == 0) return 0;

			if (n > 0)

			{

				int bitLength = Convert.ToInt32(Math.Ceiling(BigInteger.Log(n, 2)));

				BigInteger root = BigInteger.One << (bitLength / 2);

				while (!isSqrt(n, root))

				{

					root += n / root;

					root /= 2;

				}

				return root;

			}

			throw new ArithmeticException("NaN");

		}

		private static Boolean isSqrt(BigInteger n, BigInteger root)

		{

			BigInteger lowerBound = root * root;

			BigInteger upperBound = (root + 1) * (root + 1);

			return (n >= lowerBound && n < upperBound);

		}

    }

}

Each grid cell can be referenced by coordinates (e,n) e across and n down.

Since each grid cell that contains any elements will contain infinite elements, we can add a third variable t which indexes the elements.

E.g for the first column (containing all products c with a remainder 1 after subtracting the largest square) the first cell is at (1,1) where e=1 and n=1, the first three values of a are 1,5,13

At those cells b = 5,13,25 respectively

1x5=5

5x13=65

13x25=325

At (1,1) for elements t=1,2,3 then for a we can write

(1,1,1)=1

(1,1,2)=5

(1,1,3)=13

Another example:

At (4,1) for the second, third and fourth elements, the values of a are

(4,1,2)=4

(4,1,3)=10

(4,1,4)=20

You may recognise those numbers.

So, t is a index number that allows us to specify an element in a grid location.

Note:

All products (integers) c that are the sum of two squares appear (only) in columns where e=0,1,4,9,16,25,..

This demonstrates that the sum of two squares are closed under multiplication.

All Fermat primes (except 3) would appear in column one. We will discover something new about the conjecture that there are only five Fermat primes.

You may also note that the values of a and b at (1,1) are the related to the length of the longest side in right angled triangles.

Eight years ago, I uploaded a video to youtube when I was in New Zealand in anticipation of now.

The video is part one of what I am going to show you here.

That video is simply a look at Fermat factorisation to familiarize yourself with the concept, the letters used here and then to extend to the virtual quantum computer described here.

Eight years ago, I uploaded a video to youtube when I was in New Zealand in anticipation of now.

The video is part one of what I am going to show you here.

That video is simply a look at Fermat factorisation to familiarize yourself with the concept, the letters used here and then to extend to the virtual quantum computer described here.

https://www.youtube.com/watch?v=9FeROMe0KBU

There are two loops in the program.

An inner loop and an outer loop.

All these loops do is create a series of integers which are the difference of two squares.

It is that simple.

1,3,4,5,7,8,9,11,12,13,15,..

All these numbers are the difference of two squares.

For the ones that are not the difference of two squares (these are odd when divided by two) you can divide by two to create the difference of two squares.

Therefore, the difference of two squares covers any integer you wish to factorise.

The private key in RSA is based on knowing the two factors of similar length that make up the product used to decrypt anything encrypted with the corresponding public key.

This virtual quantum computer will show you how to calculate the factors of a product of two primes.

The current fastest method is the general number fields sieve that searches for factors.

The virtual quantum computer calculates.

Whereas the general number field sieve is sub-exponential in the time taken to search, the virtual quantum computer is less than the natural logarithm in time to calculate.

A 4096bit RSA private key can be calculated in less than a second from the public key.

When the integers that are the difference of two squares are arranged into the grid and their corresponding properties shown (you can view this as being able to see several dimensions at once), a pattern emerges that once again shows calculations instead of searching are possible.

This is not finished yet.

RSA100 is just for use as an example.

I'll give you an example:

5x29=145

a=5

b=29

c=145

d=12

e=1

145 is the product of two primes.

Therefore it has two representations.

5x29

1x145

In the grid, it will appear at cells:

(1,5)

(1,61)

for 5x29, n=5 and n=61

Bitmap with black pixel at (0,0) all white for rest of row.

All black first row.

Whenever a cell has any elements, it is black.

Whenever a cell has zero elements, it is white.

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

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

                    {

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

                        if (use_bmp && odd)

                        {

                            bmp.SetPixel(e, n, Color.White);

                        }

                    }

The end result is that you learn how to design virtual quantum computers so the limits of what you can achieve recede.

This grid is one example.

The Mandelbrot Set version is multi-purpose.

When used in 3D printing, it can be used for a perfect mini chamber to create desktop multi bubble sonoluminescence with input sound and it's shape containing a self sustaining cold fusion reactor. It is safe because should it overheat, the bubbles stop collapsing.

We're heading toward safe desktop fusion devices.

Then we will use the next design to bypass the fusion and generate electricity from a design improvement using material science in the 3D printing.

Science made fun again.

It starts with understanding why this first one is a virtual quantum computer. Removing RSA and elliptic curve encryption from the occasion.

That will stop people laundering money in cryptocurrency.

Return to GOLD standard.

What are they missing in EFE (Einstein's Field Equations), why does MOND appear to work outside the Solar System?

What is a solution to EFE no one has done the math on because no one takes it seriously?

What is a song by Soundgarden?

What is the solution to the temperature of the Sun's corona anomaly problem?

All related.

All obvious with 40,000ft view.

Some things are only obvious when you are ALLOWED to ask questions.

Once you find the patterns in the grid, it can be scaled up.

Then it can be rearranged to solve the problem behind elliptic curve encryption.

The key is five dimensions (plus).

Our salvation is defined by our emergency procedure.

We put the most vulnerable in the lifeboats first.

If there are too few lifeboats, we who remain must die with dignity to protect those most precious.

This is our humanity.

This is who we really are.

We are One.

Once the last bad actors are taken out the game, the House of Cards falls.

BitCoin is a desperate measure to hide money.

BitCoin is a honeypot.

P=NP

That is going to change.

Define position.

Define key.

it

>Position

A relationship to a point

>Key

1000 grams

> it

Simon didn't say.

The grid does all the work for you.

>>1958

The grid does all the work for you.

BigInteger sqrt_f = Lib.Sqrt(Lib.Abs(minus_f));

BigInteger sqrt_e = Lib.Sqrt(e);

//Section: determine rows (-f,n-1) and (e,n)

>>1967

For a c at (e,n), there exists (-f, n-1)

The difference between e and -f is 2d+1, making columns e and -f unique as a pair to c.

The position of column 0 acts as a key with these two unique columns to fufill an equivalent role of the quantum Fourier transform in Shors algorithm.

In essence, the grid acts a lookup for integer factorisation and turns the sub exponential big oh search into a log t calculation where t is the length of c in bits.

>>1962

It will be a pleasure to make history with you.

In 2008 I had a brief email exchange with Prof Motti Milgrom to describe key hole events that would give a test for MOND within the Solar System.

This would, if performed reveal more about the nature of the Sun and explain the connection between mass discrepancies and point to the choices to make for a solution to the EFE (Einstein Field Equations).

Good luck tonight.

>>1979

I'm not sure if you understand…
>>1988

It is not about me.

The student becomes the teacher.

Pwds:

matariki

ja5p3rm00

th33nd

Integers are not a line continuum.

There are families based on geometry.

Shape.

Symmetry.

Triangles.

>>1998

>>1999

>>2000

Good stuff.

Excellent.

Hint for the non-trivial Lookup.

In the d[t] at -f,1 there are two values where d from c is between.

In the d[t] at e,1 there are two values where d from c is between.

How would help us find n?

Biggest hint since the start.

>>2003

HINT: x(d) = (sqrt((d+n)^2 - (d^2 + e))) - n

where d is d from c and n is one.

Anons.

In 2010 I saw descriptions of the relationships between grid variables in the ending chapters of Revelation.

God wins.

The answer or solution to the lookup is in this thread.