>>1505

I found a pattern in (0,n) for (0,1) to (0,2)

(0,1) (0,2)

(0,1,4,2,2,8) (0,2,3,2,1,9) d = d-1, a = a-1, b = b+1

(0,1,12,4,8,18) (0,2,8,4,4,16) d = d-4, a = a-4, b = b-2

(0,1,24,6,18,32) (0,2,15,6,9,25) d = d-9, a = a-9, b = b-7

(0,1,40,8,32,50) (0,2,24,8,16,36) d = d-16, a = a-16, b = b-14

So for for (0,1,d,x,a,b) we can solve for t by t/2.

Then we can have a little square called L = t*t

Then, from (0,1,d,x,a,b) we can get (0,2,d-L, x-L, b-L+2)

I'm going to see if I can generalize this further.

>>1507

(0,2) (0,3)

(0,2,3,2,1,9)

(0,2,8,4,4,16)

(0,2,15,6,9,25) (0,3,12,6,6,24) d = d-3, a = a-3, b = b-1 (3*1)

(0,2,24,8,16,36)

(0,2,35,10,25,49)

(0,2,48,12,36,64) (0,3,36,12,24,54) d = d-12, a = a-12, b = b-10 (322)

(0,2,63,14,49,81)

(0,2,80,16,64,100)

(0,2,99,18,81,121) (0,3,72,18,54,96) d = d-27, a = a-27, b = b-25 (333)

(0,2,120,20,100,144)

Here is the pattern from (0,2) to (0,3) for cells with the same X value (also it skips x values in (0,3).

>>1509

Good to be back. I've been doing family stuff for christmas. Hopefully we can crack this shit

Also I have that for any (0,n) cell we have:

For odd n:

(0,n)[t] = (0,1)[t] * n

For even n:

(0,n)[t] = (0,2)[t] * (n/2)

Also, since we can now calculate any index for (0,1) and (0,2) we can use these rules to calculate for any (0,n).

VQC also wanted us to analyze the column with no gaps. I noticed that for every entry where e is a negative square (-1,-4,-9), there are no gaps in cells, just in the values within the cells, only within even. I've been analyzing the column -1 and I have found an interesting pattern:

For (-1,n,d,x,a,b) we can do the following to get to (-1,n+1).

If a%(n+1) == 0, then let M = a/(n+1).

Then we have the following:

(-1,n,d,x,a,b) -(-1, n+1, d-M, x, a-M, b-M+2)

I think this makes sense.

I'm going to look into -4 row next.

>>1525

(-1,1) (-1,2)

(-1,1,7,3,4,12) (-1,2,5,3,2,12) d = d - 2, a = a - 2, b = b +/- 0 M = 2

(-1,1,17,5,12,24) (-1,2,11,5,6,20) d = d - 6, a = a - 6, b = b - 4 M = 2 * 3

(-1,1,31,7,24,40) (-1,2,19,7,12,30) d = d - 12, a = a - 12, b = b - 10 M = 2 * 2 * 3

(-1,1,49,9,40,60) (-1,2,29,9,20,42) d = d - 20, a = a - 20, b = b - 18

(-1,1,71,11,60,84) (-1,2,41,11,30,56) d = d - 30, a = a - 30, b = b - 28

These M's also correspond to 2, 6, 12, 20, 30 = 2, + 4, + 6, + 8, + 10

The M's are also the same as (for any index t) (0,1)[D] / 2

Also M = a/2.

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

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

(-1,2,11,5,6,20) (-1,3,9,5,4,20) d = d-2, a = a-2, b = b +/- 0 M = 2 = 2 i=2

(-1,2,19,7,12,30) (-1,3,15,7,8,28) d = d-4, a = a-4, b = b-2 M = 4 = 2*2 i=3

(-1,2,29,9,20,42)

(-1,2,41,11,30,56) (-1,3,31,11,20,48) d = d-10,a = a-10, b = b-8 M = 10 = 2*5 i=5

(-1,2,55,13,42,72) (-1,3,41,13,28,60) d = d-14,a = a-14, b = b-12 M = 14 = 2*7 i=6

(-1,2,71,15,56,90)

(-1,2,89,17,72,110) (-1,3,65,17,48,88) d = d-24,a = a-24, b = b-22 M = 24 = 222*3 i=8

(-1,2,109,19,90,132) (-1,3,79,19,60,104) d = d-30,a = a-30, b = b-28 M = 30 = 235 i=9

For these in (-1,2) to (-1,3) we get M = a/3.

(-1,3) (-1,4)

(-1,4,4,3,1,15) i=1

(-1,3,9,5,4,20) (-1,4,8,5,3,21) d = d-1, a = a-1, b = b+1 M = 1 i=2

(-1,3,15,7,8,28) (-1,4,13,7,6,28) d = d-2, a = a-2, b = b M = 2 i=3

(-1,4,19,9,10,36) i=4

(-1,3,31,11,20,48) (-1,4,26,11,15,45) d = d-5, a = a-5, b = b-3 M = 5 i=5

(-1,3,41,13,28,60) (-1,4,34,13,21,55) d = d-7, a = a-7, b = b-5 M = 7 i=6

(-1,4,43,15,28,66)

(-1,3,65,17,48,88) (-1,4,53,17,36,78) d = d-12,a = a-12, b = b-10 M = 12 i=8

(-1,3,79,19,60,104) (-1,4,64,19,45,91) d = d-15,a = a-15, b = b-13 M = 15 i=9

For these in (-1,3) to (-1,4) we get M = a/4

Here's a little more work from my file.

>>1526

This pattern seems to work for (-4,n) also. So for any negative square e we can generate the entire column. BUT this omits some values, looking at my previous post you can easily notice the ones that don't get generated.

>>1531

I mean the whole problem is if you just took a bunch of money it's still probably illegal. Like safeguards aside, just because you can do something doesn't mean you are legally able.

>>1537

Nah not necessarily a crash. Supposedly IOTA has a chain resistant to quantum computing. That's why I put money in it. But who knows

>>1529

This absolutely works just tested it out.

This is an easier way to put my (0,n) column rule.

The cell (0,n) = (0,1) * n (for odd n)

and (0,2n) = (0,2) * n

So I've been looking through these values that I can generate for the negative square values of e. This is the output for entries (e,n,d,x,a,b,c) where c is a square number. (I checked for c to be product of 2 primes but it didn't produce any). I checked the first 30 entries of the first 30 rows of the first 30 squares (I did a bunch of them get the picture) and heres the result entries where c is a square:

