Shout out to BO for a safe space to play! ty

>>8946 to be both Root && Offspring? _p_arent && _c_hild? aN (i)magined(f)uture mANifest? interdasting!

>>8905 ty for these.

>>8891 && >>8892 good to read you pma!

Validated a number of t's for the e, n's you had in the graphc: "c259-cpivot-lea-v1.png" and got match.

For the (0,n), are you using '0' as your t[1] value with reference to the original VQC grid?

• see pic, one t diff vs. the vqc grid generated with orig source code, maybe missing something?

• here's the text for the cap (won't be formatted correctly here)

Counting t starting t=0 as t[1]?

t e n d x a b c i j

——- ——- ——- ——- ——- ——- ——- ——- ——- ————–

3 0 1 24 6 18 32 576 25 7 <- pma_t=4

4 0 1 40 8 32 50 1600 41 9 <- pma_t=5

5 0 1 60 10 50 72 3600 61 11

6 0 1 84 12 72 98 7056 85 13

7 0 1 112 14 98 128 12544 113 15 <- pma_t=8

Thanks for any feedback, just trying to dot my i's and cross my t's given the importance of precisely keying off the intended point in the sequence!!

>>8868 pt 1 of 2

Hi AA, trying to line up my e=0 and e=(-1) columns, and using some of your output as a reference. Can you please check if this is completely wonk??

Think these examples used earlier code provided in (lb) for the 'everything' cell, and may not be the latest, so take all this with a grain of salt. I have the 'qcn' running and could check that output if it helps. Just trying to stay lined up.

First 2 pics are example outputs when running the 'everything' code. This is where the (e, n, t) values were sourced from.

Next two pics are the (0,0) and (0,1) cells for t=1:25.

Finally, a comparison of various n,t values scraped from the code output for comparison. The two examples run were c=6107 and c=144, no bit trim, show everything.

Here's the paste of the values in the images, a copypasta into notepad should line things up:

$ java -cp . everything

(0,n) aa,bb = (0,722,20) = {0:722:39:38:1:1521}, f=-79, c=1521, u=380, i=761, j=760

(0,n) ab,ab = (0,0,1) = {0:0:39:0:39:39}, f=-79, c=1521, u=0, i=39, j=0

(0,n) a,abb = (0,722,20) = {0:722:39:38:1:1521}, f=-79, c=1521, u=380, i=761, j=760

(0,n) b,aab = (0,0,1) = {0:0:39:0:39:39}, f=-79, c=1521, u=0, i=39, j=0

(0,n) 1,cc = (0,722,20) = {0:722:39:38:1:1521}, f=-79, c=1521, u=380, i=761, j=760

(1,1) d=aabbn = (1,1,19) = {1:1:722:37:685:761}, f=-1444, c=521285, u=19, i=723, j=38

(0,1) a=aabbn = (0,1,20) = {0:1:760:38:722:800}, f=-1521, c=577600, u=19, i=761, j=39

(e,1) a=na = (3,1,3) = {3:1:19:5:14:26}, f=-36, c=364, u=3, i=20, j=6 — a[t] = sq+(sq)+(e-1)/2 = 4+9+1

(f,1) a=a(n-1) = (-10,1,4) = {-10:1:19:6:13:27}, f=27, c=351, u=3, i=20, j=7 — a[t] = sq+sq+e/2 = 9+9+-5

(e,1) a=bn = (3,1,17) = {3:1:579:33:546:614}, f=-1156, c=335244, u=17, i=580, j=34 — a[t] = sq+(sq)+(e-1)/2 = 256+289+1

Try c=144 (to put a perfect square in Zero Column)

(0,n) ab,ab = (0,0,1) = {0:0:12:0:12:12}, f=-25, c=144, u=0, i=12, j=0

t e n d x a b c i j

1 0 0 1 0 1 1 1 1 0 <- t=1 in VQC Grid Generator

2 0 0 2 0 2 2 4 2 0

3 0 0 3 0 3 3 9 3 0

4 0 0 4 0 4 4 16 4 0

5 0 0 5 0 5 5 25 5 0

6 0 0 6 0 6 6 36 6 0

7 0 0 7 0 7 7 49 7 0

8 0 0 8 0 8 8 64 8 0

9 0 0 9 0 9 9 81 9 0

10 0 0 10 0 10 10 100 10 0

