RSA General

Crumbs to focus on

In the (e,1) solution, d[t] = na+x

and a[t] = na

Therefore, if you can find the t value of this element, you can factor all semiprimes.

>Which column has NO gaps? [0]

>What is the pattern in COLUMN ZERO?

>One Row to Rule them All.

>A column that contains ALL and is the KEY to ALL the patterns.

>What are the patterns in COLUMN ZERO?

>If c is a semiprime, how many times does its square (c^2) appear in column zero? [5]

Why are there gaps?

The reason for the gaps may be because the VQC does not include decimal numbers. That is, because cells with gaps are the cells where the midpoint of a and b would not be a whole number. Or, worded another way, the difference between a and b would be an odd number.

There is a repeating pattern of gaps as you move horizontally from (0, n) to the right.

The pattern of gaps repeats every 2n if n is even.

The pattern of gaps repeats every n if n is odd.

>If first appearance of factor p is element t, second appearance will be at (p+1-t)

>p will be a factor of a in elements: t+p, t+2p, t+3p,…

as well as in elements:

>p+1-t, 2p+1-t, 3p+1-t,…

take d from all values of d[t] at (e,1) and there is a known pattern of (n-1) as factor in these values of d[t]-d that is different (increasingly) from the pattern of factors of n in a[t]

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

Let me break that down.

Find every value of d - d[t]

There is a pattern of (n-1) being a factor.

Find every value of a[t].

There is a pattern of n being a factor.

The pattern in the first group of values is "increasingly different" from the second. We must catalogue these patterns.

Code

C#

BigInteger Square Root —— https://pastebin.com/rz1SdACZ

Generate Bitmap within original code —— https://pastebin.com/hMTtJF6E

More on generating a bitmap with the original code —— https://pastebin.com/JUdtehb4

Generate the large square for e and t —— https://pastebin.com/nbjs2kz4

Original VQC code —— https://pastebin.com/XFtcAcrz

How to run VQC code on Linux —— https://pastebin.com/6HnN7K5X

Unity Script —— https://pastebin.com/QgAXLQj3

Unity Script 2 —— https://pastebin.com/Y38nVWgT

Java

VQCGenerator w/ Bitmap —— https://pastebin.com/Dgu9aP1h

VQCGenerator —— https://pastebin.com/VMRnkXFP

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

NodeJS

BigInteger Library and Sqrt —— https://pastebin.com/y8AXtFFr

Python

College Anon's code —— https://pastebin.com/d8xZZnm0

Create the VQC —— https://pastebin.com/NZkjtnZL

3D VQC —— https://pastebin.com/vdf8SpYt

3D VQC (v2) —— https://pastebin.com/wZM5Thzu

Fractal cryptography —— https://pastebin.com/XuN4U7Dv

Generate cells for a (and more) —— https://pastebin.com/iAizgLFF

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

Generate genesis cell —— https://pastebin.com/GKzcCpMF

Generate positive AND negative genesis cells —— https://pastebin.com/9ixjRyxt

Calculate variables based on e and t —— https://pastebin.com/4s6McdbN

Get A and B from C and N example —— https://pastebin.com/s0SZ9BNF

VQC + t —— https://pastebin.com/Lgufk0db

Rust

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

Create Bitmap using the VQC Generator —— https://play.rust-lang.org/?gist=c2446efeec452fe14e1ddd0d237f4173&version=stable

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

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

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

Factorization methods (Java)

Binary search for i —— https://pastebin.com/TAt5bDsR

Count down from t of 1c element —— https://pastebin.com/xxYa946V

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

Calculate factors using -x jumps —— https://pastebin.com/gKX9GW9r

Previous Threads

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

Videos on cryptography —— https://pastebin.com/9u3hwywe

RSA #5

>>11

>>12

>>17

>>18

>>19

>>20

>>21

>>23

>>24

>>25

>>26

>>27

>>28

>>29

>>30

>>31

>>32

>>33

>>495

>>699

>>709

>>710

RSA #6

>>1099

>>1380

RSA #7

>>1882

>>2388

>>2389

RSA #8

>>2990

>>2991

>>3381

The best thing I envisioned for keeping track of crumbs was making this but for the newer crumbs. Just never got around to it.. I'll see if I can work on it tonight

>>3390

Yes, you need to analyze odd and evens. Notice how, in the VQC, a lot of places are a sequence of odd and even numbers?

>>3393

Is it still a search algorithm?

>>3395

That's similar to what I just found.

Notice how all d - d[t]'s are even and all a[t]'s are odd.

>>3398

gcd(20, 25) = 5

>>3400

{1:1:32:7:25:41} (1, 1, 4)

