ID: 868475 RSA Lucky #13 July 4, 2018, 11:03 p.m. No.6694   πŸ—„οΈ.is πŸ”—kun

The virtual quantum computer (VQC) is a grid made of infinite yet constructable sets that follow a known pattern. Like a quantum spreadsheet.

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. Its purpose and our goal is to learn and show the TRUTH, one of them being P=NP. Cracking RSA will be a consequence.

 

When the integers that are the difference of two squares are arranged into the grid and their corresponding properties are shown, a pattern emerges that shows calculation instead of searching is possible.

 

Glossary

Column

All cells for a given e.

 

Row

All cells for a given n

 

The grid is indexed using e, n, and t, where e is the rows, n is the columns, and t is the specific element in the cell.

 

Entry, record, element

one set of variables that represents one factorization for a number.

an entry = {e:n:d:x:a:b} (e, n, t)

{1:5:12:7:5:29} (1, 5, 4) is a record AKA an element AKA an entry.

 

ab record, nontrivial factorization, prime record

the element that contains the factorization of c that is not 1*c, hence, nontrivial.

 

1c record, trivial factorization

the element generated from setting a=1 and b=c

 

Cell

All entries for a given e,n (not to be confused with an entry itself.)

 

Genesis cell

e,1

 

Remainder Tree

The remainder tree is the result of treating d and e as c's recursively until 1 is reached, creating a tree with several to many branches.

 

Functions

na transform

a movement from a record in (e, n) into (e,1) where n becomes 1 and a becomes a times the n of the (e,n) record. It has also been used to refer to moving n*a records down in a cell.

 

T

T of number or T(input) is the triangle number function. If our input is 7, T(7) returns the 7th triangle number

 

T-1, inverse T

the inverse function of the triangle number function that returns the index of a given triangle number. If our input is the 7th triangle number, the function returns 7.

 

Variables

The map's legend is {e:n:d:x:a:b}, where c is any number that is the difference of two squares, so odd numbers are included. It is the number you want to factor. It is the number that the a and b in an entry multiply to make.

a and b are, to reiterate, the factors of c. a is the smaller factor of c, and b is the larger one.

d is the integer square root of c

e is the remainder of taking the integer square root of c. Unless c is a perfect square, a remainder will be left over.

i is the root of the large square. it is the same thing as (d+n)

j is the root of the small square. it is the same thing as (x+n). i^2 - j^2, difference of squares.

n is what you add to d to be exactly halfway between a and b, and it is the root of the large square. So it takes you from d to the large square.

x is what you add to a to make d. When added to n it makes the root of the small square.

f is what you add to c to make a square. (e is what you subtract from c to make the square below it, f adds to make the square above c.)

g is the square root of c with decimals, opposed to d, which discards decimals.

t is the third coordinate in the VQC, it is a function of x.

u is the base of a triangle that helps us calculate (x+n) for certain c values. simply put, it is a representation of (x+n). 8 times the triangle number of u plus one is x+n.

s was a variable used to demonstrate patterns in (e, 1). See "(e, 1)."

 

When capitalized versions of the variables are used in comparison to lowercase versions, the capitalized versions refer to the variable's value for the trivial record, and the lowercase variables refer to the values for the nontrivial record.

{e:N:d:X:A:B} (e, N, T) is the trivial element.

{e:n:d:x:a:b} (e, n, t) in this context is the nontrivial element, the prime factorization of c.

ID: 868475 July 4, 2018, 11:14 p.m. No.6695   πŸ—„οΈ.is πŸ”—kun   >>6769 >>7025

Rules

Each cell of the grid (e,n) has infinite elements or ZERO elements.

Each cell with one value has infinite elements, since every element can make a new one.

By induction, a cell only needs one value to make infinite values, that's part of the power of this and is why it is a virtual quantum computer as a whole.

The t variable is what will allow you to walk across these infinite elements.

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

Thus, only three variables are required to identify an element: e, n and t.

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

 

(1, 1) - the key

The values of a and b at 1,1 are related to the length of the longest side in right angled triangles.

The values here can be used to create the entire grid.

The values here determine the values of the rows to the left and right, which determine the values of the whole column.

 

Columns

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

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 eachother, c will appear in two cells of one column.

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

All factors in a column are factors of the elements of the first cell in their column.

All Fermat primes (except) 3 appear in column one.

 

(e, 1)

If a number at position t has a factor s, then s is a factor at (t+s), (t+2s) and so on for a at (e,1).

Also, if a number at position t has a factor s at (e+1), then s is a factor at (s+1-t), (2s+1-t), etc for a at (e,1).

na and nb for any c can be found n places apart in the cell at (e,1).

 

(1, n)

The cells in row one where n=1 have a relationship with the cells 2n to the right and 2n to the left.

Each "a" from the first row equals na because xx+e = 2na and na is half of that. That's BIG part of the KEY

