VQC:

At this point, a good strategy would be to have a thread that is used to post patterns from The End grid.

Patterns that apply to all c in the grid.

Patterns that apply to all cells in a row.

Patterns that apply to all cells in a column.

Special rows.

Special columns.

It was hinted before and was useful to me, by enumerating all the patterns in one place, the answer will materialise.

You are looking for a key shortcut.

The grid does the ALL the work for you.

Suggestion…

Either here or a worker thread(s), discuss each rule or pattern.

When consensus is reached, put the rule or pattern in the key thread.

This process and result of this process may surprise you, more than you think.

It may change the way you think.

It may be advantage you can apply in other problem solving.

This is how you win.

If an integer p is a factor of a[t], then p will be a factor of a[p+1-t] for ALL cells in row n=1.

GCD(a[t],a[p+1-t])>=p

For all a[t] in (e,1)

If p is a factor in a[t] then there exists (e,p)

For a c at (e,n), there exists (-f, n-1)

The difference between e and -f is 2d+1, making columns e and -f unique as a pair to c.

The position of column 0 acts as a key with these two unique columns to fufill an equivalent role of the quantum Fourier transform in Shors algorithm.

In essence, the grid acts a lookup for integer factorisation and turns the sub exponential big oh search into a log t calculation where t is the length of c in bits.

Apologies if this is old to you guys, but I noticed something:

For all even numbers of 'e' in the n=1 row, cells are filled in a pattern that matches a slope of 1/e (or -1/e, since the coordinates are reversed in graphics). It's not always reduced, but it's regular; for instance, starting from e=1, n=1; you can go down 2, right two, and a cell will be occupied; you can continue this on through about half of the graphic, then onward from there at a slope of down 4, right 4. From e=2, n=1; you move down one, right two, pretty much through the entire graphic–every cell following that pattern has contents. For every even 'e' in a 64-iteration grid, the pattern holds to the edge of the graphic (up to e=52, n=1 in that case).

I've made a huge image with color overlay to help identify the trends. I haven't specifically identified trends because I'm not sure which ones you're already aware of yet…but there's a lot of "b = a" at t+2, etc.:

https://anonfile.com/Xcpeg4f5b8/outputRSA0_20480x10240_i_64_xMin_0_xMax_128_yMin_0_yMax_64_t_0_scalar160xWithTextTrendOverlay.png

You can also overlay pics related over the grid to see what I'm talking about.

I go into things in greater detail in this post:

>>6636

Again, sorry if old.

>>6561

>>6579

>>6580

Hello VQC! I missed these crumbs. I'll get to work on them tonight.

>>6639

Hello Prime Anon! :)

Where a[t] = bn

d[t - 1] - d = b(n-1)

>>6707

Hi VA! I think you got snared into the wrong thread, but it's nice to hear from you :)

>>6871

thanks for the tip–I'll have to look. There can't be many of those? If a[t] = bn, if 'a' is always less than or equal to 'b', but both 'a' and 'b' are positive in a regular grid, then that would mean that it would have to be perfect squares (a = b) in the 'n = 1' row…but all of the (a = b) squares are in (0,0). Do you mean any bn? Because that would be amazing ;)

I'll look into it further…

I'll check it out–

>>6885

In (e, 1) where a[t] = bn,

d[t - 1] - d = b(n-1).

>>6561

Correction:

a[p-1-t]

>>6969

Correcting my correction

My x to t, t to x calculation was wrong, and because of that a[p - t - 1] worked fine for me, not a[p + 1 - t].

So to add more usefulness and to keep things in one place:

Odd e: x = 2t - 1

Even e: x = 2(t-1)