↓

{1:5:12:7:5:29} (1, 5, 4)

Nvm, got it to work. Does your implementation work for 123?

>>3404

GCD is the only one this is always a factor of c.

D-NewX and NewA at the end are only sometimes factors.

So, got it to work for every number, but it may not fast enough.

Took too long on

856005528343335436096708147408503565008227

and

111086395036901246938296321

Factored 4447786245211932229 in a few seconds. Still have it running on rsa300 if it makes you feel better.

>>3408

No.

Here is the (fixed) code: https://pastebin.com/70GJSMrv

Again, I think you are going on the right path, since this code was derived directly from the a[t] vs d[t] - d hint.

>>3409

Even with that cold hard fact that we haven't beaten GNFS (though with proper use of our research one could most likely develop a faster algorithm), I still have faith that we'll find the solution, because once we make the jump from search algorithm to complete solution, it will go from exponentially slow to O(1).

Calculation would have the same number of operations for every c, or just about. Amazing thought. (Because the only time complexities lower than log n are log log n and O(1)), and Chris said LOWER than log n.

It's going to be a miraculous jump when it goes from searching to calculation. So hold out.

Found this while ACTUALLY FINISHING VQC MAP 2

What the actual fuck, kek

I'm working on the new VQC map.

"You all amaze me."

>>3432

Conf_goProgMathAnon_P_build_that-shit#

RED1_RED2_College_Anon_build_solve.

Q

Establish comms for when the VQC takes the internet with it.

>>3438

It's like this:

Anon msgboard -Private

Private -Uncomped comms

Also, the new VQC map is MASSIVE.

I'm going to put the rest of the crumbs in it.

14999x10310

I found a lot of instances of Chris triggering people when I searched the archives.

>>3447

That just gives it more credibility if HE believes that. Hitler was the one who originally researched Agartha and that is why I refuse to dismiss it.

>>3451

https://archive.fo/8upab

2018's your lucky year.

YUUUUUUUUUUUGE!

>>3454

Eat me!

I was comparing a[t] and d[t]-d values for 91, 123, 133, and 145 and some profound discoveries hit me.

Since d[t]-d values always seem to have the opposite parity (odd or even) of the a[t] values, then that means that for any e, we already know the parity of the d[t] - d values.

The n values for a given c appear to all have the same parity. EX:

n for 145 = {5, 61}

n for 147 = {2, 62}

n for 287 = {8, 128}

It'd be great if we could confirm these, because if we knew the parity of n that would be a huge improvement to our algorithms. Remember when Chris said Decision Tree? DECISIONS IMPLY A BINARY CHOICE. ODD AND EVEN!

True or false tree.

Boolean tree.

1 — is e = 0

2 — parity of e (is odd or even)

3 — ???

>>3459

>>3458

It has to be parity. That's what jumps out to me.

But I haven't yet related the parity of a[t] and d[t]-d's with e (not an obvious pattern), so I haven't yet been able to come up with a good idea of what the third decision is. Though if we are able to know for certain the parity of the n we want that would be HUGE.

>>3466

Glad you read the crumb map. I don't think I've ever felt this close to the solution. I feel like I'm only lines of code away from it. If you've read all the crumbs you'll see he said he might not even exist (which I'm guessing is referring to his name), as well as when he asked "who is CC" as if it refers to someone other than himself.

>>3464

Yeah, but the 2 decisions he listed are booleans. One or the other. And I've been iterating through so many instances of binary in my head. And like I said, knowing the parity of n AT LEAST halves your search space.

Topol was right. My phone could hardly render that whole image and it took some major tweaking to work. Perhaps I could split it into parts or something.

So, it looks like we can know the parity of the n we want for semiprimes who do not contain 2 as a factor. (Basically the numbers we need to know how to factor.) I have attached both n values to a list of these numbers. You will see that both n values have the same parity.

c——{N, n}

9——{2,0}

21——{7,1}

25——{8,0}

33——{12,2}

35——{13,1}

39——{14,2}

49——{18,0}

51——{19,3}

55——{21,1}

57——{22,4}

65——{25,1}

69——{27,5}

77——{31,1}

85——{34,2}

87——{35,7}

91——{37,1}

93——{38,8}

95——{39,3}

106——{43,17}

111——{46,10}

115——{48,4}

119——{50,2}

121——{50,0}

123——{51,11}

129——{54,12}

133——{56,2}

141——{60,14}

143——{61,1}

145——{61,5}

155——{66,6}

159——{68,16}

161——{69,3}

166——{71,30}

169——{72,0}

177——{76,18}

183——{79,19}

185——{80,8}

187——{81,1}

209——{91,1}

