User blog comment:Edwin Shade/My Googological Goals For The Year Of 2018/@comment-32697988-20180101223205/@comment-77.126.98.63-20180103180706

Pair-sequence numbers are really easy to grasp and expand (the difficult part is analyzing them and tracking which pair-sequence expression corresponds to which ordinal):

'''Note: The variant defined here simulates the good old Hardy Hierarchy. The computer program version is abit different, but they follow the same principles.'''

1. The format is:

(0,0)(a,b)(c,d)(e,f)....(X,Y)[n]

2. We call the last pair (X,Y) the "tail" of the expression.

3. If the tail is (0,0) then we cut it off and add 1 to n. For example:

(0,0)[4] = 5

(0,0)(1,1)(0,0)(0,0)[4] = (0,0)(1,1)(0,0)[5] = (0,0)(1,1)[6]

4. If the tail is (0,Y) for some Y>0, then we replace the Y with 0 and apply rule 3.

(this should never happen, by the way. I give this rule for sake of completion, but in actual use you should never have a pair (x,y) where y is greater then x).

5. If the tail (X,Y) has X>0 and Y=0 then we do the following:

(i) Find the rightmost pair-of-numbers for which x<X

(ii) Cut off the tail.

(iii) Split the entire expression at the point just before this pair we found, into two parts.

For example, if we have the expression (0,0)(1,1)(2,1)(3,0)(4,0)(3,0)[100], then the tail is (3,0) and we split it into:

Part A: (0,0)(1,1)

Part B: (2,1)(3,0)(4,0) (with the (3,0)[100] cut off)

This is because (2,1) is the rightmost pair whose x is less than 3.

Note that "Part A" may be empty. For example, if we have the expression:

(0,0)(1,0)(2,0)(1,0)[4]

Then the tail is [1,0]. The only pair in the sequence for which x<1 is the leftmost one (0,0). So we have:

Part A: [empty]

Part B: (0,0)(1,0)(2,0) (with the tail (1,0)[4] cut off).

(iv) We leave Part A untouched, and copy Part B n times. Finally, we re-append the original [n] to the entiry string.

For example:

(0,0)(1,0)(2,0)[4] = (0,0)(1,0)(0,0)(1,0)(0,0)(1,0)(0,0)(1,0)[4]

(remember that (0,0)(1,0)(2,0) has no part A at all. So we simply cut off the tail (2,0) and copy the rest 4 times)

And that's it, for expressions for which the tail's Y is 0.

6. If the tail (X,Y) has X>0 and Y>0 then the rules are a little different:

(i) Find the rightmost pair-of-numbers for which x<X and y<Y

(ii) Cut off the tail.

(iii) Split the entire expression at the point just before this pair we found, into two parts:

For example, if we have the expression (0,0)(1,1)(2,1)(0,0)(1,1)(2,1)[100], then the tail is (2,1) and we split it into:

Part A: (0,0)(1,1)(2,1)

Part B: (0,0)(1,1) (with the (2,1)[100] cut off)

This is because the second (0,0) is the rightmost pair whose x is less than 2 and whose y is less than 1..

Again, just like in the previous section, "Part A" may be empty.

(iv) As before, we leave Part A untouched.

(v) We copy Part B n times with a twist: For the nth copy, we add (n-1)*X to all the x-components of the pairs we've copied. The y-components remain unchanged.

This may sound complicated, but in reality it is quite simple, as the following example shows:

(0,0)(1,1)[4] = (0,0)(1,0)(2,0)(3,0)[4]

("Part A" here is empty and "Part B" is simply (0,0). We copy it 4 times, adding 1 to the first number in each copy).

(remember that (0,0)(1,0)(2,0) has no part A at all. So we simply cut off the tail (2,0) and copy the rest 4 times).

Another example:

(0,0)(1,1)(2,1)[4] = (0,0)(1,1)(2,0)(3,1)(4,0)(5,1)(6,0)(7,1)[4]

(here Part A is empty and Part B is (0,0)(1,1). We copy the (0,0)(1,1) 4 times, adding 2 to the first first numbers at each copy. So (0,0)(1,1) becomes (2,0)(3,1)... and then (4,0)(5,1)... and then (6,0)(7,1))

And that's it!

The above rules are everything you need to expand any arbitrary pair-sequence expression.

Note:

There are several variations on this notation. In some, you add 1 to n at every iteration. In others, you square n instead of adding 1. In still others, we use n2 as the number of copies as well. I think this last one was the original version used in the computer programs.

At any rate, all these versions have exactly the same strength. Moreover, in all of them, the exact same strings correspond to the same ordinals (though the actual evaluated numbers would - of course - be somewhat different).

=
==============================

As for learning the general Bashicu-Matrix-System: You should be warned that nobody even knows if it is well defined. That is, nobody knows if - say - (0,0,0)(1,1,1)(2,2,2)(3,3,3)[4] actually terminates. It might well expand forever.

Indeed, a previous version of the BMS was shown to have precisely this problem: For some strings, the system would fall into an infinite loop, replicated the same string over and over. The issue with that specific string was fixed, but we don't really have any reason to believe the new system is free of such bugs.

Ordinary Pair-sequence numbers, though, do work. Quite a few people here analyzed them extensively (including myself) and you can be sure - when you learn it - that you're learning a well-defined (and quite powerful) notation..