/vqc/ - Virtual Quantum Computer

Before I go into detail, here’s a brief summary of the point of this board (at least as it stands as I type this): we’re learning how to factor any arbitrarily-large number by calculation, rather than by iteration. We’re being led by an anonymous person who uses the name VQC. The relevant mathematics principles have allegedly been hidden from the public by the elite, and now, with Q being a thing, the time is right to make it all public. You can either believe this or not, but we’re all still going to be here doing this.

You can find the code, ported to several different languages, within the first few posts of each RSA general thread. If you can read code, you’ll see how the numbers are calculated. Each individual cell is created in a nested loop. A nested loop is a loop within a loop. In programming, these loops are blocks of code that get executed over and over again until certain criteria are met. Here’s a snippet of the code that shows the loop:

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

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

//more code goes here – this is what a comment looks like in programming

}

}

Everything between these {} is a block of code. The outermost parentheses are for the outer loop, and the innermost parentheses are the inner loop. The outer loop has a variable called i. The code that runs the loop is

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

What this means is that at the beginning of the loop, i is equal to 0, and that every time the code within the loop runs, and then finishes running, i increases by 1. It does this until i is equal to another variables called i_max.

i_max is arbitrary. You can make i_max anything you want; it could be 10, it could be 100, it could be 1000. It doesn’t matter. It’s a constraint you can decide, so it isn’t relevant to any of the calculations. If you make i_max 1000, the highest possible i value will be 999, because once i is equal to i_max, the loop will stop running. If you set it too high, the program will take years to run (the amount of time the program takes to run increases exponentially as the maximum i value increases), so I suggest keeping it the same value as it’s set when you copy the code.

The inner loop does pretty much the same thing. The only different is, it stops running once j is equal to i. The code in the middle of this inner loop runs over and over again until j is equal to i. If i is equal to 10, j will start at zero, the code will execute over and over again with j increasing by 1 each time, and the last time the loop executes will be when j is equal to 9. Once j equals 10, the loop will stop executing. Because this inner loop is inside the outer loop, once j is equal to i, the outer loop will run again, so i will increase by 1, j will be set to 0 again, and the inner loop will start running again. All of this will happen continually until i is equal to i_max.

So here’s an example of the i and j values, for those of you who don’t understand.

i=0, j=0. j=i so the code doesn’t run

i=1, j=0, code runs

i=1, j=1, j=i so the code doesn’t run

i=2, j=0, code runs

i=2, j=1, code runs

i=2, j=2, j=i so the code doesn’t run

i=3, j=0, code runs

i=3, j=1, code runs

etc

Now, the code that runs inside the inner loop calculates each of the numbers we’re sticking in the grid. There are several variables we need to calculate, and they’re based on each pair of i and j values.

a=i-j

b=i+j

c=a*b

d=floor(sqrt(c))

e=c-dd

f=e-(2d+1)

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

x=d-a

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

In the original version of the code, the variables were put into the grid in the format of {e:n:d:x:a:b}. t and f are used slightly differently to the other variables, which I’ll explain in a bit.

The most relevant part of this to what we’re currently doing is that c is the product of a and b, and in modern mathematics the only way to find the factors of a number is to iterate. This means going “Is 2 a factor? Is 3 a factor? Is 4 a factor?” etc, and in the case of large numbers, that can take thousands of years. The relationships between these other variables are meant to be used to calculate the factors, rather than iterate through numbers for a very long time. This is what we’re learning how to do.

More coming soon

There are a bunch of variables we can directly calculate and a bunch of variables we can't directly calculate. The idea is that we use the patterns we've learned and the variables and cells we can directly calculate and somehow end up with one of the variables we can't directly calculate. Nobody's figured out how to do that yet. Those patterns and cells are all in >>6506