221——{97,1}

247——{109,1}

253——{112,2}

287——{128,8}

So, what is n for rsa617? I don't know but it is an even number!

>>3512

c mod 4 tells you whether or not c is a difference of squares. If c%4 == 2, c is not the difference of squares. If it is any other number, it is.

n's for rsa100 (same parity theory):

761302513961266680267809189066318714859034057480651323757098846024549192056136964455981270339102876

14387588531011964456730684619177102985211280936

I find it interesting that his purported initials are CC and he referred to c^2 as cc.

"What did Einstein say about co-In(c)iden(c)e???"

God's way of staying anonymous is what he said.

"I might not EVEN exist."

"No fear for EXPRESSION."

Even, expression? Math words.

"C root of D"

Read THIS carefully.

IT is important and will be my LAST message on 8ch but NOT my last message.

You can follow ME on Twitter.

What you have ABOVE and HERE is over 95% of what You need.

Over 95%

The rest of what MATTERs is You and (you)

My name here is VQC.

Victory means Peace,

Questions mean Release,

Chris is my name,

God+/-speed

>Yes, Fermat's Last Theorem can be proved using the closure of the product of the sum of two squares. If higher dimensions existed, the product of the sum of two squares would not be closed.

a+b = 2i

>>3523

>>3524

>>3525

Look at these. I think this may be related to the decision.

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

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

I don't know who derived these, I had them in the batter at one point.

if (e is even) n = (floor_sqrt(c + (2 * t)^2)) - (d)

if (e is odd) n = (floor_sqrt(c + (2 * t - 1)^2)) - (d - 1)

if (e is even) (d + n)^2 = (2t)^2 + c

if (e is odd) (d + n)^2 = (2t - 1)^2 + c

if (e is even) (x + n)^2 = (2t)^2

if (e is odd) (x + n)^2 = (2t - 1)^2

>>3530

Chris explicitly said binary tree. What decision happens after?

>>3534

I generated this. It's something Chris said to make.

>>3521

>>3536

It's 3 maps put together. Orange is where e is even, green is where e is odd, and the last is both of them together.

Never realized it, but yeah, 2*i = a+b.

>>3538

Hitler nihil mali fecerit

Just wanna say these are probably erroneous. Google can hardly get living languages right so it's probably taking a shot in the dark when it comes to a dead language.

>>3549

For any semiprime the t value of the c record is bigger than the t value of the prime solution in e,1. So the straight path to factorization is to generate (e, n, t) for 1*c and then go to (e, 1, t) and iterate downwards (by lowering t) until you reach the solution record where x is the x that gives the factors of c.

So, a solution would be finding a way to make that fast enough/skip it entirely.

>>3553

Am gonna generate a list right now of t diffs.

Iterating t is a smaller search space for factorization than iterating n, but it still is probably going to take several years, so it needs a massive improvement.

What follows is a similar list, but of their t values, to attempt to illustrate our pattern. Similar to N vs n, I'll refer to the t value from our start point as T, and the one we want as t, and add their differences. The starting point and factors will also be added, so a pattern can be deduced.

Example:

(1,1,6) starting point for 145

(1,1,4) solution element

c——{T, t, T-t} {E:N:D:X:A:B} a*b

9——{2, 1, 1} {0:2:3:2:1:9} 3*3

21——{2, 1, 1} {5:7:4:3:1:21} 3*7

25——{3, 1, 2} {0:8:5:4:1:25} 5*5

33——{3, 2, 1} {8:12:5:4:1:33} 3*11

35——{3, 1, 2} {10:13:5:4:1:35} 5*7

39——{3, 2, 1} {3:14:6:5:1:39} 3*13

49——{4, 1, 3} {0:18:7:6:1:49} 7*7

51——{4, 3, 1} {2:19:7:6:1:51} 3*17

55——{4, 2, 2} {6:21:7:6:1:55} 5*11

57——{4, 3, 1} {8:22:7:6:1:57} 3*19

65——{4, 2, 2} {1:25:8:7:1:65} 5*13

69——{4, 3, 1} {5:27:8:7:1:69} 3*23

77——{4, 1, 3} {13:31:8:7:1:77} 7*11

85——{5, 3, 2} {4:34:9:8:1:85} 5*17

87——{5, 4, 1} {6:35:9:8:1:87} 3*29

91——{5, 2, 3} {10:37:9:8:1:91} 7*13

93——{5, 4, 1} {12:38:9:8:1:93} 3*31

95——{5, 3, 2} {14:39:9:8:1:95} 5*19

106——{5, 4, 1} {6:43:10:9:1:106} 3*51

111——{5, 4, 1} {11:46:10:9:1:111} 3*37

