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

>>3363

Posting this again since you forgot again

>>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

>>3382

A picture will probably look better than unformatted text, but until then at least this means you don't have to wait for 8 751-post threads to load.

Repost

>>3385

>"The solution is a decision tree. The first decision is whether remainder is zero. The second decision is whether the remainder is odd or even. What's the third decision?"

When did he say that? Link?

>What's the third decision?

At the top of the decision tree, if e = 0, it's a square, so it's not an RSA number (right?). If e != 0, we need to find n or x, which apparently relies on whether it's odd or even. In the second decision, whether it's even or odd determines what t is, but then to calculate t you need to know x, and if you knew x you'd know a. So do we know any other calculations that require knowing if e is even or odd? Otherwise, should we be using this to find relationships?

>>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?

>>3390

We can already find X it is the first entry where the GCD of (d(e,1) - d(e,n)) and a(e,1) is not equal to 1. Moreover this GCD is a factor of the original number.

>>3392

The even E and odd E have to do with where you start your X value. For even E, you start with X=0, and with odd E you start with X=1. You calculate your first D by the equation:

D = (X*(X+2) + E)/2

Also this E even or odd has to do with how much you shift D by each successive entry. If E is even, then your shift starts at 4, if you're at an odd E, it starts at 6. With each successive entry in the cell, you increase the shift by 4.

Ex: (odd E)

D1 = D0 + 6

D2 = D1 + 10

D3 = D2 + 14

So those are your decisions

>>3393

Is it still a search algorithm?

>>3394

You just iterate through the values in the e,1 cell so I guess it's a search. The thing is it works with every D value (including D=0) so I've been thinking that we may be able to cancel out D entirely from the equation or generating a system of equations for multiple D's to then simplify it but I haven't figured out exactly what I'm doing with that

>>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.

>>3397

Look at the first time where they have a gcd that isn't one

>>3398

gcd(20, 25) = 5

>>3399

Which X is that? (the correct one)

Also what is the GCD? (the correct factor)

>>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?

>>3402

def getGCD(A, B):

if B == 0:

return A

else:

return getGCD(B, A % B)

def factor(number):

C = number

D = int(math.sqrt(C))#can be any number s.t. d^2 < C

E = C - D*D

newX = E%2

if(newX == 1):

dShift = 6

else:

dShift = 4

newD = int((newX*(newX+2)+E)//2)

newA = newD - newX

GCD = 1

dCand = newD - D

while(GCD == 1):

newX += 2

newD += dShift

dCand += dShift

dShift += 4

newA = newD - newX

GCD = getGCD(dCand, newA)

print(D-newX, GCD)

#return GCD

#newA = D - newX

#If we switch up the D value, one of these might be negative but it will still be a factor

return newA

This is all the Python code. I switched up the loop to make it fewer calculations but there may be a better way.

>>3403

Yes

>>3404

Also I've tested it for products of the first 50 primes and it solved them all

>>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.

>>3406

Are these results significantly faster than normal methods for a number of this size?

>>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.

>>3410

You are one of the most faithful people I have ever seen.

>>3393

>you increase your D by 4

Are you sure that 4 is constant or do you think maybe the reason it's not working yet for big numbers is that the offset (maybe this is what Chris was talking about) changes depending on the cell? How did you get 4? I noticed last thread when I was analyzing c^2 in the 0 column (nobody else seemed to care about what I was doing so I don't know if anyone will know what I'm talking about) that when c is the square of a semiprime (so the square of what we want to factor), the infinite set starting from (a, b) = (1, c^2) has a beginning d value and it increases at a constantly increasing rate throughout the infinite set (i.e. for (0, 200), d = 21, 44, 69, 96, 125 - this is +23, +25, +27, +29), but the start values and increase values change depending on the cell. The value of x in these sets increases just with the one increase value for each set (same example, x = 20, 40, 60, 80 etc) and the start value and increase changes from cell to cell too. I don't know how the beginning value or the increase values are determined, but if we're using a decision tree instead of iterating through an infinite set's values, perhaps the next decision in the decision tree relates to finding the beginning value and increase values or either d or x. Of course I say this without knowing how you found those original values. If I'm right about this, I have a feeling it has something to do with the relationship between (a, b) = (1, c) and (a, b) = (1, c^2) and something to do with the relationship between t and x. Maybe it would be worth graphing a few. That's a little bit of an educated shot in the dark though.

>>3411

>(1)

Looks like you have some secret admirers, baker. I'm actually personally surprised at how many of us are still here. I thought more of us would have given up. As unrelatedly fitting as Q's message a couple hours ago about nobody being asleep tonight is considering how much progress we seem to suddenly be making, I'm off to bed.

Found this while ACTUALLY FINISHING VQC MAP 2

What the actual fuck, kek

I'm not making heads or tails of these latest crumbs from VQC. So I've been looking at something else.

I noticed how we can "climb" down the n's from a given record. As we increase the a and b monotonically we will jump between different e's and the n will at certain times lower by one until it hits 1.

For (e, 2) (where applicable) this follows a simple equation of d - floor((e - 1)/2).

Meaning to go from (3, 2, 3), which is {3:2:12:5:7:21} you add 11 to both 7 and 21.

d here is 12, 12 - (3 - 1)/2 = 11. The record for 7 + 11, 21 + 11 is (0, 1, 24, 6, 18, 32) which is also the first record that has n = 1 for 7 + k, 21 + k for k < 11. For these records the x in the record (e, 1) will always be the (e, 2) x + 1.

No idea if this is useful, but it was interesting. For n 2 I haven't spotted an obvious pattern yet.

>>3413

Yeah I'm pretty sure It's constant.

>>3414

I don't get this at all lol

>>3409

>>3410

Thank you for the replies. Thanks to the glorious US education system I find it hard to follow along sometimes. This is the coolest thing ever though and I encourage you all to keep up the good work!

>>3416

Good luck with an RSA sized number and GCD

Here is an example of two miniscule numbers relative to RSA.

D(t)-d E N D X A B

28 32 61 38 23 163

47 28 1 14 0 14 16

43 28 1 18 2 16 22

35 28 1 26 4 22 32

23 28 1 38 6 32 46

7 28 1 54 8 46 64

-13 28 1 74 10 64 86

-37 28 1 98 12 86 112

-65 28 1 126 14 112 142

-97 28 1 158 16 142 176

-133 28 1 194 18 176 214

-173 28 1 234 20 214 256

-217 28 1 278 22 256 302

-265 28 1 326 24 302 352

-317 28 1 378 26 352 406

-373 28 1 434 28 406 464

-433 28 1 494 30 464 526

-497 28 1 558 32 526 592

-565 28 1 626 34 592 662

-637 28 1 698 36 662 736

-713 28 1 774 38 736 814

-793 28 1 854 40 814 896

-877 28 1 938 42 896 982

>>3416

Try again

D(t)-d E N D X A B

28 32 61 38 23 163

47 28 1 14 0 14 16

43 28 1 18 2 16 22

35 28 1 26 4 22 32

23 28 1 38 6 32 46

7 28 1 54 8 46 64

-13 28 1 74 10 64 86

-37 28 1 98 12 86 112

-65 28 1 126 14 112 142

-97 28 1 158 16 142 176

-133 28 1 194 18 176 214

-173 28 1 234 20 214 256

-217 28 1 278 22 256 302

-265 28 1 326 24 302 352

-317 28 1 378 26 352 406

-373 28 1 434 28 406 464

-433 28 1 494 30 464 526

-497 28 1 558 32 526 592

-565 28 1 626 34 592 662

-637 28 1 698 36 662 736

-713 28 1 774 38 736 814

-793 28 1 854 40 814 896

-877 28 1 938 42 896 982

for CONTEXT of >>3414

>>>cbts/42019

https://8ch.net/cbts/res/34072.html#38114

Anon wrote:

▶Anonymous 12/05/17 (Tue) 23:30:18 f03740 No.41094>>41110 >>41997

Or the golden ratio is like, our denominator. Like our universes calling card or something?

A % Golden Ratio = Prime is fucking crazy!!!What is up with this equation?! My mind is being continuously blown! What the hell is this? VQC! Tell me! Tell me my duderino famalam!

A % Golden Ratio = Prime

>A % Golden Ratio = Prime

A % Golden Ratio = Prime

>A % Golden Ratio = Prime

A % Golden Ratio = Prime

>A % Golden Ratio = Prime

A % Golden Ratio = Prime

>A % Golden Ratio = Prime

A % Golden Ratio = Prime

>A % Golden Ratio = Prime

A % Golden Ratio = Prime

>A % Golden Ratio = Prime

A % Golden Ratio = Prime

>A % Golden Ratio = Prime

Whhhhhhaaaaaaaaaaaaaaaaaaaaat theeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee fuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuckkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk

which was a response to VQC:

▶VQC!!Om5byg3jAU 12/06/17 (Wed) 04:58:10 ecb64b No.41997

>>41094

This is where the fun really begins.

"I'm not a Monster, I'm just ahead of the CURVE"

Well done.

VQC responded to this >>3414

with:

▶VQC!!Om5byg3jAU 12/07/17 (Thu) 04:19:54 ecb64b No.47800

>>42019

Yes and only a small, finite number of dimensions are required to utilise the properties of the whole.

It's all about CONTEXT.

re: Decision Trees

>>3386

>Is this something VQC has said?

▶VQC!!Om5byg3jAU 12/06/17 (Wed) 15:59:38 12c5d9 No.44171

Integers are also related into families that you have noticed.

Like fractals.

They repeat.

They GROW.

Sea shells grow.

Establishing which patterns govern which level of the fractal and which part of the branch of that fractal, will help identify the factors of c.

Think decision trees too.

>>3385

>>3387

So Divisible by 5 likely the 5th decision, so what would be the fourth, assuming no to #'s 2&3? A quaternion?

>>3420

>>3421

>>3422

WHOA!! A%Golden ratio = prime? That means we could work backward from d to find a and x? Nice find on the crumb!!

>>3416

>Yeah I'm pretty sure it's constant

But my other question was how did you find exactly 4 and exactly 6?

>>3424

I just noticed it

>>3423

Quick Question: how do you do this if golden ratio isn't an integer. Is it just an estimation?

>>3425

Where did you notice it, so I can look into it?

>>3426

Whoever that was did it when we were blindly looking for patterns by changing the colours and criteria for bitmap generation. It isn't necessarily going to help exactly the way it looks, but obviously Chris did reply to it saying that it was "where the fun really begins". Isn't there some formula for calculating the golden ratio exactly instead of just rounding to 1.618?

>>3427

>>> from math import sqrt

>>> sqrt(5) / 2 + 0.5

1.618033988749895

>>> from decimal import *

>>> getcontext().prec = 100

>>> Decimal(5).sqrt() / Decimal(2) + Decimal(0.5)

Decimal('1.618033988749894848204586834365638117720309179805762862135448622705260462818902449707207204189391138')

>>>

>>3427

You can find a lot of it by just looking at the values in the N=1 row.

I'm working on the new VQC map.

"You all amaze me."

>>3426

Good Question CA! I didn't know the formula for the golden ratio. Glad someone else did!

>>3428

Thanks Anon!

I have to say, I've taken a few days break from intense work here, and I feel refreshed, rested, and ready to dig in again. If anyone else out there is feeling worn out, make sure to take good care of yourself, rest, and get comfy. We will work more efficiently over the long haul if we make sure to care for our bodies. I exercised today, and am now drinking a beer and getting even more comfy. Glad to be here, fellow MathFags.

>>3432

Conf_goProgMathAnon_P_build_that-shit#

RED1_RED2_College_Anon_build_solve.

Q

>>3434

Oh, you were the one who was emailing me in December. I wasn't sure which one of you it was.

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

>>3433

_All_wings_Report_IN#go_Faggots_Math-Time

RED5_RED6_Anons_op_MEGAMATH

D_CsTBA_YES[AUTH_H7^pZBVTZ7302-]

##FLY##

[OWLS] and_Reptilians_GO-BTFO.

HOT-1_pre_D

AS THE WORLD TURNS.

HAPPY HUNTING.

P_PERS: WRWY [N1LB][FG&C]

Jeremiah 29:11

Q

>>3436

Bantz + Shitz?? :)