25:

((-25, 2, 13, 7, 6, 24, 144), True)

49:

((-49, 1, 25, 9, 16, 36, 576), True)

((-49, 5, 25, 13, 12, 48, 576), True)

100:

((-100, 4, 26, 14, 12, 48, 576), True)

196:

((-196, 2, 50, 18, 32, 72, 2304), True)

289:

((-289, 5, 145, 37, 108, 192, 20736), True)

361:

((-361, 2, 181, 31, 150, 216, 32400), True)

441:

((-441, 3, 75, 27, 48, 108, 5184), True)

484:

((-484, 1, 122, 26, 96, 150, 14400), True)

((-484, 3, 122, 32, 90, 160, 14400), True)

529:

576:

((-576, 2, 51, 26, 25, 81, 2025), True)

625:

((-625, 3, 65, 29, 36, 100, 3600), True)

676:

729:

((-729, 2, 123, 33, 90, 160, 14400), True)

784:

841:

((-841, 4, 421, 61, 360, 490, 176400), True)

((-841, 6, 421, 71, 350, 504, 176400), True)

1444:

((-1444, 4, 362, 62, 300, 432, 129600), True)

1681:

((-1681, 1, 841, 57, 784, 900, 705600), True)

1936:

((-1936, 2, 244, 52, 192, 300, 57600), True)

((-1936, 6, 244, 64, 180, 320, 57600), True)

2025:

((-2025, 1, 339, 51, 288, 392, 112896), True)

2304:

((-2304, 1, 148, 50, 98, 200, 19600), True)

There is some weird stuff here.

(-49,1,25,9,16,36) [leaving out c]

multiplied by 2 (with e multiplied by 4) we get:

(-196,2,50,18,32,72) [notice that for n,d,x,a,b the previous entry was half and e was a quarter]

(this relationship could be visualized I think)

Also you got

(-484, 1, 122, 26, 96, 150)

same pattern

(-1936, 2, 244, 52, 192, 300)

So if n is one for this type of cells then you can do (newE = oldE * 4) and (newOtherpart = oldOtherpart * 2)