115——{5, 3, 2} {15:48:10:9:1:115} 5*23

119——{5, 2, 3} {19:50:10:9:1:119} 7*17

121——{6, 1, 5} {0:50:11:10:1:121} 11*11

123——{6, 5, 1} {2:51:11:10:1:123} 3*41

129——{6, 5, 1} {8:54:11:10:1:129} 3*43

133——{6, 3, 3} {12:56:11:10:1:133} 7*19

141——{6, 5, 1} {20:60:11:10:1:141} 3*47

143——{6, 1, 5} {22:61:11:10:1:143} 11*13

145——{6, 4, 2} {1:61:12:11:1:145} 5*29

155——{6, 4, 2} {11:66:12:11:1:155} 5*31

159——{6, 5, 1} {15:68:12:11:1:159} 3*53

161——{6, 3, 3} {17:69:12:11:1:161} 7*23

166——{6, 5, 1} {22:71:12:11:1:166} 3*81

169——{7, 1, 6} {0:72:13:12:1:169} 13*13

177——{7, 6, 1} {8:76:13:12:1:177} 3*59

183——{7, 6, 1} {14:79:13:12:1:183} 3*61

185——{7, 5, 2} {16:80:13:12:1:185} 5*37

187——{7, 2, 5} {18:81:13:12:1:187} 11*17

209——{7, 2, 5} {13:91:14:13:1:209} 11*19

221——{7, 1, 6} {25:97:14:13:1:221} 13*17

247——{8, 2, 6} {22:109:15:14:1:247} 13*19

253——{8, 3, 5} {28:112:15:14:1:253} 11*23

287——{8, 5, 3} {31:128:16:15:1:287} 7*41

7463——{43, 35, 8} {67:3646:86:85:1:7463} 17*439

93801——{153, 152, 1} {165:46595:306:305:1:93801} 3*31267

940683——{485, 484, 1} {1722:469373:969:968:1:940683} 3*313561

2611447——{808, 2, 806} {3222:1304109:1615:1614:1:2611447} 1613*1619

44231413——{3325, 544, 2781} {8913:22109057:6650:6649:1:44231413} 5563*7951

173648257——{6589, 740, 5849} {14928:86810952:13177:13176:1:173648257} 11699*14843

6867225401——{41434, 4805, 36629} {119977:3433529833:82868:82867:1:6867225401} 73259*93739

10967535067——{52363, 2, 52361} {209442:5483662809:104725:104724:1:10967535067} 104723*104729

867072408247——{465584, 22940, 442644} {426358:433535272957:931167:931166:1:867072408247} 885289*979423

15778598254603——{1986114, 257299, 1728815} {2970619:7889295155074:3972228:3972227:1:15778598254603} 3457631*4563413

81311001417221——{4508631, 64212, 4444419} {5475100:40655491691350:9017261:9017260:1:81311001417221} 8888839*9147539

215303158862641——{7336606, 385003, 6951603} {8465697:107651564758109:14673212:14673211:1:215303158862641} 13903207*15485863

237051716747561——{7698242, 19017, 7679225} {27978272:118525842977298:15396483:15396482:1:237051716747561} 15358451*15434611

Added some huge semiprimes just to give an idea of how far t is from T in a practical setting.

>>3561

If the factors are close together, then t is closer to t=1.

If the factors are far apart (like 3*313561) then t is closer to T.

So, as T-t increases, b-a decreases.

I've found the crumb we need to analyze.

>>3462

Review the pictures here with these formulae in mind.

So, in the starting point in (e,1), the d[t]-d value is (N-1)1, and the a[t] is N1.

And at the solution record, the d[t]-d value is (n-1)a, and the a[t] val is na.

We have a new way to iterate.

Find first appearance of factor of the factor of our N.

Calculate formulae for appearances of its multiples.

Iteration from t=1 becomes a tree instead of blind iteration.

Got muh prototype

Working pretty nice so far will improve tomorrow. If you want the algorithm it basically calculates d[t]-d for (e,1,1) (then takes absolute value of it) and then iterates over the formulae described in the crumb, and tests the x values produced.

End result are negative values of a and b.

>>3568

Yep, it GROWS exactly like he said. It's still a search algorithm but it's exactly the kind of improvement I was looking for - it's able to skip many of the elements we don't want when iterating t.

Still kinda wondering why this works.

>>3578

It gets all semiprimes in a few steps up until around 7463 and fails after that. I don't know why.

O(log n) is still less than a second, or a few seconds, so it doesn't really matter.

So, I'm probably going to make a replica of this tree soon. Until then, here's the code I had. I really have no idea why it worked for the numbers it did.