>>3436

>for when the VQC takes the internet with it

>email

?

>>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

>>3433

With a call out like that, I’ll be sure to post my limited progress on dt/at later.

>>3433

>>3440

Nice job whoever is working on the archive and VQC Map! Baker or AA? This stringer was back in RSA #2!

>>3441

I made the pdf but I'm not the one making the image version.

>>3434

>>3439

HA! Good to see you baker! Thanks for the delicious new bread. I DID thank the anon who posted the GR formula. "Looked up first Anon, I did."

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

Where's Topol? He should piss on the fire hydrant too and drop some LSD math memes. I'll go say hi over at EZ Bake.

>>3444 (nice trips)

He did say some pretty crazy shit. He said Agartha is real and that 9/11 was meant to be worse. That was fun.

>>3445

He seems to leave for several days at a time so he'll probably be back soon.

>>3445

Chris put me time out for being to about "the chatter", though this reminds me I was gonna deep dream something. ;)

>>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.

This meme is one of Topol's finest, created on the fly back in RSA 3 or 4. Posting for posterity.

>>3447

It was SUPER fun! When you start questioning everything you've ever been taught, Agartha, hollow earth, etc. doesn't seem implausible. At this time, I just want facts to validate truth. A is A. Cause and Effect. Since I have no facts (personally validated) on those specific issues, my mind remains open to new solutions.

>>3448

What's up Topol!

"That's a nice global government you have there.

Would be a shame if someone

broke the conditioning."

>>3449

>>3450

As someone who has always thought Flat Earth was bullshit but could see there was some weird shit going on (like planes not being allowed to fly over the poles, the heavy protection around the poles and Joe Biden etc going there after the US election) I think Agartha makes perfect sense. Since something like this would be provable with video etc when the time comes, and Q said the 40,000ft view would be too much for 99% of people who would just outright deny it if it was told to them, imagine how crazy the 40,000ft view really is and where this would even fit into it.

>>3451

https://archive.fo/8upab

2018's your lucky year.

YUUUUUUUUUUUGE!

>>3453

That's both brilliant and fucking retarded.

*FTFEveryone

>>3454

Eat me!

Still working on the d[t] and a[t] analysis. I have been looking at quite a bit of data, trying to make heads or tails of this. Would appreciate anyone taking a look and letting me know if I have gone too deep down the rabbit hole. (or not deep enough.)

Latest version of d[t] and a[t] analysis with a new "summary" at the top is attached. This is again for c=145.

The negative t records have been removed to save space. The results I am showing are mirrored in negative t.

The summary at the top is an attempt to condense relevant information and make it easier to review multiple test cases.

Which will follow in separate posts.

The summary columns are as follows:

(d[t]-d)/(n-1): values where n-1 is a factor.

(d[t] diffs): difference between values.

(x diffs): difference between x values where n-1 is a factor.

(t diffs): difference between t values where n-1 is a factor.

(d[t] diff)/t: Only shows where t is a factor of d[t] diff. (An attempt to find a common basis.)