11 0 0 11 0 11 11 121 11 0

12 0 0 12 0 12 12 144 12 0 AA

13 0 0 13 0 13 13 169 13 0

14 0 0 14 0 14 14 196 14 0

15 0 0 15 0 15 15 225 15 0

16 0 0 16 0 16 16 256 16 0

17 0 0 17 0 17 17 289 17 0

18 0 0 18 0 18 18 324 18 0

19 0 0 19 0 19 19 361 19 0

20 0 0 20 0 20 20 400 20 0

21 0 0 21 0 21 21 441 21 0

22 0 0 22 0 22 22 484 22 0

23 0 0 23 0 23 23 529 23 0

24 0 0 24 0 24 24 576 24 0

25 0 0 25 0 25 25 625 25 0

(0,1) a=aabbn = (0,1,3) = {0:1:12:4:8:18}, f=-25, c=144, u=2, i=13, j=5

t e n d x a b c i j

1 0 1 4 2 2 8 16 5 3

2 0 1 12 4 8 18 144 13 5 AA

3 0 1 24 6 18 32 576 25 7 <- t=3 in VQC Grid Generator

4 0 1 40 8 32 50 1600 41 9

5 0 1 60 10 50 72 3600 61 11

6 0 1 84 12 72 98 7056 85 13

7 0 1 112 14 98 128 12544 113 15

8 0 1 144 16 128 162 20736 145 17

9 0 1 180 18 162 200 32400 181 19

10 0 1 220 20 200 242 48400 221 21

11 0 1 264 22 242 288 69696 265 23

12 0 1 312 24 288 338 97344 313 25

13 0 1 364 26 338 392 132496 365 27

14 0 1 420 28 392 450 176400 421 29

15 0 1 480 30 450 512 230400 481 31

16 0 1 544 32 512 578 295936 545 33

17 0 1 612 34 578 648 374544 613 35

18 0 1 684 36 648 722 467856 685 37

19 0 1 760 38 722 800 577600 761 39

20 0 1 840 40 800 882 705600 841 41

21 0 1 924 42 882 968 853776 925 43

22 0 1 1012 44 968 1058 1024144 1013 45

23 0 1 1104 46 1058 1152 1218816 1105 47

24 0 1 1200 48 1152 1250 1440000 1201 49

25 0 1 1300 50 1250 1352 1690000 1301 51

>>8948

>>8868 pt 2 of 2

(0,1) a=aabbn = (0,1,20) = {0:1:760:38:722:800}, f=-1521, c=577600, u=19, i=761, j=39

t e n d x a b c i j

19 0 1 760 38 722 800 577600 761 39 AA

20 0 1 840 40 800 882 705600 841 41 <- t=20 in VQC Grid Generator

(0,n) b,aab = (0,3,4) = {0:3:12:6:6:24}, f=-25, c=144, u=4, i=15, j=9

t e n d x a b c i j

1 0 3 12 6 6 24 144 15 9 AA

2 0 3 36 12 24 54 1296 39 15

3 0 3 72 18 54 96 5184 75 21

4 0 3 120 24 96 150 14400 123 27 <- t=4 in VQC Grid Generator

(0,n) aa,bb = (0,8,5) = 0:8:12:8:4:36}, f=-25, c=144, u=8, i=20, j=16

t e n d x a b c i j

2 0 8 12 8 4 36 144 20 16 AA

3 0 8 21 12 9 49 441 29 20

4 0 8 32 16 16 64 1024 40 24

5 0 8 45 20 25 81 2025 53 28 <- t=5 in VQC Grid Generator

(0,n) a,abb = (0,25,6) = {0:25:12:10:2:72}, f=-25, c=144, u=17, i=37, j=35

t e n d x a b c i j

1 0 25 12 10 2 72 144 37 35 AA

2 0 25 28 20 8 98 784 53 45

3 0 25 48 30 18 128 2304 73 55

4 0 25 72 40 32 162 5184 97 65

5 0 25 100 50 50 200 10000 125 75

6 0 25 132 60 72 242 17424 157 85 <- t=6 in VQC Grid Generator

(0,n) 1,cc = (0,60,6) = {0:60:12:11:1:144}, f=-25, c=144, u=35, i=72, j=72

t e n d x a b c i j AA j=72 not in positive space

1 0 60 90 60 30 270 8100 150 120

2 0 60 240 120 120 480 57600 300 180