https://pastebin.com/nD4F7AFa

This tree is actually an amazing idea, though.. Just keep going through the remainders and square roots until you hit a factor.

Let's see if we can get to a factor of 145 by going down this tree shape.

145 = 12^2 + 1

12 = 3^3 + 3

3 = 1^2 + 2

1 = 0^2 + 1

Hmm, add 12's remainder and its remainder's remainder? That would give you five. Let's try another.

287 = 16^2 + 31

16 = 4^2 + 0

31 = 5^2 + 6

6 = 2^2 + 2

2 = 1^2 + 1

1 = 1^2 + 0

41 = 31+6+2+1+1, so this COULD work..

>>3587

Try making this into a recursive program.. see if it reaches factors of c. Gotta tend to my business.

So, got a prototype running. It's not fast enough yet, but it's getting there.

>>3618

Yes please

>>3628

You don't have to bother with that. Download a python java linker

>>3630

That's very useful. So it works for PGP?

In regards to implementing the tree, it's not so easy. I wrote some methods that added up the remainders like in >>3587 but it's too slow for higher numbers.

Also, holy shit, the House Intelligence Committee voted to #ReleaseTheMemo.

>>3637

Glad I didn't have to implement that. And you're right, it's so asinine that they wouldn't have functions for that. There are also ways to crack public keys due to noobs not configuring stuff right. If they have a bad RNG you can test some factors from similar keys that have been cracked against them to see if they are a factor. There was a professor who did this and he cracked a ton of them.

>>3639

How so? Mathematics is not illegal. Academics have always tried to crack it. Though they never actually get anywhere.

>>3641

I have no problem with starting some shit. Cryptocurrency needs to be shown as the house of cards that it truly is. Do you think bitcoiners will become distrustful of the genuine security of crypto when we get a working algorithm of this tree, or do you think they will go even further into their delusion?

>>3650

2^2 + 2 = 6

The tree was recreated using 12/2 instead of 12 because 12 as the d branch does not reach a factor.

Getting it yet? We just have to build a tree smart enough to automatically do this.

If rules for when zeroes are to be trimmed can be ascertained, 7463 in particular would take about 3 steps.

>>3648

This is an amazing graphic.

If we master that tree we can crack all the RSA numbers!

>>3657

Yes I did.

>>3659

If you find one factor, you win.

c/a = b

But yeah, generally it seems adding up the leaves on the bottom gives a.

Algorithm would basically generate the entire tree, and if it doesn't find a factor, it needs to trim the zeroes in different places until the leaves at the end add up to the factor.

>>3660

Given how fast square roots are, I'd say there's hardly an optimization issue in generating the tree.. so once the algorithm is smart enough, it's over.

>>3648

Say, just how long did it take you to generate the rsa100 tree? And what language?

>>3662

The general structure of how the solution would be is known. It needs to be automated and perfected.

>>3664

So, with optimization & implemented in Java it would be stupendously fast to generate the tree, and could be done hundreds of times in a second. Looking pretty good so far.

>>3667

Yes.

>>3669

You can iterate.

>>3675

That's what it showed me for the numbers I tested. It's not going to be a piece of cake because I don't know the rules behind when you are supposed to divide by two.

>>3686

How would that be implemented, and can you send your code?

>>3688

How did you generate >>3648 then?

Ever notice that any number whose d value has the same parity as its e value is even?

>>3695

How are you making those images?

Which branch you are on is important.

Finally factorized something with this bloody tree.. I'm happy now

I created a program that generates the d branch separately because I recognized a pattern where, whichever variable is even (d or e) is the branch where everything is trimmed.

This truly is log n if I ever saw it. Instantly generates the tree even for gigantic RSA numbers.

>>3712

Depends which one is initially even or odd.

I need that tree code.

Mine isn't very good.

>>3713

One universal pattern is this, d and e will never have the same parity for a semiprime, and the branch that starts with an even number is the one that needs to be trimmed.

>>3716

I don't know. When I was doing it by hand I just kept remaking it until it gave a factor. That's why it isn't solved yet.

>>3718

I made tree generation stop when every number on a level of a branches is less than or equal to 3, because the sum of their square roots and remainders is always the same if you branch out any more.

E.G

3 = 1^2 + 2

2 = 1^2 + 1

1 = 1^2

The sum is the same as the original number, so it can't branch any more after that.

>>3718

For the 481 example I just did what worked. If all the zeroes were trimmed it would start with 5 and not 10 (40/2²)

{e:n:d:x:a:b} + c makes the VQC a 7-dimensional grid. We've been analyzing an object with many dimensions that has been reduced to a 3 dimensional object.

Now if only I was a 7-dimensional being.