(a[t]/n): values where n is a factor.

(a[t] diffs): difference between values.

(x diffs): difference between x values where n is a factor.

(t diffs): difference between t values where n is a factor.

(a[t] diff)/t: Only shows where t is a factor of a[t] diff. (An attempt to find a common basis.)

(1/4)

>>3456

Pics attached are d[t] and a[t] summaries for different values of e, odd and even n.

c=441

an example at e=0 for a=3^2, b=7^2.

c=143 and c=145

examples at even and odd e where n is odd.

c=115 and c=481

examples at even and odd e where n is even.

(2/4)

>>3457

Pics attached are side by side comparisons of the d[t] and a[t] analysis for various values of c and their prime solutions.

Samples are for c=145, 533, 785, and 901.

Results are run over the same list of records. All starting from (e,1,1) and up to t=c.t + c.n.

(3/4)

>>3458

If you've made it this far, following are my current thoughts:

1) We can accurately identify 3 records in each of the (d[t]-d) and (a[t]) sequences. This applies only to the initial 1,c record. Don't know the value of this yet, but it is there.

For (d[t]-d): 1, xx-f, and c.

For a[t]: 1, xx-f+4, and c.

2) For the initial 1,c records, some records have t as valid factors of the d[t] diff or the a[t] diff. When these factors exist, the pattern appears to be:

For even n:

d[t] diff / t are even (2,4,6,etc)

a[t] diff / t are sequential (1,2,3,4,etc)

For odd n:

d[t] diff / t are sequential (1,2,3,4,etc)

a[t] diff / t are even (2,4,6,etc)

Don't know if this is important or not.

3) One of the sequences of values in a[t]/n uses x.

4) One of the sequences of values in (d[t]-d)/(n-1) uses (x+1).

Still have no clue what offset we are looking for.

(4/4)

>>3459

Check out

>>3413

Haven't had the time to test that out.

>>3460

I'm the one who posted >>3413 and I think it would pay to mention that I looked at the places CA was talking about in (e, 1) and they seem to always follow the pattern he mentioned (for whatever unknown reason). That said, I actually don't completely understand what CA is doing, so what I said is possibly still important, just in a different context than calculating an infinite set of ds and xs given (e, 1). We just don't know what that context is yet, and I don't really have the time to do anything other than lurk for the rest of the day. If we're using a decision tree rather than iteration then it potentially becomes important when we link (e, 1) to (e, n). Currently, from what I understand (and I might be wrong), CA's method iterates through (e, 1) to find the correct x for (e, n).

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.

>>3462

Decision Tree's aren't strictly binary, though.

Hey nerds, I've been doing my thang over at the red triangle group of also coding nerds.

I have a feeling that the RR from the Vortex Math is the same RR that's leading them through an ARG. Also kinda points to the Zodiac Killer murders being the "cover" for the Skull and Bones initiatory sacrifices. They're supposed to flaunt it because the occult likes to brag… hidden in plain site… thus the letters. "Come on! Catch me, peasants/pissants!"

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

https://www.thefreedictionary.com/meson

Also a photo of ATLAS

Some of Chris' clues directly relate to (e, 1), and since we're working on that at the moment, I'll point a few out:

>At the correct element in the grid at (e, 1) where the value of a at that element equals the na we want, if you subtract 2d+1 from na then you are in the negative half of the grid in terms of e and the value at the same element in the first row will be (n-1)a

So does that mean either the next or one of the next parts of the decision tree relates to na?

>You're going to use column e=1 to show whether the conjecture about Fermat primes is true during this

Has anyone looked for the Fermat numbers in (e, 1) yet?

>A prime appears once in a column. This is SIMPLE to calculate. This calculation is important. I call n for a prime number big_n or N

>The product of two primes appears twice. Once the same as the prime, which is easy to calculate and the second time, this is the n that we are after.

We already know most of this with (a, b) = (1, prime) etc, but this sounds like it's part of the decision tree based on how sequentially Chris describes it.

>How many times does the product of three distinct primes appear?

I looked up the phrase "three distinct primes" and I found this: https://en.wikipedia.org/wiki/Sphenic_number

He wouldn't have mentioned it if it wasn't important, so does anyone know anything about Spehnic numbers? I haven't seen anyone discussing them. He said this right after the above two lines about the product of two primes, so maybe if we can find one prime and we can find the product of three primes we can use those methods to find the product of two primes.

>The relationship between cells 2n to the left or right in (e, 1)

Has this come up in relation to the decision tree yet?

>Extend the cells at (e, 1) into negative x

Has anyone done that yet? He's said a bunch of times that listing everything we know (every rule, every positive and negative value of every integer, etc) would make the answer obvious.

>REMEMBER, take d from all values of d[t] at (e,1) and there is a known patter 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]. It is THIS that gives the offset that is used to solve the problem and thus get the cell at (e,1) to do all the work for you.

This seems like the most important of all things to focus on based on where we are right now.

Also this might be a stupid thing to consider but has anyone tried contacting Motti Milgrom and asking if he remembers emailing with a guy called Chris Curtis 10 years ago?

>>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.

>>3468

Of course, my intention wasn't to discourage, but simply to point it out. It's also a good thing to keep in mind, if some branches might require more than binary splits.

>At the correct element in the grid at (e, 1) where the value of a at that element equals the na we want, if you subtract 2d+1 from na then you are in the negative half of the grid in terms of e and the value at the same element in the first row will be (n-1)a

I'm trying to wrap my head around this one. I'll try with an example and if you guys understand it in another way let me know:

We use c = 145. This is a=5,b=29 so the correct na in our case is 25.

The d is 12, so we do 25 - (2 * 12 + 1) which equals 0.

We are now supposed to be in the negative half of the grid with regards to e, which I then assume, we are going after: e - (2 * 12 + 1) =-24. The first record in -24 is {-24:1:28:8:20:38}.

Here a is (5 - 1)5 which is correct, but the crumb states "the value at the same element in the first row will be (n - 1)a". I interpret that as the same record at t (1, 1), where a[t] = 25 should also be the t in (-24, 1) where a = 20. However, this doesn't match, since 20 appears in t=1 in (-24, 1) and 25 appears at t = 4 in (1, 1).

So does that mean that na - (2*d + 1) doesn't reference the same e, as e - (2 * d + 1)?

>>3470

Now, I'm not sure if we know but from what I've seen, if we do e - (2 * d + 1) then (n - 1)a will appear in (e - (2 * d + 1), 1) at some point.

Could it be that we have to use these two together? Somehow combine (e, 1) and (e - (2 * d + 1))?

>>3471

And, of course(?) shouldn't then (n + 1)a appear in e + (2 * d - 1) as well?

>>3466

>>You're going to use column e=1 to show whether the conjecture about Fermat primes is true during this

Has anyone looked for the Fermat numbers in (e, 1) yet?

I haven't looked into it myself, not sure if someone else has, but we know that they will always be in (1, n) for greater than 3, and this makes sense since Fermat Primes are all perfect squares + 1. All perfect squares will occur in (0, n) and since we add 1, we will give it a remainder of 1 shy from a perfect square.

>>3473

This probably won't work for large numbers, but what we do when we compute f (2*d + 1) is that we are actually increasing by one square.

Now, I'm thinking out loud again. We can do e + (2 * d - 1) and here we will find (n + 1)a. But we can generalize it to k * (2 * d - k), where k is the number of squares to add to e.

This means that the (n + k)a will be in (e + k * (2 * d - k), 1) and it will occur at a lower t. I don't know if we can guarantee it to exist as t = 1, though. I mean if we could then we would have found (n + k)a which would be amazing. Then we would be even closer to the actual answer.