(BigN-n)/(b-1) = (a-1)/2, where a and b are the numbers related to n (so not BigN's a and b) and where c is odd. This is true regardless of the number of possible n values a given c has. Example here: >>7192

For all c in the grid, we can easily calculate d, e and f.

We can also easily calculate their BigN cell (where a=1 and b=c) in positive and negative space.

In row 1 (where n=1) in positive space (so not the (f,n) cells), f=(x+n)(x+n)

The values of a,b and d each increase by ONE 2n cells to the right. They decrease by one 2n cells to the left.

For every c.

From the first two threads:

Columns contain all products that have the same remainder e. The number of factors a number has determines how many times it shows up in a given column (if it’s prime, once; if it’s a semiprime, twice; if it has three prime factors, three times, and so on).

Row one contains cells which contain all factors for each column (na and nb are n apart (at a[t] and a[t+n])

a[t+n]-a[t]%n==0. These values represent na and nb of any c. If you pick any two cells in (e,1) and subtract the lower from the higher, the result will be divisible by the gap in t values. Sometimes this will produce a result that means b is less than a, so it is not always 100% valid.

The cells that have elements have a finite number of "seed" elements that are the lowest values of c (a multiplied by b) in that cell, from which all the rest of the elements in that cell can be constructed (since values of a increase by a+2x+2n from a seed element). Other seed values can be constructed based on the value of -x+2n and depending on the number of factors within n for any given cell. There is only one seed element in row one (e,1).

As a subset of this thread, let's list each individual number or cell which, if found, would solve the grid:

-a

-b

-n

-x+n

-x

-t

-xx/2 (because na is (xx+e)/2 and na appears in (e,1) — xx/2 +1 for odd e)

-an, bn, a(n-1) or b(n-1)

-the x or t values of the an/bn/a(n-1)/b(n-1) cells

-some number which is always greater than n but less than x+n (for finding n0)

-the first cell in which a[t]=c in (e,n) (n not necessarily being the n we're looking for)

We can find two cells in (e,1) in which a[t] is a multiple of c where x=c-d and where x=c+d+1. In the first of these two cells, a[t]=cBigN. In the second of these cells, a[t]=c(c-BigN+1). There are also equivalent cells in (-f,1), where a[t]=c(BigN-1) and a[t]=c(c-BigN+2). In both positive and negative space, these cells are 2d+1 apart (the d in this gap being the d of the c we're trying to factor).

>>7354

-any of the three cells where c'=cc and where n>0

For example with 1343=559, there will be four cells: where a and b are 559 (which has an n of 0, so we aren't looking for this one), 13 and (134343), 43 and (131343), and (1313) and (43*43). If we find any of these, we'll know that either a or sqrt(a) is a factor of c.

>>7286

>>7311

>>7313

>>7314

>>7353

>>7354

>>7355

>>7357

Hello AA! I'm following. Here's my starter list. Let's build on it.

Here's a start for the list/program:

pick a c value from the grid. (let's start with odd x+n c values).

(prime) element shown.

(1,c) Big N.

(-f, c) Big N-1.

(e na transform).

(-f na transform).

(prime) x+n

(prime) d+n

(f-1) div 8

(f-1) mod 8

u and u+1 (to create odd x+n)

in (e,1) show (an) and (bn)

in (-f,1) show a(n-1) and b(n-1)

calc the needed movement from (e na transform) to (an) and (bn)

calc the needed movement from (-f na transform) to a(n-1) and b(n-1)

show polite numbers from (f-1) div 8 and multiply until we get a lock from rm (2d-1)

find the element in (e,1) that contains the f value which if we take SQRT(f) will give the correct x+n value

>>7354

-any cell where f equals the (x+n)(x+n) we want (like VA mentioned >>7372 here; when n=1, f=(x+n)(x+n), so even if the n we're looking for doesn't equal 1, the (x+n)(x+n) we're looking for will show up in (e,1) equal to its f value).

There exists a cell in (e,1) where a[t]=na (the n we want * the a we want). There also exists a cell in (-f,1) where a[t]=a(n-1), and this f is 2d+1 less than e. This is also true for b (so a[t]=nb in (e,1) and a[t]=b(n-1) in (-f,1)), and each of these values also exists in b[t] since a[t]=b[t-1] in the n=1 row. The an and bn values (and a(n-1) and b(n-1)) are n elements apart (the n we're looking for).

>

All whole numbers (integers) c, that give a remainder of 0,1,3 when divided by 4, are the difference of two squares.

>

Any number that leaves 2 when divided by four can either be divided OR multiplied by 2 to make it the difference of two squares.

>

The values of a in the first cell where e=1 contains ALL factors for odd numbers that are the sum of two squares.

>

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

>

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

>

For (e,n): B(e,2,t) = A(e,2,t+e)

For (e,n) with a = 1, we have:

B(e,n) = B(e+2,n+1) - 2

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

X(e,n) = X(e+2,n+1)

D(e,n) = D(e+2,n+1)

>

For all numbers in (e,1) we have:

A(e,1,t) = B(e,1,t-1)

A(e,1,t) + 1 = A(e+2,1,t)

B(e,1,t+1) = 2 * B(e,1,t) - A(e,1,t) + 4

A(e,1,t) = D(e,1,t+1)

A(e,1,t+1) = D(e,1,t) + X(e,1,t+1) = D(e,1,t) + X(e,1,t) + 2

D(e,1,t) = A(e,1,t+1) - 1

D(e,1,t) = D(e-2,1,t) + 1

In addition, for a=1, we have:

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

>

Choose any cell (e,n).

Take a look at the corresponding cell (e, a).

The a value of the 2nd cell = the n value of the 1st cell.

The 2nd cell is the "parent" of the tree.

Choose any cell p0 = (e, n, 1).

For that cell, there are 2 corresponding cells p1 = (e, a, 1) and p2 = (e, b, 1).

For p1 at some t1, you'll find a = n of p0. (I believe you'll also find b=n in that list too).

For p2 at some t2, you'll find a = n of p0. (I believe you'll also find b=n in that list too).

Example 1:

p0 = (6,11,1) ={6:11:5:4:1:31}

p1 = (6,1,3) ={6:1:15:4:11:21}

p2 = (6,31,1) ={6:31:37:26:11:125}

This pattern exists everywhere I believe for t0 = 1.

>

a[t+1]=a[t]+2x[t]+2n

x[t+1]=x[t]+2n

>

Generate the (e,1) for any c.

x = e % 2

a = (e/2)+x

n = 1

b = a + 2x + 2n

c = a*b

d = floor_sqrt(c);

t = 1

I don't know if y'all know this or not, but some cells are repeated.

Usually in cells, when the first two "x"s are added together, they equal 2n.

eg. for cell (1,17), 1 and 17 being respectively (e,n), the first two "x"s are 13 & 21.

13 + 21 = 34 = 2*17 = 2n.

But some cells, like (1,65), the first two xs are 47 & 57.

47 + 57 = 104 /= 2n.

This is because the cell is repeated. the first x should be added with the fourth x, the second with the third. Example below for cell (1,65)

x1 + x4 = 47 + 83 = 130 = 2n.

x2 + x3 = 57 + 73 = 130 = 2n.

Ns existing in row 1 are of sequenc "A020882" in oeis, notice the 65 is repeated.

https://oeis.org/A020882

>>7381

Definitely a useful contribution, but this thread is for patterns we completely understand. Read here >>6506

>Either here or a worker thread(s), discuss each rule or pattern.

>When consensus is reached, put the rule or pattern in the key thread.

So it might be more useful to discuss this in RSA general. Do you know how to predict which cells have n=2x and which ones have a slightly different pattern, and how the slightly different pattern works?

At (0,0) all the values of c are perfect squares (remainder e is always zero) and there is nothing to add to d to make the largest square. In other words in the cell at (0,0) we have all the squares with a square of size zero subtracted. It is the ONLY cell in row 0. No positive value of e has a cell in row zero.

In cell (0,1), e is zero, so all cs are perfect squares (the smaller square (x+n)(x+n) being 0). These values of c ALL appear in (0,0) but they also ALL have more than one way to arrange their factors. The factors this time produce an n value of 1. 4x4 = 16 can be arranged as 2x8 = 16, which is equal to 5x5 - 3x3. Notice that all the values of a in this cell are also each twice the value of a perfect square.

1+1 = 2

4+4 = 8

9+9 = 18

Notice that all the values of d for this cell also follow a pattern:

2x(1x2) = 4

2x(2x3) = 12

2x(3x4) = 24

All the values of d for (1,1) are identical to the values of a for (0,1). Notice also that all the values of a at (1,1) are the values of d in (0,1) with one added.

4+1 = 5

12+1 = 13

24+1 = 25

This cell (1,1) contains as values for a and b the values of two consecutive squares added together.

0+1 = 1

1+4 = 5

4+9 = 13

9+16 = 25

When two of these are multiplied together, the result is a twice a perfect square plus one as a remainder. Each value of a in cell (1,1) is also the long side of an integer right angled triangle.

Here's a full list of knowable parities based on the parities of our known variables, d and e.

-even e even d

-x – even

-a – even

-b – even

-f – odd

-c – even

-even e odd d

-x – even

-a – odd

-b – odd

-f – odd

-c – odd

-odd e even d

-x – odd

-a – odd

-b – odd

-f – even

-c – odd

-odd e odd d

-x – odd

-a – even

-b – even

-f – even

-c – even

The parity of n will be the same as BigN, which you can calculate from ((d^2+e+1)/2)-d. You can't, however, find the parity of n or N based solely on other parities. You have to calculate it based on BigN. So, for example, some odd e even d examples have odd BigNs and some have even BigNs. You also have to use calculation to find the parity of t, but this is a calculation based on unknowns, so it's a little harder than finding n's parity.

Choose a prime number that is a factor of any value of a in a cell in the first row (e,1).

In (e,1), p will be a factor of a in elements:

t+p, t+2p, t+3p,..

and

p+1-t, 2p+1-t, 3p+1-t,..

E.g. 5

E.g. (1,1)

5 appears as a factor of a in the second element (1,1,2,3,5,13) 5x13=65

5 will be a factor of the 2nd,7th,12th,17th value of a in (1,1) - t+p, t+2p, etc

5+1 is 6. 5 will be a factor of a in the (6-2) element at (1,1) - p+1-t, 2p+1-t, etc

The fourth element is 25.

Five will be a factor of the fourth, ninth, fourteenth, nineteenth element of (1,1).

This is true of any factor p in any cell in row (e,1).

The square of the c we want to factor will show up in (0,n), since this is the column where c is a square. It'll show up in the following ways:

a=1, b=c^2

a=a, b=ab^2

a=b, b=a^2b

a=a^2, b=b^2

So it'll show up four times. We can easily find the first example, where a=1 and b=c^2. If we find any of the others, we can factor c.

Something interesting about the cells in (0,n) where c=1c^2 and where c=a^2b^2 is that the difference between the x values in these cells is always divisible by 12.

>>7390

That %12==0 thing only applies to semiprimes, by the way.

((1xcc).x - (aaxbb).x) / ((1xcc).x - (axcb).x)) - 1 == (axb).a

To try to explain this notation a bit more clearly since this is copied from PMA's work in a specific context in a thread

(((x from the cell where a=1 and b=cc) - (x from the cell where a=aa and b=bb)) / ((x from the cell where a=1 and b=cc) - (x from the cell where a=a and b=bc))) - 1 = the a we're looking for

(1xcc).x - (aaxbb).x + 1 == (aaxbb).a

(x from the cell where a=1 and b=cc) - (x from the cell where a=aa and b=bb) + 1 = (a from the cell where a=aa and b=bb)

This also means that the square of any prime number minus 1 is divisible by 12.

If you take a square and look for it as a b value in (0,n), the difference in n values from record to record is equal to (2x)+(4T(x)).

e.g. 9*9=81

These are the records we will get (since there can't be opposite parity between a and b as it would create an invalid n, we will only see the square of all odd numbers below 9 in a[t]):

{0:2:63:14:49:81}

{0:8:45:20:25:81}

{0:18:27:18:9:81}

{0:32:9:8:1:81}

The difference in n values can be expressed as follows:

8 - 2 = 6, 6=2+4

18 - 8 = 10, 10=2+4+4

32 - 18 = 14, 14=2+4+4+4

This is true for the product of any pair of odd squares. So, for example, 11*11=121:

(0:2:10) = {0:2:99:18:81:121} f=-199

(0:8:15) = {0:8:77:28:49:121} f=-155

(0:18:16) = {0:18:55:30:25:121} f=-111

(0:32:13) = {0:32:33:24:9:121} f=-67

(0:50:6) = {0:50:11:10:1:121} f=-23

And another example, 13*13=169

(0:2:12) = {0:2:143:22:121:169} f=-287

(0:8:19) = {0:8:117:36:81:169} f=-235

(0:18:22) = {0:18:91:42:49:169} f=-183

(0:32:21) = {0:32:65:40:25:169} f=-131

(0:50:16) = {0:50:39:30:9:169} f=-79

(0:72:7) = {0:72:13:12:1:169} f=-27

Squares only ever appear in a and b in (0,n) where n=2, 8, 18, 32, 50, 72, etc

This pattern follows the formula n = 2+(2x)+(4T(x)), where x is the number of odd squares away in a you want to be. a begins as the highest square below the square in b (e.g. in (0,2) where b=9x9=81, a will equal 7x7=49). If you want a to be a different square, the x in that n formula is equal to the number of squares away you want to be (so if you wanted the cell where b=81 and a=3x3=9, 9 is two odd squares away from 49, so n will equal 2+(2x2)+(4T(2)), which is 2+4+12=18, which is one of the examples posted near the top of this post).

sqrt(a/2) in the (0,1, t for ccna) row is always equal to the 1xc row x+n.

x1 = x at 1 * c

xa = x at a * b

n1 = n at 1 * c

na = n at a * b

n1 - (x1^2 - xa^2) = aa * m

Where m is a odd number.

This implies that if we knew the multiple, we'd know a.

13 - (4^2 - 0)/2 = 5 * 1

69 - (11^2 - 5^5)/2 = 7 * 3

1237 - (49^2 - 19^2)/2 = 31 * 7

369 - (27^2 - 15^2)/2 = 13 * 9

>>7395

Since 1=11, the cells where a=1 and b=cc will also appear in these cells where n follows 2+2x+4T(x) (2, 8, 18, etc). The lowest possible 1cc in (0,n) is a=1 and b=3*3=9, which is at (0,2,2). t=2. As you cycle through these n values keeping a=1 and moving b up through the odd squares, t increases by 1 each time. So you find 1 and 25 in (0,8,3), you find 1 and 49 in (0,18,4), you find 1 and 81 in (0,32,5), etc.

The solution lies in (e,1), (f,1) and (0,n). He said this quite a few times.

In column zero, x is a multiple of n

The cell (1,1) contains as values for a and b the values of two consecutive squares added together.

0+1 = 1

1+4 = 5

4+9 = 13

9+16 = 25

>>7395

The n values in (0,n) where a and b are squares appear as the d values in (1,1).

Take a cell in (e,1). This holds for any cell in (e,1).

If it's even, its b values will appear as the d values in (e+1,1), and the a values from (e-1,1) will appear as its d values.

If it's odd, its a values will appear as the d values in (e+1,1), and the b values from (e-1,1) will appear as its d values.

Take a look at the picture as an example. In (3,1), the a values (2, 6, 14, 26, 42, 62, 86) are identical to the d values in (4,1), and the d values (3, 9, 19, 33, 51, 73, 99) are identical to the b values in (2,1). Likewise with (4,1), except (5,1)'s ds are its b values and (3,1)'s as are its d values.

>>7408

They also appear as the a values in (0,1) (and technically the b values but beginning from 8 rather than 2).

a from (e,1,1) = c at (2c,1,1) and (2c-1,1,1)

(3:2:2) = {3:2:6:3:3:13} f=-10

c=39, 2c=78, 2c-1=77

(77:1:1) = {77:1:40:1:39:43} f=-4

(78:1:1) = {78:1:39:0:39:41} f=-1

Any factor of any a in (e,1) will be the value of all n at (e,n)

At any (e,n,t), there will be another record at (e,n,t+n) where that record's b is equal to the original record's a, and the new x is equal to the old one plus 2n (meaning 'b=b+2(x+2n)+2n, or b'b+2x+6n (b' being the new b and the others being the numbers from the original cell)). This creates an infinite sequence where each subsequent cell is (e,n,t+n) (adding n to t each time), and where each subsequent x is the last +2n. If you want to jump from one cell to another cell some arbitrary number of jumps away within (e,n), e and n will be the same, x will be the starting x plus the number of jumps from the original multiplied by 2n, and you can calculate a from xx+e=2na and b from b=a+2x+2n, so you can calculate the whole record.

Also of note is that the f at each new cell is equal to (the new x multiplied by 4) plus the old f.

One way to find a solution is to use the grid or virtual quantum computer in the following way:

Find the cell value at (e,1) where e is the remainder for c.

You are looking for a[t] = na

Remember

At that value, d[t] = na+x

Also

At that value, x[t] = x, the x value in the cell is equal to the x value at (e,n)

REMEMBER, the value of x at na in (e,1) is the SAME as x at (e,n)

REMEMBER, take d from all values of d[t] at (e,1) and there is a known patter of (n-1) as factor in these values of d[t]-d that is different (increasingly) from the pattern of factors of n in a[t]. It is THIS that gives the offset that is used to solve the problem and thus get the cell at (e,1) to do all the work for you.

This isn't exactly a "known pattern" but it's a (very vague) set of steps with which to use the VQC to factor arbitrarily-large numbers.

>>7390

Bit of a dumb miss here but c^2 actually shows up five times in (0,n). The fifth cell is where a=c and b=c, which will appear in (0,0).

From someone's Twitter DMs with you know who:

"Root of d = {0, 2xd, 3xd, 2xd, d, 9xd}. All a and b of ( 0, 2xd, t) are multiple of d for all t.

Yes and that pattern can be used elsewhere."

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

For even n:

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

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

For odd n:

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

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

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

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

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

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

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

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

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

Every square is the sum of odd numbers.

4 = 1 + 3

9 = 1 + 3 + 5

16 = 1 + 3 + 5 + 7

25 = 1 + 3 + 5 + 7 + 9

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

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

There is a cell in (0,n) (following this >>7395 sequence of ns) where a=(x+n)(x+n) and b=(d+n)(d+n).

a*b can be represented as the sum of consecutive odd numbers where a is the number of terms and b is the midpoint:

5*29 = 145 = 25 + 27 + 29 + 31 + 33 = 145.

13*43 = 559 = 31 + 33 + 35 + 37 + 39 + 41 + 43 + 45 + 47 + 49 + 51 + 53 + 55

You can create a tree that is meant to solve the thing. We don’t completely understand the tree yet.

The tree is meant to find n or x+n (these are VQC’s words but this could also mean finding u).

The tree has three parts.

It starts with a decision-based component in part 1.

>if e is 0, return d (because c is a square in this case)

>if(GCD(e,d)!=1) return GCD(e,d)

That’s the end of part 1.

Part 2 is a tree made with numbers. The node at the top is c.

Each time you create a child node, you divide it by 2 until it’s odd.

The descendents of c in this tree are d and e.

You create further descendents by finding d and e of both d and e each time.

There is a third part to the tree that we never seemed to learn.

This part of the tree is where the grid comes in.

It’s meant to work with patterns in either row (e,1) or in a different way for column zero.

It’s meant to also have something to do with triangle numbers.

-

Just summing up the leafs (from part 2) for a completely trimmed RSA100 tree and dividing by two gets us to

40364365001756683226800431241044541563293164124405

which is pretty close to our factor

40094690950920881030683735292761468389214899724061

This doesn’t appear to be the solution though.

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

All odd squares = 1 + 8T

All odd square = 1 + the product of 8 triangles that are the same.

The following is just a straight copy/paste of a post by GA (CA at the time) from RSA #10. It got a response of "Coincidence? ;)" from VQC, and we're currently looking at math related to triangles again, so who knows, maybe it's useful.

-

Hey so I was looking into the 4,10,20 thing. Someone mentioned that these were tetrahedral numbers, which are the sums of consecutive triangular numbers. Triangular numbers are just the sums of consecutive normal numbers, which are sums of consecutive ones. So I listed the numbers, then the triangular with respect to that number (n(n+1))/2. Then I did the tetrahedral with respect to that number (n(n+1)(n+2))/2. And I got this first pic. Then I noticed the block on the top had 4,10,20, and it was mirrored across the diagonal. So I decided to extrapolate the pattern and make this excel sheet.

Basically column one is a triangle in 0 dimensions (all 1's)

column 2 is a triangle in 1 dimension (just a line)

column 3 is a triangle in 2 dimensions (actual triangle)

column 4 is a triangle in 3 dimensions (pyramid)

then, column n is a triangle in n-1 dimensions.

Let T(n,x) = triangle in nth dimension for value x

You can flip these across the axis, so if you have some n-dimensional triangle for T(n,x), then you also know that it is T(x,n). I don't know I thought this was cool because it has to do with triangles of higher dimensions. Maybe we can use this to help us.

>>7521

>>7522

Thanks for all your work, AA! :)

In (1,1), the a values all contain the factors of every odd number that is the sum of two squares. This was a VQC crumb. This is true because numbers that are odd and the sum of two squares (i.e. the a values in (1,1)) can only be divided by other numbers that are odd and the sum of two squares. Also, VQC didn't mention it, but Saga figured out that all of the values of a in (1,1) aren't just the sum of two squares, but they're also actually the sum of consecutive squares. (1,1)'s a values miss a few odd sums of squares (e.g. 17). These numbers still turn up as the factors of other odd sums of squares. These numbers turn up as factors of other numbers in the sequence in a pattern. Where they turn up, they will turn up again however big they are in steps again (i.e. 5 turns up 5 away from the first time 5 appears, and then 5 away from that, and 5 away from that, etc). They will also each turn up once between each of these times, the same distance away each time (again with 5, it turns up 2 away from the origin, then 2 away from the next origin (i.e. 5 away from the actual origin), and so on). It's a different inner gap for the other numbers, but they all only seem to have one, and they all fit the first mentioned pattern. Note that this is for the values of a in (1,1), not for the sequence of odd numbers that are the sum of two squares. So I guess that makes it a fractal, right?

>>7522

Oh yeah this had a little more to it. You could take the grid into the negatives and seed it with different values. Pic related is seeds for 1 and 2. I highlighted a sort of diagonal axis. I tried thinking of some type of mechanism to switch from the bottom right coordinates to one of the top or left coordinates, because if you do that and (for example use the function from bottom right to bottom left), then the cells are only influenced by the horizontal string of 1's, so you could theoretically change the column of 1's to anything else. Only problem is what you choose the center piece to be, a different value changes the negative sections of the graph so you have to stay positive. I'm looking at it again and I'm seeing something neat. Take a peek at these

>>7552

If you change the seed to 1 and 3, then you get this pattern, pic related and how it maps to the grid. More stretched out than with the 2 seed. Maybe we can generalize this

>>7553

Seeding 4 here and 5

Any triangle number plus the previous is the square of the longest side of the first triangle number

"The first three letters in the grid are: e,n,d

Because everything is "en"ed."

This may refer to the fact that everything is placed in the grid with e as the x axis and n as the y axis. It may also refer to something else, but this seems like the most likely explanation.

There have been a few suggestions as to the order in which we need to focus on particular things, one of which is the following:

"Breaking the problem down.

First by roots.

Then by triangular numbers."

The roots in this context would appear to be (but not necessarily be) the tree made from d and e.

There's a pattern of visual triangles that appears when you look at the triangle numbers in binary. This pattern repeats. A similar pattern appears in the binary representation of odd squares.

(e,n) = (1,1)

1, 5, 13, 25, 41,..

which are the sums of consecutive squares.

(1+0 = 1) (1+4=5) (4+9=13) (9+16=25)..

(e,n) = (2,1)

1, 3, 9, 19, 33,..

are sums of the same square plus one

1 = 0+0+1, 3 = 1+1+1, 9 = 4+4+1, 19 = 9+9+1, 33 = 16+16+1.

(3,1)

2,6,14,26,42

sum of consecutive squares plus one.

(4,1)

2,4,10,20,34,

sums of the same square plus two.

Since we're dealing with series here, I'm adding a few things regarding them.

To sum all the a's in a column, row 1:

odd e: n(e/2 + 1) + 2((n-1)n(n+1)/3)

even e: ne/2 + 2(n(n+1)(2n+1)/6)

The sum of d's in a column, row 1:

even e: n(e/2 + 1) + 2(n(n+1)(2n+1)/6)

odd e: ne/2 + 2((n-1)n(n+1)/3)

To get a partial sum, that is a sum between nth and nth + k (for some nth and k)

s1 = sum(e, k)

s2 = sum(e, nth - 1)

return s1 - s2

In row 1, the values of a[t] represent na for some c (e.g. RSA 100).

a[t+n] = nb

This is true for all c.

For the value of c, at the same t but in cell (-f,1), the value at a[t] = a(n-1) and a[t+n-1] = b(n-1)

This is the key.

The value of a[t] at -f and e in the first row have the same factor.

The values in each cell that have b as a factor are DIFFERENT, not aligned. They are one element apart in the two cells. In the positive side of the grid, they are n elements apart. In the negative side of the grid, the elements one less elements apart.

One cell has n as a factor at those positions at positive e column, one cells has n-1 as a factor in the negative f column.

This asymmetry can be used to solve the problem.

(e,1) has n as a factor

(-f,1) has (n-1) as a factor

Row (n-1)

Row n

At cell (e,n) c is an an element.

At cell (-f,n-1) c is also always an element

There is a pattern of repeating cells on each row. 2n in row n. 2(n-1) in row (n-1).

This gives additional information.

Information constrains values.

Every piece of information constrains values.

The most valuable information greatly constrains values as c increases.

Basic picture.

For all c.

c = ab = dd+e = (d+n)(d+n)-(x+n)(x+n) = aa + 2ax + 2an

Grid (p,q) where p and q are signed integers

Elements in a cell are products with notation: e:n:d:x:a:b

The first two of the notation correspond to the coordinates in the grid.

Horizontal black line (e,1), (-f,1)

Vertical black line (0,n)

Vertical grey line (-1,n)

For some SPECIFIC c = ab = dd+e = (d+n)(d+n)-(x+n)(x+n) = aa + 2ax + 2an

Dark green line : column that contains e

Dark maroon line : column that contains -f

Pinkish-purple square cell in dark green line at (e,1) contains an and bn at elements t and t+n which are elements:

e:1:(na+x):x:na:(na+2x+2)

and

e:1:(nb+x+2n):(x+2n):nb:(nb+2x+4n+2) (editor's note: this is a correction made by PMA. It was originally e:1:(nb+2x+2n):(x+2n):(nb+x+2n):(nb+3x+6n+2), then VQC changed it to e:1:(nb+2x+n):(x+2n):(nb+x+2n):(nb+3x+6n+2), and then when PMA said it was the first thing VQC replied with "Thank you").

Blue square in dark maroon line (-f,1) that contains a(n-1) and b(n-1) at t and t+n-1 elements

Orange squares in -f line and e line : squares that contain c as a product… -f:n-1:d:x:a:b and e:n:d:x:a:b respectively. THESE SQUARES ARE ONE LINE APART.

Pick any odd c and this holds for all. ALL.

From (-f,n-1) = c, the value of a,b and d increase by ONE every 2(n-1) cells, as you move from left to right in the grid.

From (e,n) = c, the value of a,b and d decrease by ONE every 2n cells, as you move from right to left in the grid.

These two rows are next to each other.

Any product of 2 primes will be divisible by 3 if you add either 2 or 4, or if you subtract 2 or 4.

Any product of 2 primes will be divisible by 5 if you…

Etc…

Remainders.

Patterns.

"Triangulation"

In (e,1), at the t where a[t] = nb, the d[t - 1] - d = b(n-1)

• Goto to cell (c, 1)

• Find the row where the x is equal to a

• Factor the a value at that record

• Result should be a*(d+n)

• Goto to cell (c, 1)

• Find the row where the x is equal to b

• Factor the a value at that record

• Result should be b*(d+n)

• Goto to cell (-c, 1)

• Find the row where the x is equal to a

• Factor the a value at that record

• Result should be a*(x+n) <- this is not perfect, but always a * a factor of (x+n)

• Goto to cell (-c, 1)

• Find the row where the x is equal to b

• Factor the a value at that record

• Result should be b*(x+n) <- this is not perfect, but always b * a factor of (x+n)

Moreso, it seems that these 4 records are the only records whereby the x value is a factor of the a value.

Because at any record d=x+a:

• at (c,1) where x = our original a

• the a value in that record = a*(d+n)

• the d value in that record = a*(d+n+1)

Then go back 1 record, so that x = a-2:

• the d value in that record = a*(d+n-1)

Therefore, there are 2 records in (c,1) next to each other, where d is divisible by the higher x value.

I believe this is only true where x is a divisor of c, so 4 times per (c,1) (1, a, b, c) for our semiprimes.

If a cell contains an element c, another element in the cell can be constructed from it.

Call it c'

e' = e

n' = n

x' = x + 2n

a' = b

d' = a' + x'

b' = a' + 2x' + 2n

Once c' is constructed, c' becomes c and the process is repeated ad infinitum. e and n don't change, which make sense since these are the coordinates of the cell.

All odd numbers are the difference of two squares.

The product of two primes, is the difference two sets of squares.

Every odd number is the difference of two consecutive squares.

The value of n for the product of 1 and c is defined now as BigN for odd numbers.

Since d-a=x and x+n is the smaller square in the difference of two squares, then for odd numbers, BigN is ((c-1)/2)-x

x is d-1, since a=1

The values of a[t] at (0,1) are twice the square numbers.

The values of d[t] at (0,1) are 4 multiples by the triangular numbers. All other cells at row 1 can be constructed from these values by adding to them or subtracting from them.

In (0,n), there is a pattern of a values in relation to squares, dependent on parity. This pattern applies to most cells. When n is even, the a values are all (n/2)each square in ascending order (e.g. in (0,6) it's 3, 12, 27, 48, 75 etc, which are 31, 34, 39, 316, 325 etc, and this n/2 applies to all even ns in (0,n)). When n is odd, the a values are all 2neach square in ascending order (so same thing as before; e.g. in (0,5) it's 10, 40, 90, 160, 250 etc, which is 101, 104, 109, 1016, 1025).

This pattern does not apply to every cell. At (0,8), the a values are one times the squares again (1, 4, 9, 16, 25 etc). At (0,9), the a values are all twice the squares (2, 8, 32, 50 etc). From (0,10) the pattern from the previous paragraph continues. At (0,16), the a values become twice the squares again. (0,17) is like in the previous paragraph. (0,18) is one times the squares. It's normal then again until (0,24), which is three times the squares (3, 12, 27, 48, 75, etc, like (0,6)). There seem to be further patterns to these special cases, but since I'm not aware of there being anything specific to use this for yet, I'll leave it for now.

• in (0, 1) we know a[t] = tt2.

• we also know how to "move" up and down (0,1) whereby t=p+t (I think thats the equation… please correct me if i'm off-by-one)

• This means that if we try to find all the a[t] that are divisible by 3, we can simply list:

t = 3, 6, 9, 12, etc.

• This means that at (0,9) for example, we'll see the x[t] values are equal to the x[t] values in (0,1) at t = 3, 6, 9, etc.

d[t] at (0,n) and its relationship to triangle numbers…

so, lets say we're at n = 15, what are the set of d[t]?

which rows are in (0,1) have 15 as a factor?

start with t = 16:

t=16: a = 450 = 21515 x = 30 = 215 d = ( 15 +1)( 15)2

t=31: a = 1800 = 421515 x = 60 = 2215 d = (215 +1)(215)2

t=46: a = 4050 = 921515 x = 90 = 3215 d = (315 +1)(315)2

t=51: a = 7200 = 1621515 x = 120 = 4215 d = (415 +1)(415)2

move to (0,15):

t= 1: a = 30 = 215 x = 30 = 215 d = 2215 *1

t= 2: a = 120 = 4215 x = 60 = 2215 d = 2215 *3

t= 3: a = 270 = 9215 x = 90 = 3215 d = 2215 *6

t= 4: a = 480 = 16215 x = 120 = 4215 d = 2215 *10

What this is all saying is, for odd n, d[t] = n4T(t)

In (f,1) where a=BigN-1, x is equal to our starting d value.

t is the order of members in a cell

In the first row where n=1, t gives a values of x that alternates between odd and even.

The value of x in e and -f will never both be even of odd since the gap between the column is always odd or 2d+1

a[t] is half the square of x plus e for the column

When e is larger than x by more than 2x+1, the value at a[t] will be found in a previous column in the first row.

For odd e, x=2t-1; even e, x=2(t-1)

a[t]=(((2t-1)(2t-1)+e)/2, (((2(t-1)2(t-1))+e)/2 for odd, even e

d[t]=a[t]+x[t]

In the rows below the first, where n>1, have you noticed that there is sometimes more than one set of products in the cell?

If there are two, both are growing by 2n added to x in that cell. The first set you can spot the same starting value of x from the value of x in the first cell at n=1. The second begins at -x until adding 2n makes it positive.

Since we're using floors of square roots, 2d doesn't equal d of 4c in every case. Here's an example:

c=145, d=12, e=1, 2d=24

4c=580, d=24, e=4, 2d=48

4c=2320, d=48, e=16, 2d=96

4c=9280, d=96, e=64, 2d=192

4c=37120, d=192, e=256, 2d=384

This is where it stops following the pattern.

4c=148480, d=385, e=255, 2d=770

4c=593920, d=770, e=1020, 2d=1540

It then also resets here too.

4c=2375680, d=1541, e=999, 2d=3082

4c=9502720, d=3082, e=3996, 2d=6164

And so on, every time e becomes greater than d.

>>7622

Forgot to mention, the take-home from this is that when e d, the difference is 1.

By multiplying c with 4 we're creating a new record and distributing the 4 (2x2) to both a and b, giving us 2a, 2b. This also gives us an even square to work with 2(x+n)^2.

Odd (x+n)^2 = 8(Tu) + 1

Even (x+n)^2 = 4(Tu + T(u-1))

We now have two triangle problems to solve. For an even square, half of the triangles is one unit longer than the other half.

Now for some insight into our equations (This is just for insight, not sure if it can be used for solving):

8Tu = 8(u*(u+1)/2) =4u(u+1) => 2(2u*(u+1)).

2u(u+1) should be something we all recognize as it's the same method we calculate a's or d's depending on parity of e (Missing + (e + 1)/2 or e/2). This should mean (I might be wrong) that we are using values from (0, 1) as the 4T(u), as in 4T(u) should appear in (0, 1) as d. Just to re-iterate T(u) is the triangle with a base of u, has the equation u(u+1)/2. But by multiplying 4 we get 4(u(u+1)/2) =2u(u+1). This should mean that our odd (x+n)^2 - 1 = 2(d[u + 1]) from (0,1).

For even squares we have the equation:

4(Tu + T(u-1)) which is also equal to 4Tu + 4T(u-1) =2u(u+1)) + 2(u)(u-1). Here we have two d's from (0, 1) with a difference of t by 1. Essentially d[u+1] + d[u].

I think this might be why VQC has said that column (0, 1) is so special. Our x+n squares, regardless of parity, can be expressed using d's from (0, 1).

(Note from AA - this isn't necessarily what VQC meant but it could well be)

When you decrease e by 1 but increase n by 1, the increase in f is equal to 2d-1.

When you increase e and n by 1, at the same t, the increase in f is equal to 2*(the increase in d)+1.

In every single case with a semiprime, (BigN-n)/(b-1) = (a-1)/2 (where a and b are the factors we're trying to find, so not BigN's a and b).

We can directly calculate the cell in (e,1) in which cbigN first appears as a[t]. In this cell, x=c-d (the c and d we already know). Another cell in (e,1) where a[t]%c==0 is where x=c+d+1. a[t]=c(c-BigN+1) in this cell. These cells are 2d+1 apart (just like the (e,n) and (f,n) cells). There are also equivalents in (f,1). In the equivalent first relevant cell in (-f,1) where x=c-d, a[t]=c(BigN-1). In the equivalent second relevant cell in (-f,1) where x=c+d+1, a[t]=c(c-BigN+2).

The difference between the x value of the cells in (0,n) where c=1c^2 and where c=a^2b^2 is always divisible by 12.

—

The u of the cell in (0,n) where a=b and b=a^2b is always divisible by the b we're looking for.

—

Take a[t] from (e, 1) and subtract from a in (e, 1). You'll get smooth numbers. Take d[t] from d in (f, 1) and you'll get smooth numbers. Smooth numbers are made from triangles and squares.

—

You can represent a given c with its e and f values, right? Well, this unique pair of e and f values in row 1 for the an and a(n-1) cells also represent valid cs themselves. These new c values are actually divisible by a or b (depending on which the e-f/f-e gap is divisible by) and they're divisible by BigN-n.

When a number is the sum of two squares and it's odd, it will only be divisible by other numbers that are also the sum of two squares and odd. So if you have a c value and it's in an e column where e is a square (because this means it's the sum of two squares, based on another crumb), its factors will be in columns where e is a square too.

Every value of a in (1,1) is the sum of two squares and is odd. VQC's crumb said that these values "contain ALL factors for odd numbers that are the sum of two squares", but they are also themselves odd numbers that are the sum of two squares.

While these a values are each odd sums of two squares, some odd sums of two squares are missing. Here's the first ten odd sums of squares: 1, 5, 13, 17, 25, 29, 37, 41, 45, 53. Here are the first ten a values in (1,1): 1, 5, 13, 25, 41, 61, 85, 113, 145, 181. So, as you can see, while a in (1,1) are all odd square sums, some of the odd square sums are missing, such as 17, 29, 37, 45 and 53.

The sequence of a values starts at 1 and increases by 4(x-1) where x is the place in the sequence. In other words, 1, +4=5, +8=13, +12=25, +16=41, etc. This follows the pattern of sums of squares that are odd in that they are all equal to a multiple of 4 plus 1.

These odd numbers that are the sum of two squares appear as factors of others in the series in a pattern. Where a number appears as a factor, it will appear as a factor again the number of numbers away that is equal to itself. If that was worded confusingly, take this example: where 5 appears as a factor, it will appear again 5 numbers in the sequence away, then 5 away again, and so on. It will also always appear once between these times. This seems to hold for all of them. For 5, it appears two away, then three away (this second one being 5 away from the origin), and this pattern repeats. When 13 appears as a factor, it appears 8 away, and then appears again 5 away, and so on. Where 17 appears as a factor, it appears 4 away, and then appears again 13 away, and so on. For 25, it's 18 and 7. For 29, it's 12 and 17. This seems to hold for all numbers that are odd and the sum of two squares.

In summary, the crumb "the values of a in the first cell where e=1 contains ALL factors for odd numbers that are the sum of two squares" is true because all of these a values are themselves odd numbers that are the sum of two squares, and because every number that is odd and the sum of two squares can only be divided by other numbers that are odd and the sum of two squares. I'm not sure if every c value in the columns where e is a square are the sum of two squares, but every c value that is the sum of two squares does appear in these columns. If you have a c value that is the sum of two squares, it will appear as an a value in (1,1) and its factors will appear in (1,1).

Aside from a 16 page word document I need to go through and turn into digestible stuff, I've gone through every post in every thread. I've accepted the fact that none of you are going to help me with this at this point, so once I've gone through that word document (most of it is triangles I'm pretty sure), I'll sort/enumerate all of these into groups based on the things VQC was talking about (all cells in a row, all cells in a column, etc).

>>7630

Hello AA! Thanks for your work. I have time and energy to help. I'll begin by studying everything you've posted here in Grid Patterns.

This is where you'll find the lookup.

Patterns.

Including fractal patterns.

Including the gaps between the square remainders, 3,5,7,.., columns.

The key is how many squares make up the remainder.

Use this to your advantage.

>>7639

Have you read through and checked the thread at all? I still have to make the triangle stuff more digestible before I post it but other than that I'm pretty sure I've gone through everything. Is there anything major I've missed other than that?

>>7581

If e is even, the a values in (e,1) are equal to sums of the same square plus e/2. If e is odd, the a values in (e,1) are equal to the sum of consecutive squares plus (e-1)/2. You find na, nb and cN in (e,1), which means each of these shares the same property based on these rules.

If e is even and f is odd, the t values in the prime solution cell, the an cell in (e,1) and the a(n-1) cell in (f,1) are all equal. If e is odd and f is even, the t values in the prime solution cell and the an cell in (e,1) are equal, and the a(n-1) cell in (f,1) has a t value one greater.

>>7647

These rules carry over into (f,1). The fact that 2d+1 is odd (and is the gap between (e,1) and (f,1) obviously) means that an will fit either the odd or the even rule and a(n-1) will fit the other (but with f/2 or (f-1)/2 instead of e). If an is equal to twice a square plus e/2, a(n-1) will be equal to two consecutive squares plus (f-1)/2, and vice versa (vice versa with the correct rules I mean).

Also, there are rules to the squares as well. (fyi, I’m using e to describe both e and f. f being added to something is akin to |f| being taken away, since f is negative) In odd e (e,1) cells, the a values are 0+1+(e-1)/2, 1+4+(e-1)/2, 4+9+(e-1)/2, etc, from t=1, t=2, t=3. In even e (e,1) cells, the a values are 0+0+(e/2), 1+1+(e/2), 4+4+(e/2), etc, from t=1, t=2, t=3. So when e is odd, the a values are equal to (t-1)(t-1)+(tt)+(e-1)/2, and when e is even, the a values are equal to 2(t-1)(t-1) + (e/2). This explains why (e,1) has t values starting from 1 while (f,1) has gradually increasing minimum t values. The a value at t=1 in e will be 0 plus something positive. After e=0, it’ll always have a value. The a value at t=1 in f will be 0 plus something negative. The negative value being added will gradually increase as f increases, and as it becomes bigger than each of the squares, it’ll increase the first t value at which there’s a valid (positive) a.

an, bn, BigN, c*BigN and c(c-BigN+1) all appear in (e,1). If e is even, each of these values minus e/2 will be twice a square. If e is odd, each of these values minus (e-1)/2 will be equal to two consecutive squares added together. In all cases, they’ll be different squares, but these squares will all be based around their t values. a(n-1), b(n-1), BigN-1, c(BigN-1) and c(c-BigN+2) are all in (f,1). Same rules.

(x+n) = (b-a)/2. You can rearrange this with algebra to show that the (x+n) from the cell where a=1 and b=b minus the (x+n) from the cell where a=1 and b=a is equal to the (x+n) from the cell we're looking for (since these (x+n) values are equal to (a-1)/2 and (b-1)/2 respectively).

Polite numbers are numbers that can be expressed as the sum of consecutive integers.

The set of impolite numbers are numbers that cannot.

The impolite numbers are the powers of 2.

The number of ways you can define a given polite number as a sum of consecutive numbers is equal to the number of odd factors (including 1 and itself).

Triangle numbers are obviously a subset of the polite numbers (whereby the sequence starts at 1), and a square is the sum of 2 consecutive triangle numbers.

An odd square is the 8 triangles + 1.

An even square can be reduced by dividing by 4.

Therefore the problem can be reduced down to differences of triangle numbers where one triangle is off by 1, and this difference of triangles can be expressed as polite numbers…

If you have a particular an in (e,1), there will be another cell in (0,1) or in (1,1) with the same t value. a from these cells and f from our semiprime have a relationship with a(n-1).

If e is odd, you find the cell in (0,1) with the same t as the (e,1) cell. That (0,1) cell’s a minus (f/2) is equal to a(n-1).

If e is even, you do the same thing, but with (1,1) and with (f+1)/2.

Apparently there's a useful values in the cell in (e,1) where x=f or f-1. VQC didn't say which value though. Also it appears that it doesn't make sense to say where x=f based on parities, but he said it, so I'm putting it here.

The VQC is a lookup table, and there's meant to be a "lookup x" for our given c that "gives you na or (n-1)". There's some x value somewhere in the grid that can applied to c in some way to give us na or n-1. Since there are two possibilities, it's probably based on e and f parities, given all of the patterns based around e and f parities. Also, since the x value in (e,1) where a[t] = na will always be equal to the x value in the prime solution record, finding that x value would bypass (e,1) and na completely, since we wouldn't need to factor na to know what a and b are (since we'd have the prime solution record). So this x value is most likely not the x value from the (e,1) record where a[t] = na.

In regards to the frequency of repeating A[t] values and B[t] values in (e,1), (-f,1) and other cells with same c but different d. Look at the following records images. Pay attention to the block on the right. The center dot is (e,1,t) for whatever record we have at the moment with the same x or t. Column to the left would be -f, then the next would be for d=d+2, etc. Then if you go to the right each column is d=d-1. Going down you have higher t values, and going vertical up you have lower t values. If there is a red dot that means it shares a as factor of A[t], green dot means it shares b as factor of A[t] and cyan is c as factor. Notice that for any entry in with the t=t+n shift, the location of that c row (which is origianlly the cyan one going down to the right) turns into a B line for the next record at t+n, then it is always a B line for the rest of those records.

For e=0 you can get to all records where a and b are a multiple of n just by starting at (0, n, 1) and jumping by t = t + n. First image is using c6107's d value of 78 to get to (0, 78, 1), and then jumping.

Somehow this works for 2d as well, where jumping by t+78 from (0, 156, 1), the a and b values are still always divisible by 78. Next level up you could use 156 * 2 = 312 and go to (0, 312, 1+312), and a and b is always divisible by 156.

This diagonal movement increases c 4 times for each step, and has some really interesting patterns in the generated records.

Divide e by 4

The remainder tells you whether (x+n) is odd or even.

0,1 = even

2,3 = odd

From the grid, it can be seen that columns follow a pattern mod 4. 0,1,2,3;0,1,2,3;..

(x+n): even,even,odd,odd;..

This pattern in respect of the difference of two squares where c is odd.

The factor tree is used to factor d and e.

Factoring these (and down the tree) allow for the factoring of c.

—

The tree solution finds x+n or x. If we know x+n is odd and are to construct x+n from triangles, then that must mean if we know x+n is even we are to construct x (I don't know if this last point is necessarily true. It was Jan's speculation. VQC has said "it does this or this" in relation to other things before and it's turned out to only make sense with one of them (like the cell in (e,1) in which x=f-1). Thought I'd post it here anyway in case I missed another justification).

—

You can create any negative x 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 )

—

While an will be divisible by a and n and bn will be divisible by b and n, cN will be divisible by a, b, c and N.

—

Between the starting prime solution cell and the a[t]=na cell in (e,1), the difference between the a value from the first to the second is a(n-1). This is obvious since na-a = (n-1)a. To add to this, though, the difference between the d values in these cells is also a(n-1).

Every cell in (0,n) produces a square c, since e=0. That means when a is a square b also has to be a square, so that c becomes (ab)(ab), rather than (ab)(asomethingelse).

In (0,n) where a and b are both squares, n is equal to twice the sequence of squares from 1^2 up. 2 (12), 8 (42), 18 (92), 32 (162), 50 (252), 72 (362), 98 (49*2), etc. This pattern is meant to be related to (e,1) somehow.

c^2 appears in (0,n) where a and b are equal to a and abb, aa and bb, ab and ab, b and abb, and 1 and cc.

In (0,n), where x=2c and n=2a, a=b*c.

In (0,n), if you set x=2c (and therefore with semiprimes t=c+1), each valid n value is divisible by either a or b (or both).

Where a=cc in (0,n):

>n follows that sequence of numbers (twice the squares). For simplicity's sake in the rest of the variables, I'll make a new variable r which is equal to sqrt(n/2). This is just going to be 1, 2, 3, 4, 5, 6, 7 etc throughout the sequence.

>b is equal to (c+2r)(c+2r)

>t is equal to (originalc*r)+1

>d is equal to c*(c+2r)

>x is equal to originalc*2r

>a is obviously going to be originalc*originalc the whole time not changing

The square at (0,1) is the basis of the patterns of all cells on row one.

D[t] - d = a(n-1)

D[t-1] - d = b(n-1)

Long story short with the algebra, and only for odd e (there’ll be a slightly different formula somewhere for even e), D[t] - d = a(n-1) could also be expressed as (4t^2 - f)/2 = a(n-1).

The values for D[t]-d are equal to 4 times the triangular numbers.

If we go to the record where (D[t]-d) is NOT divisible by (n-1) but where A[t] IS divisible by n, then the GCD of D[t]-d and A[t] is equal to a. Also, the X value for that record is equal to the correct D value for the record in this column that has the correct X value for the final record.

The formula for triangle numbers is (n(n+1))/2. That means n(n+1) is a triangle number multiplied by two.

If we multiply an by a(n-1) we get aan(n-1), which is a square (aa; no pun intended) multiplied by two times a triangle number (n(n+1) can be turned into n(n-1) by making n=n-1, since n+1 becomes n and n becomes n-1).

A square with 1 row or 1 column removed is 2 equal triangles of (n-1) each.

Any number of the form n(n-1) or multiple of it, has distinguishing properties and can be pick out of a crowd, especially and more easily if the multiple of n(n-1) is a square. (This is a VQC quote. I don't think we actually ever figured out what those properties were). Multiply each entry a[t] at (e,1) by the corresponding entry at (-f,1). These pairs form a series of products. Prime numbers will appear to be special. (More VQC quotes that we don't necessarily understand yet)

If you define n-1 as k, then n(n-1) becomes k(k+1) or twice a triangular number.

So, you're looking for when a series becomes two triangles where every unit of the triangle is a square.

There is a known shortcut to do this between two limiting numbers or range. (Again, don't think we figured out that "known" shortcut)

Importantly, the search is now a calculation with a known shortcut that is at most O(log t). Think about the values in 0,1 and 0,1. (direct quote; not sure if he meant two different cells and this is a typo, or he was being deliberately obtuse again)

Everything that has been discussed points at this solution.

Euler? Euler? (Mispronounced)

One interesting thing about these a.a.n.(n-1) numbers:

• if you add a.a.n, you'll get a perfect square

• if you minus a.a.(n-1), you'll get a perfect square too

In cell (0,1) the d values (also the a values in (0,0)) are these:

4, 12, 24, 40, 60, 84, 112, 144

Ignore 4 and 12 for now they're special.

24=2(34)

40=2(45)

60=2(56)

84=2(67)

112=2(78)

144=2(89)

Remember how also if you multiply any cell in column zero by a constant it is the same cell in another row

2 * (0,1,12,4,8,18) = (0,2,24,8,16,36)

So this would be a way to get any factor where the factor is divisible by 2.

So I thought about the values in (0,1)

If we think about these in 0,1 (binary) (double meaning) then we can just bit shift all these numbers over by one (or just divide by two for you newbies) and get every entry higher than 6.

So now we know that n(n-1)a*a MUST exist in column 0

Another related thing to note (pic related), the a values in (-1,2) are equal to 12, 23, 34, 45, 56, 67, 7*8 etc. So our n(n-1) will always appear as an a (and technically also a b) in (-1,2).

Since we can multiply and a[t] in (0, 1) with any number and it will exist in some row, we can multiply our a[t] = (n(n-1) * n(n-1) * a * a)/2 with 2 and it will occur in (0, 2) as a[t] = 2 * (n(n-1) * n(n-1) * a * a) / 2.

In (0, 3) it is a[t] = 3 * n(n-1) * n(n-1) * a * a / 2

In (0, 4) a[t] = 4 * n(n-1) * n(n-1) * a * a / 2 etc.

And again in (0, 5), (0, 6) etc.. It should exist in every single row in column 0.

c is the difference of two squares.

These two squares are (d+n)(d+n) and (x+n)(x+n), the latter being the smaller square. You can visualize c as an L-shape surrounding the smaller x+n square, like in the first picture.

If we found (d+n)(d+n) or (x+n)(x+n), we'd be able to factor c.

Odd squares are equal to eight times a triangle number plus one (8T(u) + 1). Even squares are equal to four times a triangle number plus four times the previous triangle number (4(T(u)+T(u-1)). This is shown in the second picture. If we represent either (d+n)(d+n) or (x+n)(x+n) as squares made of triangles like this, and if we can find the base of these triangles, we can factor c. As stated >>7656 (You) here, we can find the parity of x+n based on e%4. We then therefore know the parity of (d+n)(d+n), since we know the parity of c, and odd-odd=even, even-odd=odd, odd-even=odd, even-even=even. This means we always know whether (x+n)(x+n) and (d+n)(d+n) are 8T(u)+1 or 4(T(u)+T(u-1)). That means we know what configuration of triangles they are.

We can use algebra to rearrange (x+n)(x+n) as nn + 2d(n-1) + f - 1. This means nn + 2d(n-1) + f - 1 can also be represented as either 8T(u) or 4(T(u)+T(u-1)). If we take odd (x+n)(x+n) squares as an example, which can be represented as eight times a triangle number plus one, this makes nn + 2d(n-1) + f - 2 eight times a triangle number. That makes (nn + 2d(n-1) + f - 2)/8 or nn/8 + (2d(n-1))/8 + (f-2)/8 a triangle number.

There are four different kinds of (x+n)(x+n) square, based on parity. There are odd (x+n)(x+n) squares where either x is odd and n is even or where x is even and n is odd. There are also even (x+n)(x+n) squares where both x and n are odd or where both x and n are even.

Let's apply this to the idea of representing nn + 2d(n-1) + f - 1 as eight triangles plus one. nn is also a square. This means it can be represented based on a configuration of triangle numbers. If nn is odd, it will also be eight triangles plus one. If we take nn-1, it will be eight triangles. Since nn-1 + 2d(n-1) + f - 1 is eight triangles (the -2 distributed so that nn-1, eight triangles, is also formed), we can represent (x+n)(x+n) as eight smaller triangles within eight larger triangles, with an extra unit in the middle. This picture is an example, where n=5, nn=25, nn-1=24, and (nn-1)/8=3, which is the second triangle number (1+2). The larger triangles made up of (nn+2d(n-1)+f-2)/8 are each 21, the 6th triangle number (1+2+3+4+5+6). (x+n)(x+n) in this case is 169, and x+n is 13. 169 is equal to 21*8 +1. n is equal to 5, so x is equal to 8. If you expand (x+n)(x+n) you get xx+nn+2xn, so this picture shows nn in red (including the black square) and xx+2xn (or 2d(n-1)+f-1) around the outside. For x+n=13, x=8 and n=5 is not the only valid pair of values. You could have x anywhere from 1 to 12 and n anywhere from 1 to 12 (as long as they add to 13). Speaking of which, to clarify, x is only ever 0 in (0,0), where n is also 0, so there will never be an x+n square here (at least one we can use, i.e. that isn't 0), and n is only ever 0 here and in the negative space, and we use the positive space to represent the squares and triangles, so this is irrelevant. So that's where 1-(x+n-1) comes from in this sense.

The remainder when you take nn/8 away from (x+n)(x+n)/8 in this picture is called a polite number. This is a number produced as the sum of consecutive integers. In this case, each of these is equal to 3+4+5+6, which is 18. So odd (x+n)(x+n) with an odd nn can be represented as eight times a triangle number plus eight times a polite number plus one.

I forgot to mention that based on that algebra that shows (x+n)(x+n)=nn+2d(n-1)+f-1, the f in this case is the absolute value. So while f is usually negative, in this case, we're taking the positive version.

>>7681

Hopefully it isn't confusing but I'll be changing my (x+n)(x+n) example because this wasn't a good one for the next stuff I'm going to talk about. I'll be using (2,11,5) = {2:11:11:8:3:41}, f=-21, c=123 for at least this particular post.

So since we can represent this specific kind of (x+n)(x+n) square as eight triangles (containing eight smaller (nn-1)/8 triangles and with an extra unit in the middle), we can also break down the remaining area of the square in terms of 2d(n-1) and f-1, which are the remaining parts of the equation. Let's start with f-1. Unlike the squares we've been dealing with so far, this is not necessarily going to be divisible by 8. 2d(n-1)+f-1 will be divisible by 8, but 2d(n-1) and f-1 by themselves won't necessarily be divisible by 8. So if we were to visually divide f-1 up into eight parts and distribute them among the triangles, some of the triangles would get an extra unit. Whatever (f-1)%8 is determines how many of these triangles will have this extra unit. In this case, f is equal to 21. 20/8 is 2.5, or 2 with a remainder of 4. This means four of the triangles will have 2 units from f and four will have 3 units from f (as shown in the second image; f is blue). What is left over (green) is 2d(n-1), which is also distributed unevenly among the eight triangles.

As above, 2d(n-1)+f-1 will be divisible by 8. If (f-1)/8 gives a remainder of 4, as it did above, (2d(n-1))/8 will need to also give a remainder of 4 in order to produce a number with f-1 that is divisible by 8. If (f-1)/8 had a remainder of 3, (2d(n-1))/8 would need to have a remainder of 5. We know f and d, but we don't know n-1. Because we know that 2d(n-1)+f-1 needs to be divisible by 8, the remainder of (f-1)/8 restricts the possible values of n-1 that we could have with each valid pair of f and d values.

So with the above example, pretending we don't know what n-1 is, we have f=21 and d=11. (21-1)/8=2r4. This means whatever we multiply 11*2=22 by (i.e. n-1) needs to also have a remainder of 4 when divided by 8. So what values are valid in this case? Well, 0/8=0, so it can't be n-1=0, and 22/8=2r6, so it can't be n-1=1. Here's a list to demonstrate:

n-1=2, 44/8=5r4 — n-1=2 is valid for this d and f pair

n-1=3, 66/8=8r2 — invalid

n-1=4, 88/8=11r0 — invalid

n-1=5, 110/8=13r6 — invalid

n-1=6, 132/8=16r4 — n-1=6 is valid for this d and f pair

n-1=7, 154/8=19r2 — invalid

n-1=8, 176/8=22r0 — invalid

n-1=9, 198/8=24r6 — invalid

n-1=10, 220/8=27r4 — n-1=10 is valid for this d and f pair

…

n-1=60, 1100/8=170r4 — n-1=60 is valid for this d and f pair

As you can see, the possible values of n-1 are restricted by the remainder of (f-1)/8. Because n=((a+b)/2)-d, and d is the floor of the square root of c, the highest possible n value (when a=1 and b=c) is ((c+1)/2)-d. So while n-1=60 (and so on in that pattern) would be a valid n-1 value based on the remainders, the highest possible n-1 we could have in this case (also called BigN-1) is equal to 50. So the list of valid potential n-1s (based on remainders, not actually all the correct ns) for this c is 2, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46 and 50. The only correct ones in this list (since c is a semiprime and n will be calculated from ((a+b)/2)-d where a and b are either the two prime factors or 1 and itself) are n-1=10 and n-1=50. We can easily find n-1=50, since it comes from n=((c+1)/2)-d. We want to find n-1=10.

>>7682

So the possible n-1 values are n-1=10 and n-1=50 for this specific semiprime c. Both of these instances will have the same f and d values but different (x+n)(x+n) squares. Here they are, for comparison. The smaller one is for ab and the bigger one is for 1c.

So how do we figure out that all of those other n-1 values are invalid? The short answer at the moment seems to be that we just plug the numbers back into the equation and it doesn't produce a valid set of variable values. I haven't found any proof, but I've done a lot of testing and it appears that whenever the test n-1 produces a valid square out of nn+2d(n-1)+f-1, it's one of the valid n values (i.e. it doesn't seem to produce a square with invalid n values coincidentally or something). So if you use semiprimes with odd x+ns and odd ns, there are only ever two n-1 values out of the possibilities calculated based on the remainder of (f-1)/8 that make the nn+2d(n-1)+f-1 equation valid/a square (so there doesn't ever seem to be any extra n values that create squares out of that equation but aren't valid for our given c). This might be wrong (purely based on there not being a logical train of thought leading to it), but it seems to be right. And then for every other c where there are more than two potential n values, there are still the same number of n values that produces squares out of this equation.

Note that all of the above and the previous posts are specifically for odd x+n with odd n.

>>7683

Which means that this theoretically works when X is even and N is odd

>>7726

Well yeah, that's the whole point of this example I was going through. >>7681

>>7681

>>7682

This is amazing work. I'm going to integrate this into my current research, may solve something.

>>7871

It's just an explanation of the triangles in the (x+n)(x+n) square that we'd already done. It's not really any different, except I used odd n even x. It also isn't finished, by the way, mostly because of time constraints at the moment. There is another reason it isn't done, though, which is explained here >>7812

The following, in regards to using f/8 as a test triangle base to calculate n0, and extensions of this idea, is based around VQC's posts in RSA #10. Just so anyone who reads this knows, as I type this out, I don't necessarily know where this math leads. All I'm doing is following the logic of each post and expanding each one to reiterate and potentially decrypt what VQC is saying. That's part of the point behind this thread (having all the information in one place). Whether or not these examples use the related concepts for the correct reasons is up for debate, since this is the part when we started getting into diagrams we never seemed to fully understand.

I'll be using the following two semiprime cells for this post:

(26,3,8) = {26:3:51:14:37:71}, f=-77, c=2627

(46,5,7) = {46:5:31:12:19:53}, f=-17, c=1007

As explained previously, you can break up odd (x+n)(x+n) squares into eight triangle numbers plus one, and you can also break them up into nn+2d(n-1)+f-1. When n is odd, nn is another square made of eight triangle numbers plus one (since this is a trait of all odd squares). So when we have odd n and even x, we can break up a square into nn-1+2d(n-1)+f (notice the -1 has moved). This is shown in the first image (the x+n squares for the above cells), and was explained several posts ago.

An idea that VQC introduced in RSA #10 was a new variable called n0 ( >>4343 ). n0 is a guess version of n. To find it, we use the division of f among the x+n square to create a guess triangle base, and we use a function he posted to figure out what n would be if this value calculated from f was the correct base (knowing that it is not going to be correct because it's just an arbitrary division of f). First I'll explain the ways in which you can use f to find a guess triangle base, and then I'll (attempt to) explain the specific things they're used for.

We've been using u as the variable name for the base of each triangle in an x+n square (8T(u)+1). In the case of both these example cells, x+n is 17, so the base u=8. Let's forget about the distribution of 2d(n-1) and nn in these triangles for now and just focus on f. f is being divided by 8 and distributed among the triangles. It won't necessarily be divisible by 8, so there will be some left over. When we divide f by 8 and place it in the triangles with the nn and 2d(n-1) portions, as in the previous diagrams and explanations, we're just filling the triangle from the top row by row. f/8 (minus the remainder) can also be expressed as a line. If we were to divide f by 8 in each of these cases and treat them as an undivided line, we could put them into each triangle as an entire row instead. This is shown in the second image. Notice how in the first example, f/8 is too big to fit in the triangles (it's on the outside of the square, in case you can't tell). There are two cases in this sense: sometimes f/8 is larger than u (this case), and sometimes f/8 is smaller than u (the second x+n square in the image). In these images, the remainders of f/8 are placed underneath. In the first case, f/8 is equal to 9r5. In the second case, f/8 is equal to 2r1. If we were to treat these as triangle bases, they would create triangles with bases of 9 and 2 (which equal 45 and 3) respectively.

>>7955

Another way in which VQC explained that we could create a guess triangle base out of f was to divide f further. In VQC's example (which is far too large to make accurate diagrams out of since it's based on RSA100) he found that f was divisible by 5. From there, instead of dividing f by 8, he divided it by 40 (85). This allowed him to create another guess base out of f/40, and to turn the way f is represented within the triangles to a polite number (which is any number that is equal to the sum of consecutive integers; for example, 3+4+5=12 is polite, 2+3+4+5+6=20 is polite, every triangle number (1+2+3+4+5+…) is polite). The guess base was placed in the diagram as the row that was the same length, and the other parts of the division were placed in the adjacent rows (if that doesn't make sense it will when you read the rest of this paragraph hopefully). We can't really divide the base of 2 in the second example further, so we'll look at this in the context of the first example x+n square, where f=77=72+5 (5 being the remainder). The factors of 72 are 1, 2, 3, 4, 6, 8, 9, 12, 18, 24, 36 and 72. So let's take 72=324 as an example. f is divisible by 3 and 8, so it's divisible by 24. 72/24=3. In the previous example, we divided 72 by 8 and put a row of 9 into each triangle. In this case, since we divided f by an extra 3, and the result of that division was 3, we're putting a polite number into the triangle with a center length of 3 which has one row either side (to create 3 rows). In other words, we're putting 9=2+3+4 into the triangles (as shown in the next image - hopefully that explains what I said might have been confusing above). VQC also mentioned that you can create a guess base by dividing f (the entire f; in this case, 77) by 8 and something else that doesn't divide it with no remainder. It would change the remainder created by f/8. There aren't any situations that work for this particular example (it's very difficult to find examples for this stuff that both meet all the criteria and aren't so big that they're impossible to create diagrams for). Think of it this way. If you had 1001/8=125r1, you could represent 125 in each triangle as 23+24+25+26+27 (dividing 125 by 5). But what if you wanted to divide 125 by 3? Then you would be dividing 1001 by 24 (3*8), which is 41r17. Here you would be inserting 20+21 into the related x+n square. Where in the pictured example we have 5 extra units dispersed unevenly throughout the triangles, with this 1001/24 example, we would have 17 extra units dispersed throughout the triangles (this still leaves only one triangle with an extra unit, which is what it had before - this isn't necessarily always the case but I don't know; we'd have to test it).

>>7955

>>7956

I'll be continuing with (26,3,8) = {26:3:51:14:37:71}, f=-77, c=2627 from the two previous posts.

VQC posted a function here >>4335 which he says you're meant to put the guess triangle base into. This function calculates what n would be if the divided f value we put into it actually happened to be the correct triangle base for our x+n. If you put the correct u into it (continuing with our example with a u of 8), it creates eight triangles out of that base and adds one (creating 8T(u)+1, which is our x+n square), then it adds c (since (d+n)(d+n)-(x+n)(x+n)=c, c+(x+n)(x+n)=(d+n)(d+n), so this step calculates (d+n)(d+n)), then it takes the square root (the correct d+n), and then it subtracts d (leaving us with n). This is shown in the first picture. As mentioned >>4343 here, when we put our guess base based on a division of f, the resulting return value is n0. Since we can divide f arbitrarily for this, if we create a new variable (we don't need to use this outside of this sentence for the sake of understanding n0), maybe w, which is the extra number you're dividing f by (if we just divide f by 8, w=1; if we divide f by 24 (8*3), w=3, and so on), then we can rearrange n0 with algebra.

u' = floor(f/8w)

n0 = (sqrt(8T(u')+1 + c)) - d

Continuing with the example cell above, we have an f of 77. If w is 1 (as explained above, this means f is being divided by 81), we get a guess base of 9. If w=2 (f/(82)), guess base = 4. If w=3 (f/(8*3)), guess base = 3. Etc. There is a range of possible guess base values for any given f, calculated from f/8 to f/f. This is shown in the second picture (with the current example cell).

>>7958

VQC then posted another function a while later >>4594 which takes the guess base, n0, d and f as parameters. For the sake of explanation, continuing with the same example cell (26,3,8) = {26:3:51:14:37:71}, f=-77, c=2627, let's set the guess base to f/8. As shown previously, this guess base is equal to 9. It creates an n0 value of 3. This function, Get_Remainder_2dnm1, uses the guess base to calculate 8T(u') (so it does the same thing that the beginning of the previous function does) and uses n0 to calculate the n0 equivalent of nn+2d(n-1)+f-1 (using the correct f and d values). It subtracts (nn+2d(n-1)+f-1) from (x+n)(x+n). So if we input the correct u base and n values, it will return 0. If, however, we input each pair of potential guess base and n0 values, we won't necessarily get a gap between 8T(u) and nn+2d(n-1)+f-1 of 0. Using the same example as we've been looking at for this stuff, pic related is the output with every potential pair of guess bases and n0s. You'll notice none of the remainders is equal to 0. If any of them was equal to 0, we would have the correct square. We're not going to unless n is a factor of f and we happen to stumble upon an n0 value that equals our n value (which hasn't happened once throughout my testing, so I don't think it's probably something that can happen).

After going through these functions, VQC didn't really seem to say much else about this process. He went on to discuss other things that I'll cover eventually. It's not all stuff I entirely understand, but I didn't understand the relationship between the guess base and n0 until I went through this for the sake of this thread, so I'm sure by the time I post about it I'll understand it enough to not waste everyone's time with something that isn't true. Either way, my point here is that this is a process that is meant to be important, but it hasn't been completely explained. I have been going through RSA #10 for the past few hours to attempt to shed some light on it but it's quite a bit past midnight now.

Another way to visualize the (x+n)(x+n) square, this time in relation to (d+n)(d+n), is to look at it as analogous to an L shape on a square of d sides which incorporates the remainder e and the gap made by f between dd and (d+1)(d+1) in the L shape. This is shown in the attached diagrams. According to VQC, "the colours in the MAP will be the KEY to GUIDE you through the process of how the algorithm works", but nobody seems to have been able to figure out whatever that was supposed to mean.

For odd (x+n)(x+n), there is a finite set of cells where n!=1, and an infinite set where n==1.

——-

Since the d-value increase when you move right starting from (0, 1) to (2, 1) by one and (1, 1) to (3, 1) we can simply remove e/2 (for even e) and (e - 1)/2 for odd e from d. That should allow us to use the D[t] in (0, 1) or (1, 1) since the difference in d from (0, 1) to (e, 1) (for even e) is e/2 and the difference in d from (1, 1) to (e, 1) (for odd e) is (e - 1)/2.

——-

If a cell has values at (e,n) then there will be values in a cell at (e+2n,n). This is how you get the horizontal pattern of grid cells.

One thing VQC has brought up several times is this question: "Why are there gaps?". A simple answer to this question is that in these places, the pair of e and n values is not valid. A more complicated way to look at it is to take a look at individual patterns.

Horizontally, starting from both (0,n) and (-1,n), there will be a cell 2n to the right. So for example where n=5, there's a cell at (0,5), (10,5), (15,5), etc, and at (-1,5), (4,5), (9,5), etc. The thing about this pattern is that it can have multiple starting places. So also where n=5, it seems to start from (-1,5), (0,5) and (1,5). That's why when you go 5 cells across in this row, there are always groups of three. Where n=1, the starting places are only (-1,1) and (0,1), and they move 2n (which is just 2) across, so this is why row 1 has no gaps. The starting places seem a little weird to predict, though. Columns (-1,n) and (0,n) are always starting places, but some cells have extras in weird places. Where n=3, for example, (-1,3) and (0,3) are valid, but so are (2,3) and (3,3).

——-

c from (e,n,t) = a at (2c,1,1) and (2c-1,1.1)

The following posts are a collection of all of the hints that I personally didn’t understand or that nobody seemed to work on or find the significance behind. Since this thread is meant to be a place to collect all relevant material once it is understood, even though the following information isn’t understood or its point hasn’t necessarily been discovered (at least I didn’t see anything), it seems like a good idea to me to at least have any loose ends in the same place, just segregated off between some red text line breaks.

—————————————————————————

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.

—————————————————————————

The solution to this problem introduces a new form of algebra where two concurrent forms of equations run side by side and then merge.

The two sets of equations take the problem and simplify it. Together they handle the "lock and key" nature of the problem/solution, particularly when c is divisible by 1, c, and two other prime numbers, such as in RSA.

The two forms of equations that merge together handle staircase numbers where the base of one staircase, is one unit longer than the other.

—————————————————————————

The remainder of f when divided by 8 is a key to what values of d and (n-1) can be used.

Essentially, as I was showing with RSA100, you take a stab at the number by creating a triangle base out of f div 8. The remainder (f mod 8) is divided among the eight triangles. This restricts the multiples of 2d that can be used because they must always be in a number that supplies the gap in f and satisfy another property. That property can be broken down.

It is easier to break down the less factors there are as there are less solutions.

The answer is easier to come to the more factors there are as there are more solutions.

Starting with the smallest odd squares.

(x+n) = 1,3,5,..,

For each odd square what are the permutations of possible values of f,d and (n-1)?

What are the patterns?

What do these look like?

—————————————————————————

If you colo(u)r the values of f in the grids that show the triangles, patterns will be added, ESPECIALLY if you divide f up into 8. The remainder of f when divided by 8 is a key to what values of d and (n-1) can be used.

Playing with these patterns will organically lead you exactly where we will be going.

—————————————————————————

>>7982

—————————————————————————

Using an arbitrary divisor for f, then each of the eight triangles will have one OR one of two (the latter when c is large and the product of two different prime numbers) configurations in each triangle. The difference between those two configurations of a portion of f are that they are both staircase numbers where the base of one is a unit longer than the other. E.g. (3,4,5) and (4,5,6)

This will REALLY help if you visualise the smaller (x+n) squares and throw in a few much larger (x+n) squares. Focus on the patterns in the way f is distributed in each of the 8 triangles. Look at symmetries and how to construct the triangles when you know you need the two different portion sizes of f. This affects the values of 2d(n-1). There is a pattern to these that matches the grid which is why later you'll look back at the grid (The End) and understand all the puns and analogies of using that term.

If you draw out some odd (x+n) squares, relate them graphically side by side with the grid and see any patterns that f make and each 8 triangle, especially if portions of f are outside the (n-1) square in the middle.

(in regards to (f-1)/8) To clear this up slightly, the base of a triangle WITHIN the triangle.

—————————————————————————

What happens when you compare the -f and e columns in the grid for 4c? The square for x+n has now sides of 2(x+n) compared to c.

—————————————————————————

As stated at the start, the square root of (D)avid and what remains are the key to unsealing the The End, the grid.

—————————————————————————

When does c first appear at a[t]?

When is the second time it appears?

When is the first time a squared appears?

What is the factor it is multiplied by?

What is the first time b squared appears?

The second?

When a appears as "an" it appears another time.

When does n first appear?

What are the rules?

In column -f too?

Any one of these patterns well understood between -f and e is the step you are looking for.

—————————————————————————

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

Cell (1,1) is a mirror, what about cells to the right?

What additional information does this show?

What pattern does this show?

How about negative x in cells below (e,1)?

—————————————————————————

Here are two points made by VQC that aren’t exactly patterns but are useful to think about in the broad scope of the problem:

(in regards to things being “key”) I have found three, not including yours. Those three are in row 1, column zero and the side by side diagonal cells from the origin. There may be infinite keys.

If there are more than two prime factors, d and e are the same, you can just find the largest two first, one will just be the product of further primes, divide and go again.

I'm pretty sure that's everything. I most likely missed something, since I've been doing this alone. If at any point in the future someone notices that I've missed an entire concept or something small, let me know. Otherwise, from here, I'll eventually go through and organize all of this information into relevant categories. As stated by VQC >>6506

>Patterns that apply to all c in the grid.

>Patterns that apply to all cells in a row.

>Patterns that apply to all cells in a column.

>Special rows.

>Special columns.

Categories. So I'll go through everything and organize it as best I can.

Patterns.

Think of the following.

Each cell at n=1 contains every factor for every possible product with remainder e or -f.

What is the order in which they appear? 1,1 is the single most important cell in the grid.

The answer or solution to the lookup is in this thread.

>>7984

This.

>>7985

Don't give up AA.

The value at -f,n-1 and e,n have the same a,b but d,n, and x are different by 1.

There is a way to use this to create the lookup.

>>8264

Alright, here's c145 with all basic elements shown for use in exploring this last post. I've included (-f na) (e na) (-f prime) (e prime) (-f Big N-1) and (e Big N) elements.

>>8274

>>8264

Found something interesting studying the Grid:

For c145, the (e,1) d value is 12

The (-f) d value is 13

13^2 - 12^2 = 25 = (an)

Don't know if it works for other c values yet.

knowing that d is always one unit bigger in -f, you could make the hypothesis that (d+1)^2 - d^2 = (an)

I'll run some more c values to check if this in yet another c145 fluke.

>>7428

Can you elaborate more on this?

>>8281

Someone had a Twitter conversation with VQC back when he had a Twitter account, and everything between quotation marks was in one of VQC's messages. After whoever was having that Twitter conversation with him posted that, no mention of the root of d came up until a few months later, when VQC mentioned "the root of d" being important (he was very ambiguous, as always). We all thought that meant sqrt(d) for a while (for all we know it actually does), and then we thought it was sqrt(2d) since that was mentioned in a code comment he posted, until I was putting this thread together and I found that root of d (0,n) cell that everyone had forgotten about. 3DAnon found some interesting patterns relevant to this cell here >>7446 but we still have no idea what to do with it.

>>8284

I don't know if it was that far back. It was certainly a long time ago. So is that a hint that you wanted to talk on Discord or was it just a pun? Topol was doing that the other day so now I just automatically assume.

Hello AA! Here's a Pattern I'm working on to factor the odd (x+n) square, using (x+n)^2 -1 to get 4 rectangles or 8 triangles.

For c6107, interesting that our u1 and u2 values are 41 and 42, since our f derived polite numbers = 3+4=7

The total x+n dimensions are 83 * 83 = 6889.

4 rectangles of 41 * 42 +1 = 6889

It’s the (n-1) pattern playing out at 2 levels simultaneously.

Maybe a fluke, just brainstorming over here.

c6107 f= 134

f div 8 = 16

Sqrt(16) = 4

Sqrt(16)- 1 = 3

4+3=7. These are our two polite triangle number bases added together.

7 * unknown + 1 = correct (x+n)^2

For this example it turns out to be 984.

The factor will scale with c, since it's derived from f.

This should be blazing fast at computer calc speed! Since the two polite triangle bases come from f, it should scale upwards with increasing c values.

All we have to do is check each iteration to see if it's a perfect square.

This is the two equations merging together or running alongside each other. (i think)

Equation 1 is: SQRT(c + (x+n)^2) - d = n

Equation 2 is: f factor * iteration + 1 = a perfect square? If not, don't run it through equation 1.

This was why VQC told us we would be estimating n0 when we used the (f-1) div 8 method. We’re looking for a way to use f to construct (x+n)^2

This is one of the ways to do it. There are multiple correct methods.

I’m just working on the one that I understand the most.

Can we try it out on the RSA100 Numbers we have all the solutions for?

Essentially I'm postulating that (x+n)^2 is a multiple of f or one of its roots, so a big difference from just (x+n).

The factor derived from f * iteration forms / fills the area of the square.

Odd (x+n) formula is f * unknown + 1 = (x+n)^2

Even (x+n) formula is f * unknown = (x+n)^2 (possible)

Hello AA. Here's another pattern for c6107, this time looking for the grid shortcut:

I noticed that the Polite Triangle Bases for c6107 = 7 and (n-1) = 35 = 7 * 5.

Is this just a fluke?

For c145, PTB = 1+0=1 and (n-1) = 4 = 1 * 4

"A few more iterations and you have the Grid related short cut!!!"

Let's run a few other c values a bit larger and see if the PTB's are factors of (n-1)

>>8444

Did you have a look at the code I posted on Discord? All you'd have to do is add one line of code and you could test for the factors of n-1. I don't know if it really counts having 1 as a factor so maybe 145 wasn't the best example.

Also shouldn't this be in RSA general? I suppose you must have posted this here because it was likely to get my attention?

>>8445

Hello AA. I think this pattern belongs here, since it was mentioned extensively by VQC.

>>6185

>>5690

>The two forms of equations that merge together handle staircase numbers where the base of one staircase, is one unit longer than the other.

>>8446

Right, but if it isn't necessarily what he meant, and we need to study the thing and figure out if it is what he meant and if so what specific patterns are in play, shouldn't we do that in RSA general? This thread is for things we understand. and can explain. So far I don't even completely understand where you're going with this (since before you were looking at the triangle bases being a factor of (x+n)(x+n), and now it's n-1).

>>6639

True, I'd like to think that the first few pics are 'easy' to factor, a start of a pattern, we need to find a single point without having to find all the other ones by iteration.

sqrt(d) is between the mirrors of the elements that d is between in (e, 1)?

>>9071

What is a mirror element?

>>9081

getElement(-f, 1, getT(x[t]+1))

Where c is the product of two primes:

c % (N-1) = 2d+1

>>9121

That should be 2d-1. It also appears to be the case for all numbers regardless of the number of factors.

If n is too small, the large square appears as an exact value of i[t] in e or -f

That is what the algorithm from earlier is showing, it can be extended.

>>9124

What does "too small" mean? The point of this thread is to get all the patterns we completely understand in one place, so you'll need to figure specifically what types of n values this works for and specifically what elements they appear in in (e,1) and (f,1).

>>9125

public VQCElement getElementBelowRoot(BigInteger e, BigInteger n, BigInteger d) { BigInteger c = d.multiply(d).add(e); BigInteger f = (d.add(n)).pow(2).subtract(c); BigInteger xpn = sqrt(f); BigInteger x = xpn.subtract(n); boolean eIsEven = isEven(e); boolean xIsEven = isEven(x); if (!(eIsEven == xIsEven)) { x = x.subtract(one); } return getElement(e, n, getT(e, x)); }

>>9126

If we input -f, 1, d into this method, calculates

c = d^2 + f

(d+1)^2 - c = e

xpn = sqrt(e)

x = xpn - 1

So in this way, taking sqrt(e) and sqrt(f) give us the elements that d is between.

>>9127

That's interesting, do you know what happens if you multiply d by two?

>>9128

No, what happens?

>>9127

I was wrong about half of my observation. sqrt(f) gives you where d is between in (e,1), but sqrt(2f + e) is what gives you where d is in (-f, 1)

I misinterpreted an addition operation for a subtraction operation in my program. What it for -f is this:

c' = d^2 - f

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

xpn = sqrt('f)

x = xpn - 1

I noticed my mistake because sqrt(e) was giving the wrong x value, but sqrt(2f+e) wasn't.

>>7960

The n0 base is a way to calculate through iterations the correct value of n or n-1. The iterations required are no bigger in complexity than Big Oh for the root of c.

A staircase number is a number that can be expressed as the addition of two or more consecutive numbers (e.g. 3+4+5, 8+9+10+11+12+13, 22+23). To find one configuration of a staircase number for any odd number, we add one to the value then divide it by two. Then the number is equal to the result added to the result minus one (e.g. 67 = (67+1)/2 + ((67+1)/2)-1 = 33+34).

One place in the grid in which we find two consecutive numbers like this which can be added together to find a staircase number is the x values in (e,1) and (f,1). Two elements from two (e,1) and (f,1) cells with the same t value will have consecutive x values. For example, (-17,1,6) has an x value of 11, but (30,1,6) has an x value of 10. These are consecutive numbers, so they produce the staircase number of 10+11=21.

Something Chris has suggested that we look into is where the x values of two paired (e,1) and (f,1) elements at the same t add together to produce na or n-1 (depending on which one is odd).

>>7420

>a from (e,1,1) = c at (2c,1,1) and (2c-1,1,1)

We can find c at t=1 in both of these cells. We can also find c at t=2, t=3 etc. Since all a values in (e,1) are twice a square or the sum of consecutive squares (based around t) plus either e/2 or (e-1)/2, but we're choosing t, we can just take 2(t-1)(t-1) and (t-1)(t-1)+tt away from c to find e/2 or (e-1)/2 and therefore calculate the columns in which c will appear as an a value in (e,1). So we can find where c appears in (e,1) at t=1, t=2, t=3 etc through calculation. There is a pattern to the columns where c will appear at each t value. Where c145 appears as a[t] in (e,1) with t increasing from 1 upwards, to begin with for even e is 290, 286, 274, 254, 226, 190, etc. -4, -12, -20, -28 etc. The gap between cells increases by 8 each time for even e. For odd e, 289, 281, 265, 241, 209, 169, etc. -8, -16, -24, -32, etc. The gap between cells also increases by 8 each time, but the first started at 4 and this one starts at 8.

In all of these columns, there will be a cell where n equals our a and one of the a values equals our b, as well as where n is our b and one of the a values is our a. This is because each a[t] represents na for some c. All of these columns will have this in common. When Chris posted about this, he said "how many columns do you need to create a lookup?" This implies that having a certain number of these columns calculated will give us enough information to create a lookup. Nobody seems to have figured out what information is specifically important in this context so far.

"Values of t that are derived from imaginary numbers can be thought of as orthogonal to the grid." This could relate to when Chris told us to consider the idea of elements in the grid coming out towards you. He never elaborated about what imaginary numbers these t values need to be derived from. Obviously if we're taking a square root in order to produce imaginary numbers this would imply he's talking about negative c values. Taking sqrt(-c), we would end up with di, which, squared, would be a negative square. For example, if we take c=-559, d=23i, and dd=-529. e = c-dd, so e here would be -30. This is e for c=559 but negative. f=e-(2d+1), so here f = -31-46i. I never did imaginary numbers in school so I'm not sure where you'd go from there, but it would appear that using negative c produces a new set of cells and numbers that may be worth analyzing. This is obviously not a completely-understood pattern, but this paragraph at the very least potentially explains the opening statement from a post by Chris, which can be expanded upon when understood further.

If c has two prime factors (and is therefore semiprime), it'll have two na values (including BigN). If c has three prime factors, it'll have four na values. If c has four prime factors, it'll have eight na values. The number of na values a given c has increases exponentially with its total number of prime factors. So within (e,1) and (f,1), there will be more values of na and (n-1)a if c has a higher number of factors. This also means the number of overall factors (prime and/or composite) and the number of valid n values for a given c increases exponentially with the number of factors it has.

Chris said that we're meant to make use of this concept by multiplying c by another number q. q is meant to be the product of several small known prime numbers (e.g. 51317), and is meant to be slightly bigger than d. There was a vague post in RSA #15 that led us to believe that these small primes are meant to be odd sums of two squares, but Chris never confirmed. We're meant to multiply c by q to give us a new number for which there are more na values, giving us more information. With a semiprime c, since we will know these small prime numbers, we will know all of the corresponding na values for each known factor. So, for example, if we were to multiply 817 (1943) by q=513=65 to get qc=53105, we still wouldn't know 19 and 43 are factors of 817, but we would know that 5, 13, 65 and 817 are factors of 53105. This would give us eight known na values, thereby increasing the amount of information we know within the (e',1) and (f',1) cells. It also obviously means qc will turn up in more cells within the e' and f' columns than c appears in the e and f columns. According to Chris, "there is a point where the number of factors gives up the answer." Also according to Chris, our original a must appear twice in the first a+1 [e',1,t] elements of [e',1], and "the two values we are forcing with the grid" are the "factors [that] will also make up the two values of t where a is a factor". This statement is a bit vague. He refers to these two numbers we're forcing with the grid as factors, which would imply that we're looking for a[t]/a for the two elements in (e',1) where a appears as a factor between 1 and a+1, but he specifically says "values of t", which specifically refers to t, and not to a[t]. Either way, we are apparently looking for two values that both directly relate to two elements in (e',1) where a[t] is divisible by our unknown a and where t is between 1 and a+1 (inclusive).

This process is also allegedly meant to increase the smoothness of BigN-n (i.e. the highest prime factor of BigN'-n' should be lower than the highest prime factor of BigN-n). Chris said "if you multiply c by small primes, the smoothness of BigN-n increase". This does not appear to be the case, however, as I showed >>9049 here. It's worth mentioning in Grid Patterns given Chris said it. Maybe he'll come back and elaborate on this point eventually and I can update this post.

There are three types of prime or rather there is a way to separate primes.

Those in column [1,n], those in column [2,n] and those that are not.

Those in column 1 are the sum of two squares.

Those in column 2 are the sum of three squares.

c%d is congruent to e%d

Column (-1,n) contains an entry in every cell, like column (0,n). In (-1,1), the series of d values (1, 7, 31, 49, etc) are each two times a square minus one (so they're also the n values in (0,n) where a and b are both squares minus 1). Also in (-1,1), the series of a values (4, 12, 24, 40, etc) contain within them as factors every single prime number. They appear in a pattern, shown >>8883 here. Where a prime number appears as a factor of a[t] in (-1,1), it will also appear at this t+1. The first two appearances of primes in a cell at [e,1] have the property where their values of their position t, summed is the value of the prime plus one. Five will appear twice within the first six elements, seven twice within eight, etc. This series is meant to help our lookup somehow.

>>9156

The product of a and some values of q will appear before N'c' in [e',1] with one of the n' values.

There's meant to be a trivial lookup based on everything we already know and a non-trivial lookup that relies on the results of the trivial lookup. The trivial lookup returns t, e and f (we don't know if that t value is the correct one but given there's a separate non-trivial lookup it doesn't seem likely), and the non-trivial lookup returns n (-1 for prime, 0 for square c). Chris didn't give us enough information to infer anything about how the non-trivial lookup works yet (aside from explaining various patterns that are apparently relevant), but he did say that we would use columns -f,0,1 and e; rows 1, (n-1), n, X, Y and C. It depends at least on odd e/even e (i.e. it'll work differently for either one) at a minimum (meaning it could potentially be optimized by going further with things like odd x+n, even n, etc). Column 0 contains the square of c. X and Y are the positions of n between 1 and the square of c (this is extremely vague but it's a direct quote). X and Y will not exist for primes (that depends on the value of f and d - again, a pattern we haven't necessarily understood yet). The work we did with triangles will show which integers are primes. It also pays to mention that a certain notorious weirdo on /qresearch/ once said out of the blue "use X on Y at C", which could potentially be relevant (but possibly not).

In the (e,1) and (f,1) cells corresponding to our given c, from t=1 upwards, we see an increasing infinite series of d values. There are two elements in (e,1) and two elements in (f,1) where the d from our given c fits between the d[t] values. Something about this is meant to be important.

Here are a few more things to add to >>7982 that (as far as I could tell) nobody has looked into yet or are not fully understood.

—————————————————————————

The non-trivial method uses a pattern you might not have seen yet but has been discussed.

You know how to look up a number c from column 0 or 1. One way is to take a[t] from c in [0,1] or [1,1], divide the remainder by two and add that to the column to get c in another column.

The value c can be looked up in many columns this way.

This gives enough information to find a, x and n.

In other words.

The columns that c appears in, determines it's composition.

That is the power behind the grid.

Try it with both primes and composite numbers. Anything strike you? Once you c it…

—————————————————————————

Here is a tip, if i(t) has not been done before.

Take products, c, that have odd x+n. And even n.

Take one from x+n.

8 triangles.

Create a table.

What does f and 2(n-1) contribute?

Because the tips of all 8 triangles are from (n-1)(n-1) - 1.

Find the pattern from large to small.

There are h families!

Avoid the 13th step of AA.

—————————————————————————

All values in the cells at n=1 are products where you add a small square to e to make a square with c.

—————————————————————————

There always exist another multiple of a that has a modular congruence with c. (it was from the c%d stuff)

—————————————————————————

sqrt(a) is our long side length of the triangle, with t and t + 1 being the other two sides.

—————————————————————————

(In relation to qc)

By controlling the low prime numbers as a product with, an increasing (non-linear) amount of information is forced upon [e',1]. Each of those factors have to appear early and forever after once they appear in the grid. The sequential probability of consecutive primes being in a random value of [e',1] are low and place huge restrictions on the other primes, including a and including the values of x.

The low primes act to filter out the numbers that a cannot be based on what we know in [e,1] and, importantly in [-f,1]. Because one is odd, and one is even, the overlap and distribution of odd numbers in one of these columns and e' is such that a lookup becomes possible. BigN' comes into play.

—————————————————————————

The importance of column zero is all in the fact that it encodes c value whose remainder is 0, squares

It's filled with alternate factorisations of squares

Shouldn't such an alternate factorisation exist for i or squared?

>>9364

Just stop already.

The well has dried up.

There isn't anyone else to lure.

Nobody listens to you any more.

>>9379

Who ya talkin' to?

>>9378

>>9379

That wasn't Chris, spooky anonymous pessimist. That was one of us who doesn't post with a name.

>>9444

SeeIt v4.

C, C2 = the elements c is between in i[t] in row one

Add parity matching to half the element calculations required to check for an i[t] = i match.

Add calculations to find j[t] match in C and C2

Remove experimental na factoring.

Add new experimental calculation.

Enumeration so far

(e,1) and (f,1) elements of note

>In (e,1) we have elements where a[t]=an and a[t]=bn. In (f,1) we have elements where a[t]=a(n-1) and a[t]=b(n-1). These elements are n and n-1 apart in terms of t respectively.

>Since an and bn appear in (e,1) and a(n-1) and b(n-1) appear in (f,1), the equivalent elements appear for c=1c. In (e,1) we can find elements where a[t]=BigN and cBigN. In (f,1) we can find elements where a[t]=BigN-1 and c(BigN-1).

>In (e,1) where x=c-d and where x=c+d+1, a[t]=cBigN and a[t]=c(c-BigN+1) respectively, and in (f,1) we have equivalent elements where a[t]=c(BigN-1) and a[t]=c(c-BigN+2). In both positive and negative space, these cells are 2d+1 apart in terms of t (the d in this gap being the d of the c we're trying to factor)

>i[t]=i occasionally pops up in the elements in (e,1) and (f,1) where d is between the d[t] values. This is also true for j[t] where c falls between the i[t] values (which also means c falls between the d[t] values).

(e,1) (f,1) concepts

>If an integer p is a factor of a[t], then p will be a factor of a[p+1-t] for ALL cells in row n=1 (na and nb are n apart (at a[t] and a[t+n])

>If p is a factor in a[t] then there exists (e,p)

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

>In row 1 (where n=1) in positive space (so not the (f,n) cells), f=(x+n)(x+n)

>(1,1) contains as values for a and b the values of two consecutive squares added together.

>The n values in (0,n) where a and b are squares appear as the d values in (1,1). They also appear as the a values in (0,1).

>In (e,1) and (f,1), there's meant to be an asymmetrical pattern of n-1 as a factor of (f,1)'s d[t]-d compared with n as a factor of (e,1)'s a[t].

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

>Where a[t] = bn, d[t-1]-d = b(n-1)

>Between the starting prime solution cell and the a[t]=na cell in (e,1), the difference between the a value from the first to the second is a(n-1). This is obvious since na-a = (n-1)a. To add to this, though, the difference between the d values in these cells is also a(n-1).

>Take a cell in (e,1). This holds for any cell in (e,1). If it's even, its b values will appear as the d values in (e+1,1), and the a values from (e-1,1) will appear as its d values. If it's odd, its a values will appear as the d values in (e+1,1), and the b values from (e-1,1) will appear as its d values.

>We can find elements in (e,1) and (f,1) where a[t]=c. Since all a values in (e,1) are twice a square or the sum of consecutive squares (based around t) plus either e/2 or (e-1)/2, but we're choosing t, we can just take 2(t-1)(t-1) and (t-1)(t-1)+tt away from c to find e/2 or (e-1)/2 and therefore calculate the columns in which c will appear as an a value in (e,1).

(0,1) and (1,1) concepts

>(1,1) contains as values for a and b the values of two consecutive squares added together.

>The n values in (0,n) where a and b are squares appear as the d values in (1,1). They also appear as the a values in (0,1). These are two times the square numbers.

>The values of a[t] at (0,1) are twice the square numbers. The values of d[t] at (0,1) are 4 multiples by the triangular numbers.

>In (0,1) we know a[t] = tt2. We also know how to "move" up and down (0,1) whereby t=p+t. This means that if we try to find all the a[t] that are divisible by 3, we can simply list: t = 3, 6, 9, 12, etc.

>By multiplying c with 4 we're creating a new record and distributing the 4 (2x2) to both a and b, giving us 2a, 2b. This also gives us an even square to work with 2(x+n)^2. Odd (x+n)^2 = 8(Tu) + 1. Even (x+n)^2 = 4(Tu + T(u-1)). We now have two triangle problems to solve. For an even square, half of the triangles is one unit longer than the other half. The even square can be expressed as two d values from (0,1) added together, d[u+1] + d[u].

>The a[t] values in (1,1) are all odd sums of two squares (although not every odd sum of two squares appears as an a[t] value). The a[t] values in (1,1) are also only divisible by numbers which are also odd sums of two squares.

>>9575

(0,n) cells of note

>In (0,0) every a and b are equal and every c is a perfect square.

>If c is a semiprime, it'll show up where [a,b] = [1,c^2], [a,ab^2], [b,a^2b], [a^2,b^2] and [c,c]

>Root of d = {0, 2xd, 3xd, 2xd, d, 9xd}. We don't know what this is used for but it's meant to be important.

>There is a cell in (0,n) where a=(x+n)(x+n) and b=(d+n)(d+n).

>In (0,n), if you set x=2c (and therefore with semiprimes t=c+1), each valid n value is divisible by either a or b (or both).

(0,n) concepts

>Squares only ever appear in a and b in (0,n) where n is two times a square, so 2, 8, 18, 32, 50, 72, etc

>The n values in (0,n) where a and b are squares appear as the d values in (1,1). They also appear as the a values in (0,1).

>In column zero, x is a multiple of n

Relationships between variables

>Based on the parity of d and e, we can also find the parity of x, a, b, f and c.

>The parity of BigN is the same as the parity of n.

>2(BigN-n) = (a-1)(b-1), and we can find the cell where a=a-1 and b=b-1 (or where a=a+1 and b=b+1, for which our current unknown a and b represent 2(BigN-n)) by finding the cell (e-2n,n) (or (e+2n,n) for +1s).

>When you decrease e by 1 but increase n by 1, the increase in f is equal to 2d-1. When you increase e and n by 1, at the same t, the increase in f is equal to 2*(the increase in d)+1.

>ab can be represented as the sum of consecutive odd numbers where a is the number of terms and b is the midpoint: 529=145=25+27+29+31+33=145

>If a cell contains an element c, another element in the cell can be constructed from it. e'=e, n'=n, x'=x+2n, a'=b, d'=a'+x', b'=a'+2x'+2n

>By multiplying c with 4 we're creating a new record and distributing the 4 (2x2) to both a and b, giving us 2a, 2b. This also gives us an even square to work with 2(x+n)^2. Odd (x+n)^2 = 8(Tu) + 1. Even (x+n)^2 = 4(Tu + T(u-1)). We now have two triangle problems to solve. For an even square, half of the triangles is one unit longer than the other half. The even square can be expressed as two d values from (0,1) added together, d[u+1] + d[u].

>For each odd (x+n)(x+n), there is a finite set of cells where n!=1, and an infinite set where n==1.

>c%(BigN-1) = 2d-1

>c%d is congruent to e%d

>(x+n) = (b-a)/2

Relationships between cells

>If a cell has values at (e,n) then there will be values in a cell at (e+2n,n). This is how you get the horizontal pattern of grid cells.

>The values of a,b and d each increase by ONE 2n cells to the right. They decrease by one 2n cells to the left. This also means that one cell's c is equal to the next one to the right's 2(BigN-n).

>From (-f,n-1) = c, the value of a,b and d increase by ONE every 2(n-1) cells, as you move from left to right in the grid.

>From (e,n) = c, the value of a,b and d decrease by ONE every 2n cells, as you move from right to left in the grid.

>Choose any cell (e,n). Take a look at the corresponding cell (e, a). The a value of the 2nd cell = the n value of the 1st cell.

>Take a cell in (e,1). This holds for any cell in (e,1). If it's even, its b values will appear as the d values in (e+1,1), and the a values from (e-1,1) will appear as its d values. If it's odd, its a values will appear as the d values in (e+1,1), and the b values from (e-1,1) will appear as its d values.

>At any (e,n,t), there will be another record at (e,n,t+n) where that record's b is equal to the original record's a, and the new x is equal to the old one plus 2n.

>You can create any negative x record by substituting a and b. (1,5,4) = {1:5:12:7:5:29} = 145 becomes (1,5,-8) = {1:5:12:-17:29:5} = 145

>The a values in (-1,2) are equal to 12, 23, 34, 45, 56, 67, 7*8 etc. So our n(n-1) will always appear as an a (and technically also a b) in (-1,2).

>>9576

Bigger overarching concepts that we were told were meant to be used to directly solve the thing

>There's some kind of tree thing we're meant to use. It starts of as a decision tree which terminates if we can immediately solve (e.g. if gcd(d,e)>1). There's then a proper tree diagram in which we find d and e of c, then we find d and e of d and d and e of e, and so on until reaching 1, and also dividing by 2 if we get an even number until it's odd. This is meant to precede whatever concepts we use in either (e,1) or (0,n) to solve, although once we learned to make the tree it was never brought up again and no links were made to any other concepts. Summing up all of the leaves of the number tree diagram gets us a number that is relatively close to one of the factors. "The factor tree is used to factor d and e", apparently, even though that hasn't been shown. "Factoring these (and down the tree) allow for the factoring of c" too apparently. Another claim is that "the tree solution finds x+n or x."

>We're meant to be able to use (x+n)(x+n)=nn+2d(n-1)+f-1 to find the solution. This involves patterns that were looked for but never found, and a variable n0 which is meant as a guess base for each triangle that makes up (x+n)(x+n) and then eventually finds the right triangle base in some way we were never shown.

>Polite/staircase numbers are numbers that can be expressed as the sum of consecutive integers. There are many different variables which pop up as expressions of polite numbers, such as 2d+1. We also find staircase numbers when we add the x values from an (e,1) element and an (f,1) element (this was specifically pointed out), although nothing useful has come from analysis of this either. "The solution to this problem introduces a new form of algebra where two concurrent forms of equations run side by side and then merge. The two sets of equations take the problem and simplify it. Together they handle the "lock and key" nature of the problem/solution, particularly when c is divisible by 1, c, and two other prime numbers, such as in RSA. The two forms of equations that merge together handle staircase numbers where the base of one staircase, is one unit longer than the other." According to this statement, staircase numbers directly relate to the solution, but they have only ever come up in the explanation of the triangle method, which, as stated, we don't know how to use.

>Multiplying c by known small primes is meant to help us to find the unknown factors by increasing the frequency of their appearance. We multiply c by another variable q, which is the product of those small known primes (which for some reason are meant to all end in 01 in binary). We are then meant to multiply qc by another variable v, which will transform it into (0,n). We haven't found anything useful through analysis of qc alone, and it would appear to not currently be possible to directly calculate v. Chris also said that multiplying c by q would increase the smoothness of BigN-n (in other words, decrease its highest prime factor). We discovered that this is actually incorrect, and that the highest prime factor of BigN-n actually increases in every test case of qc.

>There's meant to be a trivial lookup based on everything we already know and a non-trivial lookup that relies on the results of the trivial lookup. The trivial lookup returns t, e and f (we don't know if that t value is the correct one but given there's a separate non-trivial lookup it doesn't seem likely), and the non-trivial lookup returns n (-1 for prime, 0 for square c). Chris didn't give us enough information to infer anything about how the non-trivial lookup works yet (aside from explaining various patterns that are apparently relevant), but he did say that we would use columns -f,0,1 and e; rows 1, (n-1), n, X, Y and C. It depends at least on odd e/even e (i.e. it'll work differently for either one) at a minimum (meaning it could potentially be optimized by going further with things like odd x+n, even n, etc). Column 0 contains the square of c. X and Y are the positions of n between 1 and the square of c (this is extremely vague but it's a direct quote). X and Y will not exist for primes (that depends on the value of f and d - again, a pattern we haven't necessarily understood yet). The work we did with triangles will show which integers are primes. It also pays to mention that ebot on /qresearch/ once said out of the blue "use X on Y at C", which could potentially be relevant (but possibly not).

>There are meant to be separate ways to solving using either (0,n) with X, Y and C (possibly including (0,e) and (0,f), or they might be their own separate solution path), (e,1) and (f,1), row 2, and (1,1).

>>9577

Things we don't know what to do with

>Root of d = {0, 2xd, 3xd, 2xd, d, 9xd}. We don't know what this is used for but it's meant to be important.

>In (e,1) and (f,1), there's meant to be an asymmetrical pattern of n-1 as a factor of (f,1)'s d[t]-d compared with n as a factor of (e,1)'s a[t].

>Apparently there's a useful values in the cell in (e,1) where x=f or f-1.

>There's meant to be a "lookup x" for our given c that "gives you na or (n-1)". There's some x value somewhere in the grid that can applied to c in some way to give us na or n-1. Since there are two possibilities, it's probably based on e and f parities, given all of the patterns based around e and f parities. Also, since the x value in (e,1) where a[t] = na will always be equal to the x value in the prime solution record, finding that x value would bypass (e,1) and na completely, since we wouldn't need to factor na to know what a and b are (since we'd have the prime solution record). So this x value is most likely not the x value from the (e,1) record where a[t] = na.

>Apparently aan(n-1) is meant to be helpful. We don't know how to find it or what to do with it.

<There are more things in this thread that I left out because either they were extremely vague, we looked into them and didn't find anything, or they're interesting concepts but they've never been brought up by anyone other than the person who discovered them and don't seem to have much use. I may include these in this section later on if anyone wants.

Here are some images I made analyzing each grid value. I thought I had more but I can only find A and X in my computer.

For a[t]=an and a(n-1), (e,1,t)'s d minus (f,1,t)'s d is (e,n)'s a minus one. For a[t]=bn and b(n-1), (e,1,t)'s d minus (f,1,t)'s d is (e,n)'s b plus one. This means you don't have to use gcd(a[t], a[t]) to find a or b (O(1) vs O(log n)).

e.g. 13x43=559

(e,1) a=na = (30,1,6) = {30:1:75:10:65:87}

(f,1) a=a(n-1) = (-17,1,6) = {-17:1:63:11:52:76}

75-63=12, one less than a

(e,1) a=bn = (30,1,11) = {30:1:235:20:215:257}

(f,1) a=b(n-1) = (-17,1,10) = {-17:1:191:19:172:212}

235-191=44, one more than b

e.g. 7*29=203

(e,1) a=na = (7,1,4) = {7:1:35:7:28:44}

(f,1) a=a(n-1) = (-22,1,5) = {-22:1:29:8:21:39}

35-29=6, one less than a

(e,1) a=bn = (7,1,8) = {7:1:131:15:116:148}

(f,1) a=b(n-1) = (-22,1,8) = {-22:1:101:14:87:117}

131-101=30, one more than b

B