hooktube.com/watch?v=Q_B5GpsbSQw

hooktube.com/watch?v=eyuRLmCphHc

hooktube.com/watch?v=S-yRYmdsnGs

>>3725

And you may not notice, but all 7 coordinates can be encoded into 3 coordinates.

(e, n, t) -{e:n:d:x:a:b:c}

So you have 7 dimensions in 3.

>>3727

hypernom.com

>>3737

The fight really isn't over. They're going to try to make it a redaction fest.

>>3744

As he stated, it gets even more complicated to factor larger numbers. When you try to sum the last levels for large numbers as I did in the examples, the number is too small to be a factor.

7463 = 228^2 - 211^2 (17*439)

7463 = 3732^2 - 3731^2 (1*7463)

7463 appears in (67, 3436, 43).

7463 appears in (67, 142, 35).

It's interesting that the t value it first appears in is 43, and the first branch of the right factorization tree starts with 43 (86 / 2). The t difference is 8, which also appears in the tree.

I'm going to contribute to putting together what we know about the grid tomorrow.

There are almost a hundred different concepts this touches upon.

Hyperspace, difference of squares, square roots, golden ratio, platonic forms, etc.

Something interesting. Ever wonder why diff of squares is always an odd number?

Every square is a sum of odd numbers.

4 = 1 + 3

9 = 1 + 3 + 5

16 = 1 + 3 + 5 + 7

25 = 1 + 3 + 5 + 7 + 9

36 = 1 + 3 + 5 + 7 + 9 + 11

49 = 1 + 3 + 5 + 7 + 9 + 11 + 13

So, when you are taking the difference of squares, you are really just taking elements out of this summation.

9 - 4 = 5

16 - 9 = 7

25 - 16 = 9

36 - 25 = 11

49 - 36 = 13

Perhaps it is here where a solution lies. To solve RSA one needs to master the number of line of squares, and thus, the set of odd numbers. It doesn't sit right with me that after all these years, this hasn't been done yet.

The RSA problem is basically to find the two different combinations of squares whose differences make the number. The amount of combinations of squares that can be made corresponds to how many factorizations a number has, for odd numbers.

For 145, it's 73^2 - 72^2. These are easy to calculate for any number, becayse 1 is always a factor. And because these two squares are adjacent, the combination of them simply makes 1 * c. So, when you look at a different factorization, the squares are never going to be adjacent.

145 = 17^2 - 12^2.

17^2 = 1 + 3 + 5 + 7 + 9 … + 33

12^2 = 1 + 3 + 5 + 7 + 9 … + 23

So, again, when you take the difference of squares you are just removing elements. Thus, factorization can be restated as finding what two odd sums' differing elements.

To factorize, all you have to do is find the sum pictured. To calculate the smal square, simply calculate the sum all the way to the first element, and calculate the sum all the way to the last element to make the big square.

>>3749

Finding what two sums' differing elements make c*

If we can put all of this together, the problem can be solved.

>>3751

Beautiful!

>>3754

The (e, 1) pattern you referenced is what I used to make a factorisation prototype algorithm. I posted the source earlier, only worked for small numbers.

>>3761

This is hard to read. There is too much data in one place.

>>3766

I'll try that out. How do you know when it's the correct x value?

>>3766

Also, did you trim the d values or just leave them as is? (Trimming = divide by 2 until odd)

>>3769

What numbers did it work on?

>>3697

Whoever this poster was, could you generate that tree image (the long one that shows the whole thing) for 2^61 - 1 and 2^521 - 1? They are Mersienne primes.

>>3774

I just did some research into General Number Field Sieve and I realized something..

When we finish the log n algorithm,

There are gonna be a LOT of pissed off number theorists, mathematicians and cryptographers.

>>3776

There are people that have spent probably a large portion of their entire life on sieving algorithms.

Here's a method for generating triangular numbers: https://pastebin.com/jPTTpgjE

For some reason Wikipedia made it look complicated by using Sigma Notation but T(n) is just (n(n+1)) / 2

>>3778

I'm not malicious, but I'm probably participating in this because I think bitcoiners are faggots.

>>3782

Thanks for doing the research. This might be related to the pattern Chris described. Did you look into it any more beyond that?

>>3784

But the Lebensraum was faked.

New hint from VQC:

Column 0 is just as good as row 1.

>>3795

So how does that help?

>>3793

Just found this. ;>

>>3825

Time complexity is small. Tree generates in milliseconds for rsa2048.

>>3807

Thanks. Haven't came up with a use for it yet, but we've just started studying these types of trees.

>>3832

Enough of that. You're ruminating on how a slow a bullet is compared to a turtle.