Take our beloved example of c = 145. We know the record we want is (1, 5, 12, 7, 5, 29).

If we then do 1 + (2 * d - 1) we will get 24. Here we will find 5 * 6 (30) at t=4 (same t as an btw, but probably not something that holds true for every number).

But let's add more squares to it: e + 4*(2 * d - 4) =1 + 4*(2 * 12 - 1) => 81.

This is the same as (n + 4)5 which is (5 + 4)5 which is 45.

For e = 81, we have the following records:

(81, 1, 42, 1, 41, 45)

(81, 1, 48, 3, 45, 53)

(81, 1, 58, 5, 53, 65)

(81, 1, 72, 7, 65, 81)

(81, 1, 90, 9, 81, 101)

Thus we've "moved" a(n+4) up to t=1. This works fine for c = 145, though. It probably won't work smooth for big numbers.

Someone want to take a look at this and see if it make sense?

def genesis_block(e): if e 0: return (0, 1, 4, 2, 2, 8) x = e % 2 a = int(e/2) + x n = 1 b = a + 2x + 2n c = math.fabs(a*b) d = math.floor(math.sqrt(c)) return (int(e), int(n), int(d), int(x), int(a), int(b)) def factorize(c): e, n, d, x, a, b = rowForAB(1, c) dd = d/2 if dd % 2 1: dd -= 1 ee,nn,dd,xx,aa,bb = genesis_block(e + dd * (2 * d - dd)) print(math.gcd(c, aa*bb))

>>3475

It only works for small numbers though. But maybe there is a way to get it faster?

>>3476

Actually, thinking more about it I just got caught up with low numbers. The big numbers multiplied by (n + k)*a will diverge too far from the genesis cell. I don't think this is a the direction to the solution.

Although I am interested in what you guys think about the (n + ..) angle, though.

I will look into negative X. I believe it may be very helpful because (xx+e)/2a doesn't care about the sign of x.

On -X, it is not a perfect mirror. Here is a view you guys are familiar with, the end in 3d plotted by E, X, and N.

-X is much smaller and compact. A different pattern.

Here they are together.

The line across E0, X0 is a bug, but can anyone else confirm that no cells exist with N= -1 for +E?

>>3482

Sorry, can anyone else confirm that cells don't exist where X = -1?

Aren't all negative x's simply the next records x * -1?

For (1, 1) we have the following records:

(1, 1, 2, 1, 1, 5)

(1, 1, 8, 3, 5, 13)

(1, 1, 18, 5, 13, 25)

(1, 1, 32, 7, 25, 41)

(1, 1, 50, 9, 41, 61)

(1, 1, 72, 11, 61, 85)

Isn't the negative x for (1, 1) these:

(1, 1, 2, -3, 5, 1)

(1, 1, 8, -5, 13, 5)

(1, 1, 18, -7, 25, 13)

(1, 1, 32, -9, 41, 25)

(1, 1, 50, -11, 61, 41)

(1, 1, 72, -13, 85, 61)

Which are the same records, except the x refers to the next records x multiplied by negative 1 (or simply negated)?

Hey guys, sorry I've been busy for a bit with work and haven't been able to post.

But this problem has still been on my mind, and I've made some more observations in patterns:

ab = dd + e

2an = xx + e

a is a factor of both dd+e and xx+e. This is the tree growth I believe that we were guided with.

2ab = 2(dd + e)

In this case our n for c = c becomes our original b.

4ab = 4(dd + e)

4ab = (2d)(2d) + 4e

In this case n = 2b.

I think these could be the key to unlocking this thing.

—-

1 more pattern i've observed that I think is linked:

a + b = 2(d+n)

a - b = 2(x+n)

Still trying to put this all together. But I think with these 2 tips we should be able to get it done.

How's everyone else?

There have been many posts since I've been here last, anything in particular I should look into?

>>3485

a + b = 2(d+n) is correct, but a - b = 2(x+n) is not. In the original grid, A < B is always true, therefor a - b < 0, and 2(x+n) 0.

Also been gone a bit, safe to ignore everything other than VQC posts.

>>3487

>a + b = 2(d+n) is correct, but a - b = 2(x+n) is not. In the original grid, A < B is always true, therefor a - b < 0, and 2(x+n) > 0.

sorry, b-a.

New useless solution record corrected.

For {E, N, D, X, A, C}

Increase N by X

Decrease D and X by X so X=0 and D=A

A and B stay the same

Record is:

{ 2*(NA+XA), N+X, A, 0, A, B}

>>3488

Checked, I assumed that after a minute, and it seems like a property of all valid cells, but it also exists for some invalid cells. Not sure how to apply it.

>>3490

Can you give me an example of it working for invalid cells?

In our c, a and b are both odd. So they're separated by an even distance. That's the 2 in 2na.

Negative X would mean that the factor A is greater than D, which means that the other factor would need to be less than D. This is how you have B < A.

If you have a record in (E,1)

D X A B

then there is another cell

D -X-2 B A

>>3467

It would surprise me if he was using his real name to give people on 8ch the knowledge necessary to crack RSA. I tried looking in various places on the internet for someone called Chris Curtis from Auckland, New Zealand out of curiosity at one point and while I didn't put much effort in, I didn't find anything.

>>3485

>>3487

CA found a way to calculate any d and x in (e, 1) cells >>3393 although it doesn't work as it's meant to because to find the correct x value at the moment we're iterating.

There's a newer version of the map >>3453

Chris hasn't been here and said anything in a while. Someone messaged him on Twitter, though, and he pointed out some things about the decision tree. The first question in the decision tree is whether e = 0. The second is whether e is odd or even (which relates to CA's thing). We're looking for the third decision at the moment. There are a lot of things you'll see in the map that seem like they relate to decisions on a decision tree, possibly some of the ones I pointed out >>3466 here, but we don't know what the third decision is yet. Other than that, there have been lots of discoveries that didn't go anywhere. I might have missed something but that's what happened last thread and this thread so far off the top of my head.

Also, is everyone aware that the distance between each 2 consecutive squares is the set of odd numbers?

Another way to think about what we're doing is that we're summing a sequence of consecutive odd numbers.

Example for c=145.

c = 25 + 27 + 29 + 31 + 33.

The middle of the sequence is b, the number of terms is a. And:

25 = 13^2 - 12^2

27 = 14^2 - 13^2

29 = 15^2 - 14^2

31 = 16^2 - 15^2

33 = 17^2 - 16^2

>>3493

For n = 1, the series of d's, a's, and x's are easily calculable from t. Here's my function, all in terms of t:

if (e == 0) {

x = 2*t;

a = 2tt;

d = 2tt + 2*t;

} else if (e % 2 == 1) {

x = 2*t - 1;

d = 2tt + (e-1)/2;

a = 2tt + (e-1)/2 - 2*t + 1;

} else if (e % 2 == 0) {

x = 2*t - 2;

d = 2tt + e/2 - 2*t;

a = 2tt + e/2 - 4*t + 2;

}

>>3494

Renders done with two different isValid checks. Both use A != 0.

First image if (c - (d * d) e && d - a x){return true;},

second image if (a + b 2 * (d + n) && b - a 2 * (x + n)) {return true;}

>>3496

Could you explain your axis's? I think I get what you're saying, but I'm not sure exactly.

You're multiplying a * b in the x and y i'm guessing, but what is z?

>>3497

For X,Y,Z I'm using E,X,N. E extends away, N extends right, X extends up/down.

>>3498

Gotcha, so you're trying all combinations of e x and n?

And in the grid where there are empty cells, the formula still holds is what you're saying?

If so, then yes, that makes sense, but it doesn't hinder us by holding true for non-grid cells.

