I haven't made any progress yet, but I'm glad to see you guys are spurring with ideas!

I made this functions for generating the content of (e, n).

def generateN(e, n, rows=10): t = getTFromA(e, n) initX = 2 * t - 1 e, nn, d, x, a, b = rowX(n, initX, 1) print((e, nn, d, x, a, b)) for i in range(1, rows): e, nn, d, x, a, b = rowX(n, 2in + initX, b) print((e, nn, d, x, a, b))

I'm going to see if I can make another similar function.

As you'll see, it only generates the one's that are 'native' to that n. Take for example (1, 5):

>>generateN(1, 5)(1, 5, 4, 3, 1, 17.0)(1, 5, 30, 13, 17.0, 53.0)(1, 5, 76, 23, 53.0, 109.0)(1, 5, 142, 33, 109.0, 185.0)(1, 5, 228, 43, 185.0, 281.0)(1, 5, 334, 53, 281.0, 397.0)(1, 5, 460, 63, 397.0, 533.0)(1, 5, 606, 73, 533.0, 689.0)(1, 5, 772, 83, 689.0, 865.0)(1, 5, 958, 93, 865.0, 1061.0)

It doesn't include a=5, b=29. The reason for this is that a=5 is the result of 25 / 5 (or n*a / n yielding a).

This only uses the rowX method for finding the next values in the chain. As a result it will not be a complete (e, n). Nevertheless it's a starting point.

>>2693

I don't think it's actually possible to generate complete (e, n) record. Every (e, n) record should potentially grow infinitely, right?

Every number in an (e, n) is there because there exists a number in (e, 1) that is a*n. If that a is a prime, then it should start a new "chain" in the n records. Take for example (0, 8). It contains 4 chains based on the initial map generation program by VCQ. It's only 4 chains, because we have a limited generation of numbers in the initial map program. If you extend this further then you should see even more chains in (0, 8)

In my function I had a limit of 10 rows, so for a given amount of rows it should be possible to generate the entire (e, n), but since every (e, n) contains these chains, it's not necessarily useful to do so.

>>2694

I hope I'm making sense.

To explain the term chain look at these records:

{0:8:5:4:1:25}{0:8:12:8:4:36}{0:8:21:12:9:49}{0:8:32:16:16:64}{0:8:45:20:25:81}{0:8:60:24:36:100}{0:8:77:28:49:121}{0:8:96:32:64:144}{0:8:117:36:81:169}{0:8:140:40:100:196}{0:8:165:44:121:225}{0:8:192:48:144:256}

A "chain" is something that links a row that contains a, b to b, c where a != b, b != c.

In (0, 8) we can see 4 different chains.

# Chain 1

1, 25 -25, 81 -> 81, 169

# Chain 2

4, 36 -36, 100 -> 100, 196

# Chain 3

9, 49 -49, 121 -> 121, 225

#Chain 4

16, 64 -64, 144 -> 144, 256

>>2695

This rowX seems to hold a lot of potential.

We can generate every instance where a = c or b = c using it.

>>rowBX(0, 0, 145)(0, 0, 145, 0, 145, 145)>>> rowBX(1, 0, 145)(286, 1, 143, 0, 143, 145)>>> rowBX(2, 0, 145)(281, 1, 142, 1, 141, 145)>>> rowBX(3, 0, 145)(274, 1, 141, 2, 139, 145)>>> rowBX(4, 0, 145)(265, 1, 140, 3, 137, 145)>>> # ......>>> rowBX(72, 0, 145)(1, 61, 12, 11, 1, 145)

Below is two functions, one for rowX which takes in three parameters (n, x, a) and rowBX which takes in three parameters (n, x, b).

def rowX(n, x, a): b = a + 2x + 2n c = ab d = int(math.floor(math.sqrt(c))) e = int(c - dd) n = int(((a + b)/2) - d) x = int(d - a) return (e, n, d, x, a, b)def rowBX(n, x, b): a = b - 2x - 2n c = ab d = int(math.floor(math.sqrt(c))) e = int(c - dd) n = int(((a + b)/2) - d) x = int(d - a) return (e, n, d, x, a, b)

The difference between rowX and rowBX is that rowX generates a record for n, x and a while rowBX generates the same, but for b.

If you ignore one of the variables, for example x = 0, and just adjust n it will still generate records and will fill in for n (as x increases).

So ignoring the second (x) parameter and just adjust n you'll see that rowXB(72, 0, 145) is the highest n will go. This is because it will generate the record where a=1, b=145. n = 0 will generate (0, 0, 145, 0, 145, 145). So you can think of n as decreasing the a-variable.

The limit is (b - 1)/2 so for b = 289, the highest n will go is 144. (289 - 1)/2 = 144.

By using rowX you can find every (e, n) where a is equal to whatever value you want.

I haven't fully wrapped my head around it, but if you modify the code to only output e = <some valueyou can see VQC's reference to:

> Take the number 71. It appears once in the grid. The number 15, twice. 71 is prime. All prime appear once. 15 appears twice, in the same column. How many times does 105 with three factors appear in one column? How many time for a number with four factors? It's not linear. If you multiple c where it is the product of two primes by say, 105, you're going to have a product, a new c, that appears quite a few times in the same column… This is where we are heading.

I don't think this is the solution, but is it possible to generate a record for (e, n, x, c)?

that is, use e, n, x and c to generate all possible solutions for c?

VQC said we only need 3 variables to solve for c. It could yield interesting results.

I've been looking at the d for (1, n) records and I have the following:

(1, 5, #1) = 2(5 t^2 - 2t - 1)

(1, 5, #2) = 2(5 t^2 + 2t - 1)

(1, 13, #1) = 2(13 t^2 - 8t - 1)

(1, 13, #2) = 2(13 t^2 + 8t - 1)

(1, 17, #1) = 2(17 t^2 - 4t - 4)

(1, 17, #2) = 2(17 t^2 + 4t - 4)

(1, 25, #1) = 2(25 t^2 - 18 t - 3)

(1, 25, #2) = 2(25 t^2 + 18 t - 3)

Here I use (e, n, #chain).

I was wondering if it's possible to get the t from d only as a point of exploration.

So the t is squared and multiplied by n, but I don't understand the pattern behind the second part.

Although it's interesting to note that the calculation for these d's for t in the different chains are so similar.

I don't think it will be possible to get a way of calculating t of d without knowing n.

I checked a few other (e, n)'s and they appear to follow a similar pattern.

>>2726

It was in the last thread post >2388

>>2750

Okay guys. So I've been thinking.

If we do a, b = 5, 29 we have c = 145.

If you "scale" the number by 5 on a, b such that a,b = 5*5, 5 * 25 then c = 25 * 145.

I noticed that when we do that, we can predict the e it will land in. e = 25. Both a and b will contain 5 as a factor =(25, 25, 60, 35, 25, 145).

It doesn't predict the 'n', but shit. We know that we can find a number a % 25 == 0 in (25, 1). Then just use 25 * i + t and 25 * i + 1 - t to search for a, b.

Again, we simply multiply c with a square of our choosing. Then we find the first a in (e, 1) that contains our number (non-squared) as a factor.

This is our prime, we can then use this to factorize c by generating more a's that fit p * i + t, p * i + 1 - t and using gcd.

def solveTest(c, rows=20): e, n, d, x, a, b = rowForAB(1, c) e, n, dd, xx, a, b = rowForAB(1, x2 * c) li = generateGenesis(e, rows) t = 1 for cell in li: e,n,d,xx,a,b = cell if a % x == 0: break t = t + 1 for i in range(1000): p1 = xx * i + t p2 = xx * i + 1 - t pp1 = int(getAFromT(e, p1)) pp2 = int(getAFromT(e, p2)) gp1 = gcd(c, pp1) gp2 = gcd(c, pp2) if gp1 != 1 and gp1 != c: print(t,i, pp1, gp1, c, c / gp1) break if gp2 != 1 and gp2 != c: print(t,i, pp2, gp2, c, c / gp2) break

Here I use x as an example. It doesn't have to be x, it could even be a chain of primes squared (I think).

I've also been thinking that maybe we can use e again. e will be the k * c, where k is some squared number.

>>2751

> If you "scale" the number by 5 on a, b such that a,b = 5*5, 5 * 25 then c = 25 * 145.

I'm an idiot, here I meant a, b = 5 * 5, 5 * 29

>>2751

This is heavily non-optimized. I don't even think we need to search for the first a that contains our factor.

If we for example use e as our prime (the number we squared) then we could simply use getTFromA(e, e). Then iterate on that to find the number that gcd(c, somenumber) != 1 and gcd(c, somenumber) != c.

I haven't tested that, but I think it should work. We should then be able to skip the first generation of genesis cells and go straight to the prime iteration process.

In my code I added a range(1000), but if we know what we are looking for we can just iterate indefinitely until we hit the proper i.

>>2753

> In my code I added a range(1000), but if we know what we are looking for we can just iterate indefinitely until we hit the proper i.

Correction, if we know that e * i + t, e * i + 1 - t will yield a number where gcd(c, somenumber) == a or b, then we don't need a range-limit.

>>2751

Correction, we can't "predict" e. It appears it doesn't always equal the number we square. But I think we can still use this approach.

>>2775

Why did you select (1, 29)?

>>2782

Nevermind re-read.

Btw great work! This looks very interesting

>>2775

8700 - 160 = 8540

8540 - 1464 = 7076

>>2785

Yeah, this shit feels soooo god damn close. If only we can get to one of those records, we got it.

>>2788

Based on (4, 34, 161, 76, 85, 305)

n = (xx + e) / ((f + a) - 2x)

>>2789

Damnit, clicked reply too fast:

n = (xx + e) / ((2 * (d + a)) - 2x)

>>2790

Doesn't work for c=145, so might be a fluke, but then again there might be a different equation for odd e

>>2792

I know, but for (4, 34, 161, 76, 85, 305) I calculated the following rows based on the factors of 34 * 85:

(4, 1, 2966, 76, 2890, 3044)

(4, 2, 1521.0, 76, 1445.0, 1601.0)

(4, 5, 654.0, 76, 578.0, 740.0)

(4, 10, 365.0, 76, 289.0, 461.0)

(4, 17, 246.0, 76, 170.0, 356.0)

and

(76 * 2 + 4) / (2 * (161 + 85) - 276) = 17.

I was thinking maybe that's the key.

>>2793

(76 * 2 + 4) / (2 * (161 + 85) - 276) =17.0

(76 * 2 + 4) / (2 * (161 + 85 + (85 + 34)) - 276) = 10.0

(76 * 2 + 4) / (2 * (161 + 85 + (85 + 34) + (34 + 85 + 85 + 85)) - 276) = 5

>>2795

Adding more 34 + 85.. terms doesn't get to the (4, 2) record though.

However, the (4, 2) record, when divided by 2 is equal to 85 * 34 (2890)

>>2787

What do you mean "move between n's other than 1"?

While right now we are a bit limited in the moving regard, but we can, for example, move from (1, 61) to (123, 61).

>>> rowX(61, 2 * 61 + 11, 145)

(1, 61, 278, 133, 145, 533)

>>> createForENX(1 + 2 * 61, 61, 133)

(123, 61, 279.0, 133, 146.0, 534.0)

>>> createForENX(123 + 2 * 61, 61, 133)

(245, 61, 280.0, 133, 147.0, 535.0)

>>> createForENX(1 - 2 * 61, 61, 133)

(-121, 61, 277.0, 133, 144.0, 532.0)

>>> createForENX(-121 - 2 * 61, 61, 133)

(-243, 61, 276.0, 133, 143.0, 531.0)

>>2818

It even keeps the logic behind xx + e = 2na

>>rowForAB(1, 13 * 19)(22, 109, 15, 14, 1, 247)>>> rowX(22, 2 * 22 + 14, 247)(40, 10, 317, 70, 247, 407)>>> createForENX(40 - 210, 10, 70)(20, 10, 316.0, 70, 246.0, 406.0)>>> createForENX(20 - 210, 10, 70)(0, 10, 315.0, 70, 245.0, 405.0)>>> 245 * 102450>>> getTFromA(0, 2450)35.0>>> generateNthRowFromGenesis(0, 35)(0, 1, 2380, 68, 2312, 2450)>>> generateNthRowFromGenesis(0, 36)(0, 1, 2520, 70, 2450, 2592)>>> createForENX(0 + 2 * 1, 1, 70)(2, 1, 2521.0, 70, 2451.0, 2593.0)>>> createForENX(2 + 2 * 1, 1, 70)(4, 1, 2522.0, 70, 2452.0, 2594.0)>>> createForENX(38 + 2 * 1, 1, 70)(40, 1, 2540.0, 70, 2470.0, 2612.0)>>> (70**2 + 40)/22470.0

>>2819

Oh boy I messed that code up. I was trying to look at the next row for 247, but I used e instead of n and it jumped from e=22, to e=40. I don't trust the result from the code above. Need to verify

Wasn't there an equation for moving around (e, n)'s?

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

>>2812

I can't tell you why, but I did some minor algebra on it:

b - 1 = 4x

b = 4x + 1

b = a + 2x + 2n

4x + 1 = a + 2x + 2n

4x - 2x = a + 2n - 1

2x = a + 2n - 1

x = (a + 2n - 1)/2

x = a/2 + n - 1/2

For n:

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

For a:

a = 2x - 2n + 1

Appears to check out for multiple records:

c = 145

c = 1313

c = 3905

I don't know if these equations will be helpful, but at least here they are.

>>2823

I played some more with the numbers

We know x = a/2 + n - 1/2 for some c's (at least the ones I've been making by taking two primes and multiplying them).

We also know xx + e = 2a*n. I ran this through wolframalpha:

So by substituting x*x we get:

(a/2 + n - 1/2)^2 + 1 = 2 * a * n (for (1, n))

This yields:

n = 1/2 (a - 2*sqrt(a - 1) + 1)

Integer solutions:

a = 4 m^2 + 8 m + 5

n = 2 m^2 + 2 m + 1

m element Z

>>2824

So for c = 145,

a = 4 * 5^2 + 8 * 5^2 + 5 = 145

n = 2 * 5^2 + 2 * 5^2 + 1 = 61

(1, 1, 5) = {1:1:50:9:41:61}

c = 901

a = 4 * 14^2 + 8 * 14 + 5 = 901

n = 2 * 14^2 + 2 * 14 + 1 = 421

Again, not sure if this is of any actual use.

One thing I've been thinking of.

How would these patterns look if we look at numbers we know are primes?

For example, take a,b = 1,17. We know 17 is a prime. So patterns should diverge from when the case it's not.

My point is, have we discovered a better primality test than the ones that exists so far? If so, then it lends creedence to the truthability of the whole VQC.

Another thing I'm curious about, VQC said he was going to show us a lot of things. This grid is just one virtual quantum computer. He never said anything else about the second one which we are supposed to use to show us the language of math.

What's the row for a, b = 2, 7?

>>2847

14 mod 4 = 2. So ignore it or divide it by 2.

>>2853

Sorry, I'm still at this project, just real life that is catching up now that the new year is upon us.

I'm not going to give up this easily. I don't have anything new, I've been working for the past few days and after work I have other commitments, but I still read over crumbs and think every day.

I've been looking into the patterns behind the 1, c rows.

So take c = 145. The row for a,b = 145 = (1, 61.0, 12, 11, 1, 145)

I've been wondering about the relationship between this N and the 5. So this doesn't let us find 'n', but it should give us some insight into how these are connected.

So we know for row (1, 5) we have the following:

{1:5:4:3:1:17}

{1:5:12:7:5:29}

{1:5:30:13:17:53}

{1:5:46:17:29:73}

{1:5:76:23:53:109}

{1:5:100:27:73:137}

{1:5:142:33:109:185}

{1:5:174:37:137:221}

{1:5:228:43:185:281}

{1:5:268:47:221:325}

{1:5:334:53:281:397}

{1:5:382:57:325:449}

{1:5:460:63:397:533}

If we split these up into two chains we get:

Chain #1

{1:5:4:3:1:17}

{1:5:30:13:17:53}

{1:5:76:23:53:109}

{1:5:142:33:109:185}

{1:5:228:43:185:281}

{1:5:334:53:281:397}

{1:5:460:63:397:533}

and

Chain #2

{1:5:12:7:5:29}

{1:5:46:17:29:73}

{1:5:100:27:73:137}

{1:5:174:37:137:221}

{1:5:268:47:221:325}

{1:5:382:57:325:449}

Now take the a, b's from chain #1 and generate the row for a=1, b=c. We get:

>>rowForAB(1, 1 * 17)(1, 5.0, 4, 3, 1, 17)>>> rowForAB(1, 53 * 17)(1, 421.0, 30, 29, 1, 901)>>> rowForAB(1, 53 * 109)(1, 2813.0, 76, 75, 1, 5777)>>> rowForAB(1, 185 * 109)(1, 9941.0, 142, 141, 1, 20165)

For chain #2 we get:

>>rowForAB(1, 5 * 29)(1, 61.0, 12, 11, 1, 145)>>> rowForAB(1, 73 * 29)(1, 1013.0, 46, 45, 1, 2117)>>> rowForAB(1, 73 * 137)(1, 4901.0, 100, 99, 1, 10001)>>> rowForAB(1, 221 * 137)(1, 14965.0, 174, 173, 1, 30277)

Note: I didn't compute every a=1, b=c for the different chains, but you should get the picture.

Today I've been looking into how the n grows and found two equations, one that explains it for the main chain (#1) and one for the second chain.

For chain #1 we can predict the n, d and x values without knowing the entries in (1, 5). Instead, we base it on the n (5) and d, x from (1, 1). I haven't found any good equation for (1, n) where n doesn't appear in (1, 1), but I'll look more into that later.

For even e:

n[t] * t^2 + d[t] * t + (x[t] / 2)

For odd e:

n[t] * t^2 + d[t] * t + ((x[t] + 1)/ 2)

This equation is only for the chain #1. For chain #2 we have instead:

n[t] * t^2 + d[t - 1] * t - x[t-1]

Again though, this doesn't solve for n. It doesn't solve much right now, but at least it explains the relationship between n and the big N's.

To give you a better understanding here is a few examples:

Let's try with (5, 1). We'll pick some values, we will start with finding the big N for values in (5, 27). So we have the row:

{5:1:34:7:27:43}

>>n = 1>>> 27 * n * n + 34 * n + (7 + 1)/265.0>>> getAFromT(5, 65)8323.0>>> rowForAB(1, 69 * 245) # This is the 3rd entry in (5, 27), but the second entry in chain #1 after a=1,b=69(5, 8323.0, 130, 129, 1, 16905)>>> n = 2>>> 27 * n * n + 34 * n + (7 + 1)/2180.0>>> getAFromT(5, 180)64443.0>>> rowForAB(1, 529 * 245)(5, 64443.0, 360, 359, 1, 129605)

As for the d and x in those records, they are d = 2 * (27 * n * n + 34 * n + (7 + 1)/2) and x = 2 * (27 * n * n + 34 * n + (7 + 1)/2) - 1

>>2920

I noticed my formulas might lead to some confusion.

For even e:

n[t] * t^2 + d[t] * t + (x[t] / 2)

For odd e:

n[t] * t^2 + d[t] * t + ((x[t] + 1)/ 2)

This equation is only for the chain #1. For chain #2 we have instead:

n[t] * t^2 + d[t - 1] * t - x[t-1]

Here [t] represents the t for n in (1, 1) while t is the t for (1, n[t]).

>>2923

MIMD as in Multiple Input Multiple Data (as opposed to SIMD)?

I don't quite understand the pattern yet, but for (1, 17) the big N equation is:

17 * n * n - 4 * n - 4

17 * n * n + 4 * n - 4

And for (1, 29) it is:

29 * n * n - 12 * n - 6

29 * n * n + 12 * n - 6

The parts I don't understand yet is why 12 and 6 are important.

I'm assuming they refer to d-values and x-values.

For 17, we do have d = 4 at {1:5:4:3:1:17}

and for 29 we have {1:5:12:7:5:29}.

Both d's in this case match the d's in the equation used, but I haven't locked down why or if this is a coincidence. As for the x-part I'm still lost.

>>2927

For (1, 37) we have the following equations:

37 * n * n - 6 * n - 9

37 * n * n + 6 * n - 9

Again, {1:13:6:5:1:37}.

Here the d is correct, but I can't make heads and tails of the x value.

Sorry guys, real world is catching up and I got work, but damn. Figuring out the relationship between n and big N seems like a big achievement.

I need a fresh mind for tomorrow. My brain is stuck on this pattern.

>>2933

Then you found the right spot.

If you don't mind sharing, what is the quadratic equation you found?

>>2955

How did you get the different numbers?

He said earlier that he doesn't want to tell how how to solve what he is doing, but he is willing to give us hints so we can solve it ourselves. Literally, inside a thread about the exact same thing.

The guy has his own thread so just hide his posts and move on.

>>2993

Actually, no. It isn't known where factoring is with regards to P or NP. Only that it is in BQP. However, being able to factorize fast will be a proof of the VQC. I think it's only a stepping stone in the right direction.

I've been looking into the latest, hot off the press, crumb from VQC. Here I subtracted 12 (d for c = 145) from the d's in (1, 1).

-10, -4, 6, 20, 38, 60, 86, 116, 150, 188, 230, 276, 326, 380, 438 5, , , 5, , 5, , , 5, , 5, , , 5, , 4, , 4, , 4, , 4, , 4, , 4, , 4,

It shows that 5 (n) and 4 (n - 1) as factors in 20 and 60 (d=32, d=72 where a = 25, a = 61 respectively).

I tried some gcd-magic just to see how it handles and managed to find (n - 1) for some n = 17, but it doesn't appear to be a consistent solution as n's are all odd numbers in (1, 1) and (n - 1) will be even, thus contain at least 2 as a factor. However, this is very interesting.

VQC mentioned that the pattern behind d[t] - d will give us the offset. The question is then, the offset to what?

And there is a pattern in the numbers of d[t] - d, for the numbers that contains (n - 1) as a factor. So we don't know which numbers, yet. Since we don't know which n to look for. But I have a feeling we aren't really going to look for n, but rather have n fall into our laps once we fully understand these patterns.

Okay, I've been looking more into the crumbs by Mr. VQC.

So we know if we do d[t] - d, we have some kind of pattern.

This relates to the equation to calculate an arbitrary d for e for n = 1. This we know how to do.

For even e it is:

(e / 2) + 4 * ( (t * (t - 1) ) / 2)

For odd e, it is:

(e + 1) / 2 + 2t*2 - 1

Now, the fun thing is that the equation for a, is the opposite. To calculate an arbitrary a, for (e, 1) we do the opposite equations.

For even e, we do:

(e / 2) + 2(t)*2

For odd e, we do:

e / 2 + 2 * (t * (t - 1)) + 1

Now I was looking into the crumb for c=145, we have d[0] - d = -10. If we use -10 as an offset for our calculations of d, we get:

-10 + 2 * t**2 - 2 (which is close to our a formula for even e).

When t = 4, we get 20. Now if we look at the calculations for n - a[t], we also have an offset.

So for n = 5 (a=5, b=29) we get 1 - 5 =-4. So we'll use -4 as our offset.

We'll do:

-4 + 2 * (t * (t - 1)).

For t = 4 we also get 20.

I'm thinking, maybe we are supposed to find the t, where the two equations intersect?

>>3040

One downside is that we won't know the -4 offset, so this might be barking up the wrong tree. Since we only get -4 by doing 1 - 5 (and we are trying to find 5)

I've been looking more into the patterns of (n - 1) for d, and I've found that there is a lot of reoccuring, but alternating patterns:

(1, 5, 1)

a[t] - n: 1, 2, 3, 4, 5, 6, .., 31

d[t] - d: 2, 4, 6, 8, 10, 12, 14, 16.., 30

(1, 5, 2)

d[t] - d: 2, 4, 6, 8, 10, 12, 14, 16.., 30

(1, 5, 3)

d[t] - d: 1, 3, 5, 7, 9, 11, 13, 15, .., 31

(1, 5, 4)

d[t] - d: 1, 3, 5, 7, 9, 11, 13, 15, .., 31

(1, 5, 5)

d[t] - d: 2, 4, 6, 8, 10, 12, 14, 16.., 30

(1, 5, 6)

d[t] - d: 2, 4, 6, 8, 10, 12, 14, 16.., 30

(1, 5, 7)

d[t] - d: 1, 3, 5, 7, 9, 11, 13, 15, .., 31

(1, 5, 8)

d[t] - d: 1, 3, 5, 7, 9, 11, 13, 15, .., 31

(1, 13, 1)

a[t] - n: 1, 3, 4, 6, 7, 9, 10, 12, 13, 15, 16, 18, 19, 21, 22, 24, 25, 27, 28, 30, 31

d[t] - d: 3, 9, 15, 21, 27

(1, 13, 2)

d[t] - d: 1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31

(1, 13, 3)

d[t] - d: 2, 4, 8, 10, 14, 16, 20, 22, 26, 28

(1, 13, 4)

d[t] - d: 6, 12, 18, 24, 30

(1, 13, 5)

d[t] - d: 1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31

(1, 13, 6)

d[t] - d: 1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31

(1, 13, 7)

d[t] - d: 6, 12, 18, 24, 30

(1, 13, 8)

d[t] - d: 2, 4, 8, 10, 14, 16, 20, 22, 26, 28

>>3050

The code I've been using:

def generateGenesis(e=0, rows=10): cells = [] genesis = genesis_block(e) block = genesis if e % 2 0: offset = 2 else: offset = 4 if e != 0: cells.append(block) for i in range(rows): e, n, d, x, a, b = block a = b b = b + (offset + 4 * (i + 1)) c = math.fabs(a * b) d = math.floor(math.sqrt(c)) x = math.floor(math.sqrt( (d + n)**2 -c ) - n) block = (int(e), int(n), int(d), int(x), int(a), int(b)) cells.append(block) return cellsdef testing(e, d, n, rows=30): cells = generateGenesis(e, rows) print(e, d, n) print('d[t] - d:') for cell in cells: ee, nn, dd, xx, aa, bb = cell if (dd - d) % (n - 1) 0: print((xx + 1)/2, dd - d, (dd - d) % (n - 1))# print()# print('a - n:')# for cell in cells:# ee, nn, dd, xx, aa, bb = cell# print((xx + 1)/2, aa - n, (aa - n) % (n - 1))

>>3050

My notation is (e, n, t) and I only display a[t] once, since it's the same for the entire (e, n) row.

>>3052

I haven't gotten any further with the patterns, though. Just wanted to share what I got. I still can't see the underlying patterns VQC is talking about. I'm sure some of you guys might though.

>>2990

I miss read him the first time. He states that d[t] - d is different from the pattern of factors of n in a[t]. Not the factors of (n - 1) in the difference of a[t].

The factors of 5, in a[t] at (1, 1) is:

2, 4, 7, 9, 12, 14, 17, 19, 22, 24, 27, 29

Which are two interleaving patterns, which we also know is the same as pk + t (for k=1,2,…) and pk + 1 - t. (In this case p = 5 and t = 2)

And as for the "different (increasingly)" I think he is referring to the difference between the numbers where (n - 1) is a factor of d[t] - d.

For example, take (1, 5, 2) where a = 5, b = 29 and c = 145.

Here d is 12, the (d[t] - d) that have 4 as a factor are the following:

-4, 20, 60, 116, 188, 276, 380, 500, 636

These increase with:

24, 40, 56, 72, 88, 104, 120, 136.

The difference between the increase is 16.

So could this 16 be what he refers to? Or could it be the 24? Or 24 + 16?

Nevertheless, we still don't know the (n - 1) we are looking for so I'm still a bit stumped.

>>3074

I might have been a bit of a dumbass again.

So I checked the increasing values of (1, 13, 2) and the (d[t] - d) that contains (n - 1) as a factor is:

-36, 12, 60, 204, 300, 540, 684, 1020, 1212, 1644, 1884

This is, again, two interleaving patterns. Pattern one:

-36, 60, 300, 684, 1212, 1884

Starts with 96 in difference between -36 and 60, but then if you add 96 + 144, you'll get 300.

So for (1, 5, 2) the increasing number is 16, which is 44. For (1, 13, 2) it's 144, which is 1212.

The other part of the interleaving pattern is:

12, 204, 540, 1020, 1644

Which starts with 192. Again, if you do 12 + 192 you'll get 204. If you do 204 + 192 + 144 you'll get 540.

So the increase is also 144 for the interleaved pattern.

However, for (1, 17, 1) and (1, 17, 2) it's increasing by 16 again. While (1, 17, 3) appears to be 64. Could be a special case since 17 isn't a part of (1, 1)?

For (1, 25, 2) we see again, two interleaved patterns: -72, -48, 48, 120, 312, 432, 720, 888, 1272, 1488

Pattern 1: -72, 48, 312, 720, 1272

Pattern 2: -48, 120, 432, 888, 1488

Both increase by 144 (12^2). However, this is for the record:

{1:25:80:43:37:173}

And 37 appears in (1, 13). So could be that we aren't looking for the 'n', but rather an 'n' where a exists?

I don't have much time to look for patterns right now, but once time opens up. I'll dig more.

>>3075

As for the reason I dismissed the pattern before I checked (1, 13) was that (1, 5, 3), which has 30 as d appears to change with 2. So I don't know if the above is the silver bullet, but it's at least an interesting pattern.

Okay guys, I have one idea, no idea if it works. It doesn't sound like the thing VQC had in mind, but hear me out.

We know how to find the big N. And it appears as if every big N's exists in (e, 1). Now from what I've seen, the big N's D - d will contain (n - 1) as a factor.

If we can factorize the big N's (D - d), then we can figure out the (n - 1). Sounds silly, but what if we use a recursive algorithm. Essentially, we just keep factorizing the D - d value of the big N until we hit a prime number, in which we found one factor of our original (D - d).

To give you an example:

c = 145, this gives us:

>>rowForAB(1, 145)(1, 61.0, 12, 11, 1, 145)>>> getTFromA(1, 61)6.0>>> generateNthRowFromGenesis(1, 6)(1, 1, 72, 11, 61, 85)>>> 72 - 1260>>> rowForAB(1, 60)(11, 23.5, 7, 6, 1, 60)>>> getTFromA(11, 23)3.458039891549808>>> generateNthRowFromGenesis(11, 4)(11, 1, 37, 7, 30, 46)>>> 60 / 302.0>>> 37 - 730>>> rowForAB(1, 30)(5, 10.5, 5, 4, 1, 30)>>> getTFromA(5, 10)2.4364916731037085>>> generateNthRowFromGenesis(5, 3)(5, 1, 20, 5, 15, 27)>>> 30 / 152.0>>> rowForAB(1, 15)(6, 5.0, 3, 2, 1, 15)>>> getTFromA(6, 5)1.0>>> generateNthRowFromGenesis(6, 1)(6, 1, 3, 0, 3, 5)>>> 15 / 35.0>>> 15 / 53.0>>> # Our factors for 60 => 2, 2, 3, 5

Now I honestly don't know if this will work or not with bigger numbers. And I don't know if this is what VQC had in mind. But I think it's worth taking a look at.

As for those numbers where it turns into 10.5, I get the T for that value and round up.

>>3090

Also interesting to note, d[t] - d for t = 2, 4, 6, 10, 12, 20, 30 and 60 all contains (n - 1) as a factor for c=145.

Those are all the result of different combinations of the factors of 60.

>>3094

It get's the t for a[t] in (e, 1).

For example in (1, 1) getTFromA(1, 5) will return 41, which is the a[t] where t = 5.

>>3095

generateNthRowFromGenesis returns the nth row from genesis in (1, 1).

So generateNthRowFromGenesis(1, 5) will return {1:1:50:9:41:61}

>>3097

Correction, from (e, 1)

>>3096

getTFromA takes in e as the first parameter and a as the second. It returns t.

>>3100

I've posted both code pieces before. Numerous times. If you're going to be an asshat, then you can look for it yourself.

https://themarshallreport.wordpress.com/2017/11/24/the-mystery-q-solved-or-not-all-roads-lead-to-in-q-tel-bigger-than-big-brother/

Yeah, so I'm out guys. I believe this is just a LARP. We're not really getting anywhere, we're just running around in circles.

Kudos to you VQC, you had me going for a looong ass time, racking my brain back and forth. It's been fun.

>>3103

Yeah, no. I've posted them in other threads along with the equation behind them.

def getDFromT(e, t): if e 0 or e % 2 0: return (e / 2) + 2 * ( (t * (t - 1) )) else: return int( (e + 1) / 2) + 2t2 - 1 def getAFromT(e, t): if e 0: return (e / 2) + 2(t)*2 if e % 2 0: return (e / 2) + 2(t - 1)*2 else: return int(e / 2) + 2( (t * (t - 1)) ) + 1def getTFromD(e, d): if e % 2 0: t = d - (e / 2) t = t / 2 t = t * 4 + 1 t = t / 4 t = math.sqrt(t) + 1 return -1/2 + t else: t = d - (2 + int(e / 2)) t = t / 2 t = t + 1 t = math.sqrt(t) t = t return tdef getTFromA(e, a): if e 0: t = a * 2 - e t = math.sqrt(t) + 2 t = t / 2 return t - 1 if e % 2 == 0: t = a * 2 - e t = math.sqrt(t) + 2 t = t / 2 return t else: return math.sqrt((a - (e / 2))/2) + 0.5

I had some issues with e = 0, but anyways. There you have it. It should work fine for any (e, 1). As for every other function I've referenced they're either posted here or copied from College Anon's code from OP.

>>3112

Nah. Only thing I've observed is that the (d[t] - d) for record with a[t] = big N contains (n - 1) as a factor.

As for my recursive attempt, it doesn't work. It essentially divides by two. Feel free to try, it only worked on a few selected methods.

>>3119

Ugh, I agree. LARP or not, I can't help but looking more into this. Too many fascinating patterns from such a simple algorithm.

Yeah, yeah I'm out bla bla bla. I'm quitting tobacco, so I'm a bitch right now.

So I took a look at another angle of the (d[t] - d) and the pattern of n as factor of a. I haven't found any silver bullets or anything useful, but I did observe what appears to be another pattern.

If we look at the difference between (d[t] - d) and (a[t] - n) we can see there is a t where this difference is 0. At this t, we can find the n by d[t] - d - a. However, this t appears to be the result of the t from big N - (n + 1)/2. So it still requires knowledge of n.

The hint I'm going to look more into is this:

> I will post more on The Grid later but think about the distribution of n and (n-1) in cell (e,1) in the a[t] and d[t]

values respectively. This is the quick way to utilising f.

Also, has anyone looked into (n, 0) columns? VQC gave a hint about it:

> Tomorrow I will show the way in which na and (n-1)a relationships between a[t] and d[t] in row 1 cells (e,1) and the pattern in column zero (n,0), these can both be used to factor arbitrary c in < O(log l) where l is the length of c in bits.

Maybe something in (n, 0) will yield something interesting.

>>3149

Take e = 1, n = 5, d = 30 as an example:

1.0 -28 -24 -43.0 -12 -20 85.0 20 -16 367.0 68 -12 809.0 132 -8 14011.0 212 -4 21613.0 308 0 30815.0 420 4 41617.0 548 8 54019.0 692 12 68021.0 852 16 83623.0 1028 20 100825.0 1220 24 119627.0 1428 28 140029.0 1652 32 162031.0 1892 36 1856

Here we have:

t, (dd - d), (dd - d) - (aa - n), (dd - d) - ((dd - d) - (aa - n)).

We can se at some point t = 13, the (dd - d) - (aa - n) equals 0. Before that it was equal to -4, -8, -12 and after it is equal to 4, 8, 12, … So the change is 4.

We can get 13 by doing (30 / 2) - (n - 1)/2). However again, this requires us to know n.

>>3150

For (1, 5, 46) we can predict the t:

(46 / 2) - (5 - 1)/2 = 23 - 2 = 21

And the following:

1.0 -44 -40 -43.0 -28 -36 85.0 4 -32 367.0 52 -28 809.0 116 -24 14011.0 196 -20 21613.0 292 -16 30815.0 404 -12 41617.0 532 -8 54019.0 676 -4 68021.0 836 0 83623.0 1012 4 100825.0 1204 8 119627.0 1412 12 140029.0 1636 16 162031.0 1876 20 1856

If we could find another way of getting to t = 21, we can find n, since it's d[t] - d - a[t].

I haven't had much time today, but I've also looked into the (n, 0) records. Haven't found any patterns, but I did just observe something "funny". I was curious about these records and decided to play with d-values from (1, 1).

Try this code:

def findOnes(en): en = en ** 2 en = en * -1 for i in range(1, 1444 * 15): ee, nn, dd, xx, aa, bb = createForEND(en, 0, i) if aa < 0: aa = aa * -1 if bb < 0: bb = bb * -1 e, n, d, x, a, b = rowForAB(aa, bb) if e == 1: print(i, (e, n, d, x, a, b), (ee, nn, dd, xx, aa, bb))

It's a pretty rough brute force method, but it does show some interesting results.

So I checked with 2, 8, 18, 32 and 50 and it appears the "last" record that has a corresponding record in (1, 1) out of the lot is always equal to ((en ** 2) / 2 + 1). And it appears to give numbers related to the n's within the record from (1, 1) and the given d.

I don't understand it, but take a look:

>>findOnes(2)3 (1, 1, 2, 1, 1.0, 5.0) (-4, 0, 3, 2.0, 1.0, 5.0)>>> findOnes(8)9 (1, 5, 4, 3, 1.0, 17.0) (-64, 0, 9, 8.0, 1.0, 17.0)33 (1, 1, 32, 7, 25.0, 41.0) (-64, 0, 33, 8.0, 25.0, 41.0)>>> findOnes(18)19 (1, 13, 6, 5, 1.0, 37.0) (-324, 0, 19, 18.0, 1.0, 37.0)35 (1, 5, 30, 13, 17.0, 53.0) (-324, 0, 35, 18.0, 17.0, 53.0)163 (1, 1, 162, 17, 145.0, 181.0) (-324, 0, 163, 18.0, 145.0, 181.0)>>> findOnes(32)33 (1, 25, 8, 7, 1.0, 65.0) (-1024, 0, 33, 32.0, 1.0, 65.0)105 (1, 5, 100, 27, 73.0, 137.0) (-1024, 0, 105, 32.0, 73.0, 137.0)513 (1, 1, 512, 31, 481.0, 545.0) (-1024, 0, 513, 32.0, 481.0, 545.0)>>> findOnes(50)51 (1, 41, 10, 9, 1.0, 101.0) (-2500, 0, 51, 50.0, 1.0, 101.0)1251 (1, 1, 1250, 49, 1201.0, 1301.0) (-2500, 0, 1251, 50.0, 1201.0, 1301.0)

The first "record" also appears to be (d + 1) and the last appears to be (d**2 / 2) - 1. Not sure about the ones in between though.

Another interesting this is this:

>>findOnes(12) # d = 12 for c = 14517 (1, 5, 12, 7, 5.0, 29.0) (-144, 0, 17, 12.0, 5.0, 29.0)73 (1, 1, 72, 11, 61.0, 85.0) (-144, 0, 73, 12.0, 61.0, 85.0)>>> findOnes(30) # d = 30 for c = 90135 (1, 17, 18, 13, 5.0, 65.0) (-900, 0, 35, 30.0, 5.0, 65.0)451 (1, 1, 450, 29, 421.0, 481.0) (-900, 0, 451, 30.0, 421.0, 481.0)>>> findOnes(46) # d = 46 for c = 211751 (1, 29, 22, 17, 5.0, 97.0) (-2116, 0, 51, 46.0, 5.0, 97.0)1059 (1, 1, 1058, 45, 1013.0, 1105.0) (-2116, 0, 1059, 46.0, 1013.0, 1105.0)

Here, every 'n' is an 'a' in (1, 5), but these records start off from d + n, so it won't solve anything. But maybe it sheds some light on these (n, 0) records?

Remember chris giving a hint about negative x in (e, n) row's?

I remember I took a look at it, but I couldn't generate any. Instead, all I do is "jump" backwards. So trying to generate records with negative x for (1, 61) jumped me instead to (1, 41) at t = 1.

Maybe we should take another look, and see if either we can generate negative x records for (e, n) or if the jumping can reveal something?

Okay, so I tested something and I can now generate negative x-values for (1, 61). There's two interleaved patterns here, one where it starts with 1, 101, and the other is 1, 145.

So to generate negative x records I started by generating the record where a = 1, b = 145 and one where a = 145 and b = 1.

This gives us:

(1, 61, 12, 11, 1, 145)

(1, 61, 12, -133, 145, 1)

Now I found this by trial and error, but the way to keep going in the "negative part" is by creating a record for E N X with this:

>>rowForAB(1, 145)(1, 61, 12, 11, 1, 145)>>> rowForAB(145, 1)(1, 61, 12, -133, 145, 1)>>> createForENX(1, 61, -133 - 261)(1, 61, 278.0, -255, 533.0, 145.0)>>> createForENX(1, 61, -133 - 461)(1, 61, 788.0, -377, 1165.0, 533.0)

>>3203

Actually, createForENX(1, 61, -11 - 2 * 61) will also give you (1, 61, 12, -133, 145, 1).

And I just remember that maybe we were able to do this in the last thread?

It seems like VQC makes an appearance and drops a hint, once a week. Maybe he'll stop by this week too with a hint.

I'm going to keep looking into the whole d[t] - d thing.

Since we started to talk about binary and VQC said some patterns are easier seen in binary I re-did patterns in >>3050 and looked at the d's in binary.

For (1, 5) (Note, since I struggle a bit with 0 and 1, - means 0 and k means 1). The code for bprint was found on stackoverflow.

>>bprint(12)------------kk-->>> bprint(30)-----------kkkk->>> bprint(46)----------k-kkk->>> bprint(76)---------k--kk-->>> bprint(100)---------kk--k-->>> bprint(142)--------k---kkk->>> bprint(174)--------k-k-kkk->>> bprint(228)--------kkk--k-->>> bprint(268)-------k----kk-->>> bprint(334)-------k-k--kkk->>> bprint(382)-------k-kkkkkk-12 gives d[t] - d: 2, 4, 6, 8, 10, 12, 14, 16.., 30 (Change of 2, or 4 if interleaved)30 gives d[t] - d: 1, 3, 5, 7, 9, 11, 13, 15, .., 3146 gives d[t] - d: 1, 3, 5, 7, 9, 11, 13, 15, .., 3176 gives d[t] - d: 2, 4, 6, 8, 10, 12, 14, 16.., 30100 gives d[t] - d: 2, 4, 6, 8, 10, 12, 14, 16.., 30

So we can see that the second LSB is either 1 or 0 and when it is, the alternating pattern is the pattern of d's where d[t] - d contains n-1 as a factor. Again, not sure if this is a fluke or a pattern.

For (1, 13)

>>bprint(6)-------------kk->>> bprint(38)----------k--kk->>> bprint(68)---------k---k-->>> bprint(132)--------k----k-->>> bprint(182)--------k-kk-kk->>> bprint(278)-------k---k-kk->>> bprint(348)-------k-k-kkk-->>> bprint(476)-------kkk-kkk--6 gives 3, 9, 15, 21, 27 (Change of 6)38 gives d[t] - d: 1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 3168 gives d[t] - d: 2, 4, 8, 10, 14, 16, 20, 22, 26, 28132 gives d[t] - d: 6, 12, 18, 24, 30182 gives d[t] - d: 1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31278 d[t] - d: 1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31348 d[t] - d: 6, 12, 18, 24, 30476 d[t] - d: 2, 4, 8, 10, 14, 16, 20, 22, 26, 28

Here we have three (or four if you count (1, 13, 1)) distinct patterns of d[t] - d mod (n - 1).

The only bit 348 and 132 has in common is the 4th LSB, which is set to 1. While 38, 182 and 278 has the 4th and 2nd bit equal to 2 in common. 68 and 476 has 68 in common, but with more d's that give the same pattern, maybe there is more too it.

All in all though, I'm not sure if we are barking up the wrong tree here.

>>3220

Oh, wow. I had no idea that this beautiful pattern existed in something as simple as binary numbers.

Thank you! That's is amazing.

I played some with it:

Here we see (c, e, d, binary)

1 0 1 | 2 1 1 | 3 2 1 || 4 0 2 | 5 1 2 | | 6 2 2 || 7 3 2 ||| 8 4 2 | 9 0 3 | | 10 1 3 | | 11 2 3 || | 12 3 3 || 13 4 3 | || 14 5 3 ||| 15 6 3 |||| 16 0 4 | 17 1 4 | | 18 2 4 | | 19 3 4 || | 20 4 4 | | 21 5 4 | | | 22 6 4 || | 23 7 4 ||| | 24 8 4 || 25 0 5 | || 26 1 5 | || 27 2 5 || || 28 3 5 ||| 29 4 5 | ||| 30 5 5 |||| 31 6 5 ||||| 32 7 5 | 33 8 5 | | 34 9 5 | | 35 10 5 || | 36 0 6 | | 37 1 6 | | | 38 2 6 || | 39 3 6 ||| | 40 4 6 | | 41 5 6 | | | 42 6 6 | | | 43 7 6 || | | 44 8 6 || | 45 9 6 | || | 46 10 6 ||| | 47 11 6 |||| | 48 12 6 || 49 0 7 | || 50 1 7 | || 51 2 7 || || 52 3 7 | || 53 4 7 | | || 54 5 7 || || 55 6 7 ||| || 56 7 7 ||| 57 8 7 | ||| 58 9 7 | ||| 59 10 7 || ||| 60 11 7 |||| 61 12 7 | |||| 62 13 7 ||||| 63 14 7 |||||| 64 0 8 | 65 1 8 | | 66 2 8 | | 67 3 8 || | 68 4 8 | | 69 5 8 | | | 70 6 8 || | 71 7 8 ||| | 72 8 8 | | 73 9 8 | | | 74 10 8 | | | 75 11 8 || | | 76 12 8 || | 77 13 8 | || | 78 14 8 ||| | 79 15 8 |||| | 80 16 8 | | 81 0 9 | | | 82 1 9 | | | 83 2 9 || | | 84 3 9 | | | 85 4 9 | | | | 86 5 9 || | | 87 6 9 ||| | |

>>3223

You can see how every time c is a perfect square, the d "resets" and starts counting up again.

>>3224

Correction, the e resets.

Here we have the first 15 records from (1, 1)

5 1 2 | | 65 1 8 | | 325 1 18 | | | | 1025 1 32 | | 2501 1 50 | | ||| | 5185 1 72 | | | | 9605 1 98 | | || | | 16385 1 128 | | 26245 1 162 | | | || || 40001 1 200 | | ||| | 58565 1 242 | | || | ||| 82945 1 288 | | | | 114245 1 338 | | | ||||| || 153665 1 392 | | || | | 202501 1 450 | | ||| | ||

>>3226

In that one the binary is a c in binary.

This one is d in binary for first 15 records of (1, 1):

5 1 2 | 65 1 8 | 325 1 18 | | 1025 1 32 | 2501 1 50 | || 5185 1 72 | | 9605 1 98 | || 16385 1 128 | 26245 1 162 | | | 40001 1 200 | || 58565 1 242 | |||| 82945 1 288 | | 114245 1 338 | | | | 153665 1 392 | || 202501 1 450 | |||

>>3229

Regarding interwoven / interleaved patterns, you'll see theres 4 or 5 I think in (0, 8). 2 isn't a magic number, I suspect that you can find infinite interwoven patterns in any (e, n) if you extend the grid into infinity.

Maybe there is a limit, but I haven't spent any time looking into it. All we know is that for every an in (e, 1), the a will exist in (e, n). Thus assuming infinite long (e, 1) and given the p * i + t, p * i + 1 - t I conjecture (That's right guys, I'm a math guy now) that there's infinite of them.

>>3234

I'm just thinking out loud here. VQC is very adamant about:

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

> 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

Now, why is the x so important? Why do we need to care that x at na in (e, 1) is the SAME x as (e, n) if we are supposed to find na?

I mean, why would he stress that x is the SAME at (e, 1) as (e, n) if na already hit's the spot?

If we are supposed to find a pattern for (n - 1), then in the end, we'll now what n - 1 is, and then we know what n is and then we'll just do na / n to get a. So why is x important? Could it be that there is more to it than we think?

Also, why is d[t] = na + x so important? We know from that equation that d[t] - x = na, d[t] - na = x. Yet if we find the correct d[t] we have x and na, so again. Why are those three highlighted by VQC in the latest hint?

>>3235

So if the x is important, maybe we aren't going to find n or (n - 1).

He also talks about an offset. That the pattern of (n - 1) in (e, 1) will give us an offset. So the offset will somehow give us x?

Maybe the offset will aid in generating numbers that will be potential x's? And at some point we have to use that to find (e, n) for a given c?

I'm probably talking about things everyone already knows. I just want to try and air my thoughts.

>>3258

I know you've talked about this m, before but I coulnd't a description.

Could you explain m? And could you give an example of moving mutliple d's at a time?

Has anyone noticed this before?

(0, 5). Divide the a's by 5 and you'll get (1, 1) d's.

{0:5:20:10:10:40}

{0:5:60:20:40:90}

{0:5:120:30:90:160}

{0:5:200:40:160:250}

{0:5:300:50:250:360}

{0:5:420:60:360:490}

>>> 10/5

2.0

>>> 40/5

8.0

>>> 90/5

18.0

>>> 160/5

32.0

>>> 250/5

50.0

>>> 360/5

72.0

>>3342

And the a's for (0, 4) is also equal to the d's of (1, 1)

Do we have a collection of Chris' crumbs?

>>3385

Is this something VQC has said?