Bashicu matrix system

**Bashicu matrix system** (BMS) is an ordinal array notation by Bashicu first made in 2014 that has come into vogue within recent years due to its ease of learning, simple rule set, and large ordinal outputs.

## Lexicographic ordering

Bashicu matrix system works under a **lexicographic ordering** ordering of ordinals, which means that if one ordinal B is bigger than another ordinal A, then B will come past A in a dictionary where you have a predefined alphabet. In BMS, the alphabet is not letters but numbers, and instead of words you have arrays. An array is an m x n grid structure holding a bunch of numbers. All BMS arrays have infinite height and extend infinitely far downwards, but all rows past those being used at the moment will be filled with nothing but zeros, so we can ignore this Zeroland and preserve the rows with relevant numbers.

These preserved arrays are then converted into linear strings of number groups to make them easier to work with. The number groups are formed from writing down the numbers in columns from left to right, top to bottom, such that every number group is a column.

There is no real need to do this, but it makes working with arrays easier as they are often discussed online where formatting arrays can be tricky.

On account of these groupings and the notation's properties, one can compare two ordinals very easily by checking the lexicographic ordering of two ordinal's corresponding strings. For example, if we have (0)(1)(1)(1) and (0)(1)(2), we can see which one comes after the other by writing them down side by side:

```
(0)(1)(1)(1)
(0)(1)(2)

```

(0)(1)(2) is greater than (0)(1)(1)(1) because (2) is of later priority than (1). For arrays which reduce down to pairs we can still compare them. For the case of (0)(1)(2)(1) and (0,0)(1,1)(1,1)(1,0) we can just add 0s to every number in the first array (annexing part of Zeroland) and write them down side by side:

```
(0,0)(1,0)(2,0)(1,0)
(0,0)(1,1)(1,1)(1,0)

```

(0,0)(1,1)(1,1)(1,0) is greater than (0,0)(1,0)(2,0)(1,0) because (1,1) is of later priority than (1,0).

This process of comparing number groups for arrays with any number of rows. BMS is built in stages like a rocket, where the first stage only deals with all *valid* single-row arrays, or groups of number with only one number per group. These are arrays like (0)(1)(2)(3)(2)(1) and (0)(1)(2)(3)(4). The limit of this notation is (0,0)(1,1), which is bigger than any single row array. So too (0,0,0)(1,1,1) is bigger than any two row array, (0,0,0,0)(1,1,1,1) is bigger than any three row array, and so forth. The limit of BMS is the first ordinal greater than (0)(1), (0,0)(1,1), (0,0,0)(1,1,1), (0,0,0,0)(1,1,1,1),. . .

## Evaluation

### Single row arrays

The number we are incrementing is placed in square brackets to the right of the array. When the array is reduced to nothing, the number left in the bracket is said to be the numerical output of the array. When there is no square brackets, we treat the array as an ordinal. With the bracket it becomes like the fast growing hierarchy.

The simplest BMS array is (0), and it is treated the same as 1. (0)[n] = n + 1 and in general, A(0)[n] = A[n + 1] where A is an existing array. This applies for higher rowed arrays, so that in general, (0,0,. . .)[n] = n + 1 and A(0,0,. . .)[n] = A[n + 1].

What if the ending column (a) is not (0) though - how do we evaluate A(a)[n]? First, we look within the array A for the first column (b) before (a) such that b + 1 = a. Everything in the array before this column is called A' while everything from (b) and the column *right before* (a) is labeled A''. Given that Xn denotes concatenation of the string X a total of n-times, A(a)[n] = A'A''n[n].

As an example, suppose we have the array and number (0)(1)(2)(1)(1)[2]. First we look at the last column of the array. It is (0)(1)(2)(1)**(1)**[2], so we must look for the first column (a) such that a + 1 = 1, or a = 0. This is **(0)**(1)(2)(1)(1)[2]. There is nothing before (0) so A' is empty. From (0) to right before the ending (1) there is **(0)(1)(2)(1)**(1)[2], so that we treat the part in bold as A'' and duplicate it twice, as two is the number in the brackets. Thus (0)(1)(2)(1)(1)[2] becomes (0)(1)(2)(1)(0)(1)(2)(1)[2]. We can keep reducing it like so:

```
(0)(1)(2)(1)(0)(1)(2)(1)[2]
(0)(1)(2)(1)(0)(1)(2)(0)(1)(2)[2]
(0)(1)(2)(1)(0)(1)(2)(0)(1)(1)[2]
(0)(1)(2)(1)(0)(1)(2)(0)(1)(0)(1)[2]
(0)(1)(2)(1)(0)(1)(2)(0)(1)(0)(0)[2]
(0)(1)(2)(1)(0)(1)(2)(0)(1)(0)[3]

```

Note it took six reductions from (0)(1)(2)(1)(1) just to increment the number in brackets by one. There is an issue though, what of arrays like (0)(2) or (2)(1)(0)? From the rules given it may seem there is no way to expand these arrays. For (0)(2), the final column is (2) but there is no (1) column and thus no expansion. To fix this, we define a *valid* array as one that is derivable from expansions of the arrays (0)(1), (0)(1)(2), (0)(1)(2)(3), and so on, given that we're allowed to change the number in brackets at any point. So for instance you might start out with (0)(1)(2)(3) and expand it into (0)(1)(2)(2)(2)(2) through (0)(1)(2)(3)[4]. Then you may change the bracket number to 3 and expand (0)(1)(2)(2)(2)(2) into (0)(1)(2)(2)(2)(1)(2)(2)(2)(1)(2)(2)(2). The set of all possible such arrays is the set of valid arrays within single row BMS.

In addition to expansion, one can also contract single row arrays by expanding in reverse. In general, every (0) tacked on the end of an array adds one to the equivalent ordinal, where (0) is equivalent to 1. When you have a repeating *unit* (one or more columns), the limit of these units is the first followed by the first column of the second unit incremented by one. For instance, (0) = 1, (0)(0) = 2, (0)(0)(0) = 3, and the limit of (0), (0)(0), (0)(0)(0),. . . would be the first unit (in this case just (0)) followed by the first column of the second unit (still (0)) incremented by one (1). This is (0)(1). Thus, (0)(1) = ω. Some correspondences for single row BMS is given.

The limit of single row BMS is ε0, which is also the limit of all the ordinals you can make with nothing but {0,ω} and repeated addition, multiplication, and exponentiation.

### Double row arrays

As (0,1) is not a valid array but (0,0)(1,1) is (for reasons which will be dealt with soon), we begin double row BMS at (0,0)(1,1), defined to be ε0. The same exact rules apply only now when we have a limit of repeating units, we make sure to specify that the *first* number in the column is incremented by one. For example, (0,0)(1,1)(0,0), (0,0)(1,1)(0,0)(0,0), (0,0)(1,1)(0,0)(0,0)(0,0),. . . would have a limit of (0,0)(1,1)(0,0)(1,0), *not* (0,0)(1,1)(0,0)(0,1) or (0,0)(1,1)(0,0)(1,1).

Additionally there is a special limit case in double row BMS arrays which goes like so:

* The limit of a series of arrays with units of columns all of whose column's numbers are being incremented by a constant amount is the first unit followed by the second unit with the second number incremented by one.

What does this mean? Let's take the array series (0), (0)(1), (0)(1)(2), (0)(1)(2)(3),. . . It is clear that the unit is just a single column at the very beginning, and every number in that column (in this case only one number) is being incremented by one every time this unit is repeated. Thus the block visual of these arrays resemble staircases. According to this special rule, we keep the first step in the staircase (0) and increment the *second* number in the second step by one. This forces us to switch to double row arrays, and so this is why the limit of single row arrays is (0,0)(1,1).

As another example let us take (0,0)(1,1)(0,0), (0,0)(1,1)(0,0)(1,0), (0,0)(1,1)(0,0)(1,0)(2,0),. . . The units begin after the (0,0)(1,1), starting with the second (0,0). The limit of these arrays would be (0,0)(1,1) then (0,0) then (1,0) with the second number incremented by one (1,1) leading to (0,0)(1,1)(0,0)(1,1).

The following is an analysis of double row BMS.