The a's & b's in the grid are always the same parity, otherwise, n would not be a whole number. And as I mentioned before, a & b in our case for semi-prime c will always be odd.

>>3499

Checked again. Yes, this is all combinations of E, X, and N using my bruteforce cell creation method.

And correct again, I'm saying formula applies in cells that aren't valid but I can also say the formula always applies in cells that are valid. At least where E>=0, but for any X (positive or negative) and any N < 0.

>>3500

N>0**.

>>3500

Checked!

>>3501

Cool cool :) same page.

A pythagorean triplet can be made by:

hypotenuse = b+a

side1 = b-a

side2 = 2ab

This all seems connected.

b+a = 2(d+n)

b-a = 2(x+n)

2ab = 2c

1st pic, the front of the end, with +E left, +F right, +X up, -X down.

2nd, at E=0, looking towards +E.

3rd, at E=0, towards +F (-E).

4th, at E=0, X=0, looking up towards +X.

5th, at E=0, X=0, looking down towards -X.

>>3503

I'm a little shaky on the -X values, I don't have anything to check them against, and I lost my code to put the signs on the front of the blocks. Will validate -X next by re-coding the sign process.

Pretty sure those rays aren't supposed to be there across F, -X.

Confirmed, minor bugs :)

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.

There are patterns in plus X that seem to be mirrored but rotated in minus X. -X appears to be much more compact across N space. I think the signs will show something interesting.

>>3502

My pythagorean triplets equations are wrong, sorry.

hypotenuse = b^2+a^2

side1 = b^2 - a^2

side2 = 2ab

This makes it a little trickier.

But it may be related to the mod 4 = 2 set of numbers.

Here's something else, this is the same bruteforce view, but plotting by D instead of X. -X has positive D's as well, so they're inverted for the purpose of the render. It would seem that -X is a perfect mirror in terms of E,D,N.

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!

>>3511

Sounds like another decision for the decision tree. It also cuts the time in half if we were to iterate. Nice work. If n is even and d is even, that means (a+b) % 4 == 0, right? Because it means (a+b)/2 is an even number too. That means if n is even and d is odd that (a+b) % 4 != 0. Vice versa for odd n values. Chris said something about mod 4, right? I don't remember what it was so I don't remember if it applies to this situation.

>>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.

>>3513

c mod 4 will never be 2 or 0.

Otherwise c is divisible by 2…

>>3514

my sides

>>3513

>>3514

a+b, not a*b. I'm not talking about c, I'm talking about (a+b) from the equation n = ((a+b)/2) - d.

>>3516

Gotcha, sorry for teasing you.

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

>>3519

Frickin' double c again…

Sight beyond Site!

Blasting off faster than the speed of light.

c^2… c squared… a squared open circle…

Planes of Light?

>>3455

Thanks for putting the new Map together Baker! Read it and expanded my thinking again.

>>3494

Hey Teach! Good to see you, and thanks for this great explanation.

Decision Trees:

I think step 3 is finding t and x for na (1,c) in (e,1).

Thoughts?

>>3524

How do you turn that into a decision?

Last one before I pop over to the EZ bake with variations and anything else that might pop up (for a bit)

>>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

>>3525

Wondering the same thing, Anon. It's not binary tho. Here's what I have so at the moment: "Choose Your Starting Point." Find na (1,c) in (e,1) and complete the element (x,t now known). Then use that knowledge to find the element that has matching d[t], x[t], and has the "Prime Solution". LOL, Baker should make us some Hitler memes with the Prime Solution.

>>3528

I derived those, with PMA's help. Pic relevant.

PMA found that in (e,1) the small square was tied to t, this part was all his work:

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

T equations verified by Chris, see pic.

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

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

These were my work, based on using t to solve for the small square:

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)

The quadratics are derived easily by subbing out PMA's t solution for small square, and then using algebra to isolate n.

>>3530

Chris explicitly said binary tree. What decision happens after?

>>3531

Tree have ROOTS, a main trunk/body (the genesis cell?), and branches/twigs/leaves that GROW toward THE LIGHT.

So what's being mapped out with the VQC may be all the points where the roots, trunk, branches, twigs, and leaves "are". Are those the primes?

Wasn't there talk about - and going backwards to move forward or something? If y'all know where to find m'discord, you can see all the direction I've been pulled in throughout the Q A.R.G. Phenomenon.

Hmmm… this is where the square root of primes and… something someone hit me up with but I'm not finding the conversation…. maybe it was this?

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

>>3531