>>3838

God's with us. Through Him I am able to form patterns from chaos. Through Him I am able to help all of you.

If you love God, he'll solve this in the most beautiful way and he'll do it with your hands.

>>3841

Logarithmic primality test.

2 birds; one stone.

>>3843

Want to see something neat?

Draw the d,e tree for some c.

Then redraw the tree with each number replaced with its triangle number.

>>3845

T(n) = (n(n+1)))/2

And the inverse function =

(sqrt(8*T+1) - 1) / 2

Where T is your triangular number.

Now repopulate the tree with the inverse function of every value in the original c tree and find where a factor appears.

……………287

…..16………………31

……………23

…..5……………….7

287 = 7*41

I'm not saying a factor is going to appear every time.

But they do happen to just "show up" in the tree.

So we need to find every possible way that makes them show up to see the underlying pattern.

>>3859

My general criteria was stopping when every value on the level was less than or equal to 4. But sometimes reached a factor before that.

I'm mad at myself for not finding this 2 months ago.

It literally didn't show up in Jewgle search.

Chris Curtis - Wikipedia

https://archive.fo/UJy1M

And now there's random people on 4 mentioning Chris.

What is happening

>>3864

https://boards.4chan.org/pol/thread/158983713#p158985726

>>3868

Come on. You already have hints that will lead you to the solution.

THESE ARE YOUR HINTS.

>>3870

No, I haven't, I just went in the right direction with these triangle functions.

https://en.wikipedia.org/wiki/Square_triangular_number

This article demonstrates how squares are made from triangle numbers.

The square of a number is equal to its triangular number added to its last triangular number.

Namely, n^2 = T(n) + T(n-1)

If you were to attempt to apply this to our equations, you would have something like this.

d^2 + e = c

T(d) + T(d-1) + e = c

i^2 - j^2 = c

(T(i) + T(i-1)) - (T(j) + T(j-1)) = c

Interesting to note, that n-1 appears in the hints,

and T(d+n) + T(d+n-1) would be the large square.

Anyone else try to apply the VQC to different problems lately?

If you forget the equations for each variable then what you're left with is a geometrical object that

-has coordinates

-has variables derived from each coordinate

-has 1:1 correspondence from element to set of coordinates

And then if you fill those in with other mathematical functions, you could apply it to anything.

So, really all you'd have to do to apply it to other cryptography and math problems is map coordinates to variables with equations.

>>3878

Yes, that observation works as well.

n^2 = 2*T(n-1) + n

I feel like this can be used somewhere..

145^2 = T(144) * 2 + 145

>>3881

No, those identities don't work. They only work for perfect squares. You could add the remainders into the equation.

>>3883

Just a fancy word for equation. It means that

"Function a = function b + this and that"

>>3884

Basically that the equation is always right. So like many of the equations we use for the VQC.

>>3891

@ChrisRootODavid

>>3894

Nope, not at all. Takes hours to create keys that large.

>>3912

Add triangle number functionality to the application. Chris implied it had something to do with finding x+n

>>3914

If you think about it, c is a rectangle.

>>3918

If na is a triangle number, which triangle number is it?

E.g if T(n) = n(n+1) / 2

what is n

>>3865

I was trying to replicate your code and I had no clue what was going on regarding the string manipulation.

Could you clarify lines 108, 130 & 134?

https://pastebin.com/CZy8f0HD

>>3925

What about T(c)?

>>3927

Fascinating. I wonder what relation triangle numbers have to actual triangles.

>>3928

Besides the fact that they are the result of arranging integers in an equilateral triangle.

>>3931

Error? What error?

>>3939

Yeah. Now, the FINAL piece necessary for our tree algorithms to work is figuring out what we have to do to each value on our tree to make it spit out x or x+n.

If any of you are frustrated that he didn't come back onto the board, don't be. It's important for us to step through us ourselves. It is a million times more rewarding and meaningful to go through the steps of solving this on your own. I'm already learning how to apply the VQC to other maths, and before this I didn't even like math.

>>3944

>>3943

The growth of n-1 as a factor in d[t]-d is similar to the growth of n as a factor in a[t]

Use the equations in >>3564 with both.

>>3948

It'd be great at solving any unsolved problem in mathematics you can think of.

>>3961

This has been stated from the beginning. The roots of the squares added together is b, and their difference is a.

>>3964

How behind are you? Finding x+n solves c. (x+n)^2 + c = (d+n)^2

x+n = j

d+n = i

i+j = b

i-j = a

You check if a number is x by subtracting it from d and checking if it is a factor of c. You check if a number is x+n by squaring it and adding it to c, if the sum is a perfect square, it is the correct value of x+n. You are looking for one or the other in the tree. You are to trim every even value until it is odd by repeated divisions of 2.

