ID: 99fc86 RSA #7 Dec. 30, 2017, 4:21 a.m. No.1713   πŸ—„οΈ.is πŸ”—kun

Our task is simple. We are going to completely break the entire RSA cryptosystem! We're bigshots now.

 

But wait, how are we going to just crack RSA? With the Virtual Quantum Computer! Quick rundown to follow.

 

The main mathematical task that must be achieved to break RSA is to be able to factorize any integer instantly. The VQC is a promising way to do that.

 

What is the VQC?

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

The grid is the superposition. The collapse of that superposition will be two input parameters, d and e which can be calculated easily for all integers, c, where c is the difference of two squares.

 

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

 

Legend

The map's legend is {e:n:d:x:a:b}, where d is the result of removing the largest square from c AKA the square root,

e is the remainder,

n is what you add to d to be exactly halfway between a and b,

and x is what you add to a to make d.

c is any number that is the difference of two squares, so odd numbers are included.

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

 

Rules of the grid: global rules

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

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

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

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

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

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

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

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

The x-intercept of the line that goes through the point containing the factors of c is (a + 1).

 

(1, 1) - the key

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

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

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

 

(f, 1) is an interesting cell.

 

Columns

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

If c is a prime number, it will appear in one column exactly once.

If c is the product of two prime numbers that do not equal eachother, c will appear in two cells of one column.

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

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

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

 

(e, 1)

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

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

 

Rows

(1, n)

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

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

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

Every single factor of any value of a in the first row will be referred to as s.

 

Useful Equations and Notation

ab = c

dd + e = c

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

a + 2x + 2n = b

a = d - x

d = a + x

d = floor_sqrt(c)

e = c - (dd)

b = c / a

n = the difference between the square root d and the larger of the two squares

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

d + n = number that is exactly halfway between a and b

d + n = i

x = d - a

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

x + n = j

f = e - 2d + 1

t = the variable that lets you traverse the infinite elements in for a given (e, n) that has values.

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

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

ID: 99fc86 Dec. 30, 2017, 4:21 a.m. No.1714   πŸ—„οΈ.is πŸ”—kun   >>2317

CodePost Guide

Because of the tendency for post links to disappear I will now be using Pastebin.

 

C#

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

Generate Bitmap within original code β€”β€” pastebin.com/hMTtJF6E

More on generating a bitmap with the original code β€”β€” pastebin.com/JUdtehb4

Generate the large square for e and t β€”β€” pastebin.com/nbjs2kz4

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

How to run VQC code on Linux β€”β€” pastebin.com/6HnN7K5X

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

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

 

Java

Create a Bitmap using the VQC Generator β€”β€” pastebin.com/Dgu9aP1h

VQCGenerator β€”β€” pastebin.com/VMRnkXFP

Traverse the VQC cells in real-time β€”β€” anonfile.com/W44cofd6b6/VQCGUI.7z

Traverse the VQC cells in real-time [V2] β€”β€” anonfile.com/TeH6q3d8bd/VQCGUI_v2.7z

 

NodeJS

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

 

Python

College Anon's code (VERY USEFUL) β€”β€” pastebin.com/d8xZZnm0

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

3D VQC β€”β€” pastebin.com/vdf8SpYt

3D VQC (v2) β€”β€” pastebin.com/wZM5Thzu

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

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

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

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

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

Get A and B from C and N example β€”β€” pastebin.com/s0SZ9BNF

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

 

Rust

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

Create Bitmap using the VQC Generator β€”β€” play.rust-lang.org/?gist=c2446efeec452fe14e1ddd0d237f4173&version=stable

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

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

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

 

Previous Threads

RSA #0, or the VQC thread β€”β€” archive.fo/XmD7P

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

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

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

RSA #4 (not finished, but dead) β€”β€” archive.fo/eihrQ