Sheeeit. Good question, Anon. Trying to figure out how to put it in binary decision form. (I'll take Step 3 in Binary for $1000, Alex?)

>>3532

Great visual projection Topol! This is where I have to keep my spiritual and emotional focus. If I let myself get frustrated by "lack of progress", I lose my joy. TREES ARE GOOD AND BEAUTIFUL! I love trees and math. This is an abstract math tree that exists in the source of all knowledge. We have been called here (self-selected perhaps?) to help reveal this beautiful tree to the world. We never give up, we just keep going. How do you say that in Latin?? That shit should be our motto here.

>>3534

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

>>3521

>>3535

It's beautiful! The patterns are all laid out to see. Interesting that a+b seems to highlight specific patterns that flow in lines from the origin, like branches.

>>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.

"Perseus Usque Semper Victoria"

"Perseus Usque Victoria"

"Usque Fidelis Victoria"

Vote for your favorite motto, faggots.

>>3538

Hitler nihil mali fecerit

>>3538

"Autismus Possum Telum" it's the closest Latin I could get to "weaponized autism"

>>3539

"Solutio Primo Oportet Te Auris Laxant, Padawan"

Prime Solution Unlock You Must, Padawan.

>>3538

Hang on…

Perseus was coming up elsewhere in the Q…

…and the Gorgon.

Now was it Red Triangle or NROL/SpaceX related… hmmmm…

>>3540

Weaponry Of The Mind

"mens illa armamentarium"

>>3543

>>3540

Autismus illa armamentarium my Bruddahs.

(Pic related to Autism Possum)

>>3542

Topol, you wonderful faggot! We all know you are Chris' shitpost account. You and Chris "Had a little talk" (between yourself(s)) about not blessing us with TOO many Math LSD memes. Fess up.

>>3545

I legit was looking at the page to tell y'all to take this to the EZ Bake :P

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.

>>2974

>>3031

>>3131

Let's focus again on c=145 for a minute.

We never made the connection between c and p records. This is where we gotta focus. na=a at (e,1) for c solution. Then d[t] x[t] for n are the same in the prime solution. The only (e,1) difference was the lesser t value for the prime solution.

Side Note: There's gotta be some Golden Ratio / Fib Sequence to how d,x,a,b tie together. All Nature and Growth are governed by these same rules, We're just helping uncover them.

>>3549

Error Correction:

>Then d[t] x[t] for n are the same in the prime solution.

Should be:

Then d and x for (prime n) are the same in the prime solution as they are in (e,1)

>>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.

>>3551

Thanks for understanding my idea, Baker. It's so nice to be with your minds who can do the things I like to do. Most people around me can't even begin to understand how excellent this forum is.

Just doing Math(s) is/are? improving my life.

The relationship between d, x, and a is amazing. I'm wondering if there's a pattern between [delta]t for (1,c) and t for (Prime Solution). Can we run those numbers, programAnons? Let's take known c's from the basic grid so everyone can follow. Let's do the (1,c) and (Prime) for each c value. If willing, PMA, would you please pick some c values starting at c=145 and greater? Just a few examples needed to examine this [delta]t idea between na=a for (1,e) and (e,n). Thoughts welcome.

>>3551

>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

Exactly. But if [delta]t is known (or patterns of [delta]t are known) can we then lower t to the proper integer using a known formula? Asking for a friend.

>>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.

>>3511

So…?

1. Check if e is zero

2. Check if e is odd or even

3. Check if big N is odd or even

…?

>>3556

1. Check if d is odd or even?

Parity of d will give us parity of x, right?

We can't deduce parity of d from e alone, as you can see in (4, 2).

Of course, I'm now assuming we CAN figure out the parity of x by looking at d. Not sure if we can / haven't looked enough to see if it's possible.

>>3555

Checked!!

Agreed. But if we can go from (1,c) to (prime) using a formula based on t in (e,1), then that gives us our x and t values, which are supposed to be the same in (e,n)?

>>3556

>>3557

Looks like this could be next steps for decision tree?

>>3557

If we know the parity of d and n then we know the parity of (a+b) too, as explained >>3512 here. a = d - x. If d and x are both odd or both even, a is even. If d is either odd or even and x is the opposite, a is odd. If a is even and (a+b) is odd, b is odd. If a is even and (a+b) is even, b is even. If a is odd and (a+b) is odd, b is even. If a is odd and (a+b) is even, b is odd. If (a+b) is odd then c is even (oddeven or evenodd). If (a+b) is even then c could be odd or even (oddodd=odd or eveneven=even). So if we know the parity of x, we know the parity of every variable. I'm too tired to remember if we know how to find the parity of x yet.

>>3559

Okay I don't know if we actually do have the parity of d and n yet just rereading my post from earlier. As I said I'm a bit sleep-deprived. But if we do, all the logic in this post still checks out.

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

>>3564

This essentially states that 5 as a factor accumulates over t's.

And since this holds for 5 and 25, it also holds for 85, 145 etc. So 5 will continue to grow as a factor of a in (1, 1). So will 25, 85 etc.

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.

>>3511

Take a look at >>3090

>>3571

Err, i meant >>2920

>>3361

>>3564

>https://archive.fo/RgVko (RSA#1)

VQC:

Anonymous 12/05/17 (Tue) 09:34:37 ID: ecb64b No.36154

I'll work through RSA100. If you're using C# the BigInteger namespace is handy.

c = 1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139

d = 39020571855401265512289573339484371018905006900194

e = 61218444075812733697456051513875809617598014768503

n = 14387588531011964456730684619177102985211280936

x = 1045343918457591589480700584038743164339470261995

a = 37975227936943673922808872755445627854565536638199

b = 40094690950920881030683735292761468389214899724061

In the element at (Rsa100e,1) you find that the element where x = Rsa100x, you will find a = Rsa100n x Rsa100a

If you find a that is Rsa100n elements further down, then that a will equal Rsa100n x Rsa100b

Then at grid cell (Rsa100e, Rsa100n) which is obviously in the same column, you'll find the product c.

In summary, the factors in any cell in the first row govern ALL the behaviour in the column below in a pattern or, if you perfer, in MANY patterns.

A member of Pink Floyd said in an interview during a documentary on MUSIC PRODUCTION that the GAPS are absolutely as important as where there are NO gaps.

Let the VQC take the strain. The more you c it's beauty, the more it will give you (back).

You all amaze me.

Can't find the crumb, but VQC mentioned we can take a prime of our CHOOSING. The crumb you pulled is an example of this, using 5.

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.

Thank you for your patience.

The decision tree has parts.

The decision tree terminates upon finding a factor.

Pre-factorisation, trim trailing zeros (in binary) or equiv is to divide by two until odd.

This is 1 and c for primes.

This is the square root for squares.

This is the pair of factors that are not 1 and c for the product of two primes that are not the same numbers (not a square).

This is the pair of factors closest to the square root for products of more than two factors (not including 1 and c as factors).

The first part.

Determine if a square.

Find the square root d and remainder e.

First decision, if e is 0, return d.

Second decision, if(GCD(e,d)!=1) return GCD(e,d);

That is the end of part one.

Part two.

Part two is recursive (since the grid is effectively an overlay of the fractal nature of integers).

A recursive part should immediately make sense in hindsight or will come as less of a shock in due course, considering that the complexity claim was at most big oh of the natural log of the length of c in bits.

The inputs into part two are to factorise d and e.

The end result of part two is a tree, descending from c with branches d and e, then branches descending from d and e or each of their square roots and remainders.

>>3579

What changes? Is there a branch in the binary tree? Does the growth pattern remain the same?

>>3580

Oh, hello VQC! Wow, that is a lot to digest, but makes perfect sense. Please provide a moment for the 'in due course' bit to hit. Feels YUUGE. Much gratitude.

>New inputs! factorise d and e!

Excellent, was digging into the d-primes. Hadn't thought about the e-primes. ok!!

Question please? With the Einstein crumb.(and 2 c's), was going down the path of Eisenstein and Conway and Gaussian and Eisenstein integers. Wrong turn for Part 1?

>>3580

Thank you for this direction.

>or will come as less of a shock in due course

A bit surprised, yes. Will get over it! :-)

>>3580

Welcome back! These hints are great

First stab at part one (using gmpy2 for fast bignums)

from gmpy2 import mpz, isqrt_rem, t_div, gcddef one(c): # Determine if a square if t_div(c, 4) 2: # Make it square? c = t_div(c, 2) # Find the square root d and remainder e d, e = isqrt_rem(c) # First decision, if e is 0, return d if e 0: return d # Second decision, if(GCD(e,d)!=1) return GCD(e,d) tmp = gcd(e, d) if tmp != 1: return tmp return None

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.

>>3561

>>3562

>>3563 Factor Trees Crumb

>>3565 (N-1)a and na combined with Factor trees crumb? How to combine?

Thanks Baker for crunching the numbers for [delta]t. Seeing some very interesting patterns. You're right about the distance from T and t being too large in the RSA setting. Good progress on the (N-1)a and na ideas tho, and how they combine with the factor tree crumbs.

>>3576

Great find on this crumb!

>>3580

All right! Just saw this, VQC is back! Good to see you.

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.

What did Q say about something being necessary?

Some preliminary work:

def rowForAB(a, b): 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)def recurse(c): e, n, d, x, a, b = rowForAB(1, c) if e == 0: return [d, c//d] if gcd(e, d) != 1: return [gcd(e, d), c//(gcd(e, d))] return [[e, recurse(e)], [d, recurse(d)]]

This can be used to study the branching.

>>3580

Of course, welcome back!

>>3590

Thanks. Reminds me how much I hate recursive programming too :)

If you're lazy like me and want to see the tree immediately you can cheat a bitprint(json.dumps(recurse(c), indent=4))This needs to go in OpenGL for the larger numbers!

>>3589

Disinfo is necessary and used.

anon thinks can at times be related to requirement for plausible deniability.

>>3592

please drop a screencap of that!

>>3593

Filtering out some useless formatting, this is what I get for RSA100 61218444075812733697456051513875809617598014768503 13204334350125320769126278 2 6602167175062660384563139 7824221627472775882440665 1915100302336 1357695 5 271539 1383871 895 54 5 1 1 1 2 1 1 1 1 1 1 7 3 2 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 29 4 2 2 5 1 1 1 2 1 1 1 1 1 1 1176 2 588 2797181014427 1698898 1089 33 33 1303 7 3 2 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 36 6 6 1672477 628 3 2 1 1 1 1 1 1 1 1 1 25 5 5 1293 68 4 17 35 5 7 39020571855401265512289573339484371018905006900194 2 19510285927700632756144786669742185509452503450097

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

>>3580

Thank you.

>>3580

graph viz

>>3597

Good to see you Teach!

Exactly! Been picturing this, including ordering of the factors.

When we look up at the tree, we see primes. If there is something behind, obstructed, then what we are seeing can factor that integer.

