The solution? Lol.. we got this.. just gotta think trees.
Trees.
Trees.
Trees of numbers.
I just realized something.
The amount of jumps is n*a.
Like VQC said.
We can use it because we know n*a.
Oh.
If you take any c, and generate the 1*c cell, you can go n down and find a number whose second factorization contains the a you want for c.
145:
start with {1:61:12:11:1:145}
go down n (61) entries in the cell
and you get {1:61:278:133:145:533}
145*533=77285
all you have to do is find out how to get the second factorization of 77285, and you have a:
5*15457 = 772851
145 / 5 = 29
5*29 = 145
Second example: 533
{4:244:23:22:1:533}
getting to this cell is trivial. now go 244 cells down.
{4:244:1043:510:533:2041}
533*2041=1087853
now all you have to do is get the other factorization of 1087853 to factor 533
1087853 = 13 * 83681
533 / 13 = 41
13 * 41 = 533
Somebody tell me how to mirror a cell.
I think that's the solution. Every cell on the positive e side has a counterpart on the negative e side.
Found it, I'll work on it tomorrow.
Knowing how the factor trees work in the VQC lets you factor it.
When you make an xjump from a 1c cell you get a number which has a for c as a factor.
Just keep working on it. We're closer than we've ever been. I finally understand the na is n apart crumb.
Yes, there's somewhat of a wall when you try to factor it by moving around and ignoring the e,1 cell, because you can't "go back." You can go up the branch of the tree and get more numbers who share prime factors of the c you are using, but you can't get the factors. I really think we just have to pay attention to e,1. e,1 contains the factors for every x jump from 145.
In log(n) time?
Just to give you an idea how little the world understands about factorization, How RSA 155 was solved:
pastebin.com/8BnqvvtT
Yes, they're huge. If e wasn't large enough the number would be vulnerable to primitive versions of Fermat's factorization. You don't really have to worry about how big RSA numbers are. Just solve it for humanly-understandable c's, program it and let the computer do the work.
Yes.
To go into more detail, when the prime factors of RSA numbers are calculated, they have to be a certain amount apart, so that programs like our binary search program are made to fail. If abs(a-b) is too small, you can factor the number using the normal Fermat factorization method.
Patterns.. oh so beautiful patterns.
f+c of 145 = 169
625 = 5^4
145 = 5 * 29
225 = 5 * 45
225841 = 1451305
225841= 537845
2901090=1452180
f+c of 95 = 100
190706=951412
190706=526828
95 = 5 * 19
100358 = 57160
bottom of picture.
{1:25:8:7:1:65}
c = 65 appears at (1,1,2).
(1,1,2) = {1:1:8:3:5:13}
See the pattern to crack it yet? :x
Am I walking up and down the branches now?
There's so many adjacent squares, they're everywhere. Seems as if the tree of numbers + tons of squares = simple factorization of all numbers.
All products (integers) c that are the sum of two squares appear (only) in columns where e=0,1,4,9,16,25…
0^2 = 0
1^2 = 1
2^2 = 4
3^2 = 9
4^2 = 16
5^2 = 25
I must have not checked that. I'm using this method. If I want to go down, I pass in n,x,a for 1c
If I want to go up, I pass in n, -(2n+x), c
>>def rowNegX(n, x, a):... b = a + 2(-x) + 2n... c = ab... d = int(math.floor(math.sqrt(c)))... e = int(c - dd)... n = int(((a + b)/2) - d)... x = int(d - a)... return (e, n, d, x, a, b)
Also, I think it says it's an invalid record because 290 is not the difference of two squares because it's even, but if you divide it by two it becomes the difference of two squares.
I wonder if that's important.
Passing in -(2n+x) as the formula makes it make the na jump like the crumb says.
Just use geometry if you want to figure that out.
Reminds me, I need to draw a few things.
Got a lot on my plate right now.
So, in other news, /cbts/ has been shoahed. (((BaruchTheScribe))) (The BO) lied about many things:
>having a private conversation with Q
>not being able to verify Q's IP
>Q's second trip being cracked
He's also a big enough dunce to get screenshots of the Discord posted to the top of plebbit for all to see. He also insulted Q. He is very Weak Minded.
/thestorm/
and
/qpol/
Are coming in quite handy.
Either way, I love Q even more for BTFOing Zion agent Baruch. Lots of new ideas in /thestorm/
Maybe they'll even convince Q to verify himself with GPG..
but oh dear.. One problem.. Kek.
Lmao, ok. I'll post the ones for RSA-240 since this is the lowest that hasn't been factored. I didn't factor the number, just set n = 1. Also, ab != c because there are only 2 factorizations for semiprimes. 1c and ab
I have to rewrite the method because I lost it. Can you repost the formula?
Here are the values if you assume n=1 for rsa240.
It is not the factorization of rsa240.
rsa240c = 124620366781718784065835044608106590434820374651678805754818788883289666801188210855036039570272508747509864768438458621054865537970253930571891217684318286362846948405301614416430468066875699415246993185704183030512549594371372159029236099
if you assume n=1 (it isn't), these are the values you get:
pastebin.com/W40p18aG
The ↑ I was using in my previous was t+na
I changed it to t+na,
and now the ↑ stands for -x jump with parameters
(n, -(2n + x), a)
t+na uses the parameters
(n, -(2n + x), c)
Pay attention to b for all the cells pictured.
Subtract b of ↑d from b of ↓d
Subtract b of ↑e from b of ↓e
Subtract b of ↑n from b of ↓n
Subtract b of ↑x from b of ↓x
Subtract b of ↑f from b of ↓f
Subtract b of t+na from ↓c
Always the same number.
Always a multiple of 2.
Let's call it.. o for now
Because why not.
o for 991 = 1980
o for 533 = 1064
o for 169 = 336
o for 145 = 288
o for 54 = 104
I am using this method.
>>def rowNegX(n, x, a):... b = a + 2(-x) + 2n... c = ab... d = int(math.floor(math.sqrt(c)))... e = int(c - dd)... n = int(((a + b)/2) - d)... x = int(d - a)... return (e, n, d, x, a, b)
Here are the parameters for the method for each element derived from c in the pictures:
→ = 1*c cell
↓ = (n, x, 1)
↓c = (n, x, c)
↓d = (n, x, d)
↓e = (n, x, e)
↓x = (n, x, x)
↓n = (n, x, n)
↓f = (n, x, f)
↑ = (n, -(2n + x), 1)
↑d = (n, -(2n + x), d)
↑e = (n, -(2n + x), e)
↑n = (n, -(2n + x), n)
↑x = (n, -(2n + x), x)
↑f = (n, -(2n + x), f)
t+na = (n, -(2n + x), c)
Try subtracting ↑d on top from ↑d on bottom*
Lots of patterns here.
Maybe you can find more.
I've provided the way to generate these.
That is an unacceptable solution.
Read the pictures I sent and try taking the difference between two ↑d's or two ↓d's
It's predictable based on a. I'm working on whether you can derive it from c and work backwards.
Always multiple of 2.
For simplicity sake I am going to refer to o as the difference between a ↓ element and a ↑ element, and I'm going to refer to the difference between the ↑ element of the ab element and the ↑ element of the 1c element as p
Two↓ elements also works here.
If you don't recognize this notation just look at the pictures I sent.
This difference, p, may be directly related to a and maybe can be derived from c.
I don't know the linear formula, but most of the values of p for a can be found when you put a into the formulas for all the elements.
For example, you get 8*22 when you type in 8, and p is always 22 when a=8
For example, you get 4*10 when you type in 4, and p is always 10 when a=4
Full list of relationships:
a = 1, p = 0
a = 2, p = 4
a = 3, p = 6
a = 4, p = 10
a = 5, p = 12
a = 6, p = 16
a = 7, p = 18
a = 8, p = 22
a = 9, p = 24
a = 10, p = 28
It might be congruent to this sequence.
oeis.org/A006093
Try entering d for any c into the element deriver that I sent the formulas for. I noticed the value of p is always there, but I haven't confirmed this. If it is, then you'd be able to factor the number by finding what term p is of the sequence above. (E.g 16 is the 6th term of that sequence if you ignore 1).
It's all there. Value of p seems to be close to d.
a is equal to the number of the sequence I posted that p is, minus one.
I'll be busy until Wednesday or Thursday. Tell me what you all find regarding the prime sequence and the -x jumps.
I'm not 100% sure the sequence of p for increasing a is congruent to the sequence I sent but it was very similar:
oeis.org/A006093
There are a lot of things I missed in my -x jump brute force factorization program. Try calculating change between each b it prints out. It also sometimes gives a instead of n. I think there is something valuable there. I just noticed it but I have to go.
Add System.out.println(v);
after line 46 in my x jump code to see what it actually does
I honestly thought it was an AI.
Wow. It was that simple.
So, we can factorize d?
If we can factorize d with (0, 2d), can we factorize c^2, with (0, 2c)?
My DMs with him
>>2903
You lost me a while ago. What is w?
I really don't understand any of this, so I won't condemn you by saying it's not relevant. Your brain seems to be on max CPU usage though, so think about the crumb that the solution is hidden in plain sight.
Found some pretty patterns. Go to (1,1) and take the difference of (d+1)^2 and d^2 for each cell.
Very beautiful pattern, and it's exactly what my program prints out when I factorize 145
Each value is also only 1 integer away from a square.
In short, if you want to see even more amazing patterns, make a list of each cube and square and take the differences of them.
I think I'm seeing something in my head here.
WHY ISN'T C THE FIRST COORDINATE FOR THE FACTORIZATION?
That's what I discovered.
The VQC is a sea of squares and remainders. Think about what happens if cells are identified with (n, e). Think about what happens if d^2+n is used instead of d^2 + e, or d^2 + f
numbers above 1*c are little and big square for 1c,
numbers above ab are little and big square for ab
for any c, d^2 and (d+1)^2 are the 2 adjacent squares
Yes, and this is how it was meant to be. f is like an opposite remainder.
Imagine a ton of valleys of squares, and each semiprime we work on is inbetween two of them.
145 is inbetween 144 and 169.
e is the distance from c to the left valley, and f is the distance from c to the right valley.
Thus,
c - e = 144, or d^2
and
c+f = 169, or (d+1)^2
95 = 9^2 + 14
95 = 10^2 - 5
178 = 13^2 + 9
178 = 14^2 - 18
e is the remainder of the left, and f is the remainder of the right.
Therefore, you can represent c using f like so: c = (d+1)^2 - f
The mountains are the squares, and the valleys are the numbers who are not perfect squares.
d^2 + e
(d+1)^2 - f
n is the distance from d to the root of the big square.
j^2 or the little square is the distance from c to the big square.
LOL! I agree. Their job would be to monitor threads like this. ;)
Try it on a number with a different e. Solution hiding in plain sight.
Also, ask yourself why numbers are indexed with distance from d^2 and distance from d to root of big square.
Why aren't they indexed with c or d? It's almost as if there is a similar property for all numbers with the same remainder (e). Dreamt of this
Pictures are formatted like so:
d[t]-d{ } a[t]{ }——{difference between the two}——{difference between their squares}
odd and even.
Hmm.. What to do with this information. Not sure why, but for every number that ends in 5, the element which contains the x value for the proper factorization is always in (e, 1, t-2) where t is the t value of the 1c factorization.
It's easy to factorize any number that ends with 5 by dividing by 5.. But what if there is a formula just like that one for every other digit a number ends in?
Unsure. Need to look at it in other number systems.
Has anyone investigated my hypothesis that all numbers that end with the digit 5 have a solution in e,1 (x) whose t value is 2 minus the t value of the 1c element? It worked for all instances I tested it for.
You can always just divide it by 5, but at least it's a way to do it with the VQC.
How about explaining what each method does. What is generateNthRowFromGenesis doing and what is getTFromA doing
Ok.
Wonder if this will drag on long enough for me to create a portable VQC APP.. I need one.
A negative cell exists for every positive cell because f is literally just the opposite of e (if you think about my mountains and valleys analogy). That's YUUUGE part according to Chris.
They are the same thing. You can create the same e,n cell with f and (d+1) (which is also the ceiling square root of c)
Completed the logic for generating n=0 cells
THIS IS HOW IT'S A MIRROR.
if you have (e,n,d) you have the cell.
if you have (f, n-1, d+1) you have the cell.
1 is subtracted from n because d is added to n and thus it requires one less integer to get to the large square.
Mirror. (e,n,d) = (f, n-1, d+1)
it's the same information
examples:
{1:5:12:7:5:29}
mirror=
{-24:4:13:8:5:29}
{20:1:22:4:18:28}
mirror=
{-25:0:23:5:18:28}
{-17:4:17:9:8:34}
mirror=
{16:5:16:8:8:34}
works every time.
f is a mirror of e
(d+1)^2 is the square after d^2
if n is the distance from d to (d+n)^2 (the large square) then
(n-1) is the distance from (d+1) to (d+n)^2
you see?
I'm cleaning up my code and then I will share it. It's not the formula for d it is the formula for the first a value in an n=0 -e is a perfect square cell.
Then any other element in the cell can be generated by adding (t-1) to the first a value.
Cleaned up the logic, just going to add in the generation of -e, n>0 cells (the left side)
Here's the code: pastebin.com/8Q6siWwj
That works because in the left cells the d value is incremented by one, and the e value is f. But d^2 + (-f) is not c.
Still, they are pretty much a mirror of each other.
123 = {2:51:11:10:1:123} (2, 51, 6)
123 = {-21:50:12:11:1:123} (-21, 50, 6)
123 = 62^2 - 61^2
visit (0, 50, 61)
{0:50:264:120:144:484}
sqrt(484) = 22
22^2 - 123 = 19^2
22^2 - 19^2 = 123
22 + 19 = 41
22 - 19 = 3
123 = 3*41
numbers that aren't the diff of 2 squares are just as important
>wasted
You know what we've neglected? Column 0.
What I did with 123 doesn't work with many others but I think you can get the point that it isn't a coincidence.
I don't believe anyone with malicious intent has the faith or intellect required to solve it.
We've defined so many terms and equations that you really are going to have a hard time understanding what we put out unless you interact with us, and I've spent so many hours on this because of faith.
I only got a few hours of sleep.. so hard to look at. I'm just going to analyze (0, n).
Chris said it was one column to rule them all!
Oo.. I remember this. All numbers are a fractal!
wired.com/2011/01/partition-numbers-fractals/
researchgate.net/profile/Carlo_Cattani/publication/221433042_Fractal_Patterns_in_Prime_Numbers_Distribution/links/540499ef0cf23d9765a688ab/Fractal-Patterns-in-Prime-Numbers-Distribution.pdf
I didn't understand it at the time, but Chris said that any number can be a remainder.
He said my "remainders in a sea of squares" was brilliant.
Must have hit the right note.
the code I wrote to generate e = negative perfect squares with n=0 matches the VQC.
pastebin.com/8Q6siWwj
That's just the 1*c record. What record do you start with?
e makes it all possible. It is the bridge from square to semiprime.
When you keep doing the mirror jumps as you specified you always eventually get a perfect square. I hypothesize (but haven't thoroughly tested it) that it is always this perfect square where you will find the prime factorization of the number in (-e, 0).
It didn't work for any other numbers I tried, but with 145 and 287, the t value the factorization appears in is n-t, where n and t are the values from the 1*c element.
At first it seems pretty useless to need to find the t value where it appears because you've already found the small square when you find the perfect square, but if you could find the t value where the factorization appears maybe you could skip all of that, like how if you find the t value where the factorization appears in (e,n) you don't need to find n because the x value is in (e, 1, t).
That sounds interesting. What's d^2 + n?
I made a program that carries out this factorization.
It appears there is a straight path from semiprime to prime factorization. We just have to create a wormhole and go from start to end. :^)
If you create a cell for 1*c
and then visit (t, N, t)
you find c
sometimes it's in (t, N-1, t) or (t, N-1, t+1), I'm trying to figure out the exact rule
{6:60:13:12:1:145} (6, 60, 7)
{8:127:17:16:1:287} (8, 127, 9)
{11:219:22:21:1:481} (11, 219, 11)
Discovered something neat.
There's multiple solution records in (e,1), and there's more than one n that solves the number.
145
{1:61:12:11:1:145} (1, 61, 6)
{1:1:32:7:25:41} (1, 1, 4)
{1:5:12:7:5:29} (1, 5, 4)
{1:1:882:41:841:925} (1, 1, 21)
{1:-29:12:41:-29:-5} (1, -29, 21)
123
{2:51:11:10:1:123} (2, 51, 6)
{2:1:41:8:33:51} (2, 1, 5)
{2:11:11:8:3:41} (2, 11, 5)
{2:1:113:14:99:129} (2, 1, 8)
{2:-33:11:52:-41:-3} (2, -33, 27) [not sure why t changes here]
95
{14:39:9:8:1:95} (14, 39, 5)
{14:1:19:4:15:25} (14, 1, 3)
{14:3:9:4:5:19} (14, 3, 3)
{14:1:427:28:399:457} (14, 1, 15)
{14:-21:9:28:-19:-5} (14, -21, 15)
77
{13:31:8:7:1:77} (13, 31, 4)
{13:1:8:1:7:11} (13, 1, 1)
{13:1:8:1:7:11} (13, 1, 1)
{13:1:206:19:187:227} (13, 1, 10)
{13:-17:8:19:-11:-7} (13, -17, 10)
287
{31:128:16:15:1:287} (31, 128, 8)
{31:1:65:9:56:76} (31, 1, 5)
{31:8:16:9:7:41} (31, 8, 5)
{31:1:1697:57:1640:1756} (31, 1, 29)
{31:-40:16:57:-41:-7} (31, -40, 29)
7783
{39:3804:88:87:1:7783} (39, 3804, 44)
{39:1:36469:269:36200:36740} (39, 1, 135)
{39:-200:88:269:-181:-43} (39, -200, 135)
{39:1:1077:45:1032:1124} (39, 1, 23)
{39:24:88:45:43:181} (39, 24, 23)
One of the things I tried was factorization of (e, n, t+na) instead of c itself because I thought that the smallest a for the c of t+na would also be a for c, however I discovered that this 145 is special, and that doesn't work for all numbers.
(t+na c for rsa617 has 17 as a, which obviously isn't a factor of rsa617.)
Perhaps there is a hidden pattern there. It is very easy to factorize the c from t+na, even for gigantic numbers, but it doesn't give you the right factorization.
Example:
t+na c for 145 = 145*533
the factorization of 145533 (77285) = 515457
5 is a factor of 145, so we factored 145. But this doesn't work for the other numbers. Obviously c*any number is going to have the factors of c in it, but the smallest a isn't always the right a.
But at least I know this is the right way to go, because I'm starting to see why knowing the pattern of a[t] and d - d[t] is useful - it gives you a way to go through e,1 faster, or without searching at all
The bruteforce algorithm is the simplest fastest method of factorization that we've come up with so far. There is always one path to the factors of a semiprime - down.
So all it does is decrement t in (e,1) starting 1*c's t until it reaches the right x. There are only 2 steps to the factors of 145 this way.