Anyone want to look further into this?

>>1560

ignore the True, that just means it's a valid record

>>1560

((-484, 1, 122, 26, 96, 150, 14400), True)

((-484, 3, 122, 32, 90, 160, 14400), True)

((-1936, 2, 244, 52, 192, 300, 57600), True)

((-1936, 6, 244, 64, 180, 320, 57600), True)

484 = 22^2

1936 = 44^2

122*2 = 244

1*2 = 2

3*2 = 6

26*2 = 52

32*2 = 64

etc..

Very cool

>>1564

I used C# for my job this past summer. I also have a mac and recently installed C# and visual studio on it to run this stuff. It wouldn't work for me either. I run my shit in python now.

>>1589

>>1604

>>1605

>>1607

This one is actually B's. Ignore the text

>>1587

IOTA (MIOTA) is a crypto I think developed by

…microsoft…

so they will still be in control with it, BUT I'll have more money so thats neat

>>1589

This is all the prime A values I think. My original file is named DiffAs.bmp so I think that is what this is. White would be A = 1 or 2, then yellow would be the next prime etc. If we can somehow generalize this then we could have a set of lines for any prime A to show all the products of it.

Also if you look at my AVals you can notice that there are parabolas that slide down the graph that do not move. These dots are all probably integer selections on the parabola. I'm going to try and generalize these into equations because I've wanted to do it for a while but I've been lazy.

9………………..+………………………..

0…………….+….+..++……………………

1………………..+….+..++………………..

2……………..+……+….+………………..

3…………+……..+……+….+…………….

4…………….+……..+……+……………..

5………………..+……..+………………..

6………….+……….+……..+…………….

7……………..+……….+……..+…………

8……..+…………+……….+……………..

9…………+…………+……….+………….

0…………….+…………+………………..

Copy and past into same width text file.

The end is saying there is a record divisible by 2 at -5,-1. Also it said there is one divisible by 3 at -7,-1 and one divisible by 4 at -9,-1. Could this N = -1 be a key entry???

Also I'm planning to do a code dump later today. Hit me with some (you)'s if you guys are interested. I have code to generate the pictures (even gifs!) but you'll need to modify some of the code (its easy though). I also have a way to generate these outputs above (I could generalize this for anything) because these are easier to look at than bitmaps to really find patterns. Also I have code to generate any (0,n) cell and any (e,1) cell. Also I have code to (I'm not sure if the function is surjective, but it could be helpful) to generate any (-(q^2), n) column.

>>1611

I also have a bunch of shit typed out in .txt files that are different series and patterns and notes

>>1615

Entries for A = 2

(-5,-1)

(-9,0), (-4,0), (-1,0), (0,0)

(-5,1), (0,1), (3,1), (4,1)

(-8,2), (-1,2), (4,2)

(-13,3),(-4,3), (3,3), (8,3)

From any value of A at (e,n) if we go to the cell(e+4, n+1) we will (probably) get another entry.

Also if at (e,n) we have A.

The centers of any line are going to be on the (0,q^2) cell where

Also, the generation seems to be independent of the (0,0) and (0,4) cell (4=2^2)

So our start is at (0,1). We can then do the pattern twice to the right and once to the left.

n: cells where A = 2

1^2: (-4,0) <1< (0,1) >2 (4,2) (5,3)

From here, to get to the next line we can take all of our cells and shift them by:

(e,n) -(e-1,n+[1]) and then add another cell to the left side of the line to get:

(added to left)

(-9,0), (-5,1), (-1,2), (3,3), (7,4)

We can also get to the previous line (but you remove the last entry on the right before doing this)

(e,n) -(e-1,n-1) to get

(-5,-1), (-1,0), (3,1), *[(6,3)] gets removed

Then to get the next 3 lines we have to do

2^2, so we start at (0,4) and we use our pattern to go to the left twice (2) and to the right 3 times (2+1).

So we get

(-8,2),(-4,3) <2< (0,4) >3(4,5), (8,6), (12,7)

Then, like before, if we want to go to the next line we do

(e,n) -(e-1, n+[2]) and add an entry to the left

(added)

[(-13,3)],(-9,4),(-5,5),(-1,6),(3,7),(7,8), (11,9)

And the previous is the pattern

(e,n) -(e-1, n-[2]) and you remove an entry on the right to get:

(-9,0), (-5,1), (-1,2), (3,3), (7,4) [(11, 5) would be removed]

This is info on how to calculate the coordinates for any cell where a = 2.

It is very simple to calculate them. I am going to try and generalize to higher a.

>>1615

No coincidences at all. Here is a pic that looks real cool. with pyramidal stuff.

Also this one look at the LITERAL 3D SPIRAL GOING DOWN THE CENTER. This is where X mod P is base [ i think base = (a+b)/a ]

>>1617

Also this is pic related for the series.

>>1617

A = 3

2 up from origin of parabolas is (-7,-1), (-1,0), (5,1)

For this we can notice that the origins of the parabolas are:

(-3,1), and (3,2), and (9,3), (15,4) (idk how this pattern is formed)

From these origins we can calculate anything on the parabola. You can go up N like:

(e,n) -(e-1,n+1) -> (e-2,n+1) -> (e-4,n+1)

and down like:

(e,n) -(e-1,n-1) -> (e-2,n-1) -> (e-4,n-1)

From any cell in (e,n) where a = 3 we know the cell (e+6,n+1) and (e-6,n-1) contains another a=3.

Only inside this huge parabola, but I suspect the pattern continues for really high values that our theend didn't generate. Moreover, if we do this to get to (e+/-6, n+/-2) then the entry on that parabola is SAME entry in the parabola shape.

x x*x

1 1

2 4

3 9

4 16

5 25

(0,0)(1,1),(2,4)

So generally if we have a cell (e,n) that is divisible by 3 and is the origin of the parabola, then the entries (e-(y^2), n+y) that are also divisible by 3 for all y.

So if we are at a cell (e1,n1) divisible by 3, then it is equal to (e0 - (y^2), n0 + y) for another e0,n0 where e0 != e1, and n0 != n1. Also, (e0,n0) is the origin on the parabola these line up on. If we go to (e+6,n+1), we can call this (e2,n2). Then we have that (e2,n2) is equal to (e3-y^2, n3+y) which are the SAME Y VALUES. So here we can get coords for any a=3

Also, if we have 2 cells at (e,n) and (e-1,n-w) we can generate more cells by doing the following:

(e,n) -(e-1,n-w)

-(e-4,n-2w)

-(e,9,n-3w)

And also the reverse

(e,n) -(e-1,n+w)

-(e-4,n+2w)

etc..

>>1620

Big if Huge.

Also if we have a n origin cell at (e,n) and to to (e -(2^2), n - 2*w) = (E,N),

that cell is equivalent to (e0 - (1^2), n0 - 2(w+1)) where (e0,n0) is another parabolic origin.

A = 4

For this, the pattern is similar. The third [4-1] above the origin is:

The difference is the function goes from (e,n) to (e+8,n+1) and the relation between two parabolas is

(e,n) [origin of paraobola] to (e -(2^2), n - 2*w) = (e0 - (1^2), n0 - 2(w+1))

where (e0,n0) is another parabolic origin.

It seems that we can generally say the following:

For any A

If you are at a parabolic origin cell (e,n) with the parabola being (e-(j^2),n+(w*j)) for any cell, then if you go to the entry by plugging in this j

j = {j/2 if A even OR (j+1)/2 if A odd}

you reach a new cell that is equivalent to (e - (i^2), n +(w*i))

where (e+(2A) , n+1) = (e,n*)

and i = {A/2 if A even, and (A-1)/2 if A odd}

Now, if we can find a pattern to get these initial entries then we can generate every entry with factor A.

>>1621

So through this method for (e,n,d,x,a,b):

We know E,N,A and can shift along the parabola

aa + 2ax + 2an = c (a,x,n,c)

b = a + 2x + 2n (b,a,x,n)

a * b = c (a,b,c)

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

x = d - a (x,d,a)

d * d + e = c (d,e,c)

Have E,N,A:

(b,a,x,n)

(a,b,c)

(d,n,x,c)

(x,d,a)

(d,e,c)

So now we have relations between:

(b,x) .

(b,c) .

(d,x,c)

(d,c)

(x,d)

(b,x) and (b,c) -(x,c)

(x,c) and (x,d) -(c,d)

(d,c) and (c,d) -c or d!!

b = a + 2x + 2n

a * b = c

- c/a = a + 2x + 2n