>>3594

Nice. Thanks.

>>3597

>>3598

Wasn't quite picturing everything you put down, that was helpful. Good notation.

>>3597

teach, why d_2? Shouldn't they all be sqrt(d) and e?

>>3597

Great diagrams, Teach! Thanks.

>>3600

>teach, why d_2? Shouldn't they all be sqrt(d) and e?

I was wondering the same thing. Chris did say you could pre-factorize by dividing by 2 until odd. Then you take d and e and repeat until those branches terminate in a factor.

>>3597

I see your graph viz and raise you ete toolkit

>>3602

Keep going anon!!

Was looking at your 'screencap', >>3594

playing a bit in Wolfram Alpha. Then you drop this.

What a big week.

etetoolkit.org

Title:ETE Toolkit - Analysis and Visualization of (phylogenetic) trees

Description：The ETE toolkits is Python library that assists in the analysis, manipulation and visualization of (phylogenetic) trees.

>>3601

>I was wondering the same thing. Chris did say you could pre-factorize by dividing by 2 until odd. Then you take d and e and repeat until those branches terminate in a factor.

That recursive part is starting to make sense, using the power of the VQC (on d and e).

>>3603

Looks way more like a fractal when chopping off the trailing zero bits

>>3602

>>3603

Pretty sweet results.

Anyone have a better square root function for biginteger in c# (other than what was originally posted) that works well at smaller values?

>>3604

I screwed up the filename on the last one, both of those are RSA100. The 2048 one is apparently too large to post. You can have 1536 instead.

>>3605

I love these, just need to figure out how to change the background color! Tons of possibilities for layout too

bee tee dubz, this is "c root of d" according to wolfram:

http://www.wolframalpha.com/input/?i=c+root+of+d

Good to see you all too!!!

Hello VA, Topol, PMA, CA, MA, Baker, (am i missing anyone).

>>3605

d_2 is the divide repeatedly by 2 like VA assumed.

I have one in js you could port:

function sqrt(c) {

if (c.isZero()) {

return c;

}

if (c.lesser(4)) {

return BigInt(1);

}

var n, p;

var high = c.shiftRight(1);

var low = BigInt.zero;

while (high.greater(low.add(1))) {

n = high.add(low).shiftRight(1);

p = n.square();

if (c.lesser(p)) {

high = n;

} else if (c.greater(p)) {

low = n.equals(1) ? n.add(1) : n;

} else {

break;

}

}

if (c.equals(p)) {

return n;

} else if (c.equals(high.square())) {

return high;

}

return low;

}

>>3602

I haven't heard of ete before, I'll check it out.

Unrelated kinda, but I've seen the collatz conjecture represented using that circular tree diagram. Great stuff.

Sure does look familiar….

>>3609

Hadn't heard of it either till your post inspired me to look for better options. There is an interactive viewer too!

The code I used (after changing dicts in IseePatterns code to tuples) is this. There are probably better waysdata = (c, recurse(c))t = Tree(str(data) + ";")ts = TreeStyle()ts.mode = "c"ts.arc_start = 0ts.arc_span = 360nstyle = NodeStyle()nstyle["shape"] = "sphere"nstyle["size"] = 3nstyle["fgcolor"] = "red"for n in t.traverse(): n.set_style(nstyle)t.show(tree_style=ts)#t.render("image.png", tree_style=ts)

>>3608

Thanks teach. Things are getting exciting now!

>>3612

Forgot image. You guys with the gcd call were spot on. Good job!

>>3612

Sure is! I freaked out when I saw that Chris had posted.

Even in the tree diagrams there are patterns.

Considering we can ultimately express any c breaking it down to its most smallest pieces, then what are those pieces… 1 & 2 I think.

Example:

c = 145

c = 12^2 + 1

c = (223)^2 +1

c = (22(1^2 + 2))^2 + 1

c = (22(1^2 + 2*1))^2 + 1

Trying to figure out what this means now. But any number can be expressed as a recursive equation in the for:

2^j * (recursive part) + (recursive part)

where each recursive part starts from the root of 1,1.

Moving backwards towards a (or x) though, still unclear.

>>3615

>we can ultimately express any c breaking it down to its most smallest pieces

I spent quite a bit of time over the weekend breaking down the (0,1) space for d[t] and a[t] changes. Didn't post the results as it seems a bit unnecessary, and I might be stating the obvious, but all the movements between records look like they be described by prime numbers.

At it's most basic, the numbers seem to work together in very obvious patterns.

>>3616

Soooo many patterns…

When this is all over I'm going to post my notebook… I need to go buy another one in fact, filled up a grid book.

I might put a program together that takes in a public key and outputs the equivalent private key. I'll have a gap where the decision tree code will eventually go. That way, once we're there, we don't have to figure out how keys work in code at the last minute (and so far it seems quite complicated). Nobody has any objections to Java still, yes?

>>3608

>(am I missing anyone)

hi

>>3618

Yes please

>>3618

Sorry AA! I knew I was missing someone, duh.

Regarding the rsa cracking algorithm, sounds like a good idea. I have something similar ready to go ;)

>>3621

Would you mind posting it then? I've figured out most of it but if you already have something working I won't need to waste my own time.

Will do, let me fix it - might be a couple of hours sorry (gotta check in with the real world occasionally).

In the meantime, here's some slides from my security lecture, not that its nothing you won't already find on wikipedia or stackoverflow.

>>3617

>When this is all over I'm going to post my notebook

Thanks Teach. I'd be interested in reading.

RSA:

Steps to produce private key (n,d) from public key (n, e).

1) factor n into 2 primes, p, q

2) compute phi = lowest_common_multiple(p-1,q-1) // euclid algo

3) compute d = modular_inverse(e, phi) // use ext. euclid algo

Private key is (n, d).

>>3623

Oh I already know that stuff. I was the one who wrote those guides for the lurkers who didn't know anything several threads ago and then stopped because I didn't understand the grid well enough at the time myself. I'm just talking about how you're meant to import keys into Java and get the modulus and exponent out of them. If you've already got that working I won't need to, but I think I can figure it out if you haven't.

>>3618

>>3621

>>3622

>>3626

Ok so I've had this ready to go since december… Good time to drop! Please keep it safe and don't go destroying the internet

Presenting sonic_rainboom.py

https://pastebin.com/vNqnPRJR

Full support for PEM certificates and certificate requests, armored PGP public keys, SSH public keys, and verification of results before outputting private key. And ECC of course.

Ponies not included

Have fun

>>3627

This is fantastic but where does the math go? In the VQC class? This is a great contribution but I'm still tempted to rewrite it in Java at some stage just so I understand it better.

>>3628

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

>>3628

Yep. Solution goes in the factors function.

If you generate your own keys you can test it with the private keys like this

class FakeVQC: def _load(self, key): f = open(key, 'rb') key = serialization.load_pem_private_key(f.read(), None, default_backend()) return key.private_numbers() def factors(self, c): priv = self._load('rsa/key.pem') return priv.p, priv.q def ecpoint(self, curve, x, y): priv = self._load('ecc/key.pem') return priv._private_value

>>3630

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

>>3631

Yeah

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.

>>3627

Wait so you solvedd the grid and this is it all solved? What's the algorithm can you explain it?

>>3634

Yeah, just saw that now!! Crazy! #ReleaseTheMemo

>>3635

No, this is just boring wrapper code to directly read the most common types of public keys, and output correctly formatted private keys. For some reason most crypto libraries have no way to just add private numbers to a public key (since its considered impossible, who needs functions for it). Just so we don't have to code it later!

The final ingredient is missing

>>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.

>>3638