RSA General (#5) β€”β€” >>7

RSA #6 β€”β€” >>848

 

Videos and Links

For those who are passionate about cryptography (or want to be).

 

Integer Factorization of any arbitrary integer β€” Part One

youtube.com/watch?v=9FeROMe0KBU

 

The RSA Encryption Algorithm (1 of 2: Computing an Example) (Very Simple)

youtube.com/watch?v=4zahvcJ9glg

 

Encryption and HUGE numbers - Numberphile

youtube.com/watch?v=M7kEpw1tn50

 

Public Key Cryptography: RSA Encryption Algorithm

youtube.com/watch?v=wXB-V_Keiu8

 

RSA-129 - Numberphile

youtube.com/watch?v=YQw124CtvO0

 

Elliptic Curve Cryptography Overview

youtube.com/watch?v=dCvB-mhkT0w

 

A (relatively easy to understand) primer on elliptic curve cryptography

arstechnica.com/information-technology/2013/10/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/2/

 

Elliptic Curve Cryptography: a gentle introduction

andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/

 

Elliptic Curve Point Addition

youtube.com/watch?v=XmygBPb7DPM

ID: 99fc86 Dec. 30, 2017, 4:21 a.m. No.1715   πŸ—„οΈ.is πŸ”—kun   >>1721

Map of Chris (lel)

 

RSA #2

>>>/cbts/50228

>>>/cbts/53383

>>>/cbts/53432

>>>/cbts/53436

>>>/cbts/53466

>>>/cbts/53468

>>>/cbts/53469

>>>/cbts/53473

>>>/cbts/53475

>>>/cbts/53479

>>>/cbts/53481 *** importante

>>>/cbts/53482

>>>/cbts/53607

>>>/cbts/53609

>>>/cbts/53613

>>>/cbts/53615

>>>/cbts/53662

>>>/cbts/53668

>>>/cbts/53673

>>>/cbts/53678

>>>/cbts/53680

>>>/cbts/53681

>>>/cbts/53699

>>>/cbts/53770

>>>/cbts/58934

>>>/cbts/59055

>>>/cbts/65200

 

RSA #3

>>>/cbts/87168

>>>/cbts/87234

>>>/cbts/87300

>>>/cbts/87378

>>>/cbts/87414

 

RSA #4

>>>/cbts/98492

>>>/cbts/98560

>>>/cbts/107338

>>>/cbts/107342 rt >>>/cbts/107256

>>>/cbts/111903

>>>/cbts/111975 rt >>>/cbts/111942

>>>/cbts/111983

>>>/cbts/112148

>>>/cbts/112422

>>>/cbts/112425

>>>/cbts/112429 rt >>>/cbts/112172

 

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 (to date)

>>1099

>>1380

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 30, 2017, 11:31 a.m. No.1742   πŸ—„οΈ.is πŸ”—kun   >>1744

>>1737

>>1739

 

Furthermore, it "closes the gap" between the f and small square formulas.

 

>>1572

 

Reposting again from VQC:

 

( f is what you add to c to make a square )

 

f = 2d + 1 - e

( x + n )( x + n ) = nn + 2d( n - 1 ) + f - 1

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 11:32 a.m. No.1743   πŸ—„οΈ.is πŸ”—kun   >>1745

Is this the new thread?

 

>>1739

Ok, I see, so for our na row, d and a will be (n-1)a more.

I don't know if I missed this earlier, and you guys already have it all figured out, but this is I think exactly what VQC meant here:

>Tomorrow I will show the way in which na and (n-1)a relationships between a[t] and d[t] in row 1 cells (e,1)

 

Have you been looking at these relationships in the a x b row too?

 

>>1740

Glad I could help, although this is all still very unclear for me.

 

I've found hundreds of relationships and interesting things over the last week, but none of them have been useful at all. I just keep redefining the problem.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 30, 2017, 11:36 a.m. No.1745   πŸ—„οΈ.is πŸ”—kun   >>1746 >>1747

>>1743

>Have you been looking at these relationships in the a x b row too?

Yes. I've got output for all the test cases we previously discussed with their na transforms, plus various increments of e.

 

Even went up to c^4 to see if there were any patterns at higher numbers.

 

>>1744

>f is more important than you think. Take a look at (f, 1).

I have a feeling… Looking into right now!

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 11:42 a.m. No.1746   πŸ—„οΈ.is πŸ”—kun   >>1748 >>1751

>>1745

>Even went up to c^4 to see if there were any patterns at higher numbers.

 

Lol, I did the same.

 

Couple more clarifications:

> f = 2d + 1 - e

 

>>1744

>f is more important than you think. Take a look at (f, 1).

 

Isn't this formula around the wrong way? Wouldn't this give you -f?

 

I'm sure we said f = e - (2d+1)

 

If you keep performing that movement, eventually you can get back to the 1 row (or 0 row) as well but on the negative side.

 

Have you had a look at these relationships too?

ID: 99fc86 Dec. 30, 2017, 11:44 a.m. No.1747   πŸ—„οΈ.is πŸ”—kun   >>1751

>>1745

The VQC is 3-dimensional, and making an a^3 * b^3 = c^3 cell would create cubes instead of squares.

 

Chris said you could draw a line of symmetry down the VQC and fold it onto itself. (f, 1) is how.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 30, 2017, 12:04 p.m. No.1751   πŸ—„οΈ.is πŸ”—kun   >>1752 >>1753

>>1747

So the (f,1,t) entries are interesting.

 

Example below.

 

145=5x29

 

a x b *=(1,5,4) = {1:5:12:7:5:29} = 145; f = (2 * 12) + 1 - 1 = 24; (5*5) + 2 * 12 * (5 - 1) + 24 - 1 = 144; (x+n)^2=12x12=144;

a x b na =(1,1,4) = {1:1:32:7:25:41} = 1025; f = (2 * 32) + 1 - 1 = 64; (1*1) + 2 * 32 * (1 - 1) + 64 - 1 = 64; (x+n)^2=8x8=64;

a x b e=f =(24,1,4) = {24:1:36:6:30:44} = 1320; f = (2 * 36) + 1 - 24 = 49; (1*1) + 2 * 36 * (1 - 1) + 49 - 1 = 49; (x+n)^2=7x7=49

1 x c =(1,61,6) = {1:61:12:11:1:145} = 145; f = (2 * 12) + 1 - 1 = 24; (61*61) + 2 * 12 * (61 - 1) + 24 - 1 = 5184; (x+n)^2=72x72=5184;

1 x c na =(1,1,6) = {1:1:72:11:61:85} = 5185; f = (2 * 72) + 1 - 1 = 144; (1*1) + 2 * 72 * (1 - 1) + 144 - 1 = 144; (x+n)^2=12x12=144;

1 x c e=f =(24,1,6) = {24:1:72:10:62:84} = 5208; f = (2 * 72) + 1 - 24 = 121; (1*1) + 2 * 72 * (1 - 1) + 121 - 1 = 121; (x+n)^2=11x11=121

 

Similar to the na records, the e=f records satisfy the condition f = (x+n)^2.

 

Any more crumbs to share while I look for additional relationships?

 

>>1746

I don't know that we are talking about the same f. Someone else please clarify

 

The original F formula was used to create a record in the negative part of the grid. You are correct with "f = e - (2d+1)".

 

But VQC most certainly posted the other formulas:

 

from your pastebin

https:/ /pastebin.com/eHJTEwWY

>In the original vqc, I used f = 2d+1-e as the negative -e coord.

>f = 2d+1-e (f is what you add to c to make a square)

>(x+n)(x+n) = nn + 2d(n-1) + f - 1

Anonymous ID: 99fc86 Dec. 30, 2017, 12:08 p.m. No.1752   πŸ—„οΈ.is πŸ”—kun   >>1754 >>1768

>>1751

Yeah, and I'm sorry I can't just provide the meat of it, I had a friend that worked through this but would not share all of it.

 

I'm not exactly sure if it's f or -f that shows this, but f shows you that the cells left of 0, e<0 are literally just a mirror of the cells on the right of 0, e>0.

Anonymous ID: 96255b Dec. 30, 2017, 2:04 p.m. No.1766   πŸ—„οΈ.is πŸ”—kun

>>1750

All I did was go through each of the threads, copy and paste the relevant posts and separate them with a line of dashes. I didn't do any formatting (which is why some posts look different to others).

Anonymous ID: 01377b Dec. 30, 2017, 2:24 p.m. No.1767   πŸ—„οΈ.is πŸ”—kun

>>1755 we got some bitchin' batter to be throwin' in. doze 40watts are cookin' @1.21gigawatts!

>>1757 v.nice MA, or should we call you Claude!? The secret ingredient is LOVE damnit!

>>1761 pony up!

The quick links to EZ bake sure work nice for flow - we be syncin' anons!

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 30, 2017, 2:26 p.m. No.1768   πŸ—„οΈ.is πŸ”—kun   >>1770 >>1776

>>1752

Pic attached is an analysis of c=145 for various combinations of c, cc, ab, aabb, with their respective na, f, records.

 

(f in balance) indicates f = (x+n)^2.

 

Not sure yet how this is relevant.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 30, 2017, 2:37 p.m. No.1771   πŸ—„οΈ.is πŸ”—kun

>>1770

sorry, I'm not explaining myself very well.

 

there's an alternate formula that VQC gave us for (x+n)^2.

 

nn + 2d( n - 1 ) + f - 1

 

I'm checking to see if that formula equals f = 2d + 1 - e.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 30, 2017, 2:44 p.m. No.1772   πŸ—„οΈ.is πŸ”—kun   >>1773

>>1770

sorry again. yes, I do realize.

 

I posted earlier that we may be able to solve this with just the (x+n) value.

 

Struggling to find any connection between any of these records.

VeritasAequitas !!Nf9AmQNR7I ID: 33285a Dec. 30, 2017, 4:09 p.m. No.1775   πŸ—„οΈ.is πŸ”—kun   >>1776

>>1773

>>1774

Hey PMA! So are those old t equations going to work for small square? Was it:

even e: (2t)^2

Odd e: (2t-1)^2

I think that’s correct.

Also, do the transformations to row one work for other examples?

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 30, 2017, 5:15 p.m. No.1776   πŸ—„οΈ.is πŸ”—kun

>>1775

Small square equations are good. If we can identify the (x+n) of the desired record, we have t and a direct link.

 

Not sure about the transformations for other examples.

>>1768

 

I've currently got a workflow set up to create na, f and "-" negative records.

 

Don't know if these are even the records that can potentially link to an answer.

Anonymous ID: 96255b Dec. 30, 2017, 5:48 p.m. No.1781   πŸ—„οΈ.is πŸ”—kun   >>1782

>>1780

First you should prove that you solved it. Are there are RSA-encrypted messages out there? You know, maybe someone's emails got leaked but they're encrypted with their public key. Wikileaks or something.

CollegeAnon !LAbIRp9cT. ID: b65f84 Dec. 30, 2017, 5:57 p.m. No.1782   πŸ—„οΈ.is πŸ”—kun   >>1783 >>1784 >>1785 >>2160

>>1781

Well idk how to exactly fit in the public key, could you help me with that?

 

Basically I can factor a product of 2 primes easily. If given a public key, could you give me the steps I would need to solve it? Like do I factor d? Is that it?

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 30, 2017, 6 p.m. No.1784   πŸ—„οΈ.is πŸ”—kun   >>1793

>>1782

Factor this number:

17969491597941066732916128449573246156367561808012600070888918835531726460341490933493372247868650755230855864199929221814436684722874052065257937495694348389263171152522525654410980819170611742509702440718010364831638288518852689

Anonymous ID: 96255b Dec. 30, 2017, 6:01 p.m. No.1785   πŸ—„οΈ.is πŸ”—kun   >>1786

>>1782

You know what, I'll set up my own public and private keys, I'll see if I can encrypt a message, I'll post it here along with the public key used to encrypt it, and then you can take c from the public key and unencrypt my message. Give me like 5 minutes, I can't quite remember how to do that.

Anonymous ID: 99fc86 Dec. 30, 2017, 6:02 p.m. No.1786   πŸ—„οΈ.is πŸ”—kun   >>1787

>>1785

No, just factor the RSA numbers. You have to delve into the PGP specification to get the c values from public keys, which I'm qualified for and could code if he really has found a solution.

Anonymous ID: 99fc86 Dec. 30, 2017, 6:04 p.m. No.1788   πŸ—„οΈ.is πŸ”—kun

>>1787

I've worked with Bouncy Castle for a long time and I could not figure out how to get the c value. If you google it you get a bunch of stupid irrelevant questions, it's as if nobody besides an academic has ever genuinely tried to crack RSA.

CollegeAnon !LAbIRp9cT. ID: b65f84 Dec. 30, 2017, 6:18 p.m. No.1794   πŸ—„οΈ.is πŸ”—kun   >>1795 >>1796 >>1797 >>1799 >>1801 >>1813 >>1819 >>2160

>>1793

 

factorRSA(17969491597941066732916128449573246156367561808012600070888918835531726460341490933493372247868650755230855864199929221814436684722874052065257937495694348389263171152522525654410980819170611742509702440718010364831638288518852689)

(1, 17969491597941066732916128449573246156367561808012600070888918835531726460341490933493372247868650755230855864199929221814436684722874052065257937495694348389263171152522525654410980819170611742509702440718010364831638288518852689L, True)

 

It was taking a while but I made the algorithm better and solved it.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 6:22 p.m. No.1798   πŸ—„οΈ.is πŸ”—kun   >>1802

>>1795

If you guys need to generate any more keys to test with here's how:

 

openssl genrsa -out ./test.key 128

openssl rsa -text -noout < test.key

 

The "modulus" field is the C to factor, prime1 and prime2 will be A & B.

 

Congrats CollegeAnon!!!

 

Show us that algorithm!

CollegeAnon !LAbIRp9cT. ID: b65f84 Dec. 30, 2017, 6:57 p.m. No.1818   πŸ—„οΈ.is πŸ”—kun   >>1819 >>1820 >>1821

Look through my notes. You can solve it too.

 

I'm trying to fix a thing where I do repeated addition to change it to a multiplication. The big RSA number was taking like more than 5 minutes so I'm trying to optimize it. Now I can't even factor 145 :(

VeritasAequitas !!Nf9AmQNR7I ID: a610b4 Dec. 30, 2017, 7:09 p.m. No.1821   πŸ—„οΈ.is πŸ”—kun   >>1822

>>1817

Agreed, Teach!

>>1818

CA, thanks for having balls and putting your solution out there. Let’s troubleshoot and keep going! It’s really good to have your enthusiasm and brains on the task at hand.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 30, 2017, 7:32 p.m. No.1825   πŸ—„οΈ.is πŸ”—kun   >>1827 >>1830

>>1824

teach - pending CA’s breakthrough, if you review the notes above, it seems like we only need to find the delta in small squares to solve this thing.

 

we know x+n from c, we know x+n from ab.

Should we search for records that give the difference?

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 7:37 p.m. No.1830   πŸ—„οΈ.is πŸ”—kun   >>1831 >>1832

>>1825

I like your thinking PMA.

 

I'm trying to work on something now actually.

It seems that the x+n for 1xc and x+n for axb share factors.

 

So I've been following this stupid idea, not sure if it'll amount to anything, but I'm thinking that x+n is about half of c at the 1xc record.

And we know that the axb little square shares factors with the x+n, so why don't we recursively try to factor x+n.

 

Like I said, x+n for 1xc is about half of c, so that would suffice for our log n runtime.

 

Where I'm stuck is post finding our factors.

 

So recursively run down the stack, you eventually get to some prime number… then what?

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 7:58 p.m. No.1834   πŸ—„οΈ.is πŸ”—kun   >>1835

Ok, one more thing…

I think some of this overlaps with CA's work.

 

So you calculate f for our 1xc row, and don't stop there, just keep repeating that calculation.

 

Eventually you will get back to n = 0, and at that point, -e will always be a perfect square.

 

Repeat that process again but from axb, same deal.

 

No new info yet, and I get it, I'm just iterating. But here's the thing…

 

If you log as you iterate from the 1xc record any time you hit a perfect square on the way to n=0, you'll only ever get 1 hit. And that hit will correlate to the same as the -e for axb.

 

I think this can actually be useful, I'm just trying to figure out how.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 8:16 p.m. No.1836   πŸ—„οΈ.is πŸ”—kun   >>1838 >>1842

>>1835

At the point that you're at a perfect square, the n at that moment will be equal to 1xc.n - axb.n, which makes sense.

 

My approach now is to switch back to the algebra, write both equations and solve simultaneously.

The occurrence of the perfect squares is clearly parabolic and easy to calculate. The other is something I dont know the right word for. It not linear, its not exactly log (or exp if you go the other way), but similar to it. Math is my weakest part though.

 

Honestly, I think CA was trying to say a lot of these same thoughts back in RSA #6. I would not be surprised if he really was close to a solution.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 8:30 p.m. No.1839   πŸ—„οΈ.is πŸ”—kun   >>1840 >>1845

>>1838

Here's my code (sorry for js, but pretty readable):

 

var newE = c1.e;

var newD = c1.d;

var newN = c1.n;

var newX = c1.x;

 

for (var i = 1; i <= c1.n; i+=1) {

newE -= 2*newD + 1;

newD += 1;

newN -= 1;

newX = Math.sqrt(-newE);

if (Math.sqrt(-newE) % 1 == 0 && newN 0) {

console.log('hittttt newE', newE);

console.log(newE, newN, newD, newX);

}

}

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 8:36 p.m. No.1843   πŸ—„οΈ.is πŸ”—kun   >>1845 >>1856

I actually already did this calculation once before on my whiteboard, but I ignored it and moved on.

 

But if we're calculating next e = e - (2*d +1)

And each time we increment d.

What is the equation at e without calculating the previous e.

 

This has to do with using Sigma n = n(n+1) / 2.

Anonymous ID: 39766a Dec. 30, 2017, 8:47 p.m. No.1846   πŸ—„οΈ.is πŸ”—kun   >>1848 >>1853 >>1864 >>1905

First, well done. An if you aren't larping us, might be time to pick up on that 'disclosure' thread. Think of how software vulnerabilities are handled today as an example of how this might play out.

 

>>1826

Actually, don't give the other, it's an RSA. Wouldn't want you getting into trouble now CA.

 

Give us this one, it's a c that is the product of two primes a and b. You won't be 'breaking' anything, but this one example. Can give you dozens of examples like this.

 

422692110585147497553322500844140669992025757185689126521088324451300697911273329660714127618238186848623098157579122766099467283497020800856086697355540840120469652125790131359297

 

It's 180 digits long, easier than RSA100 even.

Godspeed, you've got 30 minutes, starting … NOW.

Anonymous ID: 96255b Dec. 30, 2017, 8:50 p.m. No.1847   πŸ—„οΈ.is πŸ”—kun

In case for some reason CA isn't completely right, I think I just found a way to calculate i from c using binary search (meaning you can then calculate n). I need to try a few more test cases of c but it works for 35. I might be wrong of course.

CollegeAnon !LAbIRp9cT. ID: b65f84 Dec. 30, 2017, 8:55 p.m. No.1849   πŸ—„οΈ.is πŸ”—kun   >>1852

I don't think I got it its taking too long. It works fast for small numbers but I let my CPU run for like an hour and a half for that bigass RSA number so I'm disheartened. Maybe my way is not the fastest way to do it. VQC said it would solve it practically instantaneously right?

CollegeAnon !LAbIRp9cT. ID: b65f84 Dec. 30, 2017, 8:58 p.m. No.1853   πŸ—„οΈ.is πŸ”—kun

>>1846

I'll try for this one but I'm testing other stuff now. I'm now starting to think we may need to be able to factor another number and then run it recursively.

 

Basically you generate a cell from (1,c) then use the D and traverse along the D until you get the same E value as the first one. Fairly simple

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 9:02 p.m. No.1856   πŸ—„οΈ.is πŸ”—kun   >>1861

>>1845

Notice the -e in the function. You have to flip the sign.

 

>>1843

If you want to calculate the e variable for any point in that series, you can calculate it instead of iterating.

The calculation to jump 's' number of steps backwards towards n=0, for e is:

 

E = e - (s^2 + (3+4d)s)/2

 

I hate to add new variables, but s will be the difference in n values, so if you start at n = 61 and you want to get to n = 5, s = 61-5 = 56.

Anonymous ID: 96255b Dec. 30, 2017, 9:12 p.m. No.1860   πŸ—„οΈ.is πŸ”—kun   >>1862

>>1858

People study it but they don't accomplish it. If someone breaks RSA (which is obviously going to happen), they're going to mess a lot of people's shit up for a while. You obviously would have found this board because of /cbts/. Don't you think there are powerful people who would want to either protect their shit or get revenge on whoever managed to get into their shit?

Anonymous ID: 39766a Dec. 30, 2017, 9:26 p.m. No.1864   πŸ—„οΈ.is πŸ”—kun   >>1865

>>1846

Time up a bit ago, thanks for trying though. Personal lesson learned wrt testing chit out before throwing your trips away. Love the work everyone doing, great energy here, fun night.

 

>>1858

It's the window between when you're the only credible one with 'the secret' and when the secret 'is out' and disseminated beyond the containment point that there's the most personal risk. Analogous to those w/ cell footage of 911 or Vegas and the collection activities. Might be why VQC has held off on a real demo like the one posted (vs. the faith angle)? Most def V&, and have your fav pen ready for the NDA signing. Would be surprised if the suiciders are here right now, they've likely got their hands full at the moment (or tied up). Later come those with the losses who just want to feel better about it. Best solution to save one's ass is to pastebin the sauce asap.

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 30, 2017, 9:31 p.m. No.1865   πŸ—„οΈ.is πŸ”—kun   >>1866 >>1872

>>1864

There's also a strong possibility the RSA factors could be boobytrapped in any CPU's microcode. i.e, they're already known by the NSA, and a CPU can detect them in it's memory register, and send out a distress call to the network before self-destructing.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 9:34 p.m. No.1867   πŸ—„οΈ.is πŸ”—kun   >>1869

>>1861

Yep, I've cleaned it up a bit for you (again, ignore my x values down in the bottom part):

 

213 = 3 * 71

a,b {"c":213,"e":17,"n":23,"d":14,"x":11,"a":3,"b":71,"t":6}

1,c {"c":213,"e":17,"n":93,"d":14,"x":13,"a":1,"b":213,"t":7}

—–

a,b f {"c":213,"e":-12,"n":22,"d":15,"x":12,"a":3,"b":71,"t":7}

1,c f {"c":213,"e":-12,"n":92,"d":15,"x":14,"a":1,"b":213,"t":8}

—–

Repeating f calculation on 1xc:

{ e: -12, n: 92, d: 15, x: 3.4641016151377544 }

{ e: -43, n: 91, d: 16, x: 6.557438524302 }

{ e: -76, n: 90, d: 17, x: 8.717797887081348 }

{ e: -111, n: 89, d: 18, x: 10.535653752852738 }

{ e: -148, n: 88, d: 19, x: 12.165525060596439 }

{ e: -187, n: 87, d: 20, x: 13.674794331177344 }

{ e: -228, n: 86, d: 21, x: 15.0996688705415 }

{ e: -271, n: 85, d: 22, x: 16.46207763315433 }

{ e: -316, n: 84, d: 23, x: 17.776388834631177 }

{ e: -363, n: 83, d: 24, x: 19.05255888325765 }

{ e: -412, n: 82, d: 25, x: 20.29778313018444 }

{ e: -463, n: 81, d: 26, x: 21.517434791350013 }

{ e: -516, n: 80, d: 27, x: 22.715633383201094 }

{ e: -571, n: 79, d: 28, x: 23.895606290697042 }

{ e: -628, n: 78, d: 29, x: 25.059928172283335 }

{ e: -687, n: 77, d: 30, x: 26.210684844162312 }

{ e: -748, n: 76, d: 31, x: 27.349588662354687 }

{ e: -811, n: 75, d: 32, x: 28.478061731796284 }

{ e: -876, n: 74, d: 33, x: 29.597297173897484 }

{ e: -943, n: 73, d: 34, x: 30.708305065568176 }

{ e: -1012, n: 72, d: 35, x: 31.811947441173732 }

{ e: -1083, n: 71, d: 36, x: 32.90896534380867 }

hittttt newE -1156

{ e: -1156, n: 70, d: 37, x: 34 }

{ e: -1231, n: 69, d: 38, x: 35.08560958569767 }

{ e: -1308, n: 68, d: 39, x: 36.16628264005025 }

{ e: -1387, n: 67, d: 40, x: 37.242448899072144 }

{ e: -1468, n: 66, d: 41, x: 38.31448812133603 }

{ e: -1551, n: 65, d: 42, x: 39.382737335030434 }

{ e: -1636, n: 64, d: 43, x: 40.44749683231337 }

{ e: -1723, n: 63, d: 44, x: 41.50903516103452 }

 

[[[ truncated a bunch of nonsense rows because "body too long" ]]]

 

{ e: -8436, n: 14, d: 93, x: 91.84770002564028 }

{ e: -8623, n: 13, d: 94, x: 92.86010984270911 }

{ e: -8812, n: 12, d: 95, x: 93.87225362161068 }

{ e: -9003, n: 11, d: 96, x: 94.88413987595608 }

{ e: -9196, n: 10, d: 97, x: 95.89577675789482 }

{ e: -9391, n: 9, d: 98, x: 96.90717207719973 }

{ e: -9588, n: 8, d: 99, x: 97.91833331914918 }

{ e: -9787, n: 7, d: 100, x: 98.92926766129425 }

{ e: -9988, n: 6, d: 101, x: 99.93998198919189 }

{ e: -10191, n: 5, d: 102, x: 100.9504829111778 }

{ e: -10396, n: 4, d: 103, x: 101.96077677224709 }

{ e: -10603, n: 3, d: 104, x: 102.97086966710536 }

{ e: -10812, n: 2, d: 105, x: 103.98076745244767 }

{ e: -11023, n: 1, d: 106, x: 104.99047575851822 }

{ e: -11236, n: 0, d: 107, x: 106 }

Repeating f calculation on axb:

{ e: -12, n: 22, d: 15, x: 3.4641016151377544 }

{ e: -43, n: 21, d: 16, x: 6.557438524302 }

{ e: -76, n: 20, d: 17, x: 8.717797887081348 }

{ e: -111, n: 19, d: 18, x: 10.535653752852738 }

{ e: -148, n: 18, d: 19, x: 12.165525060596439 }

{ e: -187, n: 17, d: 20, x: 13.674794331177344 }

{ e: -228, n: 16, d: 21, x: 15.0996688705415 }

{ e: -271, n: 15, d: 22, x: 16.46207763315433 }

{ e: -316, n: 14, d: 23, x: 17.776388834631177 }

{ e: -363, n: 13, d: 24, x: 19.05255888325765 }

{ e: -412, n: 12, d: 25, x: 20.29778313018444 }

{ e: -463, n: 11, d: 26, x: 21.517434791350013 }

{ e: -516, n: 10, d: 27, x: 22.715633383201094 }

{ e: -571, n: 9, d: 28, x: 23.895606290697042 }

{ e: -628, n: 8, d: 29, x: 25.059928172283335 }

{ e: -687, n: 7, d: 30, x: 26.210684844162312 }

{ e: -748, n: 6, d: 31, x: 27.349588662354687 }

{ e: -811, n: 5, d: 32, x: 28.478061731796284 }

{ e: -876, n: 4, d: 33, x: 29.597297173897484 }

{ e: -943, n: 3, d: 34, x: 30.708305065568176 }

{ e: -1012, n: 2, d: 35, x: 31.811947441173732 }

{ e: -1083, n: 1, d: 36, x: 32.90896534380867 }

{ e: -1156, n: 0, d: 37, x: 34 }

Anonymous ID: 39766a Dec. 30, 2017, 9:54 p.m. No.1872   πŸ—„οΈ.is πŸ”—kun   >>1874 >>1875

>>1865

>>1868

Interesting, thanks MA.

Intel x86s hide another CPU that can take over your machine (you can't audit it)

https:/ /boingboing.net/2016/06/15/intel-x86-processors-ship-with.html

Introducing Ring -3 Rootkits

http:/ /invisiblethingslab.com/resources/bh09usa/Ring%20-3%20Rootkits.pdf

Intel ME (Manageability engine) Huffman algorithm

http:/ /io.netgarage.org/me/

Security Analysis of x86 Processor Microcode

https:/ /www.dcddcc.com/docs/2014_paper_microcode.pdf

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 30, 2017, 10:01 p.m. No.1875   πŸ—„οΈ.is πŸ”—kun   >>1876 >>1877

>>1871

Based on what Chris has said, it should take a second to factor an RSA4096 number. Say for an average CPU, that's a couple thousand operations.

 

>>1872

I couldn't think of a more apt use for a hidden CPU. Hardware backdoor, and a monitor for something extremely serious, like the factors for an unfactorable number, or the wikileaks insurance file key, etc, etc.

Anonymous ID: 99fc86 Dec. 30, 2017, 10:03 p.m. No.1876   πŸ—„οΈ.is πŸ”—kun   >>1878

>>1875

That's a nice conspiracy theory, but it can't be implemented without a lot of suspicious parts.

They'd need to use an elaborate hashing algorithm if they wanted something to be safe, but to also check for such a condition.

And what are they gonna do, hash your whole memory? CPU would rape itself.

 

Not happening.

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 30, 2017, 10:23 p.m. No.1878   πŸ—„οΈ.is πŸ”—kun   >>1879 >>1881

>>1876

Where did you come from? /cbts/? What would you consider more realistic conspiracy theories? Hollow/inner earth? Global satanic pedophile ring? Anti-gravity/free energy devices? Public/private domain? Reptilians? And a tiny piece fragment of extremely advanced silicon is outlandish?

 

>>1877

My gut says it's a formula for N, one that takes E, and D, and spits out possible N's. I also think the key is in the -E space.

Anonymous ID: 99fc86 Dec. 30, 2017, 10:28 p.m. No.1879   πŸ—„οΈ.is πŸ”—kun   >>1880

>>1878

Yes, I came from cbts. You're right, it's pretty ironic that I find a CPU checking for certain factors and keys more outlandish than pete'sgate, CIA killing kennedy, and the rothschilds controlling the world

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 30, 2017, 10:36 p.m. No.1881   πŸ—„οΈ.is πŸ”—kun

>>1878

we know e, d, and c.

 

I agree that we need to solve for n. I believe that the movement revolves around the small square (x+n). And if we can find a pattern for how it increases from the c record to the ab solution, solving for N is easy.

 

Also looking into the -E space.

VQC !!Om5byg3jAU ID: 1e0656 Dec. 30, 2017, 10:46 p.m. No.1882   πŸ—„οΈ.is πŸ”—kun   >>1883 >>1884 >>1885 >>1888 >>1890 >>1896 >>1901 >>1909 >>1927 >>1968 >>1989 >>2067

The sophistication and organisation in this thread now is impressive.

Thank you for your efforts.

Again, impressive.

Please remember that this is the first step and we will be going through a journey.

Is there anyone more practical with access to 3D printing as we can run the sonoluminescence thread in parallel and it will be quite rewarding to build a fully functioning cold fusion generator?

Perfectly safe, boils water.

Thought it may be fun for those who prefer to build stuff.

A warning, scaling up the multi bubble fusion work would likely bring you media attention, so please bear that in mind.

I will post more on The Grid later but think about the distribution of n and (n-1) in cell (e,1) in the a[t] and d[t] values respectively. This is the quick way to utilising f.

Anonymous ID: 96255b Dec. 30, 2017, 10:53 p.m. No.1885   πŸ—„οΈ.is πŸ”—kun   >>1887

>>1882

Hey, if one of us cracks RSA should we post it? You said you were holding because of something Trump said. Two of us think we've either got it or we're really close (I'm the really close one, I just have some bugs in my binary search algorithm).

 

>is there anyone more practical with access to 3D printing

My friend's dad has a 3D printer. If that's happening it'll need to be before the end of February and even then I don't know what a cold fusion generator is so I don't know if I'll be able to convince him.

Anonymous ID: 96255b Dec. 30, 2017, 10:59 p.m. No.1889   πŸ—„οΈ.is πŸ”—kun   >>1891

>>1887

Why so angry? For a start, nobody has listened to anything I've suggested might lead to the answer this entire time, so if anything I should be angry at you (I'm not). Secondly, I'm asking the person who allegedly knows top-level information and who also said they weren't revealing the answers yet because reasons. I'm not the only one asking that, either. Don't you think that would be a rational thing to do? Thirdly, like I said, I haven't figured some bugs out yet.

Anonymous ID: 99fc86 Dec. 30, 2017, 11:08 p.m. No.1893   πŸ—„οΈ.is πŸ”—kun   >>1894 >>1895 >>1932

>>1892

I'm just tired of listening to people who think they are a genius for solving something that was handed to them on a platter compared to solving RSA on your own with no VQC existing yet. Same with people on CBTS. So, if you refuse to share you are just a stuck-up douche, because everyone here agreed to the fallout from the RSA solution being released a long time ago.

Anonymous ID: 96255b Dec. 30, 2017, 11:17 p.m. No.1895   πŸ—„οΈ.is πŸ”—kun   >>1897

>>1893

I'm going to release it. I never said I was going to keep it to myself. I just wonder if Chris wants us to wait, since he's waiting himself. Is that so wrong? Shit.

 

I'm pretty sure I just sorted my bug out. I've tested it on 20 or so cases of c = prime a * prime b, but I need to test it some more and make it easier to understand (and maybe tinfoil myself up before I post it). Long story short, I was onto something when I found this image. I'm 99% sure I've just written some Java that finds i for a given c.

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 30, 2017, 11:21 p.m. No.1897   πŸ—„οΈ.is πŸ”—kun

>>1895

i is used for manually rendering the grid, you're about to slam into an exponential wall, but everyone here hopes it works. If Chris didn't want this to happen, he would have delayed the initial release.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 11:33 p.m. No.1901   πŸ—„οΈ.is πŸ”—kun   >>1902

>>1882

I can access a 3d printer and would be very interested in sonoluminescence too.

What sort of materials are we talking?

 

>>1896

I understand what you mean with n and (n-1) and I agree.

 

>>1899

As to how to go backwards, it seems that you're correct, but there's plenty of primes in the list of a's and b's in (e, 1).

It looks like a lot of the a's are divisible by the first element a or b in the set? Or a prime.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 11:41 p.m. No.1904   πŸ—„οΈ.is πŸ”—kun   >>1918

>>1902

Ok PMA, here's something…

 

We know our original d.

 

And we know that there are 2 elements in (e, 1) that correspond to the na transforms you've described - one for 1xc that we know, and one for axb that we don't.

 

So lets describe our problem as finding the matching records in (e,1)…

 

We know that there's going to be a value for d in that list, that once we minus our original d, will be (n-1)a.

And that same element will have an a value of na.

 

So yes, we have to factor, but it can get a little easier because we know that n and n-1 are 1 apart!

 

Ok, I'm going to try to code some stuff to check, but this is really exciting.

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 30, 2017, 11:42 p.m. No.1906   πŸ—„οΈ.is πŸ”—kun   >>1908

>>1899

To give you a frame of reference, I was able to move to about N5000 from RSA100's E1 in about 30-40 seconds. The problem is that most of the time is spent making sure the N is invalid, or homing to it's first cell. Even after you find the first cell, you need to calculate how X varies individually for each one. Even then, at that high of an E and N, C barely moves.

 

>>1903 see >>1579

 

>>1905

Java 8 has a BigInteger class, but the Java 9 version has more useful functions.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 30, 2017, 11:42 p.m. No.1907   πŸ—„οΈ.is πŸ”—kun

To clarify, if two numbers are na and (n-1)a they are a apart… easy to minus one from the other and check if a factor, if not, keep going…

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 30, 2017, 11:49 p.m. No.1910   πŸ—„οΈ.is πŸ”—kun   >>1913

>>1908

Yeah you do have to rewrite the whole thing, because the difference between an 18 digit long coprime and a 100 digit long coprime is that the 100 digit long coprime is 10000000000000000000000000000000000000000000000000000000000000000000000000000000000 times more complex of a problem.

Anonymous ID: 99fc86 Dec. 31, 2017, 12:03 a.m. No.1915   πŸ—„οΈ.is πŸ”—kun

>>1912

If I can offer some advice: put your original math code in comments and then rewrite with BigInteger.

 

BigInteger equations are pretty confusing, it's a method for every operation.

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 31, 2017, 12:07 a.m. No.1919   πŸ—„οΈ.is πŸ”—kun   >>1921 >>1924

>>1911

>>1918

If you guys want to see why I stopped playing with moving N's, here's some of the home X cells for N for RSA100.

 

//2= 7824221627472775882440665

//3= 11065120340584889788671291

//4= 13551949388462096861107113

//6= 17495491430053162941856197

//8= 20700944628946021502910547

//9= 22130240681169779577342573

//12= 25950007414911080727662445

//16= 30303080060237952740005789

//18= 32260092208312369807604835

//23= 36698852429849630672007497

//24= 37523648726419088402023125

//29= 41401889257892043005821093

//256=124942799869909458872090685

Anonymous ID: 96255b Dec. 31, 2017, 12:13 a.m. No.1922   πŸ—„οΈ.is πŸ”—kun

>>1920

Clearly my code is shockingly bad because it couldn't do that. I'm currently rewriting it to be a while loop instead of a recursive binary search function, and when I've done that I'll put 75644981 into it. Until then, it definitely works for 3-digit numbers.

What is your c value?501For c = 501, a = 3 and b = 167What is your c value?485For c = 485, a = 5 and b = 97What is your c value?415For c = 415, a = 5 and b = 83

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 31, 2017, 12:14 a.m. No.1923   πŸ—„οΈ.is πŸ”—kun   >>2080

>>1918

You can get back only if you have a d that you're trying to get to, which we do, so I'll address that case, and i'll call it orig_d.

 

the dest_a = a - n - orig_d

the dest_n = a/dest_a

the dest_d = orig_d

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 31, 2017, 12:20 a.m. No.1925   πŸ—„οΈ.is πŸ”—kun

>>1924

For RSA100's E, and the N's to the left of the equal sign, X equals the right of the equal sign. Those are the base cells where no valid cell exists under that X value.

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 31, 2017, 12:36 a.m. No.1929   πŸ—„οΈ.is πŸ”—kun   >>1930 >>2346

>>1928

lmao. My formula for estimating X is almost identical to yours Teach, but with one extra piece.

 

X β‰ˆ sqrt(E*(N-1))

 

Then, if E is even, bitshift left then right once to round odds up, If E is odd, bitwise or it against 1 to add one to even values. This is actually more accurate as E increases, exact for N2, then X's variance sets in. Off by ~128 around ~N500 and grows, but was still less than 2000 at N5000.

 

I was trying to see how low I could get C by moving N, and the answer was, very, very little. Like, only a third of the digits of A and B are moving.

Anonymous ID: 96255b Dec. 31, 2017, 12:42 a.m. No.1931   πŸ—„οΈ.is πŸ”—kun   >>1940

>>1928

It's currently running, and it has been for 4 minutes. It will definitely finish eventually. My math isn't perfect yet. I'll type up a better explanation than this, but the gist of it is that I'm using two mathematical relationships to make binary search run (one for when it's too low, one for when it's "too high") and I only really understand one of them (when it's too low) so I have some patchy code that does what it's meant to but isn't optimised by any means. Regardless, it uses math to find a and b from c. That's what we've been trying to do this whole time, so now all we have to do is optimize it. When I've typed up an explanation and I post my code here, hopefully you'll all actually start paying attention to what I'm saying, because some of you are bound to have better ideas than I currently do in my tired and stressed-out state.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 31, 2017, 12:45 a.m. No.1932   πŸ—„οΈ.is πŸ”—kun   >>1935 >>1937

I'm not saying this to brag but I've been factoring 35 digit numbers in sub 10 seconds for days now, maybe weeks.

 

I say this because there's so much humble bragging going on in this thread and I'm so tired of it.

>>1893

This thread said it best.

Get humble.

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 31, 2017, 12:46 a.m. No.1933   πŸ—„οΈ.is πŸ”—kun

The only other interesting property I discovered, is that for any cell in E, any value of A or B can predict that that value of N column will exist.

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 31, 2017, 12:48 a.m. No.1935   πŸ—„οΈ.is πŸ”—kun   >>1936

>>1932

It's the difference of people who've thought they've had the answer many times and had their ideas crushed over and over, vs the new people who think they have the answer for the first few times.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 31, 2017, 12:49 a.m. No.1936   πŸ—„οΈ.is πŸ”—kun   >>1941

>>1935

Precisely, I've done it, CA did it, I'm pretty sure PMA has chased some tails.

And its totally fine. Its just the attitude. It makes this a less enjoyable community in my opinion.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 31, 2017, 12:55 a.m. No.1938   πŸ—„οΈ.is πŸ”—kun   >>1939

>>1937

I believe using a traditional sieve (m or gf) would be faster still at this stage.

My solution does not scale, hence why I've been hesitant to post it. I optimize it and improve it, but its still no way log n.

 

My measurements in time though are strictly using the grid, and minimizing work.

 

I saw a video on Andrew Wiles discussing the 3 approaches to most mathematical problems (specifically number theory):

  • geometrically

  • algebraically

  • analytically

 

I believe that using your eyes to view the grid and draw inferences and truths constitutes basic analytics.

Certainly I've been drawing a lot of geometry, as maybe you've seen my whiteboard pics.

And finally algebraically I've been trying to do the same on the whiteboard and code.

 

I think its a good mental approach to try to interpret all 3 and use all 3 approaches when solving this.

MinecraftAnon !!QXqSZ2ev8. ID: 211e15 Dec. 31, 2017, 1:01 a.m. No.1941   πŸ—„οΈ.is πŸ”—kun   >>1942 >>1943

>>1936

We might be able to construct a VQC to calculate the difference of the crushed ideas of those who've been here too long (the big square) vs the crushed ideas of people just starting to try (the little square).

 

(I'm never going to get tired of this meme.)

 

I think it's more of a common courtesy of understanding basic concepts like exponential growth and the bare minimum of quality control before posting.

 

Do you have any resources for brushing up on the drawing geometry bit? I need a refresher and I'm coming up with nothing.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 31, 2017, 1:13 a.m. No.1943   πŸ—„οΈ.is πŸ”—kun   >>1944

>>1940

I sincerely hope you crack it.

Sorry again, it wasn't meant as a personal thing.

 

>>1939

>>1941

There's several youtube videos that I've found that help me understand more of the scale. Mostly long lectures on ECC. I never studied math as a major, so I'm lost after 30 mins. But here's some youtube goodies:

 

  • First, some history on FLT: youtube.com /watch?v=nUN4NDVIfVI

This is a numberphile video with Ken Ribet who provided a crucial element to the proof of FLT

 

  • Then meet the man himself, Andrew Wiles, this is the interview where he talks about approaches to how to approach solving something like FLT: youtube.com /watch?v=cWKAzX5U85Q

 

  • Really good elliptic curve description, has lots of our good old variables and relationships in it: youtube.com /watch?v=6eZQu120A80

 

  • FLT explained by G. Frey: youtube.com /watch?v=UHvHW6HBtxI

Anonymous ID: 96255b Dec. 31, 2017, 1:54 a.m. No.1945   πŸ—„οΈ.is πŸ”—kun

I'm about to post my code and explanation. Before I do I want to emphasize part of it: when factorizing 223916479610897, it figures out the first 8 digits of the 14-digit-long i value almost instantly, but it doesn't quite narrow it down. Some of you might think it's wrong because it doesn't use the grid like you've all been trying to, but trust me, it'll work as soon as the upper bounds are figured out.

Anonymous ID: 96255b Dec. 31, 2017, 1:54 a.m. No.1946   πŸ—„οΈ.is πŸ”—kun   >>1949 >>1952 >>2201 >>2265

We're given c, and we're meant to find prime factors a and b. i and j are used to generate a, b, c and some other variables we can use. If we can use c to calculate i, we can calculate a and b by doing the following:

>d = floor(sqrt(c))

>n = i - d

>o = (d+n)(d+n)

<I'll explain why there's this extra variable eventually

>x = floor(sqrt(o - c)) - n

>j = x + n

>a = i - j

>b = i + j

All we need for each of these operations is to find i from c. There isn't an obvious mathematical relationship, so one way to find ideas it to make visual plots.

 

When we change the co-ordinates of the {e, n, d, x, a, b} grid from (e, n) to (c, i) and turn it into a picture, we get pic related. As you can see in this picture, there are several linear lines created by spaced out pixels. Each of these dots indicates a product of primes c and its corresponding i value. Each c only has one possible i value.

 

Now, you'll probably notice that there aren't infinite lines in all directions. What you'll see if you change the code around again to make a grid with c and i as the axes is that each of these lines has a constant a value. For example, the lowest line you'll see has a constant a value of 3. This is the lowest prime we can use for prime products, since 2 would create even numbers. The next line up has a constant a value of 5, then the one above that 7, then 11, then 13, then 17, etc. What you'll also probably be wondering is how the gradients of each of these lines works, and where each line begins. Again, using a grid version and highlighting cells, you can find the following:

 

Gradient Prime

1/6 3

1/10 5

1/14 7

1/22 11

1/26 13

1/34 17

1/38 19

1/46 23

 

The gradient of a given prime number's line is 1/(prime * 2). Each of these lines begins where a and b are the same (in other words, at the square of said prime - e.g. 5's line starts where a and b are 5, 17's line starts where a and b are 17, etc).

Anonymous ID: 96255b Dec. 31, 2017, 1:55 a.m. No.1947   πŸ—„οΈ.is πŸ”—kun

Now how do we use these lines to calculate i from c? Well, VQC said we were meant to be able to factorize prime products in O(log n) time. An example of an O(log n) time program is binary search. Binary search uses a known value and looks for it in a big list of other known values. If the current value is less than the value we're looking for, it looks only above the current value, and if the current value is higher than the value we're looking for it looks only below the current value. That means that it halves the number of steps necessary each time.

 

Thinking of this in the context of c and i, we know what c is and we want to find the particular i value in a big list of possible i values. As I mentioned earlier, there is one line below which no other line can be generated. This is the 3 line. That means any i value along this line is the largest possible i value for any given c. If we know what c is, we can use the gradient of this 3 line to find the maximum possible i value for it, and then we'll know the upper and lower bounds (the lower bounds I've been using are 0). Now we have most of what we need for binary search.

 

What we also need is a mathematical relationship that allows us to decide when i is too low and when i is too high. Knowing when i is too low is reasonably easy. In order to check if the current i corresponds to the c we want to calculate a and b for, we need to use some math. We can plug i and c into the following formulae:

>d = floor(root(c))

>n = i - d

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

>j = x + n

>a = i - j

>b = i + j

>c = a * b

If c does indeed = a * b, we'll know our i is correct. For our lower bound, we can use the following

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

What we're looking for is a square root. If we take the square root of a negative number, we're going to get an imaginary number, and we can't really use that. That's why I had that extra variable

>o = (d+n)(d+n)

If o is less than c, we're going to get an imaginary number. d is going to be the same regardless of the i we're guessing (since d depends on c), but n depends on i. n = i - d. Whether or not o is less than c depends on how high i is. If i is too low, o will be less than c. That means we have a reason to increase the lower bounds.

Anonymous ID: 96255b Dec. 31, 2017, 1:55 a.m. No.1948   πŸ—„οΈ.is πŸ”—kun   >>1952

The higher bounds are a little trickier for me personally to figure out. In the case I was testing as I figured this out, which was 35, it just so happened that i was the first possible value above all of the possible i values that were too low. I didn't completely go through many other examples, so I don't know if this is always the case. That said, I wrote some code that I knew would work for 35 just to test. It worked for most cases. I still had the grid I generated for finding gradients open, so all I had to do was click a cell with values in it, input that cells c value and double check that it output the correct i value. It did this for most cases, but occasionally I'd get a stack overflow error (at the time I was using recursion instead of an infinite loop) because it would loop. I used some patchy guess code (the if(mid_index == upper_bound) part) and it magically worked. What I'm saying is, the code does factorize prime numbers in O(log n) time, but I don't know how the upper bounds work. What needs to be done to this in order for it to work is for someone to understand how the upper bounds work and implement it into the code. It can obviously be done, because this code works flawlessly on every prime product from 501 down. It has trouble on bigger numbers, but it finds the general range of i almost instantly (for example, when factorizing 223916479610897, it figures out the first 8 digits of the 14-digit-long i value almost instantly, but it doesn't quite narrow it down. I think as soon as one of you looks this over you'll see the issue and we'll crack it.

Anonymous ID: 96255b Dec. 31, 2017, 1:57 a.m. No.1949   πŸ—„οΈ.is πŸ”—kun   >>1952

>>1946

>the lowest line you'll see has a constant a value of 3. This is the lowest prime we can use for prime products, since 2 would create even numbers.

That's probably wrong. I've been having way too little sleep working on this and all my other shit.

Anonymous ID: 96255b Dec. 31, 2017, 2:01 a.m. No.1950   πŸ—„οΈ.is πŸ”—kun   >>1951 >>1952 >>1953

import java.util.;public class Gradient{ private static long c; private static long i_poss; private static long upper_bound_real = 0; private static long bound_change = 0; private static long i; private static long d; private static long n; private static long o; private static long x; private static long j; private static long test = 0; private static boolean changed = false; public static void main(String[] args){ Scanner input = new Scanner(System.in); System.out.println("What is your c value?"); c = input.nextLong(); i_poss_create(); long mid_index = (long) (Math.ceil(((upper_bound_real)/2))); upper_bound_real = (long) (Math.ceil((double)((c-8)/6))) + 5;; long correct_i = binary_search(mid_index, upper_bound_real, 0); long a = i - j; long b = i + j; System.out.println("For c = " + c + ", i = " + i); System.out.println("For c = " + c + ", a = " + a + " and b = " + b); } public static void i_poss_create(){ long iMax = (long) (Math.ceil((double)((c-8)/6))) + 5; i_poss = iMax; } public static long binary_search(long mid_index, long upper_bound, long lower_bound){ while(test != c){ if(upper_bound < lower_bound){ lower_bound = upper_bound-4; upper_bound+=3; /long temp = upper_bound; upper_bound = lower_bound; lower_bound = temp;*/ } System.out.println("Upper = " + upper_bound + ", middle = " + mid_index + ", lower = " + lower_bound); changed = false; i = mid_index; d = (long) Math.floor(Math.sqrt((double) c)); n = i - d; o = (d + n) * (d + n); if(o < c){ //then it needs to check everywhere above this point lower_bound = mid_index+1; mid_index = lower_bound + ((upper_bound - lower_bound)/2); changed = true; } x = (long) (Math.floor(Math.sqrt((double)(o-c)))) - n; j = x + n; test = (i-j) * (i+j); if(test != c){ //then it needs to check everywhere below this point if(!(changed)){ upper_bound = mid_index; mid_index = upper_bound - ((upper_bound - lower_bound)/2); if(mid_index == upper_bound){ bound_change++; mid_index = upper_bound_real - bound_change; upper_bound = upper_bound_real; } } } else { return i; } } return i; }}

Anonymous ID: 96255b Dec. 31, 2017, 2:14 a.m. No.1954   πŸ—„οΈ.is πŸ”—kun   >>1956

>>1952

Nice to see you aren't so angry now. I definitely hope some of you can work with it. The upper bounds I coded in work perfectly for most cases. I just don't know when they don't completely work. I'm thinking of putting something together that outputs c every time i isn't directly above the highest value that produces an imaginary number just to see if it ever even is the case (I'm pretty sure it is) and if so what the pattern is. When that isn't the case, it works fine. I just tested with a few 6 digit prime factors (762709 and 809009) and they were factored instantly (as soon as I took my finger off the enter button), so there's definitely just going to be one tiny thing wrong with it. I should probably sleep eventually though. It's almost 2018 where I live.

 

>>1953

Oh man, thank you. That'll give me time to work on the ideas I have regarding the upper bounds issues.

Anonymous ID: cc6071 Dec. 31, 2017, 3 a.m. No.1955   πŸ—„οΈ.is πŸ”—kun

I just want to say I love you all you crazy fucking faggots. Even if this does turn out to be the most autistic math LARP of all time, I have no regrets. None whatsoever.

 

You know, it does strike me in all of this that the language of math is somewhat fucked. If indeed the true nature of reality is crawling crazy "structures" or whatever the fuck these things are, and traversing them, iterating through them, and defining warps, or transforms, or whatever, then math is going to need to look a lot more like programming. Maybe a subtext of this whole thing is the underhanded assertation that academicfags are kinda purposefully using shit tools and the equivalent of our /usr/bin/awk v1.0 to jerk themselves off for a living. I mean, fuck it's to the point where math is fucking useless because 99% of the time, it's wrong, incomplete, or whatever, but if you have running code you at least have something tangible in a real way that a lot of faggot academic math isn't.

Anonymous ID: 99fc86 Dec. 31, 2017, 3:16 a.m. No.1956   πŸ—„οΈ.is πŸ”—kun   >>1959

>>1954

Interestingly your code only works for certain semiprimes, but I tested it after converting it so it's possible I made a mistake.

 

However, it did work for these.

3*313561 = 940683

3*31267=93801

17*439=7463

7*23 = 161

5*29=145

3*3=9

 

Ones it didn't work for:

15 (it gave me -1*-15 lol)

7474

940666

940679

 

I optimized the code a little, based on what was unnecessary, here it is.

I'll try to add to it when I understand it better.

It's very interesting to me that some semiprimes worked even though they were very large.

 

Let me know if there's an error.

pastebin.com/Sx5NHhpU

Anonymous ID: 96255b Dec. 31, 2017, 3:23 a.m. No.1959   πŸ—„οΈ.is πŸ”—kun   >>1960

>>1956

I think you rewrote it wrong, at least for the first example.

>15

Works perfectly for me.

What is your c value?15Upper = 6, middle = 0, lower = 0Upper = 6, middle = 3, lower = 1Upper = 6, middle = 5, lower = 4Upper = 6, middle = 5, lower = 4Upper = 6, middle = 4, lower = 4For c = 15, a = 3 and b = 5

I haven't looked at your code yet so I don't know why.

>7474

It doesn't work for prime products where one of the factors is 2, since I'm using the line where a = 3 as the gradient. It's the equivalent of using the gradient from the 5 line. That would stop you from being able to factorize any prime products where one of the factors was 3.

>940666

As above.

>940679

Yeah, like I said, it isn't perfect. I'm not sure why some numbers work and some don't yet, but I know it has something to do with the upper bounds.

Anonymous ID: 99fc86 Dec. 31, 2017, 3:26 a.m. No.1960   πŸ—„οΈ.is πŸ”—kun   >>1961

>>1959

I'll take a look at it again tomorrow. I changed the first equation in the beginning method to 1 because that's what it always comes out to (it starts out as 0, so dividing it by 2 is 0 and then taking math.ceil is just adding 1.)

 

I'll see what I did wrong tomorrow.

Anonymous ID: 99fc86 Dec. 31, 2017, 3:32 a.m. No.1962   πŸ—„οΈ.is πŸ”—kun   >>1963 >>1964 >>1966

>>1961

Okay, I see my error, I tested your code and the first equation actually comes out to zero. Let me see if that fixes 15 factorization.

 

You can test my rewrite on RSA numbers when you're ready.

 

[java] public static String rsa100c =

"1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139"; [/java]

Anonymous ID: 99fc86 Dec. 31, 2017, 3:35 a.m. No.1963   πŸ—„οΈ.is πŸ”—kun

>>1961

>>1962

Yeah, changing from one to zero fixed 15 factorization. It's perfectly fine that you can't factor a number where the factor is even, or 2, because RSA numbers have giant factors and 2 is the only prime even number.

Anonymous ID: 96255b Dec. 31, 2017, 3:40 a.m. No.1966   πŸ—„οΈ.is πŸ”—kun

>>1962

If you didn't figure out how the upper bounds work, I sincerely doubt it's going to be that easy. I have it running just in case but it's all over the place in terms of digits.

IseePatterns !kIkD/SqZ4s ID: 29c3ab Dec. 31, 2017, 3:42 a.m. No.1968   πŸ—„οΈ.is πŸ”—kun

>>1882

 

I'm still not sure if he means (n - 1) as in literally n - 1 or the previous n.

 

I'm looking more into this pattern and trying to see the distribution between na, (n-1)a and f. So far I'm running a bit in the dark.

Anonymous ID: 96255b Dec. 31, 2017, 4:01 a.m. No.1973   πŸ—„οΈ.is πŸ”—kun   >>1974 >>1975

>>1972

If some of what I say seems patronizingly simple, don't take it personally. I just like to explain things as simply as I can.

 

When you're doing binary search on a big list of sequential numbers to see if the one you have is in there, you figure out the lower bounds of each given iteration of the loop when you find that the current value you're looking at is lower than the value you're looking for. For example, if you had every number from 1 to 18, you wanted to know if 7 was in there, and the current value you were looking at was 4, the lower bounds on the next iteration and subsequent iterations would be at least 4. You would never check below 4 again because you'd know it isn't in there. Same thing with upper bounds. If you were currently looking at 11, you know it's higher than 7 so in the next iteration of the loop and subsequent iterations, your upper bound would be at least 11.

 

In terms of this RSA stuff (or at least my code), we aren't calculating the bounds based on a big list of all possible i values and the current i value being too low or too high. We don't know the correct i. That means we have to check if i is valid for the c we're using and we have to find mathematical properties of the calculations we do in order to find those bounds. The lower bounds are found in this case because when i is too small, the calculation of x creates an imaginary number. When we plug c in and the current i value we're looking at creates an imaginary number in the x calculation, the lower bound becomes at least that i value. What we need to find is a mathematical property of these calculations that can be used as an upper bound. In at least most of the cases I tried by doing the math by hand, it seems (I can't confirm off the top of my head) that the correct i value is 1 greater than the highest i value that creates an imaginary number. That might not actually be it. If we can find that upper bound (and if the lower bound does indeed work on 100% of cases, which I think it does considering it obviously does factorize primes), it'll be complete and we'll be able to factorize RSA numbers.

Anonymous ID: 96255b Dec. 31, 2017, 4:06 a.m. No.1975   πŸ—„οΈ.is πŸ”—kun   >>1976

>>1972

>>1973

I guess I forgot to mention that at the beginning of the code the upper bound is meant to be the highest possible i value, since we don't know yet whether it's right. If a = 3, it'll be the highest possible i value and all others will create imaginary numbers (I think… don't quote me on that).

 

>>1974

That's the idea, yeah. This whole time I was trying to figure out how this could work in O(log n) time, so I was trying to find a way to apply binary search. Here it is. VQC's real.

Anonymous ID: 96255b Dec. 31, 2017, 4:09 a.m. No.1977   πŸ—„οΈ.is πŸ”—kun

>>1976

Oh, that was you? I remember that. I also remember agreeing with you, but I haven't heard of any other O(log n) algorithms that could be applied to anything like this.

Anonymous ID: 96255b Dec. 31, 2017, 4:18 a.m. No.1978   πŸ—„οΈ.is πŸ”—kun

I found an example of my theory being wrong (the one about the correct i being directly above the final lower bound).

a = 3, b = 19, c = 57, i = 11, d = 7

Let's say i = 10

n = 10-7 = 3

(d+n)(d+n) = 10*10 = 100

100 57, so it'll think to check lower down. The fix case I had for this was to set the upper bound and the middle index back up near the maximum i value and start the loop again since I couldn't figure it out. I'll just work out the rest of the calculations for i.

 

Also I don't think this is the solution VQC intended. I still have no idea how this relates to quantum computing and qubits at all, and a lot of what VQC has been saying seems a bit irrelevant. I guess that means either there are multiple solutions or it's impossible to find the upper bounds. I sure hope it's the former.

Anonymous ID: cc6071 Dec. 31, 2017, 5:35 a.m. No.1979   πŸ—„οΈ.is πŸ”—kun   >>1981

IS VQC A LARP?

 

I hope for the best but years in Internet backwaters such as these have turned me somewhat cynical by default. The facts are, VQC has neglected to carry out his plainly stated intentions: to guide us to a significant factoring basically around Christmas. He has failed to guide us recently except overly vaguely, yet still finds time to retweet inconsequential bullshit on twitter. Is tweeting with ~400 followers about Brexit 32 minutes ago more or less important than our crack squad of CIA NIGGERS ready to crack RSA? Well, right now, less by definition since he is doing that and not helping us, even though he already has the solution and it would be no real skin off his back.

 

I regret that this post is even necessary, quite frankly. VQC, get on top of your shit!

Anonymous ID: 96255b Dec. 31, 2017, 5:52 a.m. No.1980   πŸ—„οΈ.is πŸ”—kun

I've spent all day on this and I'm way too tired to function anymore so if anyone does anything with my code and they want me to explain something, it'll have to wait at least 6 hours, possibly 12 (what am I doing to myself?).

IseePatterns !kIkD/SqZ4s ID: 29c3ab Dec. 31, 2017, 7:03 a.m. No.1982   πŸ—„οΈ.is πŸ”—kun   >>1983 >>1985

Maybe it's mental fatigue, but I can't wrap my head around what VQC means when he says na and (n - 1)a and how it relates to a[t] and d[t].

 

Somehow this will be useful for f, but I don't know how to use f, much less how that relationship will assist me.

IseePatterns !kIkD/SqZ4s ID: 4e9ed8 Dec. 31, 2017, 8:30 a.m. No.1986   πŸ—„οΈ.is πŸ”—kun   >>1987

>>1984

 

Okay, so I have no idea if this is actually the proper method, but it appears to sometimes work (it's not like math is an exact science right/s)

 

We know e, d and c. Compute f (e - (2 * d + 1)).

 

If you take d + k where k is an a from (f, 1) you will find a * n. However, it doesn't always lie on (f, 1, 1). It can be further out.

 

I'm not sure if it helps.

Hobo !!1yNgQ3NlCs ID: 77a00f Dec. 31, 2017, 9:17 a.m. No.1989   πŸ—„οΈ.is πŸ”—kun

>>1882

 

I would be very interested in working on the device you mentioned. Curious what sort of 3d printer is required. Are we talking a RepRap level machine or more of a https:// www.protolabs.com/ level device? I feel I could simply take a 3d plan and send it to them. Tell them it is a wind chime or a water filter holder or whatever so they don't get wind of it. Hell, Just tell them it is a cold fusion device that was made with alien technology and they will laugh and make it since that is an unbelievable story. Anyway, count me in as I think that would be really fun and such a device will be required to help people when this stuff really kicks off. I love building things… Lastly, I heat my water at the hobo camp with wood in a rocket stove with a heat exchanger and that sucks so I want this for myself ha ha.

Hobo !!1yNgQ3NlCs ID: 77a00f Dec. 31, 2017, 9:28 a.m. No.1990   πŸ—„οΈ.is πŸ”—kun   >>1993

>>1862

Hey CA. Just wanted to throw my thoughts out there as to what you should do if you got it to work. FIrst and foremost, back it up. Also keep some notes with your backup if possible so that it can be recreated. I'm sure you are doing this but even consider printing it out.

 

Next, This is very valuable and dangerous technology. Much good and much bad can come from its use. It is important that you keep this in mind. Don't just use it to go steal or break shit. This will end badly.

 

As for release here. I would post it here. It is important that it is not lost. Like VA said, I am a pessimist in some ways. I guess I am a deeply hopeful pessimist. A lot of very powerful people will loose their power when this device is out. Not right away but it will happen.

 

This is a good thing but it would be awful if it were captured and locked away again so post it for archive and backup. Also I worry that if you are the only one with it then there is a single point of failure which is always bad in any system. It is not safe for you to be in that position and you should think about that before you start posting RSA answers publicly without ever posting the code. There are people out there who will come after a single person. They will shy away from coming after a whole board scattered all over the world.

 

That is my opinion of the situation. I will do another chapter in the chronicle today and talk to these points. -TGH

CollegeAnon !LAbIRp9cT. ID: b65f84 Dec. 31, 2017, 9:54 a.m. No.1993   πŸ—„οΈ.is πŸ”—kun   >>1995 >>2001 >>2133

>>1990

 

I understand. My father said "Don't figure it out and tell everyone, theres only a few chances to really profit in life and this may be one of them" so I would hate to figure it out and not help my fam. Then the problem becomes the fact that I didn't really break it VQC did and guided me through it.

 

Heres the map for D. I think this is the key to it all.

Topolanon +++ !!UrvFpU0has ID: 7ed024 Dec. 31, 2017, 11:57 a.m. No.2000   πŸ—„οΈ.is πŸ”—kun

>>1998

Weeeeeeeeeeeeak.

His mom has already taken the D's, we're just cavorting through the vast expanse that is her gaping vagina to find them. Which makes you a faggot because you're inside a woman and all you can think about is how many D's you can get your dirty, greedy little hands on.

 

That being said…

SNIZZITY SNACK TIME BITCHESES!!!

>>1999

MinecraftAnon !!QXqSZ2ev8. ID: 4b9fd2 Dec. 31, 2017, 12:39 p.m. No.2003   πŸ—„οΈ.is πŸ”—kun   >>2004

>>1994

If you're using the a = (x^2+e) / (n * 2) method of generating a cell, you're diving by zero for n=0. If N is the midpoint for A and B, n=0 implies A=B. Which implies X=0, and D=A. It's outside the system of rules the VQC is inside of.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 31, 2017, 12:45 p.m. No.2004   πŸ—„οΈ.is πŸ”—kun   >>2006

>>2003

which leads to the creation of valid records like:

 

(-121,0,6) = {-121:0:62:11:51:73}

(-121,0,6) = {-121:0:73:11:62:84}

 

Still trying to figure out how this is possible.

MinecraftAnon !!QXqSZ2ev8. ID: 4b9fd2 Dec. 31, 2017, 1:32 p.m. No.2006   πŸ—„οΈ.is πŸ”—kun   >>2007

>>2004

I don't think they're valid records so much as artifacts of the generation process. Notice that all the X's are the same for each N0 cell. Which means they're unindexable with our current understand of T. It might mean that D is part of the formula for T though.

CollegeAnon !LAbIRp9cT. ID: b65f84 Dec. 31, 2017, 1:44 p.m. No.2007   πŸ—„οΈ.is πŸ”—kun   >>2008 >>2013

>>2006

I disagree, I think that all these negative values are actually important, because they can be used to navigate the grid. Look at this pic:

>>2001

Most of those values are invalid according to our current understanding of the records (e,n,d,x,a,b), but this pattern is constant for every number, so even if the values are 'invalid' we could still use them to traverse along the graph.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 31, 2017, 2:45 p.m. No.2013   πŸ—„οΈ.is πŸ”—kun   >>2016 >>2201

>>2008

>>2007

 

Thanks for the thoughtful responses.

 

I checked the original grid and the n=0 records do have some special properties:

 

e is negative and one of = 1^2, 2^2, 3^2, 4^2, etc.

x = sqrt(-e)

b-a = 2x

d-b = x

 

Also noticed that for c=65 a record exists:

 

(-16:0:3) = {-16:0:9:4:5:13} = 65

 

which we can almost get to from our starting position.

 

(1,25,4) = {1:25:8:7:1:65} = 65

 

Coincidence?

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 31, 2017, 3 p.m. No.2016   πŸ—„οΈ.is πŸ”—kun   >>2020 >>2023

>>2013

>which we can almost get to from our starting position.

 

correction, we can get there easily:

 

BigInteger newE = -(ter.d * ter.d);

BigInteger newX = ter.d;

BigInteger newA = ter.n;

 

TheEndRecord testNegative = TerFactory.CreateForEXA( newE, newX, newA );

 

This is the same result of doing an (n-1) shift and the f transforming the result.

 

Not sure if this has any value yet.

Teach !!UgZAPoSXEk ID: 3ccdf3 Dec. 31, 2017, 3:27 p.m. No.2020   πŸ—„οΈ.is πŸ”—kun   >>2031 >>2032

>>2016

Yep, this is the relationship I was talking about yesterday.

PMA have you produced any of the images that VQC spoke about.

Visually you can see lines diagonally down to the right from every perfect square.

These lines cross the e=0 axis at the same frequency as the growth in squares (same sized gaps).

I think this is how we're supposed to figure out which other squares it hits on the way back from 1xc by using where it crosses e=0.

CollegeAnon !LAbIRp9cT. ID: b65f84 Dec. 31, 2017, 3:37 p.m. No.2026   πŸ—„οΈ.is πŸ”—kun

>>2008

 

>>2011

>>2021

 

Here is the OP and the post specifically about why I believe we should go into the negative values. I may have gone full blown schizophrenic but I'm convinced this album is a guide.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 31, 2017, 4:21 p.m. No.2032   πŸ—„οΈ.is πŸ”—kun

>>2020

>Yep, this is the relationship I was talking about yesterday.

Sorry. It takes me awhile to catch up!

 

I created some of the images in the original threads, but after seeing MA's amazing work, I didn't see the need to continue.

 

>>2023

>BigInteger newE = -(ter.d * 2); ??

no. Your e formula doesn't create valid records.

 

newE = -(ter.d * ter.d ).

 

Question is does this record tell us anything new? Does it give us any information to relate back to any aabb or ab records?

Anonymous ID: 96255b Dec. 31, 2017, 6:26 p.m. No.2035   πŸ—„οΈ.is πŸ”—kun   >>2036 >>2037

For whenever this anon >>1976 comes back, I've got my own code (without BigIntegers) factorizing 940679 correctly now, but after implementing my changes yours doesn't seem to work. It thinks the prime factors of 15 are -1 and -15, for example, and 940679 continues to work as a loop.

ID: 99fc86 Dec. 31, 2017, 6:30 p.m. No.2036   πŸ—„οΈ.is πŸ”—kun   >>2038 >>2039

>>2035

I'm here. I made a few mistakes when I changed it to BigInteger, I was running on low fuel.

 

Did you implement these changes when you tried it on my BigInteger rewrite?

 

pastebin.com/Ke1ZfW0x

mid_index was supposed to start from zero, not one, according to the original code that Australia Anon posted.

ID: 99fc86 Dec. 31, 2017, 6:33 p.m. No.2037   πŸ—„οΈ.is πŸ”—kun   >>2038 >>2039

>>2035

>8d711d

Wait, it is you. I should really read the IDs. I'll try to understand your code a bit more, can you send me your most recent version?

The only difference there is supposed to be between the BigInteger rewrite and that is that it would be able to tested on RSA numbers.

AA !dTGY7OMD/g ID: 96255b Dec. 31, 2017, 6:43 p.m. No.2038   πŸ—„οΈ.is πŸ”—kun   >>2039 >>2067

>>2036

>>2037

>I should really read the IDs

I could always use my trip or the BO capcode if you want. People (or VA anyway) were calling me Archive Anon a while ago. I can't stand using a name so I just tend not to unless someone like you doesn't know who they're talking to. I may as well at least do it once for this thread's ID.

 

>Did you implement these changes when you tried it on my BigInteger rewrite?

I compared that pastebin to the file I'm using with my latest changes and there doesn't seem to be anything different other than my changes. I'll post both my current non-BigInteger code and my edits of your code in a bit.

AA !dTGY7OMD/g ID: 96255b Dec. 31, 2017, 6:48 p.m. No.2039   πŸ—„οΈ.is πŸ”—kun   >>2041

>>2037

>>2036

>>2038

Here's the non-BigInteger version, which factors 940679 into 71 and 13249 https://pastebin.com/pJAA3H1X

Here's the BigInteger version, which I've managed to mess up and it thinks the prime factors of 15 are -1 and -15 https://pastebin.com/5cYds2za

MinecraftAnon !!QXqSZ2ev8. ID: bb0944 Dec. 31, 2017, 7:15 p.m. No.2040   πŸ—„οΈ.is πŸ”—kun

Another interesting observation doing deep renders of the entire grid, any N where N is prime has significantly less entries than the N's where N isn't prime.

ID: 99fc86 Dec. 31, 2017, 7:55 p.m. No.2041   πŸ—„οΈ.is πŸ”—kun   >>2042

>>2039

I finally fixed the 15 factorization in my rewrite.

It's because when you use the BigInteger sqrt method on 1 it returns 0, not 1. Made that a special case.

 

I would replace the method for all the grief it's given me but I can't find anything as simple online.

Anonymous ID: 96255b Dec. 31, 2017, 8:42 p.m. No.2048   πŸ—„οΈ.is πŸ”—kun

This one took 4 seconds. c=15778598254603mid_index = 1314883187885For c = 15778598254603, i = 4010522For c = 15778598254603, a = 3457631 and b = 4563413

I can't tell if it's taking so long on these bigger ones because it scales badly or if there's a bug.

ID: 99fc86 Dec. 31, 2017, 8:44 p.m. No.2050   πŸ—„οΈ.is πŸ”—kun   >>2051 >>2052

>>2044

Doesn't work with rsa100 or rsa2048 yet (but I didn't wait very long. and of course I tried them, hehe)

 

Ones it did solve:

1613*1619=2611447

5563*7951=44231413

11699*14843=173648257

73259*93739=6867225401

104723*104729=10967535067

885289*979423=867072408247

took too long on 81311001417221

 

And your number.

Anonymous ID: 96255b Dec. 31, 2017, 8:52 p.m. No.2053   πŸ—„οΈ.is πŸ”—kun   >>2054 >>2055

>>2049

I'll explain why I did that. Some of this may be completely inaccurate (I might name a variable the wrong thing, since this is based on memory, but hopefully not). I haven't had nearly enough sleep lately. I spent most of last night trying to figure out how the upper bounds work. What I found is that, for most prime products, the correct i value is directly above the last value at which i^2 creates an imaginary number. The thing that stops it from working is the ones that don't, obviously. In the latest code I put on pastebin, there was a variable called "multiplier" and inputs for known a and b values. I was testing it on values I knew got stuck in loops (particularly 940679). What I found was that for some reason, after j gets to a certain point, i^2-c begins to loop instead of steadily increasing (the i I'm referring to is the current guess case, and the j is the j calculated based on the real c and the current guess case of i). It would go up about 10,000 from wherever the loop starts, then it would go back to the start of that 10,000, around and around forever. I figured out that it was happening because i and j were scaling together linearly (every time i increased by 1, j increased by 1) and then at the point of the beginning of each loop i was increasing by 1 but j was increasing by 2. I still have no fucking clue why that happens, and I actually have no idea how I solved it, either.

Anonymous ID: 96255b Dec. 31, 2017, 8:59 p.m. No.2054   πŸ—„οΈ.is πŸ”—kun   >>2055

>>2053

I guess I didn't really explain multiplier. When I figured out the math for 940679 by hand, I figured out that if you multiplied the highest possible i by something like 0.04207something, you got the right i value. I was planning to do this for a bunch of c values that got caught in loops and maybe plotting it to see the mathematical relationship or something. That way, if i isn't directly above the highest i value that makes an imaginary number, you can just apply some other equation to it and get the right answer.

Anonymous ID: c3dadb Dec. 31, 2017, 9:20 p.m. No.2056   πŸ—„οΈ.is πŸ”—kun   >>2058

>>1862

No way! This would revolutionize math, which is actually bigger than revolutionizing physics and the other sciences. Remember math is the "queen of the sciences," and within math, number theory, which this would turn over, is most highly regarded for purity, beauty, etc (and applies to much physics and of course cryptography). why do I know this? went to school for math anons. didn't say that earlier to not put pressure on myself to solve or be the resident expert. still travelling here.

 

anyway, here's what i recommend for benchmarking: do a 3 digit c, time the steps, repeat for 4 digit c, then 10 digit, 20 digit, just get some performance data and plot. you will quickly know your time complexity and there are enough programmers here to interpret time complexity, it's integral to CS and math too.

 

for some strange reason i actually wouldn't mind being stuck at the airport tmr, then i'd have nothing to do but interpret this stuff.

 

and thanks to baker for posting VQC hints in one place. of course i don't know if this all will turn out but i am still curious enough to be here as are the rest of you, keep up good work

Anonymous ID: c3dadb Dec. 31, 2017, 9:32 p.m. No.2063   πŸ—„οΈ.is πŸ”—kun

>>2060

ok thanks that is some code i'd like to look at tmr.

 

again i am talking about benchmarking this code, it is an easy exercise in comp sci. i already know what vqc promised

Anonymous ID: 96255b Dec. 31, 2017, 9:35 p.m. No.2066   πŸ—„οΈ.is πŸ”—kun   >>2068

>>2064

Because it worked. When it went to run the block of code in the if statement, it seemed that when the c value was too low, the bound swap would cause it to start looking in negative numbers, but if it was high enough it wouldn't cause any problems. e.g. it factored 15 as -1 and -15 (unrelated to the BigInteger sqrt problem) and it factored 940679 perfectly. Once we understand the upper bounds, we can get rid of all these dumb solutions.

VeritasAequitas !!Nf9AmQNR7I ID: 08a74e Dec. 31, 2017, 9:36 p.m. No.2067   πŸ—„οΈ.is πŸ”—kun   >>2070 >>2080

>>2038

>>1882

Hello Anons! Nice work on all the code, and Happy New Year to all! Working on VQC’s recent crumb. Have any of you made headway with this?

>I will post more on The Grid later but think about the distribution of n and (n-1) in cell (e,1) in the a[t] and d[t] values respectively. This is the quick way to utilising f.

ID: 99fc86 Dec. 31, 2017, 9:38 p.m. No.2068   πŸ—„οΈ.is πŸ”—kun   >>2069

>>2066

So, I created a multithreaded solution to print out each i value, and it's doing some strange things with the i value when calculating 81311001417221. It never goes any higher than the upper bound, it goes lower to negative upper bound, then resets.

Anonymous ID: 96255b Dec. 31, 2017, 9:47 p.m. No.2069   πŸ—„οΈ.is πŸ”—kun   >>2071

>>2068

In the first if statement in the while(test != c) loop, I added lower_bound = upper_bound+3 and upper_bound = upper_bound-4 arbitrarily. I added some stuff to the code to test which of my meaningless fixes it gets caught in (whether the bounds are being switched around endlessly in this if statement or if it's the last if statement where bound_change is used) and for this example it's getting caught in the first one.

Anonymous ID: 96255b Dec. 31, 2017, 9:50 p.m. No.2070   πŸ—„οΈ.is πŸ”—kun

>>2067

Actually the code we're messing with doesn't really take much of VQC's latest crumbs into account. We're using the gradient of a line generated when a = 3 to find the largest and smallest possible values of i for a given c and applying binary search to it. We know how to move the lower bounds (if i is too small, it creates an imaginary number in the calculation for x) and we're now trying to figure out how to change the upper bounds.

Anonymous ID: 96255b Dec. 31, 2017, 10:13 p.m. No.2074   πŸ—„οΈ.is πŸ”—kun   >>2075

>>2071

>>2072

Do you need help understanding any of the rest of my contributions to the code any time soon? I think I need a nap. I've been having 6 hour sleeps each day for the past few weeks working on this and other things and it's getting to me.

Anonymous ID: 96255b Dec. 31, 2017, 10:27 p.m. No.2077   πŸ—„οΈ.is πŸ”—kun   >>2078 >>2079

>>2075

Before that, here's something I've been working on.

 

c = 1133284519, a = 31481 and b = 35999

Multiply 188880756 (max i) by 1.7863122064166242E-4 to get the correct i of 33740

(This gets caught in the first if statement)

 

c = 940679, a = 71 and b = 13249

Multiply 156783 (max i) by 0.04247909531007826 to get the correct i of 6660

(This gets caught in the second if statement)

 

If we get a bunch of c values that don't work properly (and assuming we already know a and b), we can make a graph and see if it looks either like noise or like a mathematical function. Then, if we're lucky enough to find it's a mathematical function (which could be dependent on the respective if statement it gets caught in possibly), we can have another if statement when the correct i value isn't found instantly that applies the mathematical function to the maximum i value and see if it finds the correct i. If it all happens to be noise then I'm not really sure what to do.

 

import java.util.*;public class Right{ public static void main(String[] args){ //take a bunch of cs with the a and b values int c = 1; int a = 0; int b = 0; Scanner scanner = new Scanner(System.in); while(c != 0){ System.out.println("What is c?"); c = scanner.nextInt(); System.out.println("What is a?"); a = scanner.nextInt(); System.out.println("What is b?"); b = scanner.nextInt(); //send them to be messed with print(c, a, b); } } public static void print(int c, int a, int b){ //calculate i from a and b int j = (b - a) / 2; int i = a + j; //calculate the highest possible i based on the gradient int i_poss = ((int)Math.ceil((double)((c-8)/6))) + 5; // you'll be inputting numbers you know aren't directly above the // low thing, so you probably won't have to calculate much else //print double multiplier = (double) i / (double) i_poss; System.out.println("Multiply " + i_poss + " (max i) by " + multiplier + " to get the correct i of " + i); System.out.println("(" + i_poss + ", " + multiplier + ")"); } }

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Dec. 31, 2017, 11:47 p.m. No.2080   πŸ—„οΈ.is πŸ”—kun

>>1923

>the dest_a = a - n - orig_d

the dest_a = a - n + orig_d

 

would be great if there was a way to do this without knowing the orig_d.

 

>>2067

VA. Not sure if we're 100% correct, but this is our understanding thus far.

>>1896

 

Fellow anons and VQC: Happy new year and God bless. This has been the most interesting and humbling of adventures.

Anonymous ID: c50aac Jan. 1, 2018, 12:04 a.m. No.2082   πŸ—„οΈ.is πŸ”—kun   >>2084

I'm getting close to having e right on (e,1). It gets a and b right but it doesn't get N right. Using a transform from (0,N) to (0,1). You still have to search for the first appearance without N working.

Anonymous ID: c50aac Jan. 1, 2018, 12:26 a.m. No.2089   πŸ—„οΈ.is πŸ”—kun   >>2090

>>2087

I'm just building a map on a spread sheet so far. I'm only testing 1000 deep in my columns. So it still small numbers but seems promising. I think adding negative e will allow me to find a way to add N.

Anonymous ID: c50aac Jan. 1, 2018, 12:45 a.m. No.2092   πŸ—„οΈ.is πŸ”—kun   >>2094 >>2099 >>2106

>>2090

Do you have a derivation for the f formula. Chris gave us this formula with both negative and positive values. One of the two looks wrong to me. Seems one should be plus one and the other should be minus 1. I haven't been able to derive it. He says add f to make c a square.

Anonymous ID: c50aac Jan. 1, 2018, 12:58 a.m. No.2095   πŸ—„οΈ.is πŸ”—kun   >>2106

>>2094

2d +1 -e is the positive one.

e -2d +1 is the negative one from one of Chris's posts but it looks like it should be e -2d -1. But I haven't been able to derive it. I'm probably misunderstanding Chris about what it means

ID: 99fc86 Jan. 1, 2018, 1:14 a.m. No.2099   πŸ—„οΈ.is πŸ”—kun   >>2100 >>2102 >>2330

>>2092

That doesn't make much sense, because (x + n)^2 is what you add to c to make a square. I'll try to find where he said that.

 

>>2097

All RSA numbers don't work, neither does that 45-digit semiprime.

 

The smallest number that doesn't work is

81311001417221

 

It doesn't make a lot of sense to me right now why, because these do, and they are one digit longer:

215303158862641=13903207*15485863

237051716747561=15358451*15434611

 

I'll get you some more small-semiprimes that don't work for you to make a graph. Would including the RSA numbers help, or too large to work with? Because I tested all of them.

ID: 99fc86 Jan. 1, 2018, 1:37 a.m. No.2101   πŸ—„οΈ.is πŸ”—kun   >>2103

>>2100

That doesn't mean RSA isn't compatible with such an algorithm.

 

Read the picture. For example, the distance between rsa100a and rsa100b is relatively small.

 

37975227936943673922808872755445627854565536638199

*

40094690950920881030683735292761468389214899724061

 

RSA-155's factors are close as well.

102639592829741105772054196573991675900716567808038066803341933521790711307779

*

106603488380168454820927220360012878679207958575989291522270608237193062808643

Anonymous ID: 96255b Jan. 1, 2018, 1:50 a.m. No.2102   πŸ—„οΈ.is πŸ”—kun   >>2105

>>2099

What we need is a bunch of semiprimes that don't work with known a and b variables. That way we can graph the multiplier. It has to be semiprimes that don't work or it might turn out that semiprimes that do work follow a different pattern and it'll add noise to the graph.

ID: 99fc86 Jan. 1, 2018, 1:58 a.m. No.2105   πŸ—„οΈ.is πŸ”—kun

>>2102

Okay, I'll try to find some smaller semiprimes that don't work.

 

>>2103

It's not even that the algorithm is taking too long, it's just inaccurate. Try it yourself by printing out each i. You'll see that it repeats very quickly, meaning it already searched all the space. If the variables are configured properly it could factor those numbers.

ID: 99fc86 Jan. 1, 2018, 2:09 a.m. No.2106   πŸ—„οΈ.is πŸ”—kun   >>2137

>>2095

>>2093

>>2092

Figured it out. c MINUS f makes a square.

 

c = 3057

a = 3

b = 1019

f = -79

c - f = 56^2

 

c = 8883

a = 9

b = 987

f = -142

c - f = 95^2

 

c = 187452

a = 254

b = 738

f = -37

c - f = 433^2

 

c = 194421

a = 283

b = 687

f = -60

c - f = 441^2

 

Therefore, c + (x + n)^2 and c - f are two perfect squares to the right of c (on the number line).

IseePatterns !kIkD/SqZ4s ID: 4e9ed8 Jan. 1, 2018, 2:13 a.m. No.2107   πŸ—„οΈ.is πŸ”—kun   >>2260

One thing I just noticed,not sure if it's known or helpful.

 

Have you noticed that the a and b's in (e, 1) is the same values as the d's in the next (e + 1, 1)?

 

And for (e + 2, 2) the d's alternate between (e, 2) a's and b's. For example, (12, 2) has d's equal (8, 2) a's while (16, 2) has d's equal (12, 2) b's.

Anonymous ID: 96255b Jan. 1, 2018, 3:12 a.m. No.2113   πŸ—„οΈ.is πŸ”—kun   >>2114 >>2116

I don't know why I'm finding it so hard to find a way to graph these points somewhere. LibreOffice Calc won't do it properly and every website I've tried hasn't worked properly. Anyone have any suggestions?

 

These are the points I've got so far, if anyone's curious. We need the gradient. It looks like it might be linear but it's probably not a good idea to guess.

(1653304, 0.00196213158620556)

(1704619, 0.00192946341675178)

(1714251, 0.00192212225630902)

(1787371, 0.00187593957829684)

(1903996, 0.0018009491616579)

(2486975, 0.00171975994933604)

Anonymous ID: 96255b Jan. 1, 2018, 3:26 a.m. No.2115   πŸ—„οΈ.is πŸ”—kun

>>2114

If it is linear like it seems to be, rise / run. If it isn't, we'll be able to tell by looking at it if it's exponential or whatever. If it's all over the place then we'll know that it's super complicated and that this has all been for nothing (I don't think that's the case, it doesn't look noisy at all).

Anonymous ID: 96255b Jan. 1, 2018, 4:05 a.m. No.2120   πŸ—„οΈ.is πŸ”—kun   >>2121

>>2116

It doesn't seem to be linear, but it also doesn't seem to follow any other distinct equation.

Gradient 1 = -6.3662E-10

Gradient 2 = -7.62164E-10

Gradient 3 = -6.31601E-10

Gradient 4 = -6.43005E-10

The gradient of point 1 to point 4 is -6.42950012555885E-10

What I've been thinking is that when it comes to these semiprimes that don't work straight away, maybe the function of the multiplier used to turn the maximum possible i into the real i is made up of a bunch of lines just like the (c, i) plot I found the original gradient from, and we'd need to do binary search on the range of possible multiplier values to find the correct multiplier. Then there might be another set of gradients created when we find all the times that the multiplier isn't found with binary search. I don't know for sure, but this might be some kind of fractal.

Anonymous ID: 96255b Jan. 1, 2018, 4:19 a.m. No.2122   πŸ—„οΈ.is πŸ”—kun

>>2121

For a start, we'd all have to completely understand each other's work. You're the only one who's been working on what I've been posting about (I doubt anyone else completely gets what we're talking about), and I haven't really helped with the cell jumping stuff (mostly because I don't entirely understand it or see where it's going). Maybe you're right though.

Anonymous ID: 96255b Jan. 1, 2018, 7:20 a.m. No.2124   πŸ—„οΈ.is πŸ”—kun

I'm at the point where I don't even understand my own code, so I think I should give it a rest for a day. I'll still be here to do any BO stuff I might have to do. Good luck all.

IseePatterns !kIkD/SqZ4s ID: 4e9ed8 Jan. 1, 2018, 7:31 a.m. No.2125   πŸ—„οΈ.is πŸ”—kun

I've probably now gone back to thread 1, but it's possible to traverse (e, 1) by swapping a's, b's and d's. No idea how useful that is.

 

It branches depending on if you want to follow the a's or b's. But again, I think this was covered quite early on and I don't know if it of any use.

IseePatterns !kIkD/SqZ4s ID: 4e9ed8 Jan. 1, 2018, 7:41 a.m. No.2127   πŸ—„οΈ.is πŸ”—kun   >>2128

>>2126

 

Here:

 

{4:1:26:6:20:34} {5:1:34:7:27:43} {6:1:27:6:21:35}

 

For (4, 1) you take b as (5, 1)'s d. Then you take (5, 1)'s a as (6, 1)'s d. Then (6, 1)'s b as (7, 1)'s d. Then (7, 1)'s a as (8, 1)'s d etc.

 

For (e, 1) it alternates between a for d and b for d.

Anonymous ID: c50aac Jan. 1, 2018, 7:56 a.m. No.2129   πŸ—„οΈ.is πŸ”—kun

Tested on multiple c = ab !!

Easily calculated e such that:

a of (e,1,1) is factored by goal a goal b and N.

This is what Chris was talking about as a solution!

a repeats as factor every a*t +1

b repeats as factor every b*t +1

N repeats as factor every N*t + 1

I'm having trouble figuring out how to get to the aNt +1 record or the bNt+1 since we still don't know a or b! Any suggestions???

Anonymous ID: c50aac Jan. 1, 2018, 8:35 a.m. No.2130   πŸ—„οΈ.is πŸ”—kun

I used the formula Chris suggested. Subtract 2d +1 from a to get a new negative e. This works with one problem.We get a b and N as factors of a(new.e( e-a + 2d+1),1,1 ) I had to take all factors of 2 out of N to get negative e to work.

Hobo !!1yNgQ3NlCs ID: 77a00f Jan. 1, 2018, 11:54 a.m. No.2133   πŸ—„οΈ.is πŸ”—kun

>>1993

https://anonfile.com/48X2s9d6bb/Unforseen_Concequences.rtf

 

The next chapter of the chronicle. I'm going to try to figure out how to open up that sonoluminescence thread Chris mentioned next. Wish me luck.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 1, 2018, 12:20 p.m. No.2137   πŸ—„οΈ.is πŸ”—kun   >>2138 >>2156 >>2235

>>2106

good observation.

 

I believe the following describes the move from any (e,n,t) to its f record.

 

from (c) -(cf)

 

(c).f = 2d + 1 - e

 

(cf).e = 2d + 1 - e

(cf).n = 1

(cf).d = d + (n - 1) * a

(cf).x = x - 1

(cf).a = (n + 1) * a

 

(cf).(x+n)^2 = c - f

ID: 99fc86 Jan. 1, 2018, 1:12 p.m. No.2142   πŸ—„οΈ.is πŸ”—kun

>>2141

Furthermore, the way I was able to list all perfect squares was by only printing out the cell when

fsqrt(c+x+f is less than d-1 or where it is greater than d+1

 

Meaning that this is true for all perfect squares, namely fsqrt(c+f+x) = d - 2

Q !ITPb.qbhqo ID: 0a6a3d Jan. 1, 2018, 3:42 p.m. No.2148   πŸ—„οΈ.is πŸ”—kun

>>2146

It's fake. Just wanted to play a joke on you all.

 

Bad actors cracked Q's old trip code (in 2 months) and it was something ridiculously easy β€” "Matlock"

You can try it yourself.

 

Deep state humiliated.

Anonymous ID: 6a6600 Jan. 1, 2018, 4:21 p.m. No.2149   πŸ—„οΈ.is πŸ”—kun   >>2150 >>2152

>>2146

>>2145

Ya, there it was tense / full of lulz after a while in thread #262.

This anon actually pulled the "Matlock" password in a comment about the 7 dwarves:

>>>/cbts/222007

and the "fake q" answered "what, are you in the know?". Random.

 

It did freak me out at first, there were posts being deleted. I have some screencaps of the "we were comped from the beginning". Let me find, h/o…

 

There, attached. Will admit had a wrenching in the gut when first reading. Then post deleted. Then it unfolded and all could relax.

ID: 99fc86 Jan. 1, 2018, 4:29 p.m. No.2150   πŸ—„οΈ.is πŸ”—kun   >>2151

>>2149

Don't believe any of that nonsense they posted. Whichever CIANigger cracked Q's trip is probably suicidal over wasting 8k 60fps gaming hardware on "Matlock".

 

What a brilliant crumb..

 

Matlock.

[A]ndy [G]riffith.

Likes hotdogs.

Anonymous ID: 6a6600 Jan. 1, 2018, 4:37 p.m. No.2151   πŸ—„οΈ.is πŸ”—kun   >>2154

>>2147

And nice not to string the fine brothers and sister here along too far Q/Z, or is it SuzieQ?

>>2150

Nah, became clear in a hurry. And hey, the work you were laying down the other night was stellar. And others too, great progress, and amazed how close it looks at times.

Seriously though - Chris hasn't really kept promises to date. And just fuckering off on twitter, preaching to the choir. Do you think perhaps you've passed where he had gotten to with this project already? Is he waiting for you all to finish off the idea? Asking because the 3D Printing comment is totally fucking out there, if you actually know anything about 3DP and manufacturing and tooling and the economics of it all. Think he was pulling Hobo in on that one. Really undermines credibility for me on the whole matter though. Been re-reading some things and thinking from skeptical angle now. Not trying to suck wind out of sails.

Then again, Chris's twitter has some similar behavior to JA's, and could indicate movement of another sort. Dunno, getting odd.

ID: 99fc86 Jan. 1, 2018, 4:51 p.m. No.2154   πŸ—„οΈ.is πŸ”—kun   >>2155 >>2157 >>2158

>>2151

Regardless of my waivering opinion on whether he is legitimate, I think this can be solved. You don't know what you don't know.

 

All the variables we use to represent Fermat's factorization algorithm (that's what this started off of) are so much more advanced than what the world knows at this point. The most advanced factorization algorithm in the world is literally a brute force, but with a slightly smaller search space using a polynomial (I can explain sieving if you think that's relevant.) These are so much different. We can do so much better. We have these crazy gradients that can factor numbers using a line, and we have the grid, which has so many untapped and unexplored secrets in it.

 

He's already accomplished half of his goal: turning the people here into apprentice mathematicians.

Anonymous ID: 6a6600 Jan. 1, 2018, 5:06 p.m. No.2158   πŸ—„οΈ.is πŸ”—kun   >>2159

>>2154

Think we're on the same page. No need on the sieving, see how this is quite different. Your work, and PMA, Teach, MA and others keep the hope alive.

Am hung up a bit on how it will work when the two factors are quite different. With the 180 digit c put to CA the other night, tried to pick a couple 90's that were somewhat close

Many other 90's on this page to grab:

https:/ /www.alpertron.com.ar/googol.pl?digits=90

 

Then think about the National Security implications, of which this would have many. And, given 'we're being watched over', would it be allowed to continue if there was a risk? Is that part of the goal, let this happen organically to force the currency RV? layers upon layers, DJT did say to think bigger, very big in one speech…

ID: 99fc86 Jan. 1, 2018, 5:11 p.m. No.2159   πŸ—„οΈ.is πŸ”—kun   >>2161 >>2162

>>2158

From channing for a very long time and having participated when We The People exposed PG and Seth Rich all on our own (and with the help of some patriotic martyrs), I don't believe anyone is going to get suicided for mathematics. People our watching. Our work isn't in vain. Look how many lurkers revealed themselves when someone used Q's tripcode.

 

In fact, it's our duty to expose the fact that the world's security is based on a lie. A 2KB number.

Anonymous ID: 6a6600 Jan. 1, 2018, 5:13 p.m. No.2160   πŸ—„οΈ.is πŸ”—kun   >>2163

>>1782

>Basically I can factor a product of 2 primes easily.

>>1794

>>1803

You did touch leader on the 180lb Tarpon though, right?

>>1826

>I'm waiting for VQC, I don't want to displease GEOTUS

^^^ this is the nightmare keeping me up at night though. Won't put myself under the master's heel. Are there any men/women left that think and decide for themselves, willing to go against the whole world if need be? Sorry CA, no offense to you personally, just this is what can get the world in a whole heap of trouble. It enables dictatorships.

CollegeAnon !LAbIRp9cT. ID: b65f84 Jan. 1, 2018, 5:26 p.m. No.2163   πŸ—„οΈ.is πŸ”—kun   >>2164 >>2165

>>2160

 

Sorry to explain I was solving them pretty fast but I couldn't get the big RSA number. Then I modified the code to make it faster and I accidently had a loop condition be satisfied immediately. I got so excited that I copy pasted and posted right away. My method doesn't work for bigass numbers.

Anonymous ID: c50aac Jan. 1, 2018, 7:19 p.m. No.2172   πŸ—„οΈ.is πŸ”—kun   >>2173 >>2174

Chris has given a number of hints about a special record in (e,1).

That record is e equals 2Nab.

a, b, c, N are all factors of (2Nab, 1, 1) and all through the cell at 1+ at, 1+bt, 1+Nt, 1+sqrt(N/2)*t etc.

They are all factors of the (-2Nab, 1, t) cell also.

 

This record is what a lot of Chris hints are referring to. We just need one more step!

Anonymous ID: c50aac Jan. 1, 2018, 7:37 p.m. No.2174   πŸ—„οΈ.is πŸ”—kun

>>2172

Factors of a(2Nab, 1, t).

The records get hairy but I'll give a couple examples

 

(19, 2, 10, 3,7,17) yields

(1656956, 1, 828478, 9, 828478, 828480)

with 828478 divisible by 7, 17 and N 6962

 

{10, 1, 17, 4, 13 23} yields

{26552396, 1, 13276198, 0, 13276198, 13276200}

with a =13276198 divisible by 13, 23 and N 44402 and all up and down the cell.

Anonymous ID: 96255b Jan. 1, 2018, 8:03 p.m. No.2181   πŸ—„οΈ.is πŸ”—kun   >>2183 >>2185

For the at least one anon who has been following along with the gradient thing I've been doing, I thought it might be a good idea to make binary search look for the lowest possible i value that doesn't create an imaginary number in the x = (floor_sqrt((i^2 - c))) - n equation. I know I said I was taking the day off but I had an idea to at least clean up the binary search code (significantly) and to fix the gradient that finds the highest possible i.

 

What I didn't realize is that the lowest i where i^2 c is just the smallest square larger than c. Maybe that can somehow be useful. The following code is just used for finding that i value. It isn't used to factorize, but it does say whether or not the i it finds is the correct one for the given c. https://pastebin.com/ixDFePBX

Anonymous ID: 96255b Jan. 1, 2018, 8:07 p.m. No.2183   πŸ—„οΈ.is πŸ”—kun   >>2193

>>2181

I forgot to add that I think what that means is that the real minimum i value is floor(sqrt(c))+1. That either means that binary search doesn't work or that I just don't understand what I'm doing (I think it's the latter, since the binary search algorithm that does the factorization is right most of the time depending on how big the numbers are and it does it instantly).

ID: 99fc86 Jan. 1, 2018, 9:11 p.m. No.2196   πŸ—„οΈ.is πŸ”—kun   >>2197 >>2204 >>2217 >>2316 >>2357

>>2193

>>2194

>>2195

Think about the number line.

 

For any c value, you start out knowing 2 perfect squares, d^2 and (c - f). (c - f) is adjacent to d^2, meaning you can calculate (c - f) by adding one to d and then squaring that value.

 

c = 123824

d = 351

f = -80

c - f = 123904

(d+1)^2 = 123904 = (c - f)

 

The two squares you want to get to are called the nonadjacent squares, and they are they are how the factors of c are created. There is a larger one and a smaller one, like the picture I posted. c is equal to the difference of those two nonadjacent squares, a is equal to the difference of the roots of those squares, and b is equal to the sum of the roots of those squares.

 

i^2 = (d+n)^2

j^2 = (x+n)^2

 

c = i^2 - j^2 = (d+n)^2 - (x+n)^2

a = i - j = (d + n) - (x + n)

b = i + j = (d + n) + (x + n)

 

Previously in the field of integer factorization it was thought that you had to know both to instantly factorize the number, but you only have to know one. Look at the picture I posted and you will understand Fermat's equation and the difference of two squares.

ID: 99fc86 Jan. 1, 2018, 9:13 p.m. No.2197   πŸ—„οΈ.is πŸ”—kun

>>2196

Actually, they can factor it by knowing either nonadjacent square. But it was still something nobody could solve, namely getting to those nonadjacent squares. That's why sieves exist, they are an search algorithm that uses a polynomial to decrease the search space based on a few proofs. Nothing like what we have here.

ID: 99fc86 Jan. 1, 2018, 9:43 p.m. No.2201   πŸ—„οΈ.is πŸ”—kun   >>2202

>>2200

>>2199

>>2198

Thanks, but I didn't solve anything, I just delved deeper into premise of what the goals of factorization can be simplified into, namely:

 

-finding either of the nonadjacent squares

-finding the root of i^2 (which is what >>1946

does)

-finding n

-finding x

-finding na

 

There's many you could solve it.

 

>>2013

Also, is it useful that in the case of (1,25,4) that the e we need to get to is adjacent to -n?

Anonymous ID: 6358da Jan. 1, 2018, 9:55 p.m. No.2204   πŸ—„οΈ.is πŸ”—kun

>>2195

>>2196

Respect.

Some comfy music, along the direction CA is going in >>2011 with time cut to where the gnomes have learned "A New Way to Say 'Hooray!'"

https:/ /youtu.be/-IdDr0T90Jk?t=995

…and a nice grid here at 10:30 in:

https:/ /youtu.be/QbhhLhb3zc8

Anonymous ID: 96255b Jan. 1, 2018, 9:56 p.m. No.2205   πŸ—„οΈ.is πŸ”—kun   >>2206 >>2207 >>2210

This program takes the c we want to factor and outputs the range of possible i values.import java.math.BigInteger;import java.util.Scanner; public class i_range{ //constants private static BigInteger zero = BigInteger.ZERO; private static BigInteger one = BigInteger.ONE; private static BigInteger two = BigInteger.valueOf(2); private static BigInteger three = BigInteger.valueOf(3); private static BigInteger four = BigInteger.valueOf(4); private static BigInteger five = BigInteger.valueOf(5); private static BigInteger six = BigInteger.valueOf(6); private static BigInteger eight = BigInteger.valueOf(8); private static BigInteger c; private static BigInteger upper_bound_real; private static BigInteger lower_bound_real; public static void main(String[] args) { Scanner input = new Scanner(System.in); String str; System.out.print("c="); str = input.nextLine(); c = new BigInteger(str); upper_bound_real = c.subtract(eight).divide(six).add(three); lower_bound_real = (sqrt(c)).add(one); System.out.println("For c = " + c + ", the true i is somewhere between (inclusive) " + lower_bound_real + " and " + upper_bound_real); } public static BigInteger sqrt(BigInteger i) { BigInteger zero = BigInteger.ZERO; BigInteger one = BigInteger.ONE; BigInteger n = zero; BigInteger p = zero; if (i.equals(zero)) { return zero; } else if (i.equals(one)) { return one; } BigInteger high = i.shiftRight(1); BigInteger low = zero; //high low + 1 while (greaterThan(high, low.add(one))) { //n = (high + low) >> 1; n = (high.add(low)).shiftRight(1); p = n.multiply(n); int result = i.compareTo(p); if (result -1) { high = n; } else if (result 1) { low = n; } else { break; } } if (i.equals(p)) { return n; } else { return low; } } public static boolean greaterThan(BigInteger i, BigInteger i2) { int result = i.compareTo(i2); return result > 0; } public static boolean lessThan(BigInteger i, BigInteger i2) { int result = i.compareTo(i2); return result < 0; } }

Anonymous ID: 96255b Jan. 1, 2018, 9:59 p.m. No.2206   πŸ—„οΈ.is πŸ”—kun   >>2207

>>2205

For example:c=403For c = 403, the true i is somewhere between (inclusive) 21 and 68c=940679For c = 940679, the true i is somewhere between (inclusive) 970 and 156781c=123824For c = 123824, the true i is somewhere between (inclusive) 352 and 20639c=35For c = 35, the true i is somewhere between (inclusive) 6 and 7

What we were doing with binary search is now kinda useless. This does, however, obviously narrow it down. As has been the case the whole time in terms of this code, if we understand the upper bounds, we can factor c.

ID: 99fc86 Jan. 1, 2018, 10:02 p.m. No.2207   πŸ—„οΈ.is πŸ”—kun

>>2206

>>2205

I think I can help with that. Since i^2 = (d+n)^2, the big square that you subtract the little square from to make c. So, we just need some measure that's small enough but also includes the big square's sqrt in the search space.

 

>>2179

The side length of the big square (d+n) in that picture is what you want to find out.

Anonymous ID: efd3f5 Jan. 1, 2018, 10:02 p.m. No.2208   πŸ—„οΈ.is πŸ”—kun   >>2212 >>2213

>>2162

I've been mostly lurking since RSA1 thread. Posted from multiple devices once or twice. So that explains some of the IDs. Can't really help working on it, as I know nothing of programming and my math is atrocious. Just here because I'm interested.

CollegeAnon !LAbIRp9cT. ID: b65f84 Jan. 1, 2018, 10:05 p.m. No.2209   πŸ—„οΈ.is πŸ”—kun   >>2212 >>2213

>>2011

I really urge you to read this, it's not too long of a read beyond the lyrics but I am fully convinced this is our guide. I think I'm making some serious progress.

Anonymous ID: 6358da Jan. 1, 2018, 10:10 p.m. No.2212   πŸ—„οΈ.is πŸ”—kun

>>2202

>>2209

CA - did you see post above, called you out on that! I can explain some of it, such as the cornerstone (relates to focus/concentration and seed/base on which to build).

>>2208

Same. And the ID's vary, VA has 7 different ones in this thread, MA 5, but lot of heavy lifting from 72b8e7 and 8d711d, PMA, etc.

Anonymous ID: 96255b Jan. 1, 2018, 10:14 p.m. No.2213   πŸ—„οΈ.is πŸ”—kun   >>2214

>>2208

There's nothing wrong with that. Once we get there (I'm convinced we will at this point), some crazy, crazy shit is going to happen.

 

>>2209

I didn't want to be mean, but this seems to me like that stereotype of Tool fans taking them way, way too seriously. Using the Fibonacci sequence to decide on the length of several lines of lyrics doesn't mean he's telling you the secrets of the universe. It means he's using the Fibonacci sequence to decide on the length of several lines of lyrics. Plus, there are many bands who use occult ideas in their lyrics like as above, so below or use Enochian to name songs or albums. Unless there's a direct reference to the math in this grid, I think you're taking them far too seriously.

 

>>2210

It isn't a method for finding i from c. What I figured out is that the lower bounds we were using in that binary search algorithm (if i^2 < c) translated to simple math: instead of using binary search, we can find the end of the lower bounds by simply taking the square root of c and adding 1 to it, because the first instance of i^2 being c is when i = floor(sqrt(c))+1.

ID: 99fc86 Jan. 1, 2018, 10:17 p.m. No.2214   πŸ—„οΈ.is πŸ”—kun   >>2215

>>2213

Yes, good going! So, where do we go from now? Binary search useless? What's next? Ready to code something out here, I've been studying different factorization algorithms recently. Seeing the bigger picture is VERY useful.

Anonymous ID: 96255b Jan. 1, 2018, 10:25 p.m. No.2215   πŸ—„οΈ.is πŸ”—kun   >>2216

>>2214

>where do we go from now? Binary search useless?

I definitely don't think binary search is useless, considering we used it to very easily factor a bunch of different semi-primes. Some time around 3am this morning I somehow managed to make the original binary search I was working with factor 940679 even quicker than before, but it didn't work properly for most of the other numbers. The version in that pastebin I posted an hour or two ago is far cleaner and easier to understand, but it just looks for floor(sqrt(c))+1 at the moment, so we could adapt it so that the lower bound is floor(sqrt(c))+1 now that we know, and then once we know how to change the bounds again we can factor c.

 

From my perspective, all we still need to do is understand how these bounds work. If we find a linear relationship among the variables based on how high i is, we'll know when the current guess i is too large or too small.

Anonymous ID: 96255b Jan. 1, 2018, 10:37 p.m. No.2218   πŸ—„οΈ.is πŸ”—kun   >>2219 >>2221

>>2216

Woah, weird. Instinct tells me that's a fluke based on the real i being somewhere along the logarithmic (that's what it is, right?) plot generated when you keep halving the range of possible i's. How exactly did you merge them, and how long did it take to calculate that?

ID: 99fc86 Jan. 1, 2018, 10:43 p.m. No.2219   πŸ—„οΈ.is πŸ”—kun   >>2220

>>2218

Less than a quarter of a second.

 

All I did was change

 

i_poss = c.subtract(eight).divide(six).add(five);

to

i_poss = c.subtract(eight).divide(six).add(three);

 

and

 

BigInteger correct_i = binary_search(mid_index, upper_bound_real, zero);

to

BigInteger correct_i = binary_search(mid_index, upper_bound_real, d.add(one));

Anonymous ID: 96255b Jan. 1, 2018, 10:47 p.m. No.2220   πŸ—„οΈ.is πŸ”—kun   >>2222

>>2219

That makes me think it's a fluke. Just to explain the +5 being changed to +3, the gradient starts at (3, 9), but it was giving me problems originally so instead of making it +3 I just added a couple extra (all it did was add 2 to i_poss, so it was arbitrary, but for all I know it was involved in factoring that previously unfactorable number maybe). Have you tried any of the other ones that weren't working?

ID: 99fc86 Jan. 1, 2018, 10:55 p.m. No.2221   πŸ—„οΈ.is πŸ”—kun   >>2224

>>2218

Next number in order of magnitude that doesn't work is

 

523022617466601111760007224100074291200000001

 

I think this a step forwards because the same algorithm works better for all semiprimes, however I noticed that changing the lower bound to d+1 only makes it work SOME of the time.

 

10967535067 only works with the previous edit.

So lower bound = 0 factors this,

 

but it doesn't factor 81311001417221 and lower bound = d+1 does. Interestingly, changing the gradient from +5 to +3 doesn't change the results, but lower bound does.

 

Any ideas on how I would be able to programmatically check it a certain starting value didn't work?

Anonymous ID: 96255b Jan. 1, 2018, 11:03 p.m. No.2224   πŸ—„οΈ.is πŸ”—kun   >>2225

>>2221

Did changing it from +5 to +3 change anything about it? Did it take any extra steps? I guess in the grand scheme of things integer rounding will diminish the difference with big numbers when you're halving them, but if i just happened to be maybe 2 away from the starting point, changing it would change things (although not only do I not think that would ever happen but it also wouldn't be based on an actual understanding of how this works).

>how to programmatically check if a certain starting value doesn't work

If you mean you want to check if d+1 = i, you could just plug that into the equations for generating a and b within main before you call binary_search and see if test == c there.

 

>>2222

>>2223

Quads confirm we're making headway. Do you have any idea why it isn't factoring the 45-digit one? Also do you have any idea how long it takes the sieve method to factor a 44-digit semi-prime? Because even if we haven't gotten there yet this seems pretty crazy.

ID: 99fc86 Jan. 1, 2018, 11:06 p.m. No.2225   πŸ—„οΈ.is πŸ”—kun   >>2226 >>2227

>>2224

4 seconds for a sieving method

70 minutes for rsa100

800 years for rsa200

14000years for the higher ones that have been cracked

(this is cpu time)

 

Not very impressive, but with the level of jumps we're making I think we'll surpass them quite quickly. Besides, your algorithm is unique in that if it works, it's always around a few seconds. Right?

ID: 99fc86 Jan. 1, 2018, 11:14 p.m. No.2226   πŸ—„οΈ.is πŸ”—kun   >>2227

>>2225

I should also mention that the 45 digit semiprime I've been trying to factor is

 

38! + 1

 

So it might be special.

It takes 4 seconds for that with advanced sieving algorithms. But that shouldn't deter us.

ID: 99fc86 Jan. 1, 2018, 11:20 p.m. No.2228   πŸ—„οΈ.is πŸ”—kun   >>2229

>>2227

It loops from

 

22869687743093501059308 to 87170436244433518626667870683345715199995947

 

(highest value it prints out to lowest)

 

the highs and lows it prints out are all slightly different after that, but it just keeps looping around the same magnitudes

ID: 99fc86 Jan. 1, 2018, 11:26 p.m. No.2230   πŸ—„οΈ.is πŸ”—kun   >>2232

>>2229

523022617466601111760007224100074291200000001

 

don't factor this one.. hehe

22701801293785014193580405120204586741061235962766583907094021879215171483119139894870133091111044901683400949483846818299518041763507948922590774925466088171879259465921026597046700449819899096862039460017743094473811056991294128542891880855362707407670722593737772666973440977361243336397308051763091506836310795312607239520365290032105848839507981452307299417185715796297454995023505316040919859193718023307414880446217922800831766040938656344571034778553457121080530736394535923932651866030515041060966437313323672831539323500067937107541955437362433248361242525945868802353916766181532375855504886901432221349733

Anonymous ID: 96255b Jan. 1, 2018, 11:28 p.m. No.2231   πŸ—„οΈ.is πŸ”—kun

>>2230For c = 523022617466601111760007224100074291200000001, the true i is somewhere between (inclusive) 22869687743093501007952 and 87170436244433518626667870683345715200000001

It didn't really narrow much down.

Anonymous ID: 96255b Jan. 1, 2018, 11:35 p.m. No.2232   πŸ—„οΈ.is πŸ”—kun   >>2233

>>2230

Here's something interesting, based on those two changes (d+1 for 0 and +3 instead of +5) and a factorization of that bigger number:Upper = 150671169417991225046059544758357156789444171603745255851676744300137107192940602659695771463416894743331134777436564854445241931765583656307311832859469292745085419037055008587098920882459584299695035925409370319142460098639819301505752289155099234767934684476314251383056405936484795788156351765009446474080, middle = 150671169417991225046059544758357156789444171603745255851676744300137107192940602659695771463416894743331134777436564854445241931765583656307311832859469292745085419037055008587098920882459584299695035925409370319142460098639819301505752289155099234767934684476314251383056405936484795788156351765009446474080, lower = 150671169417991225046059544758357156789444171603745255851676744300137107192940602659695771463416894743331134777436564854445241931765583656307311832859469292745085419037055008587098920882459584299695035925409370319142460098639819301505752289155099234767934684476314251383056405936484795788156351765009446474080

It loops. It converges to this number, then it starts again (meaning that isn't the correct i). It took 28 seconds to reach that possible i value, so if we actually knew what we were doing, we could factorize this huge number in 28 seconds.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 1, 2018, 11:39 p.m. No.2235   πŸ—„οΈ.is πŸ”—kun   >>2237 >>2505

>>2137

I've been spending some time trying to understand the (f,1,t) records.

 

These can be created from any (e,n,t) by:

 

new.e = ( 2 * orig.d ) + 1 - orig.e

new.n = 1

new.t = orig.t

 

Don't fully understand the importance of these records, but can say that when you compare (f,1) records created from (1xc) and (axb), the a and b values are starting to get closer together.

 

Example below:

 

145=5x29

a x b *** =(1,5,4) = {1:5:12:7:5:29} = 145;

a x b f =(24,1,4) = {24:1:36:6:30:44} = 1320;

 

1 x c =(1,61,6) = {1:61:12:11:1:145} = 145;

1 x c f =(24,1,6) = {24:1:72:10:62:84} = 5208;

 

I believe I have figured out the formulas to create these records directly - but only for odd values of e.

 

e = 2*d + 1 - e

n = 1

d = d + (n - 1)*a + (a - e)

x = x - 1

a = (n + 1)*a - e + 1

 

Even values of e seem to be a little more tricky.

Anonymous ID: 96255b Jan. 1, 2018, 11:48 p.m. No.2239   πŸ—„οΈ.is πŸ”—kun   >>2240

>>2236

Derived from the equations, I would think. What I'm saying is, we have a big ordered smallest-to-largest list of potential i values for our given c, and we need to find some way of applying binary search to it in a more logical way than we currently are. We need to be able to say "i = 38 through to i = 22 are too big, i = 20 through to i = 0 are too small, and i = 21 is just right". It can't be based on imaginary numbers in the x calculation, because that's how we found d+1 as the lowest possible guess i.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 1, 2018, 11:56 p.m. No.2244   πŸ—„οΈ.is πŸ”—kun   >>2245 >>2255

>>2242

disagree. Binary search is interesting. But it's not the solution.

 

There are a simple set of formulas to describe record creation.

I believe there is another set of formulas to describe movement between records.

 

Understanding that movement is critical to figuring this out.

Anonymous ID: 96255b Jan. 2, 2018, 12:05 a.m. No.2250   πŸ—„οΈ.is πŸ”—kun   >>2251

>>2246

>I choose to believe

So in other words you don't even know what it is we're doing? You can't just say "it doesn't work because I don't believe it works", especially considering this whole thing revolves around math. If you're saying you don't believe because Chris hasn't said anything about it, for one, I don't see why there couldn't be multiple solutions considering this isn't territory many people have studied and considering we might be interpreting the method Chris used in a different way, and secondly because Chris said himself that we can crack RSA in O(log n) time, and binary search is an O(log n) algorithm. The way you're working on probably works great, if you can figure it out.

Anonymous ID: 96255b Jan. 2, 2018, 12:12 a.m. No.2254   πŸ—„οΈ.is πŸ”—kun   >>2256

>>2253

The gradient of the lowest line in (c, j) is 1/6, just like the (c, i) grid. That means we could use either i or j almost interchangeably in the way we've been using i, but I'm not sure if that means we could use it for binary search.

MinecraftAnon !!QXqSZ2ev8. ID: 57f8d7 Jan. 2, 2018, 12:14 a.m. No.2255   πŸ—„οΈ.is πŸ”—kun

>>2244

I agree that binary search won't lead to the answer, but it seems like ideas and theories are getting lost in the noise of the general thread.

 

We have an entire board that we can utilize, where threads don't get pruned. If we're looking for the hidden relationship to unite this thing into one functioning piece, we can make progress by dividing and conquering the problem.

 

So, we make 5 threads. One for E, F(-E), N, D, X. We look at specific values which cause strange behavior with other values. For example, E58. This is the least populated E in the entire grid. Why? because E58 has an absolute fuckton of primes and coprimes in it. But why E58? What can we learn about the rest of the grid through E58?

 

N for example, where N is prime, the populated cells have significantly less values. Why? What insights can we gain by breaking this grid into the smallest pieces? What formulas can we create to relate variables to other variables? Can we understand how every little tiny piece works and bring it back together when we're done?

Anonymous ID: 96255b Jan. 2, 2018, 12:25 a.m. No.2258   πŸ—„οΈ.is πŸ”—kun   >>2259

>>2257

I'm not entirely sure, but I put together a program that shows the way guess i and j scale up together based on a given c. You give it a c and a maximum i up to which you want it to check, and it calculates what j would be if that combination of i and c was correct. This was written before I knew the minimum i was d+1.import java.util.;public class Wrong{ public static void main(String[] args){ print(1000, 497143); } public static void print(int i, int c){ System.out.println(); System.out.println("c = " + c + ", i = " + i); int count = 0; while(count < i+1){ int i_sq = countcount; int fl_sq_c = (int)Math.floor((int)Math.sqrt(c)); int fl_sq_isqMc = (int)Math.floor((int)Math.sqrt(i_sq-c)); int j = (count - fl_sq_c) + (fl_sq_isqMc - (count - fl_sq_c)); System.out.println("i = " + count + "\tj = " + j + "\t (i-j)(i+j) = " + ((count-j)*(count+j)) + "\t real c = " + c); count++; } }}

If you run it with the c I used and change the maximum i value in the method call, you can see how j doesn't scale entirely linearly with i, but it is constantly increasing with it and never goes higher than i obviously since that would create a negative a.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 2, 2018, 12:56 a.m. No.2260   πŸ—„οΈ.is πŸ”—kun

>>2107

 

I'm still looking into this for now. One thing I noticed is that (e, 1)'s d will always be (e + 1, 1)'s a. Thus we can easily get the factor a for (e, 1). We know d, so we can get the t for d at (e, 1). Then we simply get a at t for (e + 1, 1) and we have one factor.

 

Since we won't have our c in (e, 1) it doesn't give any instant solution, but I think it is a useful observation.

Anonymous ID: 96255b Jan. 2, 2018, 1:12 a.m. No.2264   πŸ—„οΈ.is πŸ”—kun

>>2263

I was printing the wrong c value in mine, too, and I've just found something very strange. This is for 940679, for which the real correct i value is 6600, but in this case i is a guess based on putting i through the equations.i=6600 j=6528 'c'=945216 a=72 b=13128 e=6255

The c is wrong.

Anonymous ID: 96255b Jan. 2, 2018, 1:38 a.m. No.2265   πŸ—„οΈ.is πŸ”—kun   >>2266 >>2267

I just had a binary-search-related thought. So we've got all of these lines >>1946, each starting based on the square of primes in order, and each with a gradient of 1/(prime*2). These lines all diverge, so they'll always be in smallest-to-largest order. For a given c, we can calculate how many lines there'll be based on the squares. What if, for binary search, we took the middle line and calculated what i would be based on our given c by taking its starting point and applying the gradient to it? Since all of these lines diverge, the i along any of these lines for a given c will always be in order. I really hope I explained that right because it might be part of the solution.

Anonymous ID: 96255b Jan. 2, 2018, 1:46 a.m. No.2268   πŸ—„οΈ.is πŸ”—kun   >>2269

>>2266

>>2267

I'm talking about the co-ordinates of the start of each of those lines in the (c, i) plot. The first one starts where a and b = 3, and has a gradient of 1/6. The second one starts where a and b = 5, and has a gradient of 1/10. The third starts where a and b = 7, and has a gradient of 1/14. Etc. Now that I think about it I'm not 100% sure we can calculate the start of each line, but I'll check. If we can, aside from having to generate a big list of prime numbers, we should be able to do it. Don't hold your breath.

Anonymous ID: 96255b Jan. 2, 2018, 1:54 a.m. No.2270   πŸ—„οΈ.is πŸ”—kun   >>2272

To figure out the latest line to have started, we take the highest square of primes below c. That means finding the highest prime below d (which I guess I'll call m). The latest line to have started on this (i, c) plot will start at (m, m^2) and have a gradient of 1/(m*2). If we had an array of primes (which might be quite time consuming to generate, but I'm figuring this out as I type), we could take the length of that array as the bounds, and start binary search with the middle as the center line. We'd then use the starting position of the m/2 line and its gradient to calculate where i would be for our given c. m will either be correct, too low or too high. Since these lines are diverging, if m is too low, we definitely go higher, and if m is too high, we definitely go lower. I think this it is.

Anonymous ID: 96255b Jan. 2, 2018, 1:58 a.m. No.2273   πŸ—„οΈ.is πŸ”—kun   >>2274 >>2275

>>2272

If we can find the highest prime less than d without it being, like, O(n^2) or some shit, this will work. Otherwise, we'll need a big list of every prime number up to however many digits are in the factors of a 2048-bit RSA number.

Anonymous ID: 96255b Jan. 2, 2018, 2:02 a.m. No.2274   πŸ—„οΈ.is πŸ”—kun   >>2275

>>2273

>>2272

Actually, apart from in regards to d, do we need to worry about primes? We could just imply that there are lines for every number. They're all going to have different i values at the point of a given c (most of which will be decimals).

Anonymous ID: 96255b Jan. 2, 2018, 2:09 a.m. No.2278   πŸ—„οΈ.is πŸ”—kun   >>2279

>>2276

Give me a minute. I realized how we can do it without needing to worry if a number is prime. I'm just typing up an explanation. Sorry to everyone for posting a gorillion times instead of formulating my thoughts better, by the way.

ID: 99fc86 Jan. 2, 2018, 2:11 a.m. No.2279   πŸ—„οΈ.is πŸ”—kun

>>2278

Good, I had a feeling this prime search nonsense would lead us astray.

 

It's another problem the world can't solve yet.

Checking if a number is prime in a not terrible time.

Anonymous ID: 96255b Jan. 2, 2018, 2:13 a.m. No.2280   πŸ—„οΈ.is πŸ”—kun   >>2282 >>2283

Each of the lines in that picture of (c, i) is based on a prime number, but if we just pretended there were lines for every number, they would follow the same rules (same starting point and gradient rules) but they would never create an i that worked with any c. Only the primes would. That means we don't necessarily need to know that a particular line is based on prime numbers in order to use it for binary search (and therefore don't have to figure out if a number is prime before doing anything). What that means is, we plug c in, we take d as the range of possible lines, we make the starting point floor(d/2), we figure out what i would equal on that line at this c given the middle line's respective line has a starting point of (middle, middle^2) and a gradient of 1/(middle*2), and if that i is lower that becomes the new lower bound, if it's higher it becomes the new upper bound, and if it's correct it's correct.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 2, 2018, 2:13 a.m. No.2281   πŸ—„οΈ.is πŸ”—kun

>>2277

 

By all means, keep at it! I don't want to discourage anyone, I'm just curious.

 

If we get a binary search to work (and one that beats sieve) then it's a great starting point. We might be able to optimize things further after that

Anonymous ID: 96255b Jan. 2, 2018, 2:14 a.m. No.2282   πŸ—„οΈ.is πŸ”—kun   >>2283 >>2284

>>2280

To make it a bit clearer, the middle line is d/2's line (I've been naming the lines based on the numbers in them, so the 3 line is the lowest line in that picture because a always equals 3 and it starts at (3, 9)).

Anonymous ID: 96255b Jan. 2, 2018, 2:20 a.m. No.2285   πŸ—„οΈ.is πŸ”—kun   >>2289

>>2283

You don't. We're performing binary search on a bunch of lines. Each line begins at (num, num^2), and the second axis is c, so the latest line to start for a given c will be the highest square below it. The number itself will be the number of lines there are at that point. The bounds are the first line to the last line.

Anonymous ID: 96255b Jan. 2, 2018, 2:22 a.m. No.2286   πŸ—„οΈ.is πŸ”—kun   >>2289

>>2284

That's the gradient of the lowest line when you turn the {e, n, d, x, a, b} grid generator from plotting (e, n) to plotting (c, i). It puts each endxab record in based on its c and i values. The lowest prime (other than 2, which we aren't really using) is 3. To get from one record with a = 3 to another, you go 6 c's to the right and 1 i down (or it might be the other way around).

Anonymous ID: 96255b Jan. 2, 2018, 2:30 a.m. No.2291   πŸ—„οΈ.is πŸ”—kun

>>2289

Are you understanding what I'm talking about? I'm figuring out how to implement this code-wise at the moment so if I'm not explaining it well enough you could wait for that I guess.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 2, 2018, 2:43 a.m. No.2293   πŸ—„οΈ.is πŸ”—kun   >>2297

> I'll show you all how to move easily from the first or second cell (odd or even e) to any value c and then any value that is the product of p and c, where p is a prime.

 

From VQC in thread #5. Have we solved this, has VQC showned it or is this still unsolved?

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 2, 2018, 3:52 a.m. No.2299   πŸ—„οΈ.is πŸ”—kun

We've been told a few different things regarding finding c.

 

> If we multiply c by 105 ( 2 * 3 * 7 ) that number should appear in the column it belongs multiple times.

 

So far I don't know how to count those times (assuming VQC means the number of times that number occurs in (e, n).

 

> If we figure out the relationship between n * a, (n - 1) * a and a[t] and d[t] respectively we can use f.

Still not sure what this means. Is (n - 1) the previous n, or just n - 1? ProgramMathAnon has looked into into it at >>1896

Anonymous ID: 99fc86 Jan. 2, 2018, 5:08 a.m. No.2301   πŸ—„οΈ.is πŸ”—kun

This looks useful! I thought we would be stuck with Sieves for prime number identification until I saw this.

 

https://en.wikipedia.org/wiki/Prime_number_theorem#Table_of_Ο€(x),x/_log_x,_and_li(x)

Mr.E Melange !!4RyW8fD.HU ID: ae4705 Jan. 2, 2018, 6:45 a.m. No.2302   πŸ—„οΈ.is πŸ”—kun

>>2261

Hehe, and he's getting censored.

Why not leave the post and put the big red message Off Topic, or Banned? Maybe Palantir hit a nerve??

posts 228156 and 227566 deleted, maybe others. Guess they don't want the 'normie' anons having nightmares? Kek.

 

Y'all are amazing, just catching up on the evening's work!!

Mr.E Melange !!4RyW8fD.HU ID: ae4705 Jan. 2, 2018, 9:10 a.m. No.2309   πŸ—„οΈ.is πŸ”—kun   >>2311

>>2307

Sure PMA, thank 8e68ad though, I just linked.

 

Speaking of linking, think I was too hard on Chris with the twattering comment. He's been busy as shit in cbts. Look at thread early this am (also Topol's crazy fun w/ the RED images)

 

CBTS #269 PATRIOTS , Passports , Planefags and Power Outages Edition

>>>/cbts/227400

https://8ch.net/cbts/res/227400.html - #269

VQC: ID: efe6f8 (42 posts)

 

..and he's on a tear in #270:

VQC - ID: 153378 (40 posts so far, w/ 75 left in the bread)

>>>/cbts/228142

Anonymous ID: 96255b Jan. 2, 2018, 4:15 p.m. No.2331   πŸ—„οΈ.is πŸ”—kun   >>2333

>>2328

What would we use it on?

 

>>2329

We did that when we were finding the minimum possible i. The only time i^2 seems to be in a situation that can be used for binary search is when i^2 < c, and that's how we figured out that the minimum possible i is ceiling(sqrt(c)). I don't think we can use i^2 for binary search when it's c. Do you have any idea how this grid could be used in O(log n) time without it being binary search? I'm not saying to give up (I'm about to test a thing) but the reason I started with binary search is because it's the only O(log n) algorithm I'm aware of.

Anonymous ID: 96255b Jan. 2, 2018, 4:37 p.m. No.2332   πŸ—„οΈ.is πŸ”—kun   >>2333 >>2338

>>2328

>>2329

You know how I said that when i and j get to a certain point, they'll scale up together most of the time and then for some reason j increases by 2 instead of by 1 and it causes the guess c to loop around a certain range of values? I wrote some code that tells us what the guess c is at the start of each of these loops.import java.util.;public class Wrong{ public static void main(String[] args){ print(9000, 940679); } public static void print(int i, int c){ System.out.println(); System.out.println("c = " + c + ", i = " + i); int count = 0; int previous_c = 0; while(count < i+1){ int i_sq = countcount; int d = (int)Math.floor((int)Math.sqrt(c)); double fl_sq_isqMc = (int)Math.floor(Math.sqrt((double)i_sq-(double)c)); int j = (count - d) + ((int)fl_sq_isqMc - (count - d)); int c_guess = (count-j)(count+j); int e = ( (count-j)(count+j) - (d*d) ); if(c_guess < previous_c){ System.out.println("i=" + count + "\tj=" + j + "\t'c'=" + c_guess + "\ta=" + (count-j) + "\tb=" + (count+j) + "\te=" + e); } previous_c = c_guess; count++; } }}

And here are some of the results.i=6069 j=5991 'c'=940680 a=78 b=12060 e=1719i=6147 j=6070 'c'=940709 a=77 b=12217 e=1748i=6227 j=6151 'c'=940728 a=76 b=12378 e=1767i=6309 j=6234 'c'=940725 a=75 b=12543 e=1764i=6393 j=6319 'c'=940688 a=74 b=12712 e=1727i=6480 j=6407 'c'=940751 a=73 b=12887 e=1790i=6569 j=6497 'c'=940752 a=72 b=13066 e=1791i=6660 j=6589 'c'=940679 a=71 b=13249 e=1718i=6755 j=6685 'c'=940800 a=70 b=13440 e=1839i=6852 j=6783 'c'=940815 a=69 b=13635 e=1854i=6951 j=6883 'c'=940712 a=68 b=13834 e=1751i=7054 j=6987 'c'=940747 a=67 b=14041 e=1786i=7160 j=7094 'c'=940764 a=66 b=14254 e=1803i=7269 j=7204 'c'=940745 a=65 b=14473 e=1784i=7382 j=7318 'c'=940800 a=64 b=14700 e=1839

So what I found, at least for this specific c, is that when i and j get to the point of looping, c will be the lowest value at the start of all of these loops. Every other guess c at the start of a loop is greater than the actual c value. I haven't tested it on any other real c yet, and I don't know how we'd find it if it was always the case.

Anonymous ID: 96255b Jan. 2, 2018, 5:26 p.m. No.2336   πŸ—„οΈ.is πŸ”—kun   >>2337

>>2335

The first graph was for 940679, and this one is for 497143. It shows the relationship between a and the i at the start of each of these loops. I haven't checked for 497143, but for 940679, the correct i is 6600 and the correct a is 71, which shows up in the graph at (71, 6600). I don't know if we can calculate that in any way, so I don't know if this is useful.

ID: 99fc86 Jan. 2, 2018, 5:41 p.m. No.2337   πŸ—„οΈ.is πŸ”—kun

>>2336

I found the perfect lower bound setting: d-1

It works for semiprimes where the factors are sufficiently close, regardless of size.

 

9999999999999999999197600000000000000000184023=99999999999999999991999*99999999999999999999977

Anonymous ID: 96255b Jan. 2, 2018, 5:41 p.m. No.2338   πŸ—„οΈ.is πŸ”—kun   >>2339

>>2332

I did this for 497143 as well.i=707 j=52 'c'=497145 a=655 b=759 e=120i=712 j=99 'c'=497143 a=613 b=811 e=118i=714 j=112 'c'=497252 a=602 b=826 e=227i=716 j=124 'c'=497280 a=592 b=840 e=255i=717 j=130 'c'=497189 a=587 b=847 e=164i=721 j=150 'c'=497341 a=571 b=871 e=316i=722 j=155 'c'=497259 a=567 b=877 e=234i=724 j=164 'c'=497280 a=560 b=888 e=255i=726 j=173 'c'=497147 a=553 b=899 e=122i=729 j=185 'c'=497216 a=544 b=914 e=191i=730 j=189 'c'=497179 a=541 b=919 e=154i=732 j=196 'c'=497408 a=536 b=928 e=383i=733 j=200 'c'=497289 a=533 b=933 e=264i=735 j=207 'c'=497376 a=528 b=942 e=351i=736 j=211 'c'=497175 a=525 b=947 e=150i=739 j=221 'c'=497280 a=518 b=960 e=255i=742 j=231 'c'=497203 a=511 b=973 e=178

The correct i for 497143 is 712. This one also shows that the correct i produces the lowest guess c out of each of them at the start of a loop, which was what 940679 did too. So it would seem that, whenever we can't find i with binary search normally, if we find the range of possible i value (which is d to (c-8)/6) and then find the start of each loop for i values between these bounds, the correct i will produce the lowest guess c. That's still O(n), so the solution is obviously different, but it does most likely shave a couple thousand years off the calculation. There might be a relationship between guess i and guess c that allows us to predict where the lowest guess c will be, but I have no idea yet.

Anonymous ID: 96255b Jan. 2, 2018, 5:53 p.m. No.2340   πŸ—„οΈ.is πŸ”—kun   >>2341

>>2339

At the moment you'd implement that by going through every possible i value individually (hence the O(n) thing, and hence me saying it isn't the solution), storing the guess c value, comparing the guess c to the previous guess c, and if guess c went down, it's the start of a loop, so you'd save that value too. You'd do that for every loop, and each time guess c < previous guess c, you'd compare the previous c at the beginning of a loop (when guess c < previous guess c), and save it if it's lower. So like this: public static void print(int i, int c){ int count = 0; int previous_c = 0; int previous_previous_c = c2; int correct_i = 0; while(count < i+1){ int i_sq = countcount; int d = (int)Math.floor((int)Math.sqrt(c)); double fl_sq_isqMc = (int)Math.floor(Math.sqrt((double)i_sq-(double)c)); int j = (count - d) + ((int)fl_sq_isqMc - (count - d)); int c_guess = (count-j)(count+j); int e = ( (count-j)(count+j) - (d*d) ); if(c_guess < previous_c){ if(previous_previous_c c_guess){ previous_previous_c = c_guess; correct_i = count; } } previous_c = c_guess; count++; } System.out.println(correct_i); }

VeritasAequitas !!Nf9AmQNR7I ID: 282205 Jan. 2, 2018, 9:07 p.m. No.2342   πŸ—„οΈ.is πŸ”—kun   >>2343 >>2346 >>2350 >>2419

Hey lads, I think I found something of high value! Could be wrong, but could I please get some eyes on this?

 

For Row 1 (e,1) I think I figured out how to factor any C by deriving X from F. Formula is as follows

X = Floor (SQRT(abs( f ))). I've tested it up to t=100 for (1,1) and (1,2), as well as test cases in higher e, which all work fine. Some further verification for Row 1 would be appreciated.

When I move down to C inputs in higher values of N, I get factorizations immediately, but they aren't the same as the (e,n) factorization. However, maybe knowing the n=1 factorization could help us know how far down in n to move? Thoughts, Anons?

Anonymous ID: 211561 Jan. 2, 2018, 9:19 p.m. No.2346   πŸ—„οΈ.is πŸ”—kun   >>2347 >>2349 >>2363

>>2342

That formula is basically this one

>>1929

But for the F side you would do X β‰ˆ floor(sqrt(abs(F)*(N)))

 

Every A/B value in (E/F, 1) is a valid N, along with the factors of A/B. Along with any A/B values of any N cell in that E/F. The problem is divining which N to factor with, or which X in (E/F, 1) is the correct one to factor against.

Anonymous ID: 96255b Jan. 2, 2018, 11:03 p.m. No.2353   πŸ—„οΈ.is πŸ”—kun   >>2354

>>2351

That would be funnier if it didn't mean having bounds around possible i values, which would make the thing O(n logn). That would take even longer than the current method of O(n) that we're trying to beat. It is good to have ideas like that from any lurkers who are watching, because it gives us all a different perspective, so if you or anyone else has any ideas, even if you think they're dumb, post away.

Anonymous ID: 96255b Jan. 2, 2018, 11:21 p.m. No.2355   πŸ—„οΈ.is πŸ”—kun   >>2356

>>2354

They may have been here all along. The implications of this are pretty big. Even if none of us who are working on it are going to do anything shitty with it when we've figured it out, there's almost definitely at least a few people following this because they want to steal Bitcoins or something. There are also probably, like, feds or whatever. Whoever hasn't already been arrested or fired by Trump. In terms of the new thread, I have no idea. You did a good job of this one. Since you and I are the only ones who have been messing with the binary search idea, I don't know if it would be ll that useful to add to everything.

ID: 99fc86 Jan. 2, 2018, 11:24 p.m. No.2356   πŸ—„οΈ.is πŸ”—kun

>>2355

Well, they can do whatever they want with it.. Just a race against time. Their window would be from solution produced to the world finally taking us seriously.. (they don't right now).

VeritasAequitas !!Nf9AmQNR7I ID: bd1aae Jan. 2, 2018, 11:25 p.m. No.2357   πŸ—„οΈ.is πŸ”—kun   >>2358

>>2350

>>2196

Thanks Baker! Your clear explanation of var f sent me the right way. Have you been able to verify to your satisfaction? Happy to be proven wrong if it's incorrect. In fact the sooner the better so I can go to bed.

>>2351

Lol! Well said, Anon.

 

Also, one of my new year's resolutions is to stop having 7 UID's for each bread by posting from all my devices when I get excited.

VeritasAequitas !!Nf9AmQNR7I ID: bd1aae Jan. 2, 2018, 11:53 p.m. No.2360   πŸ—„οΈ.is πŸ”—kun   >>2361 >>2373 >>2375

>>2358

Ruh Roh! Am I missing something here, or are you provoking the wrath of Topol? Does this count as Lewding?

 

Also, the cool thing about the factorization at n=1 is is gives us reference points for x, a, b, d, etc. so we really do know "where" we're working in terms of general area. The a and b at n=1 are the closest together(i think?), so as n increases, shouldn't a decrease and b increase, with c remaining itself?

 

>>2349

>What is N and how do I find it?

This is another great meme waiting to be born.

ID: 99fc86 Jan. 2, 2018, 11:58 p.m. No.2361   πŸ—„οΈ.is πŸ”—kun   >>2362

>>2360

I didn't mean n, I meant N. Lmao, they're different things apparently. I should find the definition and include it in the batter. Even I have to go back to it. It's apparently the next step in factoring from the genesis element.

Anonymous ID: 96255b Jan. 3, 2018, 1:11 a.m. No.2364   πŸ—„οΈ.is πŸ”—kun   >>2365 >>2366

I'm out of ideas for binary search. It figured out how to greatly lower the bounds of any possible i, and it can factor 44-digit semiprimes (using blind magic), but I have no idea how to make it logically work.

Anonymous ID: 96255b Jan. 3, 2018, 1:39 a.m. No.2369   πŸ—„οΈ.is πŸ”—kun   >>2370

>>2365

You've got the most recent code. I spent today graphing the relationships between different variables looking for a linear relationship. The only useful thing I found was that whenever i and j are high enough that they cause a loop (which you can probably predict with math but I have no idea), the lowest c produced from then on is the correct c. That would take O(n) time to figure out, because pic related is the lowest cs. As much as the range increases, the lowest of all the low ones doesn't seem predictable/linear/whatever, so even if we could figure out how far apart they all are we might have to check all of them if there isn't an easily predictable relationship. This picture only shows a small chunk of the cs in this section, too. I generated all of them for the entire possible range of i but it's gigantic and I think the relationship changes higher up (this chunk contains the real c so that's why I picked it). I did also figure out that (c, b) produces similar lines to (c, i), but they have pretty much the same relationship, so it doesn't give us anything new.

Anonymous ID: 96255b Jan. 3, 2018, 1:52 a.m. No.2371   πŸ—„οΈ.is πŸ”—kun   >>2372

>>2367

It would be even better if he stuck to the release dates he said. Several times now, the dates he stated have come and gone with nothing (e.g. Christmas), and there's no indication of whether that happens because we aren't doing well enough, or if he really is LARPing, or if there's something happening in the background that he can't tell us. I've spent every waking moment of the last week thinking about this, and, I mean, I guess we managed to fluke-factorize a 44-digit semiprime pretty quickly, but I'm out of ideas. I guess it gave me an opportunity to touch up on my coding before the uni year starts, and you all seem like interesting people.

 

>>2366

I'm talking about that one you said you got to work.

ID: 99fc86 Jan. 3, 2018, 2:04 a.m. No.2372   πŸ—„οΈ.is πŸ”—kun

>>2371

It's because the factors were close together.

 

RSA numbers have factors that are calculated in a way so as that the normal Fermat factorization algorithm takes thousands of years.

But I have faith in us.

 

>>2371

Yep, d-1 as the lower bound works the best. I can post the code I have, it's not been modified really.

Anonymous ID: 49178c Jan. 3, 2018, 3:06 a.m. No.2374   πŸ—„οΈ.is πŸ”—kun

>>2334

Could be something simple of the form y=x^-2/3 or something like that. If you post the endpoints and three more points from approximately 1/4, 1/2, and 3/4 way along the curve, it will be easy to check for a form like this.

Topolanon +++ !!UrvFpU0has ID: 7ed024 Jan. 3, 2018, 3:06 a.m. No.2375   πŸ—„οΈ.is πŸ”—kun   >>2376 >>2413

>>2360

>What is N and how do I find it?

Dear I fear we're facing N problem…

(You) are lost in confusion, I know, and…

Maybe there is nothing that I can do…

To make you do….

So…I dig… I mem, and I pray!

SOLVE ME! SOLVE ME!

(saaaay that you'll sove me)

Find N! Find N!

(Go on and find N!)

I don't care 'bout any-thing buuuut Q…..

(Anything buuuut Q…..)

Topolanon +++ !!UrvFpU0has ID: 7ed024 Jan. 3, 2018, 3:34 a.m. No.2378   πŸ—„οΈ.is πŸ”—kun   >>2379

>>2351

Y'know… I was sitting here wondering if I'd get more out of a VQC if it wasn't explained to me what the hell is going on here with everyone's floor squirts… but I guess… I mean it's y'all's biscuit… do what you want with it.

 

Anyway, I was wonder if the quantum weirdness I roll with (perpetual… energy… device… how to start it… what's the genesis)…

 

If it wasn't explained or sort of explained… or fully explained and I was allowed to ask questions and we were drinking the whole time but like…

 

I didn't go into this with the perpetual energy device idea in mind.

 

Huh.

 

Pic related.

Show bobs.

Topolanon +++ !!UrvFpU0has ID: 7ed024 Jan. 3, 2018, 3:46 a.m. No.2379   πŸ—„οΈ.is πŸ”—kun

>>2378

Aight so… what if a perpetual energy device is a slight of hand/observation entanglement?

 

As long as it's going when you first see it…

And it never stops…

 

Missions Accomplished?

Even if you figure out the Riddle of the VQC…

It was already in motion…

But from your observation…

It quantuam always was/is/will be…

Alpha… Infinity… Omega…

AIO

I Owe

 

Everything is happening in the "Now".

The Device Is Operating.

What time is it always and all ways?

Right the fuck now.

Look at the code.

Where is the time?

Show me all the time that went into it.

When I look at the code, it's as if it was always in that state.

 

Like a finished game.

Not some… unfinished, make you DLC the rest of it.

 

Complete from the beginning.

It's quite the Prime Paradox.

A Cosmic Dick Pun?

Kek.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 3, 2018, 4:25 a.m. No.2381   πŸ—„οΈ.is πŸ”—kun   >>2382

I've been trying to wrap my head around this hint:

 

>> 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 let's generate an example:

>>e, n, d, x, a, b = rowForAB(5, 29)>>> e, n, d, x, a, b(1, 5, 12, 7, 5, 29)>>> 5 * 5 # = na25>>> 25 - (2 * d + 1)0

 

Now what? I assume this means that we expect 20 to be in (0, 1) at t = 4, but it's not there.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 3, 2018, 8:47 a.m. No.2390   πŸ—„οΈ.is πŸ”—kun   >>2413

>>2363

VA - nice work!

 

BigInteger x = Lib.Sqrt( BigInteger.Abs( f ) ) - 1;

 

I was able to verify values of x using the above formula for all (e,1) where t != 1.

 

Might just be a difference in the sqrt formula in excel.

Mr.E Melange !!4RyW8fD.HU ID: abf640 Jan. 3, 2018, 8:52 a.m. No.2391   πŸ—„οΈ.is πŸ”—kun   >>2413

>>2389

Thanks for answering the call. Be sure to get some rest, I'm sure you need it!

Last night I got 12hrs sleep instead of 3. Finally, dream recall this am - remembered 3 good ones.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 3, 2018, 9:58 a.m. No.2396   πŸ—„οΈ.is πŸ”—kun

>>2395

Correct. Only in (e,1).

 

Sample data:

 

(1,1,-4) = {1:1:32:-9:41:25} = 1025

(1,1,-3) = {1:1:18:-7:25:13} = 325

(1,1,-2) = {1:1:8:-5:13:5} = 65

(1,1,-1) = {1:1:2:-3:5:1} = 5

(1,1,0) = {1:1:0:-1:1:1} = 1

(1,1,1) = {1:1:2:1:1:5} = 5

(1,1,2) = {1:1:8:3:5:13} = 65

(1,1,3) = {1:1:18:5:13:25} = 325

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

(1,1,5) = {1:1:50:9:41:61} = 2501

 

(2,1,-4) = {2:1:41:-10:51:33} = 1683

(2,1,-3) = {2:1:25:-8:33:19} = 627

(2,1,-2) = {2:1:13:-6:19:9} = 171

(2,1,-1) = {2:1:5:-4:9:3} = 27

(2,1,0) = {2:1:1:-2:3:1} = 3

(2,1,1) = {2:1:1:0:1:3} = 3

(2,1,2) = {2:1:5:2:3:9} = 27

(2,1,3) = {2:1:13:4:9:19} = 171

(2,1,4) = {2:1:25:6:19:33} = 627

(2,1,5) = {2:1:41:8:33:51} = 1683

(2,1,6) = {2:1:61:10:51:73} = 3723

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 3, 2018, 11:31 a.m. No.2399   πŸ—„οΈ.is πŸ”—kun   >>2400

>>2398

 

For shits'n'giggle I also played with a = -5 and b = -29, this gives (1, -29, 12, 17, -5, -29)

 

Not sure if this is actually useful or if it's just a side effect or the rules.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 3, 2018, 11:48 a.m. No.2400   πŸ—„οΈ.is πŸ”—kun   >>2401

>>2399

Confirmed. You can create any negative record by substituting a and b.

 

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

(1,5,-8) = {1:5:12:-17:29:5} = 145

 

(1,61,6) = {1:61:12:11:1:145} = 145

(1,61,-66) = {1:61:12:-133:145:1} = 145

 

looks like x = d - a is the correct x.

 

and the formula for any negative x in (e,n) could be:

 

x = -( x + 2*n )

 

>Not sure if this is actually useful or if it's just a side effect or the rules.

we wouldn't be sent down this path if it wasn't useful. Question is how.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 3, 2018, 1:13 p.m. No.2401   πŸ—„οΈ.is πŸ”—kun   >>2403

>>2400

 

Again, not sure if this is useful, buuuuut

 

>>rowForAB(1, 1452)(0, 10368, 145, 144, 1, 21025)>>> rowForAB(-1, -1452)(0, -10658, 145, 146, -1, -21025)>>> 10368-10658-290>>> 290/2145.0

 

So what we see is that when changing from positive a, b to negative if affects the n by -(n +145 * 2).

 

>>rowForAB(52, 292)(0, 288, 145, 120, 25, 841)>>> rowForAB(-52, -292)(0, -578, 145, 170, -25, -841)>>> 578-288290>>> 290/2145.0

 

So this applies the record for aa, bb.

 

This means we have some kind of knowledge of n for -aa and -bb. I'm wondering if this can be combined to find the n (using na for (0, n)).

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 3, 2018, 2:07 p.m. No.2406   πŸ—„οΈ.is πŸ”—kun   >>2407

>>2403

 

I'm not after negative x-records. I was playing with generating rows using negative numbers and saw that when I generate the record for a=1 b=145^2 I get n = 10368.

 

When I then generate the record for a=-1 and b=-145^2 I get n = -10658.

 

The difference between 10658 and 10368 is 2*d.

 

This pattern appears to hold true for all values, but I don't know if it is a useful pattern.

 

Generate two records, one for a, b and one for -a, -b. The n in -a, -b will be equal to

-(n - 2*d) // where n is the same as the n from the a, b record.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 3, 2018, 2:23 p.m. No.2409   πŸ—„οΈ.is πŸ”—kun   >>2411

>>2407

and for the c=145 case, the difference equals 2c. The numbers 10658 and 10368 appear often when creating records from a=1 and b=cc.

 

And if you create records at a=aa and b=bb, you'll get n values of 288 which look surprisingly like 2*(c - 1).

 

Unfortunately, this doesn't hold true when looking at other test cases.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 3, 2018, 2:26 p.m. No.2411   πŸ—„οΈ.is πŸ”—kun   >>2412

>>2409

 

This isn't limited to aa, bb or c*c records.

 

>>rowForAB(101, 2887)(1066, 955, 539, 438, 101, 2887)>>> rowForAB(-101, -2887)(1066, -2033, 539, 640, -101, -2887)>>> (2033 - 955)/2539.0>>> rowForAB(4637, 6917)(4560, 114, 5663, 1026, 4637, 6917)>>> rowForAB(-4637, -6917)(4560, -11440, 5663, 10300, -4637, -6917)>>> (11400 - 114)/25643.0

 

It appears to hold true for any given a, b and their -a, -b counter part.

VeritasAequitas !!Nf9AmQNR7I ID: 65f0e7 Jan. 3, 2018, 2:33 p.m. No.2413   πŸ—„οΈ.is πŸ”—kun   >>2414

>>2390

Thanks PMA!

>>2405

Thanks, Anon!

 

Just glad to have something verified by you all that helps. Plenty of ideas have been crushed, so nice to move the ball forward a bit. It gives us row one for any C, but that's all at the moment. Seems like you guys are already working on VQC's crumb about mirroring it up into negative x. Any idea on how to move the factors down into higher values of n? Maybe 2f? f^2? if that's the closest set of factors to d, then maybe we can scale up? Thinking out loud here.

 

>>2388

>>2389

 

>>2391

Thanks Mr E. For getting Senpai on the airwaves.

 

>>2375

Topol, here's verse two!

 

Lately I have desperately pondered

Spent my nights awake "N" I wonder

What I could have done to solve you another way

Fags are we fake and gay? No way!

 

Reason will then lead to solutions

We won't end up in lost N confusion

I don't care if you really care

Let's make N our goal!

 

So…I dig… I mem, and I pray!

SOLVE ME! SOLVE ME!

(saaaay that you'll sove me)

Find N! Find N!

(Go on and find N!)

I don't care 'bout any-thing buuuut Q…..

(Anything buuuut Q…..)

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 3, 2018, 2:47 p.m. No.2415   πŸ—„οΈ.is πŸ”—kun   >>2416 >>2418 >>2427

>>2414

 

Yes it would appear so.

 

Also, we talk about f, but from what I gather what we are really doing is computing the difference of perfect squares.

 

So f = (2*d + 1) - e

 

We remove e, because it is our remainder of c from our "perfect square" d*d. So naturally c + f will be the same as (d + 1)(d + 1).

 

If we want to "jump" with f further we can use the general function f* = k( 2 * d + k).

 

So c + (2 * (2 * d + 2) - e) will give (d + 2),

c + (3 * (2 * d + 3) - e) will give (d + 3).

 

But I don't think we would want to use that to find n, that just seems like an overly complicated way of doing fermats factorization.

ID: 99fc86 Jan. 3, 2018, 2:51 p.m. No.2416   πŸ—„οΈ.is πŸ”—kun   >>2417 >>2427

>>2415

This is exactly what I dreamt of.

 

(c-f)^2 is close to i^2, relatively.

Take those 2 squares and the c^2 square,

and

take (d+1) from c, and now you have a distance that includes j.

 

It's the distance from the c^2 square's side length (c) to sqrt(c-f) which is d+1.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 3, 2018, 2:58 p.m. No.2418   πŸ—„οΈ.is πŸ”—kun

>>2415

(f,1,t) gives some interesting combinations of a and b.

 

I agreed about the jumping. We've known how to iterate factors by t and d for awhile.

 

It appears that VQC is telling us the answer (or a part of it) lies in the negative space - looking into the mirror - like right is left…

Anonymous ID: c50aac Jan. 3, 2018, 3:48 p.m. No.2421   πŸ—„οΈ.is πŸ”—kun   >>2424 >>2425 >>2427

Remember all the discussion of moving up and down t to find records where target a is a factor of a(e,1, t).

So for (e=2c, 1, t)

a is factor every t= a*m+1

b is factor t = b*m + 1

c is a factor t = c*m +1

for integer m

Here's the interesting part….

For (e = 2c-1, 1, t)…

a is factor every t= a*m+1 and

a is a factor every t =a*m

b is factor t = b*m + 1 and

b is a factor t = b*m

c is a factor t = c*m +1 and

c is a factor t = c*m

for integer m

It works on the negative side too.

This seems highly useful but I haven't made any progress yet!

Anonymous ID: c50aac Jan. 3, 2018, 4:19 p.m. No.2426   πŸ—„οΈ.is πŸ”—kun

>>2425

In testing the even odd pairing with the same factors is e = 2c with factors a, b, c and

e = 2c-1. Not e + 1. For both even and odd records s is factor at (s + 1 - t), (2s +1 - t), but also at s,2s,3s The important part is that if s odd is a factor of 2e then s is a factor of all those described a of (2c, 1, t) and (2c-1,1, t)

VeritasAequitas !!Nf9AmQNR7I ID: 65f0e7 Jan. 3, 2018, 4:24 p.m. No.2427   πŸ—„οΈ.is πŸ”—kun   >>2429

>>2421

Thanks Anon, well explained! I've been working to understand this too, but still haven't figured it out. Some kind of way to climb up and down the factor tree we've yet to find.

 

>>2415

>>2416

VQC crumbed "all C factors for a column (e, which we know right away) are contained in the first cell (e,1). We know c, d, e, f, and x just from C in row one now, along with one pair of solutions for a and b.

 

Here's my current thinking: how do we scan down in (specific e,n) n to find matching C values after solving row one? C is given, and the row one factorization should be the closest possible to d? (I think?) As n increases, the distance between a and b gets larger. a decreases, and b increases. At the beginning of the n number line is our row one factorization, n closest together. At the extreme end of the number line is a,b = 1,c. In between are more possible solutions??? I think this makes sense. Can you all verify If this concept is correct? Thinking out loud to get the idea out.

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 3, 2018, 4:37 p.m. No.2430   πŸ—„οΈ.is πŸ”—kun

>>2428

 

You can use the following to create any valid record by ENT. For n = 1, you can simply iterate e and t values. n = 0 doesn't work.

 

For n 1, the t becomes tricky, so simply looping won't do it.

 

public static TheEndRecord CreateForENT( BigInteger e, BigInteger n, BigInteger t ) {

 

BigInteger x = GetX( e, t );

BigInteger a = ((x * x) + e) / (2 * n);

BigInteger d = a + x;

BigInteger b = a + 2x + 2n;

 

return new TheEndRecord( e, n, d, x, a, b );

 

}

 

private static BigInteger GetX( BigInteger e, BigInteger t ) {

 

if ( ( e & 1 ) == 0 ) { // even (performance improvement)

 

return 2*t - 2;

 

} else {

 

return 2*t - 1;

 

}

 

}

ID: 99fc86 Jan. 3, 2018, 9:44 p.m. No.2432   πŸ—„οΈ.is πŸ”—kun   >>2433

AAanon: I noticed something about your binary search code.

 

You know the higher bound that's calculated based on the gradient?

 

That value of i is always right when c is a perfect square. Meaning the first guess is what it would be if c was a perfect square.

ID: 99fc86 Jan. 3, 2018, 10:06 p.m. No.2436   πŸ—„οΈ.is πŸ”—kun

Also, Chris said you add f to c to make a perfect square because he was using 2d+1 - e as f, where I use e - (2d+1)

 

It just makes it so I subtract from c to make a square instead of adding.

Anonymous ID: c50aac Jan. 3, 2018, 10:11 p.m. No.2437   πŸ—„οΈ.is πŸ”—kun   >>2438 >>2450

Big picture thoughts.

Start with ab=c record

Fully describe it.

(e, n, t) for c = { e, n, d, x, a, b}

we know c e and d

Can we answer the problem here.

It seems not.

We do our first transform.

We square the record.

No information lost.

Our new record is { 0,N, cc, cc-1, 1, cc}

Have we gained anything? Well if we know original n we can solve the problem. Now we know an N record. Its huge so it doesn't tell us much. we do know that it codes for the difference between perfect squares. If you examine these n's it turns out they are all twice a perfect square.

That pattern shows up a lot so its worth noting.

We still can't solve the problem.

Still need more information.

It turns out that the (e,1) row offers a lot of information. a and b of (e, 1) cell elements are factor a tree. The starting values of the tree show up the most frequently as they are mixed with other factors which also repeat.

 

If we choose 2c for e in ( 2c, 1, 1)

Then the record is ( 2c, 1, c, 0, c, b(e1)). This tree will flower more factors of c than any other factors. There is more information on e,1 but including odd and negative trees but still not enough to solve our problem.

So we need to go to (e,n)!

Going to (e, n) is tough. I believe there are going to be only 5 records in (e,n) matching the five (0, n) difference of perfect squares records of cc.

When we can fill in (e,n) computationally, not iteratively we solve the problem. First one to figure out that out cracks RSA. On your marks!

Good night anons!

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 3, 2018, 10:51 p.m. No.2444   πŸ—„οΈ.is πŸ”—kun   >>2445

>>2443

My understanding is that the big N record is where a=1, b=c.

 

his full comment was:

 

the hint that na, nb for any c can be found n entries apart in the cell at (e,1) also applies to the factorization a=1, b =c.

That's the big N (d+N = (c+1)/2 so N is bigger than usual).

So N and cN are part of the sequence of a and b values in (e,1), along with na and nb.

Also the a and b values in the (e,1) are involved in deciding whether (e,n) is empty or full. Look down column 22.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 12:03 a.m. No.2449   πŸ—„οΈ.is πŸ”—kun

>>2446

This is also trivial to find for (e, 1).

 

Generate the row for a=1, b=c. Get the t1 for (e, 1) where a=1 * n, then get a in (e, 1) at t2 = (t1 + n) = Nc.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 12:17 a.m. No.2450   πŸ—„οΈ.is πŸ”—kun   >>2451 >>2468

>>2437

I'm skeptical

 

>>print(generateGenesis(2145, 20), sep='\n')(290, 1, 145, 0, 145, 147)(290, 1, 149, 2, 147, 153)(290, 1, 157, 4, 153, 163)(290, 1, 169, 6, 163, 177)(290, 1, 185, 8, 177, 195)(290, 1, 205, 10, 195, 217)(290, 1, 229, 12, 217, 243)(290, 1, 257, 14, 243, 273)(290, 1, 289, 16, 273, 307)(290, 1, 325, 18, 307, 345)(290, 1, 365, 20, 345, 387)(290, 1, 409, 22, 387, 433)(290, 1, 457, 24, 433, 483)(290, 1, 509, 26, 483, 537)(290, 1, 565, 28, 537, 595)(290, 1, 625, 30, 595, 657)(290, 1, 689, 32, 657, 723)(290, 1, 757, 34, 723, 793)(290, 1, 829, 36, 793, 867)(290, 1, 905, 38, 867, 945)(290, 1, 985, 40, 945, 1027)

 

145 = 5 Γ— 29147 = 3 Γ— 7^2153 = 3^2 Γ— 17163 is prime177 = 3 Γ— 59195 = 3 Γ— 5 Γ— 13217 = 7 Γ— 31243 = 3^5273 = 3 Γ— 7 Γ— 13307 is prime345 = 3 Γ— 5 Γ— 23387 = 3^2 Γ— 43433 is prime483 = 3 Γ— 7 Γ— 23537 = 3 Γ— 179595 = 5 Γ— 7 Γ— 17657 = 3^2 Γ— 73723 = 3 Γ— 241793 = 13 Γ— 61867 = 3 Γ— 17^2945 = 3^3 Γ— 5 Γ— 71027 = 13 Γ— 79

 

5 appears as a factor 5 times while 29 only once.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 12:23 a.m. No.2452   πŸ—„οΈ.is πŸ”—kun

>> A prime number 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

 

Are we confusing the terms for big_n or N?

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 12:31 a.m. No.2453   πŸ—„οΈ.is πŸ”—kun   >>2454

>>2451

I did another one now for 2 * c, with c = 61 * 101. 61 appears as a factor in (12322, 1) at t = 61.

 

But I don't see how we can use this to find the factors?

 

If we have to iterate over N cells in (e, 1) in order to find the proper factors, we don't have an algorithm that is O(log n).

Topolanon +++ !!UrvFpU0has ID: 7ed024 Jan. 4, 2018, 1:40 a.m. No.2458   πŸ—„οΈ.is πŸ”—kun

>>2456

TL;DR: Fuck if I know.

DAMMIT, JIM!

I'M A MAGICIAN, NOT A DOCTOR!

 

That being said:

 

"Is there a first countable, 0-dimensonal, locally compact, lindelΓΆf, non-compact space?"

 

Apparently, yes!

 

https://math.stackexchange.com/questions/491186/is-there-a-first-countable-0-dimensonal-locally-compact-lindel%c3%b6f-non-compact#492886

 

>>2457

-head pats-

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 2:45 a.m. No.2459   πŸ—„οΈ.is πŸ”—kun   >>2460

For a given a, b the absolute value of negative x will point to the next cell with b, nextB.

 

For example, take (0, 8). Here there are multiple factors at play, so a,b = 1,25 the next b, nextB = 25, 81 won't appear until x = 20.

 

The negative x for a, b is -20.

 

It appears to hold true again for other numbers.

 

>>rowForAB(145, 1)(1, 61, 12, -133, 145, 1)

 

In (1, 61) at x = 133 you'll find a,b = 145, 533.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 2:56 a.m. No.2461   πŸ—„οΈ.is πŸ”—kun   >>2462

>>2460

 

For (e, 1) the absolute value of negative x will give us the previous cell.

 

For example:

>>rowForAB(145, 181)(1, 1, 162, 17, 145, 181)>>> rowForAB(145, 113)(1, 1, 128, -17, 145, 113)

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 3:30 a.m. No.2462   πŸ—„οΈ.is πŸ”—kun   >>2463

>>2461

 

I'm not entirely sure what I'm doing or looking at, but let's say we want to move backwards from x.

 

We start with row for 1, 145

(1, 61, 12, 11, 1, 145)

 

We now know we want the record where x = -11.

 

Then a must be = 1

b = 1 + 2(-11) + 261

 

This gives b = 101.

 

rowForAB(1, 101)

(1, 41, 10, 9, 1, 101)

 

But here x = 9 and not 11. However, if we repeat these steps:

 

>>def rowNegX(n, x, a):... b = a + 2(-x) + 2n... c = ab... d = int(math.floor(math.sqrt(c)))... e = int(c - dd)... n = int(((a + b)/2) - d)... x = int(d - a)... return (e, n, d, x, a, b)...>>> rowNegX(61, 11, 1)(1, 41, 10, 9, 1, 101)>>> rowNegX(41, 9, 1)(1, 25, 8, 7, 1, 65)>>> rowNegX(25, 7, 1)(1, 13, 6, 5, 1, 37)>>> rowNegX(13, 5, 1)(1, 5, 4, 3, 1, 17)>>> rowNegX(5, 3, 1)(1, 1, 2, 1, 1, 5)>>> rowNegX(1, 1, 1)(0, 0, 1, 0, 1, 1)

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 3:32 a.m. No.2463   πŸ—„οΈ.is πŸ”—kun   >>2464

>>2462

 

I got the flu and been bedridden for a few days, so my head might still not be working correctly. I'm assuming my assumptions about rowNegX is correct, but since I'm not finding the record x = 11 something else is up.

 

Also, it appears this method allows us to go down in the tree.

 

We started with rowForAB(1, 145) and by the fourth iteration we have (1, 5) which is where a,b = 5, 29 is. So maybe this is actually the proper way to go about?

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 4:10 a.m. No.2465   πŸ—„οΈ.is πŸ”—kun   >>2466

>>2464

 

To calculate the amount of steps down from the record of a=1,b=c it's:

 

For even e:

k = sqrt(n - (e / 2))

For odd e:

k = sqrt((n - round(e / 2) - 1)/2 + 1)

 

k is the number of steps it takes to go from n to 1.

 

To go the other way, that is from k to n:

 

For even e:

(e / 2) + 2 * k^2

 

For odd e:

round(e / 2) + 4 * ( (k * (k + 1)/2)) + 1

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 4:33 a.m. No.2466   πŸ—„οΈ.is πŸ”—kun   >>2467 >>2483

>>2465

I feel kind of lost right now. So much to explore, I don't know where to begin.

 

It appears that rowNegX can also give us the first cell in (e, n).

 

Examples:

{6:1:87:12:75:101}

{7:1:101:13:88:116}

{8:1:88:12:76:102}

 

>>rowNegX(75, -12, 1)(6, 75, 13, 12, 1, 175)>>> rowNegX(88, -13, 1)(7, 88, 14, 13, 1, 203)>>> rowNegX(76, -12, 1)(8, 76, 13, 12, 1, 177)

 

If we take an 'a' from (e, 1) and the x in the same cell and compute rowNegX(a, -x, 1) it will yield the first cell at (e, a).

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 5:07 a.m. No.2467   πŸ—„οΈ.is πŸ”—kun

>>2466

I don't think traversing is the key, but it might provide more insight?

 

If you take a, b = 5, 157 you'll see it is in (1, 53). However if you take the row at a=1,b=5 * 157 and traverse down the tree with rowNegX, it will skip (1, 53) and go from (1, 61) to (1, 41).

 

It appears as if it only works for n's as defined by the a's in (e, 1)

Anonymous ID: c50aac Jan. 4, 2018, 5:54 a.m. No.2468   πŸ—„οΈ.is πŸ”—kun

>>2443

>>2446

>>2450

Yes that's what big N is.

After I found the (e=2c) contained a factor tree full of a and b I tried to solve the problem by moving up and down the tree. I compared odd to even side by side. I didn't get anywhere. Then I decided to look at (e,n) and couldn't find them.

Here is one of the very simplest (e,n) cells that I believe solve our problem. See how quick you can find a solution.

For a b equals

5 11

7 17

the (e,N) records for those to simple pairs are

( 110, 1458 )

( 289, 6962 )

I was struggling all day with this banging my head. Then I got high and realized that of course I couldn't find any. Its the solution set to

cc and I wrote my post. Now I'm sure I can find those records. We already know a and b. These are the very simplest set of cells representing solution for cc. Imagine what solving it for RSA will be like.

We have to solve it without knowing a and b and algorithmically.

Anonymous ID: c50aac Jan. 4, 2018, 9:48 a.m. No.2482   πŸ—„οΈ.is πŸ”—kun

>>2469

>>2480

Chris is back posting on twitter. Tweet I posted is gone. Chris still has anti 8 chan stuff. Like I hope q finds somewhere else to go and he's been kicked off. I think they are creating deny ability.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 9:55 a.m. No.2483   πŸ—„οΈ.is πŸ”—kun   >>2484

>>2466

 

Using rowNegX to move down the chain doesn't appear to be working for other numbers outside of (1, n). I tried with a = 1, b = 23 * 53 which gives me (63, 576).

 

But as I start moving down it jumps over to (2, n).

ID: 99fc86 Jan. 4, 2018, 10:07 a.m. No.2484   πŸ—„οΈ.is πŸ”—kun   >>2485 >>2486

>>2483

Hey, you're right!

 

The factorization works as long as e = 1!

17 = 1*17

145 = 5*29

2117 = 29*73

5777 = 53*109

10001 = 73*137

20165 = 5*4033

1077445 = 5*215489

10023557 = 17*589621

634939205 = 5*126987841

102503110881925 =

 

I factored these with what you posted! This is definitely great! We just have to find a way to get the c we want into these first rows.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 10:15 a.m. No.2486   πŸ—„οΈ.is πŸ”—kun   >>2490

>>2484

It could be that it works only for e=1 because there is an underlying pattern I haven't seen yet.

 

IF we can traverse down the list of n's, then shouldn't c % n == 0 at some point?

 

Since every prime factor and a's that occur in (e, n) for a given e and n exists as an n', then c should contain the n's it traverses down as factors.

 

I'm just thinking out loud here.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 10:27 a.m. No.2487   πŸ—„οΈ.is πŸ”—kun   >>2488

>>2485

I think the n behind (0, n) records for a=a2, b=b2 and 1, c**2 is (x + n). So with just knowing c I don't think you can just "get there".

 

Unless we know something about x and n.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 10:32 a.m. No.2488   πŸ—„οΈ.is πŸ”—kun   >>2489

>>2487

 

>>rowForAB(19, 131)(88, 26, 49, 30, 19, 131)>>> 26 + 30 # x + n = j56>>> rowForAB(192, 1312)(0, 6272, 2489, 2128, 361, 17161)>>> s(6272/2)56.0

 

I think these (0, n) records for the squared numbers is done by (x + n)^2. Which means it's j^2 since x + n = j.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 10:34 a.m. No.2489   πŸ—„οΈ.is πŸ”—kun

>>2488

 

And we know c = (d + n)^2 - (x + n)^2 since d + n = i.

 

Unless we can somehow coerce j for a,b out of c then I don't see how we can simply "get to" the (0, n) record that hold a^2, b^2.

ID: 99fc86 Jan. 4, 2018, 10:46 a.m. No.2492   πŸ—„οΈ.is πŸ”—kun   >>2493

>>2491

Well, you can factor the square of c using this algorithm but it doesn't give you the right factors.

 

It's not able to factor 15, but it can factor the square of it albeit the wrong factorization.

225 = 3 * 75

 

It can also factor 7463^2

55696369 = 17 * 3276257

 

And 9^2

81 = 3 * 27

 

And 2611447^2

6819655433809 = 1613*4227932693

 

So, it can factor these numbers' squares but not the number itself.

I have a hunch you can do something by knowing a factorization of the square.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 10:52 a.m. No.2496   πŸ—„οΈ.is πŸ”—kun   >>2497 >>2500

I think I know why this rowNegX jumps to another e at some point.

 

I did a test:

 

>>rowForAB(1, 13 * 53)(13, 319, 26, 25, 1, 689)>>> rowNegX(319, 25, 1)(13, 271, 24, 23, 1, 589)>>> rowNegX(271, 23, 1)(13, 227, 22, 21, 1, 497)>>> rowNegX(227, 21, 1)(13, 187, 20, 19, 1, 413)>>> rowNegX(187, 19, 1)(13, 151, 18, 17, 1, 337)>>> rowNegX(151, 17, 1)(13, 119, 16, 15, 1, 269)>>> rowNegX(119, 15, 1)(13, 91, 14, 13, 1, 209)>>> rowNegX(91, 13, 1)(13, 67, 12, 11, 1, 157)>>> rowNegX(67, 11, 1)(13, 47, 10, 9, 1, 113)>>> rowNegX(47, 9, 1)(13, 31, 8, 7, 1, 77)>>> rowNegX(31, 7, 1)(0, 18, 7, 6, 1, 49)

 

There isn't any a = 1 for any n below 31 for e=13. Which rowNegX assumes.

 

Is there a way of creating a cell from knowing just (e, n, x)?

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 11:10 a.m. No.2499   πŸ—„οΈ.is πŸ”—kun   >>2502 >>2503

>>2497

Are you using the same rowNegX method to iterate downwards in the (0, n) record?

 

I don't think that will work for large numbers like RSA.

 

I also don't know if traversing x is the correct method. It doesn't require f which apparently is used by VQC.

 

If VQC is still out here, a correction of path is most wanted

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 4, 2018, 11:16 a.m. No.2500   πŸ—„οΈ.is πŸ”—kun   >>2504

>>2496

 

public static TheEndRecord CreateForENX( BigInteger e, BigInteger n, BigInteger x ) {

 

BigInteger a = ((x * x) + e) / (2 * n);

 

BigInteger d = a + x;

BigInteger b = a + 2 * x + 2 * n;

 

return new TheEndRecord( e, n, d, x, a, b );

 

}

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 11:35 a.m. No.2504   πŸ—„οΈ.is πŸ”—kun   >>2505 >>2506 >>2513

>>2500

Thanks, but I noticed a pattern in x in the n records leaving x to not follow the same pattern for the rowNegX. For the rowNegX jumping down the x decreases by 2, but that isn't the case for all (e, n). Example (13, 29) x is 25, while for the rowNegX jumps it has decreased down to 8 by (13, 31). So something else is up.

 

It could still mean something though.

 

Why doesn't (13, 29) start with a = 1?

(Or any other n below 31 for that matter)

ProgramMathAnon !dSvrkhSLR6 ID: 63afe8 Jan. 4, 2018, 11:47 a.m. No.2505   πŸ—„οΈ.is πŸ”—kun

>>2504

I've been searching for formulas that describe changes between various records. Movements up and down by manipulating e, d, x, a, t, with and without factors.

 

The -x use in the a+2x + 2n is a very good approach.

 

Example of trying to understand an e = f jump.

>>2235

 

If you look at that formula for a, you'll notice that it incorporates n, a, and e.

 

Perhaps there is another variable that needs to be toggled to get better results.

 

I'm going to get my code up to speed and see if I can play with it a bit.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 12:07 p.m. No.2509   πŸ—„οΈ.is πŸ”—kun   >>2510

I'm still confused on the purpose behind generating the f. c + f = c + (d + 1)^2.

 

This leaves us with two squares, d^2 and (d + 1)^2 where c is somewhere in between these two.

ID: 99fc86 Jan. 4, 2018, 12:11 p.m. No.2510   πŸ—„οΈ.is πŸ”—kun   >>2511

>>2508

Maybe you can draw a conclusion from the amount of iterations it takes, then.

 

9 = 3 * 3iterations: 314 = 2 * 7iterations: 395 = 5 * 19iterations: 32145 = 5 * 29iterations: 57463 = 17 * 439iterations: 307493801 = 3 * 31267iterations: 234512611447 = 1613 * 1619iterations: 1282742

 

>>2509

Yes, and c is not a square, it's just the difference of two squares.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 12:24 p.m. No.2511   πŸ—„οΈ.is πŸ”—kun   >>2512

>>2510

Unfortunately that's way too many iterations. I wish it was faster, but I think we're missing something.

 

The speed of the algorithm VQC is talking about should solve all of those in waaaay less steps.

 

He said it was O(log n) where n is the number of bits in c.

 

For all those it should be done in only a few steps. If I understand it correctly, 2611447 should only take 3 operations.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 12:26 p.m. No.2512   πŸ—„οΈ.is πŸ”—kun

>>2511

For example, gcd (Greatest Common Divider) has a complexity of O(log a + log b) = O(log n). So we should have something equally fast, but for factorization.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 1:42 p.m. No.2513   πŸ—„οΈ.is πŸ”—kun   >>2514 >>2516

>>2504

 

> Why doesn't (13, 29) start with a = 1?

 

Ughhh, it's obvious now. We have two types of n-records for any given (e, n). Ones that are "prime" n's, that is they are n's which also exists as an 'a' in (e, 1) and we have "secondary" n's which are n's that exists as 'a' in (e, n) (n 1).

 

So the n's that don't exists as an a in (e, 1) will always be a multiple of an a in (e ,1).

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 1:59 p.m. No.2517   πŸ—„οΈ.is πŸ”—kun   >>2518

>>2516

Ah I follow you.

 

Unfortunately I haven't found a way. I did look for it when I was looking at the rowNegX for the zero column, but based on what I found the (0, n) for a^2, b^2 is equal to (x + n)^2, same for a=1,b=c^2.

 

So to know the difference between them you need to know a, b's (x + n) which we don't know from c (as far as I am aware).

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 2:13 p.m. No.2519   πŸ—„οΈ.is πŸ”—kun   >>2521

>>2515

 

I think I figured how to iterate over other records using rowNegX after "jumping".

 

We can find (e, n, 1) where a = 1 using rowNegX. So based on that:

 

>>rowForAB(1, 145)(1, 61, 12, 11, 1, 145)>>> rowNegX(61, 11, 1)(1, 41, 10, 9, 1, 101)>>> rowNegX(41, 9, 1)(1, 25, 8, 7, 1, 65)>>> rowNegX(25, 7, 1)(1, 13, 6, 5, 1, 37)>>> rowNegX(13, 5, 1)(1, 5, 4, 3, 1, 17)>>> rowNegX(5, -(25 + 3), 17)(1, 5, 30, 13, 17, 53)>>> rowNegX(5, -(45 + 3), 53)(1, 5, 76, 23, 53, 109)>>> rowNegX(5, -(65 + 3), 109)(1, 5, 142, 33, 109, 185)>>> rowNegX(5, -(85 + 3), 185)(1, 5, 228, 43, 185, 281)

 

It's a bit silly now, I'm negating the x-parameter on purpose now because it get's negated inside rowNegX. But the idea is as follows

 

Given the n = 5 we have (1, 5, 1) which we know is {1:5:4:3:1:17} we then compute a new b:

b = 17 + 2 * (2 *5 + 3) + 2 * 5

 

The original equation for is:

 

b = a + 2 * x + 2 * n

 

So in our new case, x = (2 * 5 + 3).

 

The 5 is because our n = 5 and 3 is because the first x is 3.

 

This will give us b = 53 and the next record is as follows:

 

{1:5:30:13:17:53}

 

We repeat it:

 

b = 53 + 2 * (4 * 5 + 3) + 2 * 5

 

Which gives us a b = 109. The next record is:

 

{1:5:76:23:53:109}

 

Now I know that there is another record between here which is:

{1:5:12:7:5:29}

 

But that exists because we have an interleaved n. The record above exists from the a = 25 from (5, 1) and is not a part of the a=1, b=17 pattern. It's a separate pattern existing in the same n-record.

 

If I'm rediscovering things and we already have names for these thing then apologies for my lack of terminology.

 

This rowNegX was supposed to only be used to move about with a negative x, but I'm over using it for other things. I'll try to think of a better name for it. We should also have two functions maybe. One for moving with positive x values and one for negative.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 2:34 p.m. No.2528   πŸ—„οΈ.is πŸ”—kun   >>2529 >>2530 >>2532

>>2527

 

Well I don't know if I follow you, but this is an example showing the "jumping down" from a=1, b=c for 5*29

 

>>rowForAB(1, 145)(1, 61, 12, 11, 1, 145)>>> rowNegX(61, 11, 1)(1, 41, 10, 9, 1, 101)>>> rowNegX(41, 9, 1)(1, 25, 8, 7, 1, 65)>>> rowNegX(25, 7, 1)(1, 13, 6, 5, 1, 37)>>> rowNegX(13, 5, 1)(1, 5, 4, 3, 1, 17)>>> rowNegX(5, 1, 1)(0, 2, 3, 2, 1, 9)>>> rowNegX(2, 2, 1)(0, 0, 1, 0, 1, 1)>>> ((61 - (e / 2) - 1)/2 + 1)-49.0>>> abs((61 - (e / 2) - 1)/2 + 1)49.0>>> s(abs((61 - (e / 2) - 1)/2 + 1))7.0

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 2:36 p.m. No.2529   πŸ—„οΈ.is πŸ”—kun

>>2528

 

But keep in mind, that equation was something I made when I thought jumping down would only go to (1, 1, 1) and not between e's.

 

So it could be wrong.

ID: 99fc86 Jan. 4, 2018, 2:36 p.m. No.2530   πŸ—„οΈ.is πŸ”—kun   >>2531

>>2528

I think we're actually pretty close to a log(n) factorization.

 

for any number in row 1

 

k = sqrt(n - (e/2) - 1) / 2 + 1

 

is the exact same number as the amount of iterations of my program required to reach (e,n).

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 2:49 p.m. No.2535   πŸ—„οΈ.is πŸ”—kun   >>2536

>>2534

I looked at the pattern of the changing n's from jump to jump.

 

I saw it was a change of sums of 4, and the "golden" pattern in all of this is the sum of (1…n) * 4…

 

To generate the d at t for any (e, 1) record you either do:

 

Even e:

(e / 2) + 4 * ( (t * (t + 1) ) / 2)

 

Odd e:

(2 + int(e/2)) + 6t + 4( ( t * (t - 1) ) /2 )

 

So I saw the change and made some quick calculations.

It's a very recurring pattern in generating of a's d's etc.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 3:15 p.m. No.2537   πŸ—„οΈ.is πŸ”—kun   >>2538

>>2536

Well to get D from T for (e, 1) I have this:

 

def getDFromT(e, t): if e 0 or e % 2 0: return (e / 2) + 4 * ( (t * (t - 1) ) / 2) else: return int( (e + 1) / 2) + 2t*2 - 1

 

And to get A from T I have this:

def getAFromT(e, t): if e % 2 == 0: return (e / 2) + 2(t - 1)*2 else: return int(e / 2) + 4 * ( (t * (t - 1) ) /2 ) + 1

 

The reverse way:

 

To get T from D in (e, 1):

def getTFromD(e, d): if e % 2 == 0: t = d - (e / 2) t = t / 2 t = t * 4 + 1 t = t / 4 t = math.sqrt(t) + 1 return -1/2 + t else: t = d - (2 + int(e / 2)) t = t / 2 t = t + 1 t = math.sqrt(t) t = t return t

 

To get T from A in (e, 1):

def getTFromA(e, a): if e % 2 == 0: return math.sqrt((a - (e / 2))/2) else: return math.sqrt((a - (e / 2))/2) + 0.5

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 3:17 p.m. No.2538   πŸ—„οΈ.is πŸ”—kun   >>2539

>>2537

I knew my original equations were a bit off, when I started. My original getDFromT would be off-by-one t. So I took some time now to refurbish them.

 

They should work correctly, assuming the first cell in (e, 1) is considered t=1.

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 3:32 p.m. No.2540   πŸ—„οΈ.is πŸ”—kun

{1:61:12:11:1:145}

{1:61:212:111:101:445}

{1:61:278:133:145:533}

(1, 61, 678, 233, 445, 1033)

(1, 61, 788, 255, 533, 1165)

 

I don't know how to predict / calculate these d's. Though. However, they do have an interesting pattern.

 

212 % 61 = 29

278 % 61 = 34

 

(212 - 29)/61 = 3

(278 - 34)/61 = 4

 

678 % 61 = 7

788 % 61 = 56

 

(678 - 7) / 61 = 11

(788 - 56) / 61 = 12

 

Again notice the interleaving patterns. This is because 61 appears as an a in (1, 1), but also as a 61 * 101 in (e, 1) (which is at t = 56)

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 3:33 p.m. No.2541   πŸ—„οΈ.is πŸ”—kun

>>2539

I honestly don't know right now. We do know that negative x is now more interesting.

 

It allows us to move between these n-records and generate their "initial" cell (where a = 1)

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 3:43 p.m. No.2542   πŸ—„οΈ.is πŸ”—kun   >>2543 >>2549

Right now I feel like I am a bit all over the map. We have a lot of neat patterns, but I don't see a "deeper" connection between them.

 

What use is f?

Why did VQC's original C# code refer to x + n?

Why is negative x important?

IseePatterns !kIkD/SqZ4s ID: 109284 Jan. 4, 2018, 3:45 p.m. No.2543   πŸ—„οΈ.is πŸ”—kun   >>2546

>>2542

 

VQC also talked about moving from the first (or second cell) to any value c. Then about controlling c by multiplying it with primes in order to coerce the factors.

 

I'm still not sure if this is all a LARP, or if we are close or if we are still far away.

Anonymous ID: dbd176 Jan. 4, 2018, 4:05 p.m. No.2548   πŸ—„οΈ.is πŸ”—kun   >>2551

>>>/cbts/13923

>Your prize will be the ability to spend the BitCoin by the inventors that are unspent in the BlockChain.

Not to ruin our fun here but I'm gonna have to call bullshit on this statement, unless our VQC can also reverse RIPEMD160 and SHA256 in addition to ellipitc curves. The reason being mined blocks contain only hashes of the public EC key, not actual keys.

We'll still break bitcoin though, as any address that has had a single outgoing transaction can be calculated since the public key can be extracted from a signature. Even if every address is only used once, there is still a race condition as we can just crack any new transactions before they are mined and make our own transaction with higher fees. Currencies are not very useful if you can't move the coins without them being stolen

 

We just can't touch any unspent coins or newly mined blocks…

 

Keep going!

Anonymous ID: dbd176 Jan. 4, 2018, 4:35 p.m. No.2552   πŸ—„οΈ.is πŸ”—kun

>>2551

Only when someone already spent some and you have their public key, so yes! Or if they try to spend it. No spending mined coins without a transaction first as far as I can tell