>>3972

I find it VERY interesting that 14 and 11 show up and the x+n you're looking for is 13.

>>3974

zip it up

uguu.se

>>3976

Do you want to be babied through this or something?

>>3978

If that's the purpose, don't you see the reason why he would underestimate our progress and then want to let us go farther ourselves?

It's not hard to post a hint on a board of something you know forwards and backwards; he worked on it for ~7 years. He clearly values the importance of us working throughout it ourselves.

So, of course he would go back on his word in giving us a hint that could potentially complete the log(n) algorithm.

I also believe that the fact that he walked us through the VQC instead of giving us this tree which doesn't have an (immediately) clear connection, (though you can see how it was derived from the VQC if you note the appearance of fractals) is because he devised a specific plan for people to work through it exactly as he did. Except with a VQC that was improved from the original version.

I just don't see why anyone would want any more hints. There's a million things to discover from these mathematical devices, they've probably never been studied in this way.

>>3983

And you don't discover much if the solution is spoonfed to you.

>>3987

From the beginning he has stated that he had provided all that was necessary to solve it.

Guessing we didn't put 2 and 2 together as easily as it looked. But it's a lot of 2's and 2's to put together to surmise that the solution to this would be fractals and triangular numbers.

Replicated PMA's recursive tree algorithm in Java. It's self-contained and ready to run.

https://pastebin.com/VZnQQR2i

>>3990

I changed the order of it to e and d instead of d and e so you can just go up the tree and see that 3^2 + 3 = 12, 12^2 + 1 = 145, etc.

I programmed in a version of the tree that checks for x and x+n values, as Chris has initially described the solution would work. It doesn't work for large ones (probably because they have to be extracted out of the tree in a different way than just checking values) but if you enter some random values from 1-400 you'll see it does find the factorization for quite a lot of them. It needs to be optimized a bit more before it's able to instantly check the rsa-sized trees.

https://pastebin.com/0jPr3RrE

>>3992

>(1)

>>3997

Let's make that 179 just for you

>>4004

You chec the DOW lately? Whichever Jew it is they're going all in with the sabotage, I can't see a reason for the market to be crashing like this.

>>4042

Sure thing. Your semiprime exists between two squares, they're the two mountains, and every number between that is differentiated by it's remainder. You can reference a number by the first square, d^2 and e, it's distance or you can reference a number by it's 2nd adjacent square, (d+1)^2 and it's distance from that, equal to f.

So all your numbers exist between two squares.

>>4043

You can denote c as the distance from any square. I haven't looked into whether that gives any insight.

145 = 1^2 + 144

>>4045

Yes, exactly.

>>4077

Hmm…

>>4081

There are plenty of ideas. Have you analyzed (0,n)? The significance of n and n-1 becomes clear.

>>4084

What do you mean?

221 is 14^2 + 25 and n value is 1

c will either appear in (0,n) or (0,n-1). That's the pattern I've seen

>>4137

You don't need to search. Calculation is possible

Good morning to all! Fresh bread.

I included my self-contained recursive tree generation code.

>>4140

>>4141

na and nb for any c are n elements apart.

You might find my traversal code useful.

https://anonfile.com/TeH6q3d8bd/VQCGUI_v2.7z

The source code is included, I only put it in a JAR because there are a lot of classes and it has a neat theme

Example:

145 = 5 * 29

55 is 5 cells apart from 529 in (1,1).

>>4116

Will do. We've discovered a lot. For example, the parity of n is known. Plus we've invented a ton of new algorithms, though none (yet) have beaten sieving. Another is that if gcd(e,d) isn't 0, it is a factor of c.

>>4147

1* I mean. I'm going to love explaining to the cryptographers how it works when we find the solution.

>>4149

Yeah, I think so. There's gonna be a LOT of heat, probably in the news too.

>>4149

We need to say it loud and clear, ANYONE can be a GENIUS!

I will definitely make an explanation of the VQC, fractals, the tree, and the final piece that ties it together when we find it.

Needs to be a picture too, so it spreads far and wide :-)

>>4154

We're educators now? I love it

>>4157

You can create (e,n,t) w/ pen and paper.

You can calculate (e, N, T) w/ pen and paper.

You can calculate (e, 1, T) w/ pen and paper.

No programming necessary. I'll write down the equations in a sec.

>>4162

>>4171

Open the catalog.

>>4170

I've already seen somewhat of how 0,n and e,1 are the same. You'll see that (0,n) or (0,n-1) contains c, and e,1 of course has the pattern of factors of n and factors of n-1.