Yeah and its tedious to do by hand even when you have the factors (especially PGP, the keys this spits out can be used right away). I wanted this available for when shit hits thef fan, and its a good way to verify our factoring algorithm against real keys as well (this could be considered illegal if they are not yours, fyi). This is the most obvious proof I can think of, right after solving all RSA numbers in a few minutes.

The "keep it safe" bit was serious too, please create backups!

>>3639

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

>>3640

I am not a lawyer. Hence the "could be". I'm betting someone will make the argument that cracking the Verisign root key shows malicious intent or something, DMCA laws and all. Would rather not be the one to defend that in a courtroom claiming "but mathematics!". Not disagreeing, just saying.

>>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?

>>3640

>>3641

Just to clarify, cracking RSA is completely fine, and can be proven without using keys you do not own as proof. Posting "someone elses" private keys, even if they are just numbers is a grey area imo. What you do is none of my business, but am pointing it out anyway.

>>3642

Obviously the proof will spread like wildfire and everything based on broken crypto will have a bad time. Nothing can stop that.

The tree we're working on now is not gonna put a dent in any cryptocurrencies until we get the crumbs on how elliptic curves are the same as prime numbers (or something). When that happens and ECC is broken as well, everyone will shit their pants, including bitcoiners, as there are no implemented alternatives ready to go, anywhere.

>>3644

I can't wait for the crazy shit Chris said we would do when we're ready to turn this into a company or whatever he called it, but, I've got to be honest, causing mass world hysteria sounds quite entertaining too, even if we're also affected ourselves. I bet CNN etc will try to act like they have any idea what they're talking about and act like they're super smart while saying absolutely nothing of substance (like the "hacker known as 4chan" thing), and all those YouTubers will try to make sense of it while the ones who use their accounts to teach people math will fumble around with it for a while.

Actually, now that I think about it, people might actually kill themselves over this when crypto goes under. A few did when it tanked recently. Fuck. I'm definitely still on board because this is inevitable and if anyone should do it it should be people like us who have good intentions, but I point this out because it should hopefully discourage anyone from taking credit for it publicly.

By the way, >>3577

>>3602

So I have a question for everyone: I'm looking at these factor trees (nice job, Anon!) and seeing all the smaller factors (the leaves?) medium size factors (branches) and larger factors (main trunks). Are these larger factors all prime?

>>3647

Thanks! RSA100 with primes colored red

>>3649

I see where you're going Baker. Sum of (1,c) factors can be used to create all the remaining factors? However, checking your math wouldn't it be 12/2 = 2 and 6. Then 6 = 3 and 2? So the termination points would be 1, 2, 2, 3? Could be wrong here, just trying to make sure I understand what you're hinting at. Can you elaborate on your idea?

>>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!

>>3655

Yeah, it's beautiful. Looks like the cross section of a giant sequoia, where you can see the growth rings.

>>3655

Checked! I will cook up some more tomorrow if the whole thing isn't broken already. Seem to have made more art during this adventure than actual breakthroughs, hope they're inspirational

>>3653

>>3654

You're just killing it with these, did you make them by hand? I might steal your color scheme. Awesome stuff

>>3657

Yes I did.

>>3654

So are you saying we can find one of the prime factors by adding up the "leaves" or "outer ring" of smaller factors and then use that to find the other prime factor? That would be cool!

>>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?

>>3660

What so we've figured it out? I was away for the last couple hours.

>>3662

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

>>3656

Just for you

>>3661

Its stupidly fast, even with unoptimized python code on a single core. Generating the images takes way longer

RSA100 tree without removing trailing zeroes (binary) is 0.3ms

RSA100 tree with all trailing zero bits removed on every branch is ~1ms (can probably cut this in half compared to my current code)

RSA2048 tree with zero bits removed is about 2.4ms…

The full RSA2048 circular image which is 18673x18723 and too large to post takes about half a minute.

Will see what happens if we need to remove one bit at a time and try all combinations of every branch though

>>3664

That looks like it could be turned into a really cool album cover.

>>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.

>>3664

Thanks Anon!

>>3666

Interesting Malicious Digits, Checked!

So we sum all the "leaves" (termination points) in the whole circle/tree to find one prime factor? That should be easy to verify for you programAnons. Is that your idea Baker?

>>3667

Yes.

>>3667

>Java

>Malicious Digits

Right on!

>That should be easy to verify for you programAnons

>should be

Did I mention I hate recursive programming?

>>3669

You can iterate.

>>3665

Gonna have to make an album now…

>>3670

Yeah but thats even more annoying when dealing with recursive problems. Easier to write it with recursion and refactor it with tail-calls and accumulators and shit afterwards, which says a lot.

>>3671

I'm a musician but as cool as I think it looks I wouldn't want to out myself publicly as a part of this.

>>3673

Good point. Have to wait till its public knowledge or obscure it really well. Tree-based procedural generation of landscapes from random RSA keys or something.

Wouldn't call myself a musician, I just mess around with synths tbh

>>3660

Is this leaf addition thing true? If so, its easy to code. I'll test it out gladly if its known to be true.

>>3666

Man, you keep getting trips all the time. Were you working on a Java version or did you want someone else to?

>>3674

Yeah, I don't know if you've thought about it much, but consider >>3645 this. Once it's all over the media and everything people might be able to get away with it. I've been trying to think of ways to use the grid to create music, too.

>Wouldn't call myself a musician, I just mess around with synths tbh

There are people who consider themselves musicians who don't even know how to mess with synths, so I hope you don't say that out of pessimism. I'm a little more invested in it than that. I have a thing recorded and mixed professionally, and one of the song names is a subtle reference to Q. It's not out yet, but hopefully it's subtle enough that all 5 people who will ever hear it don't think I'm an evil internet hacker nazi who masturbates to anime.

>>3675

Teach. Looking into this now also.

Sample for c=481 attached. I added (x+n) just as conceptual for which nodes get included.

>>3676

There is all kinds of applications for this that we can't even imagine yet. Guess its called the tree of knowledge for a reason… can't wait to se where we're going, now that the tree is taking shape my mind is already going crazy with possibilities

No pessimism here, just a fun hobby I hope to get good at someday, if not its still fun! Good luck with your album/EP!

>evil internet hacker nazi who masturbates to anime.

Did I forget how deep this rabbit hole is again? Yay for reminders

>>3677

Also added prime factors for d[t] and a[t] analysis. See pic attached for c=481.

The d[t]-d primes column really clarified for me where the values are we are searching for.

Also, if you look at the (40,1,209) record, the d[t]-d value can be calculated by (xx-f)*(n-1). Perhaps the tree factors are a way to simply remove certain factors from the value?

>>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.

>>3641

Yeah, I'm so screwed on that also.

BUT THERE WERE POOOOOONIIIIIIIES!!!!!

>>3682

Insanity plea?

Btw, here's my algorithm for calculating private key from 2 primes, written in js, not using BigInts yet. Its very simple.

var p = 61;

var q = 53;

var e = 17;

var p1q1 = (p-1)*(q-1);

var lcm = (p1q1)/xgcd(p-1, q-1)[2]

var mi = xgcd(e, lcm);

var d = lcm + mi[0];

console.log(d)

function xgcd(a,b) {

if (b == 0) {

return [1, 0, a];

} else {

temp = xgcd(b, a % b);

x = temp[0];

y = temp[1];

d = temp[2];

return [y, x-y*Math.floor(a/b), d];

}

}

>>3681

That's where I'm stuck too. Playing with the tree now.

>>3685

>>3681

My only thought so far is adding every possibility (no division, divide once, twice etc.) as a separate branch and summing the leaves for every case. It should still be pretty quick considering how small the trees are, but a pain to code.