c/a = a + 2x + 2n

x = d - a

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

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

d * d + e = c

c = aa + 2a(d-a) + 2an

dd + e = aa + 2a(d-a) + 2an

d = sqrt( 2ad - aa + 2an - e )

then

c = dd + e

x = d - a

so we can generate any (e,n,d,x,a,b) for a constant a by

shifting along this parabola and using this equation.

DO WE HAVE A WINNER?

>>1626

>>1625

>>1621

This is to generate other entries with the same A. I checked and it works for A=2,3,4,5 (1 was linear so I skipped it, also its lame) so I think it might work for more. I'll write code to check it later.

>>1628

>>1618

This is pic related for A=2. I'll post a couple more.

I haven't necessarily figured out how to figure out how long the lines are, but it seems like they start with 3 and add 1 on the right and then 1 on the left each time or something like that. I had it figured out for A=2.

>>1629

Seems that for each number a, there exists an origin for the parabola at cell (0,2*a). So for any a We can generate every other cell with value a.

>>1630

Moreover if you go from (0,2a) and add or subtract 2a to e, you generate another origin for the parabola.

>>1624

Fucked up the math on this one sorry guise. Trying to fix it (quadratic eqn)

>>1624

I incorrectly had this as the equation

>dd + e = aa + 2a(d-a) + 2an

>d = sqrt( 2ad - aa + 2an - e )

d = a +/- sqrt(8an - 4e)/2

So, believe it or not, for any E,N,A, we can generate TWO records for d.

>>1634

We know E,N,A

aa + 2ax + 2an = c (a,x,n,c)

b = a + 2x + 2n (b,a,x,n)

a * b = c (a,b,c)

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

x = d - a (x,d,a)

d * d + e = c (d,e,c)

dd = c - e

dd + 2dn + nn - (x+n)(x+n) = c

c - e + 2dn + nn - (x+n)(x+n) = c

2dn - e + nn - (xx + 2xn + nn) = 0

2dn - e + nn - xx - 2xn - nn = 0

2dn - e - xx - 2xn = 0

2n(d-x) = xx + e [x = d-a =a = d-x]

2na = xx + e

xx = 2na - e

x = math.sqrt(2na-e)

Then d = x + a

c = dd + e

b = c/a

This might be an easier way to calculate. Pls verify if you're following along

>>1636

Just remember dd+e = c. For negatives D isn't necessarily the side of the largest square less than c it could just be any square and e is what you add to it to make it c.

>>1639

VQC made the grid by multiplying and doing that stuff. He said this grid is practically effective everywhere so I'm trying to shed my preconceptions about what all the values are because they can probably be calculated in many different ways.

pic related:

For 40 we have parabolic origin cells at

(0,20), (0,80), (0,180), (0,320)

Notice: (vg = vertical gaps)

(0,20) = (0, (40/2) * 1) (vg = 0)

(0,80) = (0, (40/2) * 4) (vg = 1)

(0,180) = (0, (40/2) * 9) (vg = 2)

(0,320) = (0, (40/2) * 16) (vg = 3)

So for any value A (if A is even) you have parabolic origin cells at ( 2AH, (A/2) * T^2 ) for any integers H,T.

Then from those cells (say (e,n)), (depending on what T you chose), you can get another cell (with the same a) by the following:

(e,n) -(e+2A*J, n-J) (for any J)

(e,n) -(e-J^2, n + J*T) (for any J)

I may have posted someting earlier, which said that you could go (e,n) -(e+2a, n) which is wrong, this above is the correct formula.

>>1642

Now for 41 (odd number) we get origin cells at:

(-41,20), (41,21)

(0,82)

(-41,184), (40,185)

(0,328)

(-41, (411-1)/2), (41, (411+1)/2)

(0, (41*4)/2)