3 0 60 450 180 270 750 202500 510 240

4 0 60 720 240 480 1080 518400 780 300

5 0 60 1050 300 750 1470 1102500 1110 360

6 0 60 1440 360 1080 1920 2073600 1500 420 <- t=6 in VQC Grid Generator (j=420!)

(e,n) cell = (0,18,4) = {0:18:7:6:1:49}, f=-15, c=49, u=12, i=25, j=24

t e n d x a b c i j

1 0 18 7 6 1 49 49 25 24 AA

2 0 18 16 12 4 64 256 34 30

3 0 18 27 18 9 81 729 45 36

4 0 18 40 24 16 100 1600 58 42 <- t=4 in VQC Grid Generator (j=420!)

5 0 18 55 30 25 121 3025 73 48

>>8899 nice dubs!

Would you be kind enough to provide some t-outputs and supporting formulas for various (0,n) and ((-1), n) cells?

• just getting the base 'x' value at t[1] would be most helpful.

• a view to the t-sequences in e=(-1) would be golden.

• Here's a pastebin of the vqc code output:

pastebin: https://pastebin.com/fLvvuZ8M

name: VQC output eZero eMinusOne

t = 25 (so shifted_row# mod25 gives start of next cell)

Attached pic gives sense of the x at t=1 pattern in n0 for n=1:263

>>8947 pma, think worded improperly, and this isn't much better: when VQC element=t[1], you may be displaying t[2], not t[0] as implied.

>>8952 ty again AA.

Yes, that's the program used, from 12/21. Did the four corrections, changing the subtracts to add (2 were at lines 553 & 554).

Also worked to follow your other recent code with the 'qcn'. Have looked at, run, or translated most of the other code sources listed in the thread links or dropped in threads.

> if(e%2==0) t=(x+2)/2, else t=(x+1)/2. That's the formula I've always been using. And with the (0,0) cell, all of them are t=1. The x values are all 0.

Started there and had lower n cells working, but the deviations don't start popping up until a bit later. See the graph above, the two 'lines' in the graph are the formulas you reference, but the dots down below are the deviations that am working to enumerate. First started trying different mods and formulas, but wasn't generalizable for all n so needed to dig in further. Still in the middle of it, but have several of the pattterns down.

Using the VQC C# code, generated a grid to n=128, then went further to around n=263, and t-vals from 1:25. This is reference for patterns and debugging, and source of the pastebin above.

e(-1) is more complicated than e0 as there are interleaving patterns within the t's, while all t's for any n in e0 are trivial once you have the 'x_base'. The x value where t=1 for a cell is 'x_base'.

Attached are three graphs of the same x_base in e0 data, different zoom levels. Macro view highlights the patterns, and the boxed area are the bounds for the second graph. Note the flat line for all t-points for each n, this is why it's trivial to calc any element once the x_base is known.

Few patterns to note:

=: in e0, if n is prime, x_base = 2*n appears to hold for all n.

=: in e(-1), if n is prime, x_base = 2*n-1 appears to hold for all n.

=: in e0, if n is a perfect square (2, 4, 9, 16, …), then x_base = 2*(sqrt(n))

>>8955 thanks pma, appreciate the response.

We are not aligned properly: are you suggesting we ignore the original VQC algorithm and grid? (do recognize the questionable element starts in the -e space, esp. clear with n0 and the squares - see pic).

Are we to ignore the additional seeds in cells that have more than one?

Perhaps we start with the e0 column, and consider n>3. Have provided several here >>8949 and in the pastebin above (a .csv file).

Enumerate the patterns. Reconcile with the original grid output. What do you see?

>>8957 Nice encouragement. Are you ready?

>>8638

>I'll be using small and very large integers to demonstrate so have your BigInteger library ready to follow!

>>8964

Awesome VA!!! Me too, a coder would laugh at this spaghetti, but hey, it's working and making progress. Learned a lot reading through the java and python examples and translating that code. The Rust code is nice, great structure, can see Rusty takes pride in his work.

Been a series of back and forth between code and excel to prototype things. Learning to spend more time 'white-boarding' and less debugging.

Making good progress && closing in on Column Zero atm. Found a few keys after sewing seed that germinated and grew quite nicely.

>>8970 Look at you!! Totally agree, feels good.

Will take a look, am working on a couple odd issues && (-e) but close. The (16, 1) am spot on.

e n t e n d x a b c

16 1 11 : 16 1 228 20 208 250 = 52000

16 1 59 : 16 1 6852 116 6736 6970 = 46949920

16 1 60 : 16 1 7088 118 6970 7208 = 50239760

>>8971 great response, ty

>no, most definitely not.

Excellent. Am using as basis for all enumeration && debugging.

>But we should understand that it was a small subset of an infinite grid.

Absolutely, but enough to see the patterns and enumerate the various series. Most importantly, our code output should be coherent with that finite portion of the sample grid output. If there is discord between vqc algorithm gridcode and other code generation, it may not work for the lookup. Figure that given it's all about time, it needs to match to a "t".

Point was and is, best I can tell, it doesn't currently line up in the e0 examples cited, from perspective of the "t" value associated with an element in that e0, n cell, for larger n-vals.

Appreciate the comments, and exposition of the code. Don't quite understand the following statement (but it's ok, please don't feel the need to explain it further):

>This generates data between (0,n) and (1020,n), over an n range of 0 to 480.

I did get head around the f-transform that is done with these bits:

int f = e - ((2 * d) + 1);

..

if (!theend.ContainsKey(f)) theend[f] = new Dictionary<int, List<string>>();

if (!theend[f].ContainsKey(n - 1)) theend[f][n - 1] = new List<string>();

And modified the next couple lines (to catch the i&j outputs, to understand how the inner and outer loop worked, and validate calcs in other code.

Format("{0}:{1}:{2}:{3}:{4}:{5}:{6}:{7}:{8}", e, n, d, x, a, b, c, i, j) + "}";

Format("{0}:{1}:{2}:{3}:{4}:{5}:{6}:{7}:{8}", f, n - 1, d + 1, x + 1, a, b, c, i, j) + "}";

In order to generate reference grid (& the pastebin output above) with larger n values and deeper on the t values (Count z in gridCode), changed the Output part to:

public static void Output(int i_max = 11111, int x_min = -16, int y_min = 0, int x_max = 16, int y_max = 264, int set_size = 25)

That y-max is about the highest that works before the gridcode won't finish running. It still misses some of the higher t-elements (see little yellow dashes in 2nd pic here: >>8953 as example of the limits of i-max).

Was great what Prime Anon did for visualizing how the grid fills with the inner and outer loops. For the original link to bitchute see: >>7279 (bread rehash thread). There's an mp4 here: >>8933 (pic related).

Think primary issue is e0 and e(-1) for n>10 or so.

Will check against the (-4, 1) and (-9, 1) outputs, including negative t-values, and keep an eye on where "0" falls from minus-t on over to plus-t elements. Red line, blue line, t-line! Thanks for generating.

>You'll notice that the output you posted doesn't include any records before (-4,1,3) or (-9,1,3).

Haha, did that on purpose!

>>8953 continuing in e(-1).. it's humbling, but her secrets unfold with perseverence. Series upon series of linear and quadratic patterns.. nesting, overlapping and interleaved (pic). Enumerating and generalizing.

Nice work all!

And for fun, a selection from some offline reading centered around sequences lately.

2018 paper titled: "There are no Coincidences":

Let us start with evil and odious numbers introduced by John Conway.

A non-negative integer is called evil if the number of ones in its binary expansion is even and it is called odious otherwise.

The sequence of evil numbers is A001969: 0, 3, 5, 6, 9, 10, 12, 15, 17, 18, 20, 23, 24, . . ., starting from index 1. We will denote the sequence as e(n).

The sequence of odious numbers is A000069: 1, 2, 4, 7, 8, 11, 13, 14, 16, 19, 21, 22, 25, 26, . . ., starting from index 1. We will denote the sequence as o(n).

Let s2(n) denote the binary weight of n: the number of ones in the binary expansion of n. Thus n is evil if s2(n) ≡ 0 (mod 2), and n is odious if s2(n) ≡ 1 (mod 2).

The Thue-Morse sequence, t(n), is the parity of the sum of the binary digits of n, which is also call[ed] the perfidy of n. It is A010060 (starting with index 0): 0, 1, 1, 0, 1, 0, 0, 1, .. ..

Perfidy is to parity as evil is to even and odious is to odd.

By definition, t(n) = 1 if n is odious, and 0 otherwise. In other words, t(n) = s2(n) (mod 2). Or, t(n) is the characteristic function of odious numbers.

The Thue-Morse sequence has many interesting properties:

• recursive definition: t(2n) = t(n) and t(2n + 1) = 1 − t(n), where t(0) = 0.

• fractal property: the sequence t(n) is a fixed point of the morphism 0 → 0, 1 and 1 → 1, 0.

• cube-free: the sequence t(n) does not contain three consecutive identical blocks. In particular it does not contain 0, 0, 0 nor 1, 1, 1.

"Perfidy is to parity as evil is to even and odious is to odd."

• had to share that!

Hopefully will have a bit more [t]ime to chip away at this in a week or two.

>>9088 PMA, that's incredible progress, ty for sharing.

>>9083

>…. a square?

>>9084 >>9087 AA, you've really got a good sense of the squares and how they play together!

The discussion of squares reminds me of this sequence was studying recently, as part of the e=(-1) enumeration. Am about 1-year behind you all in this, but making some progress.

Let's look at the A033580 pattern in x where t=[1] in e=(-1) column.

First pic (A033580-1): this excel snap shows the first several n (green) and x (yellow) values in the e(-1) column.

• the initial "seed" value for this sequence is 8, "planted" at n=8. The "Occ" column is the "Occurrence", often "i" or "k" for series equations. There are excel equations that use these parameters to generate and highlight the series of "n" for this sequence.

A033580 Four times second pentagonal numbers: a(n) = 2n(3*n+1).

0, 8, 28, 60, 104, 160, 228, 308, 400, 504, 620, 748, 888, …

Second pic (A033580-2): for each sequence, the 'dashboard' pulls the Occurences into a list with the n and x_base values, and calculates the 1st, 2nd, and 3rd differences. This quickly highlights where there is a series and the 'order' of the series (this is 1st order example).

• there are also points where the sequence match to the vqc grid 'breaks down', where the actual x_base in the vqc grid doesn't match the sequence. This cap shows 2 instances, first at Occ 3 for n=60 (sequence would be 19 vs the desired 11 value), and another at n=1980. This is another topic, due to 'dominanance' by another (higher order?) sequence that also has an integer solution for that n. Will leave that aside for this post.

Third pic (A033580-3): This sequence plotted along with several other examples. This is the 3rd from the bottom, the Orange dots.

Fourth pic (A033580-4): This is where it gets more interesting. This sequence plotted against all the x_base values (the tiny blue triangles).

• note that there is another identical sequence with same pattern, just to the left of each orange dot. So we've really identified and extracted a 'sub-sequence' in this case.

• Also note the 'gaps' where there is no x_base triangle. We'll come back to these 'ghost' points in a moment.

Fifth pic (A033580-5):

• first column 'n' values, the bold (160, 228, 308, 400, 504, …) is the sequence highlighted here. Searching OEIS resulted in the (A033580) sequence match.

• the non-highlighted (140, 204, 280, 368, 468, …) are the x_base that this sequenced missed. Search OEIS for that sequence and you'll find:

A033579 Four times pentagonal numbers: a(n) = 2n(3*n-1).

0, 4, 20, 48, 88, 140, 204, 280, 368, 468, 580, 704, 840, 988, 1148

• search both sequences together (140, 160, 204, 228, 280, 308, …) and you'll find:

A062717 Numbers m such that 6*m+1 is a perfect square.

0, 4, 8, 20, 28, 48, 60, 88, 104, 140, 160, 204, 228, 280, 308, 368, 400, 468, 504, 580, 620, 704, 748, 840, 888, …

• the '6' is the growth (usually noted as 'd' in sequence equations). This is 1/2 of the 12-growth used initially here, thus catching both.

What about those 'ghost' values?

• they are 'non-integral' n-values. Note that if these were included x_base is a simple sequence increasing by 2 for each k.

• there is likely a hidden part of the grid that can be used to traverse with these, haven't gone there yet. Diff 2 is constant, so a Second Order series.

The A062717-1 and A062717-2 columns use the 'k' and 'x' values in the previous columns to calculate x_base. These equations are: (= 6k^2 + 10k + 4) and (=(6x(x-1) + (2x-1)(-1)^x + 1)/4) respectively.

• these are then translated into an algorithm to generate the x_base value in e(-1) for any 'n' at t[1]. From there, the rest of the parameters can be calculated.