Each element in a cell can be generated by moving up (t-1 = x-2) or down (t+1 = x+2). Other variables can be generated from x.

 

For more of these rules, see the grid patterns thread.

 

Useful Equations and Notation

ab = c

dd + e = c

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

a + 2x + 2n = b

a = d - x

d = a + x

d = floor_sqrt(c)

e = c - (dd)

b = c / a

n = ((a + b) / 2) - d

d + n = i

x = d - a

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

x + n = j

j^2 = 8*T(u) + 1

f = e - 2d + 1

u = (x+n) / 2

 

if (e is even) t = (x + 2) / 2

if (e is odd) t = (x + 1) / 2

ID: 868475 July 4, 2018, 11:17 p.m. No.6696   πŸ—„οΈ.is πŸ”—kun

Code

 

C#

BigInteger Square Root β€”β€” https://pastebin.com/rz1SdACZ

VQC code w/ Bitmap β€”β€” https://pastebin.com/hMTtJF6E

PMA's tree generator β€”β€” https://pastebin.com/ZH9fSWu2

Original VQC code β€”β€” https://pastebin.com/XFtcAcrz

Unity Script β€”β€” https://pastebin.com/QgAXLQj3

Unity Script 2 β€”β€” https://pastebin.com/Y38nVWgT

 

Java

Traverse the VQC cells in real-time β€”β€” https://anonfile.com/TeH6q3d8bd/VQCGUI_v2.7z

Tree Generator β€”β€” https://pastebin.com/VZnQQR2i

VQCGenerator β€”β€” https://pastebin.com/Dgu9aP1h

VQC Triangle Number Methods β€”β€” https://pastebin.com/NCQ3HK2K

 

NodeJS

BigInteger Library and Sqrt β€”β€” https://pastebin.com/y8AXtFFr

 

Python

3D VQC [V2] β€”β€” https://pastebin.com/wZM5Thzu

Useful methods from CollegeAnon β€”β€” https://pastebin.com/d8xZZnm0

Create the VQC β€”β€” https://pastebin.com/NZkjtnZL

Fractal cryptography β€”β€” https://pastebin.com/XuN4U7Dv

GAnon's Viewable Grid code β€”β€” https://pastebin.com/czpK8A4j

Generate any cell in (0,1) and (0,2) β€”β€” https://pastebin.com/gRTYpdMU

Generate cells for a (and more) β€”β€” https://pastebin.com/iAizgLFF

Generate genesis cell β€”β€” https://pastebin.com/GKzcCpMF

Generate positive AND negative genesis cells β€”β€” https://pastebin.com/9ixjRyxt

VQC + t β€”β€” https://pastebin.com/Lgufk0db

RSA & PGP key wrapper β€”β€” https://pastebin.com/vNqnPRJR

 

Rust

Additional VQC code β€”β€” https://play.rust-lang.org/?gist=50def916ad48400bc5d638fbf119ae85&version=stable

Check if a number is prime β€”β€” https://huonw.github.io/primal/primal/fn.is_prime.html

Create Bitmap using the VQC Generator [V2] β€”β€” https://pastebin.com/zGSusyz5

Generate the VQC β€”β€” https://play.rust-lang.org/?gist=6b6beb372b6b931f1abd30642a35a80c&version=stable

 

Static Java/C# class with all RSA numbers β€”β€” https://pastebin.com/XYFpsDWE

 

Factorization methods (Java)

Binary search for i β€”β€” https://pastebin.com/TAt5bDsR

GCDFactor β€”β€” https://pastebin.com/70GJSMrv

Calculate factors using -x jumps β€”β€” https://pastebin.com/gKX9GW9r

Count down from t of 1c element β€”β€” https://pastebin.com/xxYa946V

Mirrors 1c until e=(-x+n^2) β€”β€” https://pastebin.com/WJBqPM4P

Shor's Algorithm (enter a random number < c as m) β€”β€” https://pastebin.com/RD83RTNc

 

Other Threads

Fermat's Last Theorem β€”β€” https://archive.fo/iTneU

Grid Patterns β€”β€” https://archive.fo/isamV

 

RSA #0 β€”β€” https://archive.fo/XmD7P

RSA #1 β€”β€” https://archive.fo/RgVko

RSA #2 β€”β€” https://archive.fo/fyzAu

RSA #3 β€”β€” https://archive.fo/uEgOb

RSA #4 β€”β€” https://archive.fo/eihrQ

RSA #5 β€”β€” https://archive.fo/Lr9fP

RSA #6 β€”β€” https://archive.fo/ykKYN

RSA #7 β€”β€” https://archive.fo/v3aKD

RSA #8 β€”β€” https://archive.fo/geYFp

RSA #9 β€”β€” https://archive.fo/jog81

RSA #10 β€”β€” https://archive.fo/xYpoQ

RSA #11 β€”β€” https://archive.fo/ccZXU

RSA #12 β€”β€” https://archive.fo/VqFge