(-41, (419-1)/2), (41, (419

(0, (41*16-1)/2)

So in general for an odd A, we will have parabolic origin cells at (indexed by t):

Odd t:

(-A, (A(t^2)-1)/2), (A, (A(t^2)+1)/2)

Even t:

(0, (A*(t^2))/2 )

Then, obviously, we can still use the pattern

(e,n) -(e+2AJ, n+J*t) for any J

to move along the parabolas. Previously, I had written a way to traverse to and from parabolas from the origin cells.

>>1621 (here)

So now this is a way to generate the origin cells for any A

>>1643

Pic for 41

>>1643

Just tested this out. It works.

def ENA(E,N,A):

X = int(math.sqrt(2 * N * A - E))

D = X + A

C = D * D + E

B = C / A

return (E,N,D,X,A,B,C)

#This will give coords for parabolic origins and also P is the shifter for N for the parabola

def originForP(A,P):

if(A%2 == 0):

return ENA(0,(A/2)PP,A)

else:

if(P%2 == 0):

return ENA(0, (A(PP))/2,A)

else:

return ENA(A, (A(PP)+1)/2, A)

def shiftFromOrigin(origin, P, t):

E = origin[e] - (t * t)

N = origin[n] + t * P

A = origin[a]

return ENA(E,N,A)

Python code if you guys want it.

I think I have found a pattern for any x value.

X:

Start with (e,-1) = (-x^2, -1).

Then we can generate a line from this point by doing the pattern

(e,-1) -(e + 2J, -1 + J). This is the line that goes down and to the right.

Then from any of these cells, (e,n), we can find the next cell where X is

the same value by doing

(e,n) -(e+2n, n)

Or we can start at our (e,-1) = (-x^2,-1) cell and shoot lines out from it with:

(e,-1) -(e + 2dt, -1 + t) for any integers d,t

Similar to the constant A values, we need to generate an entry by having (e,n,x) values.

Here are our equations:

aa + 2ax + 2an = c (a,x,n,c)

b = a + 2x + 2n (b,a,x,n)

a * b = c (a,b,c)

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

x = d - a (x,d,a)

d * d + e = c (d,e,c)

x = math.sqrt(2na-e) (x,n,a,e)

From this we can get

xx = 2na - e

a = (xx + e)/2n

Then we have

d = x + a

b = a + 2x + n

c = a * b

to generate a new cell.

So now given any value X we can generate every cell with the same X.

Pic related is an example of this.

>>1661

INSTEAD OF STARTING AT (-x^2,-1) this pattern starts at (-x^2, 0). Sorry

>>1663

No this is starting at X we can generate any other cell with the same X. Given our C, we can generate (for a=5,b=23, a*b = 115):

Our entry for C is

(15,48,10,9,1,115) or (15,48,10,-105,115,1)

and our destination cell is:

(15,4,10,5,5,23)

So our C gives us the correct D value. We need a way to calculate these other values from our original cell.

>>1664

I think I've already solved all the (0,n) columns. Look at this code (I'm pretty sure I've already tested it and it works) but give it a look over.

(index is basically the t value)

def zeroN(N,index):

if(N == 1):

return zeroOne(index)

if(N == 2):

return zeroTwo(index)

if(N % 2 == 0):

#Even

factor = N/2

baseRec = zeroTwo(index)

else:

#Odd

factor = N

baseRec = zeroOne(index)

E = baseRec[e] * factor

D = baseRec[d] * factor

X = baseRec[x] * factor

A = baseRec[a] * factor

B = baseRec[b] * factor

C = A * B

return (E,N,D,X,A,B,C)

#Generates any entry in the (0,1) cell

def zeroOne(index): #index starts at index = 1

A = index * index * 2

D = 2 * index * (index + 1)

X = index * 2

E = 0

N = 1

B = A + 2 * X + 2 * N

C = A * B

return (E,N,D,X,A,B,C)

#Generates any entry in the (0,2) cell

def zeroTwo(index):

X = index * 2

A = index * index

B = (index + 2)**2

C = A * B

D = X + A

E = C - D*D

N = ((X * X) + E)/(2 * A)

return (E,N,D,X,A,B,C)

>>1666

Yeah I had that too. They all are good I'm pretty sure. I've tested like the first 10 of the first 10 rows of the first 10 whatever so I'm just assuming it works forever because its infinitely long ya know

>>1668

I can't check it with RSA values I don't know what to even do with that. Currently I'm trying to find relationships between entries with the same (x,d,a,b) values. I've already found a pattern to get all cells for any x value. Also all the cells for any A value. I'm trying to find patterns in the grid and learn the grid. We haven't even come up with a method to find the factors yet, so plugging in RSA values wouldn't be worthwhile. Also VQC said the patterns in the first few cells extend to the entirety of the grid, so I see no point in doing these values. Also I don't have BigInt for my python and I don't feel like downloading it. My computer isn't that fast I run the thing and every record it goes through (sometimes I was going pretty deep into each cell) prints True for whether or not its a valid record and I kill the program when I'm tired of watching it print True. I'll say with 98% confidence all this is true.

I'll post my Python code. Give me a minute.

>>1668

pastebin .com/d8xZZnm0

Here is my code. It's verified enough to me. I only post stuff on here if I haven't found any holes in it. The imaging stuff is in another file and I would have to reformat it and change some variables around. You'd also have to download a whole package which is a pain in the ass so I left it out. This is my freshest file that I've been working with.

Some of the stuff doesn't work when you start with 0. (Like the A stuff for A=0). If you get an error that would probably be it. Otherwise I think it's pretty error free code.

>>1670

Okay. Then what? I can multiply the primes together then do what? Thats where I don't get the point of using the RSA. I'm generating these values through E,N,X or E,N,A so the C is kind of a byproduct of those. I'm trying to analyze the grid so I can understand all the patterns so that I can eventually figure out an algorithm to factor the large products of primes, I don't see the point of just throwing bigger numbers at it if we don't even know how we are going to factor it.

MORE FOR A:

If we have an origin cell(e,n) and the P value (the vertical jump size it takes to get to the next part on the parabola, also the root of the square value multiplied by a/2 to get origin cell) then we go from an entry for

(e,n,d,x,a,b,c) to (e, n+P, d2, x2, a+1, b2, c2)

(just another cell to be made from E,N,A, which we already have code for.)

This can also be reversed to yield:

(e,n,d,x,a,b,c) to (e, n-P, d2, x2, a-1, b2, c2)

Also for a cell on a parabola with a certain p (EVEN P) value and a certain t value (t is which spot it is on parabola. t=0 is origin, t=-1 is where n = originN-t*P etc.)This is can be derived from the same pattern above with prior rules that I found out.

Remember parabola origins are of the form for even p:

(2aH, (a/2) * p^2)

If our entry is on the parabola from this origin we can do

[n+(p*p)/2 is not verified my pictures were not large enough I'll test it later sue me]

(e,n,d,x,a,b,c) -(e+2H, n+(p*p)/2,d?,x?,a+1,b?,c?)

(e,n,d,x,a,b,c) -(e-2H, n-(p*p)/2,d?,x?,a+1,b?,c?)

both are from (e,n,a) so we can calculate them.

If these patterns are true, then we would have, for each entry:

e,n,d,x,a,b,c,p,t,h

(shit dats a lot of variables batman!)

where we already know what (e,n,d,x,a,b,c) are and

p = the value such that n = (a/2) * p^2 for the origin of parabola

t = the entry on the parabola started by the origin

h = the number of parabolic shifts to the right you've taken to get to the origin from (0,n)

I like to think of p as the parabola depth (they all are same pattern at same depth). t as in the entry along the parabola. if you shift t along the same parabola the p value won't change. H will not change unless you do the function (e-2a, n-1, a, H-1) -(e,n,a,h) -> (e+2a, n+1, a,H+1).

More on the T, if we have parabolic origin value (t=0)

(e,n,d,x,a,b,c,p,0,h) then we can generate values along the same parabola by changing t.

(e,n,d,x,a,b,c,p,0,h) -(e-p(t^2), n+pt, d?,x?,a,b?,c?,p,t,h) for any t.

Pic related for a = 34

>>1677

>(2aH, (a/2) * p^2)

Should be

(2aH, (a/2) * p^2 - H)

>>1681

What I can do is generate any valid cell for any a value. What I can't do (yet) is figure out how to calculate a given t from (e,n,d,x,a,b,c) but maybe someone could figure that out. If we could do that, then starting from our cell (e,n,d,x,1,c,c), (with t) we could ride up and down our parabola. Then with t we could ride it down to t=0 or the origin, which would give us our h value. Then from there we could ride h back home to h=0 the (0,n) column to figure out that parabola we are on by getting the value p. Once we have that value p, we can go back to our original cell and potentially shift a up until we find something?? I'm not exactly sure how we'll use this, but this is certainly a way to index and navigate these cells.

So if I had to say to do anything it would be to find out how to get t from an entry. This will probably be tough.

>>1684

Whoops I thought you were chirping us baker sorry I misinterpreted who you were calling famefags.

Same as what I've been doing for constant D values (because for C record we already have correct D, so this could help us navigate through the D's:

pastebin. com/5cd4k2rz

Graph. (+ = from the end, *= extrapolated from pattern).

For any d, we can start off and say there will be an entry at

(e,n) = (-d^2,-d+1)

We can call this our origin cell for D. Now, to navigate along this graph we would need to generate cells from their (e,n,d) values, which I do not think we can do yet. However this pattern is still notable.

Starting at our origin cell (the Zeroth origin cell), (e,n) I THINK we can generate any cell for this pattern:

(e0,n0) -(e0,n0+u) for any u [I'll go 70% on this step, cuz I can't generate to test, the other ones are pretty certain though]

Then, from our origin cell, if we go to the right one cell we get a second origin cell (origin cell 1). (e0,n0) -(e0+1,n0) = (e1,n1) From this cell we can do

(e1,n1) -(e1+2u, n1+u) to navigate down the line as many times as we want

Then, if we go down the line once (e1+n1)->(e1+2,n1+1) and then shift to the right (e1+2+1, n1+1) we get the third origin cell (e2,n2).

From the third origin cell, we can do:

(e2,n2) -( e2 + 4u, n2+u ) to generate more cells for any u.

Generally:

The zeroth origin cell for D can be found at:

(-d^2, 1-d).

For the zth origin cell, (e,n) we can generate any other entry with the same d by this equation:

(e,n) -(e + 2zu, n + u)

Also, from any origin cell we can generate the next origin cell.

( z to z+1), which boils down to going down the line once and then adding 1 to e.

(e,n) -(e + 2z + 1, n + 1)

So now we have a method to determine all the entries (e,n) with the same d. Also, this may be an impossible task, but if anyone can generate an entry just given the (e,n,d) values that would be sweet, but I don't think we can.

This may be the biggest thing I've discovered. This path for valid d values is the same for every d. As in, the only difference between entries for certain d values is the zero origin for d. Other than that you use the same exact steps to figure out what other cells have the same d. Knowing that, if we have a valid d, we can say, WITH SUPREME CONFIDENCE, that.

origin cell is at (-d^2, 1-d)

the origin cell for d-1 is at ( - (d-1)^2, 1-(d-1)) = (-dd +2d -1, -d) (same formula)

So if we have a cell we know for certain we can navigate to a valid cell by:

(e,n,d,x,a,b) -(e+2d-1, n-1, d-1, x?, a?, b?)

to go down a d value.

>>1725

>>1725

The pattern for the origin cells is more consistent if the zero origin is calculated at (-d^2, -d) because that way you can still do the same pattern (go down the line once, then shift e by 1) to get the next origin cell. Before it was that pattern for all origins not equal to 0, now it is consistent.

>>1727

holy fuck thanks for this code i would have been at a dead end without you

a bit of output

>((-36, 0, 6, 6, 0, 12, 0), 'a=0')

>((-36, 1, 6, 6, 0, 14, 0), 'a=0')

>((-36, 2, 6, 6, 0, 16, 0), 'a=0')

>((-36, 3, 6, 6, 0, 18, 0), 'a=0')

>((-36, 4, 6, 6, 0, 20, 0), 'a=0')

>((-36, 5, 6, 6, 0, 22, 0), 'a=0')

Okay so I tested this code and and it only gave me values of A where A = 0. I used to have that a=0 meant an invalid cell, but heres the thing: For A=0, you can have ANY value for (e,n,d) that you want and they all could still be valid entries right? Like 0 is a number so why couldn't it be in entry a? Maybe these are all valid entries.

Suppose they are, our output from AB and C fun

C(21) = (5,7,4,3,1,21,21) = start

AB(3,7) = (5,1,4,1,3,7,21) = goal

So for this we have the correct E and D right off the bat. We may be able to iterate through these n values and search things from there, because these are valid cells, but we cannot do END(5,7,4) because I think it takes root of -1. But for this remember we have the correct D. So we can go to the (-d^2) column, which is basically the root for d ((-d^2,-d) would be the seed I guess). From that column, we can expand out and generate any cell for the same (correct) d. We could do this and iterate through the cells from each D origin cell and go down until we either hit or pass e. Then I think we may have our correct cell at that point.

Tada!