Introduction to Bashicu Matrix System

Versions are BM4 and BM3.3

==Primitive Sequence System==

PrSS is the most basic form of BMS, having only 1 row. A matrix looks like this: (a)(b)(c)... where a, b, c... are all non-negative integers. A column is an area surrounded by two parentheses including only numbers or commas. Matrices may be followed by [n] where n is a non-negative integer. (If you are familiar with the fast-growing hierarchy, or other similar notations, [n] is exactly the fundamental sequence function except for cases where the matrix is followed by a column of 0s.) I will provide some example matrices.

* (0)(1)(2)

* (0)(1)(2)(3)

* (0)(1)(1)

First, we have to find the bad part, which will be marked in bold. We just find the first column smaller than the last column, called the bad root, and mark it as the bad part, as well as every column following it, save for the final column.

*(0)(1)(2)

*(0)(1)(2)(3)

*(0)(1)(1)

Now, on to evaluation.

* (empty string) = 0


 * 1) (0)[n] = #[n]+1 where # is any string.

If these cases don't apply then do the following:

Remove the last column, remove the bad part, and copy it n times. (Note that when n is 0, the bad part is not copied at all.)

* (0)(1)(2)[n] evaluates to (0)(1)(1)... with n (1)s.

* (0)(1)(2)(3)[n] evaluates to (0)(1)(2)(2)... with n (2)s.

* (0)(1)(1)[n] evaluates to (0)(1)(0)(1)... with n (0)(1)s.

That's it for PrSS.

==Pair Sequence System==

PSS is a bit more complex but is as easy to learn as PrSS. This time a matrix looks like (a,b)(c,d)(e,f)... where a, b, c, d, e, f... are all non-negative integers. The nth row is an array of the nth entries of each column. Everything else, except when otherwise stated, is the same. I will provide some example matrices.

* (0,0)(1,1)(2,0)(1,1)

* (0,0)(1,1)(2,2)

Finding the bad part is a bit more complex. We look at the first row that isn't made up entirely out of 0s.

* (0)(1)(2)(1)

* (0)(1)(2)

If the entry immediately before the last element is greater than or equal to the last element, we cross it out. We repeat this until we have a strictly increasing sequence, meaning every entry is larger than the last.

*(0)(1) (2) (1) -> (0) (1)(2) (1)

*(0) (1) (2)

We put back the columns of the entries that weren't crossed out and-

* (0,0)(1,1)

* (0,0)(2,2)

we do the same thing with the next non-0 row as we did with the first. In these examples, no entries are crossed out.

* (0)(1)

* (0)(2)

The bad root is the column of the second to last column that isn't crossed out. We find the bad part like in PrSS.

*(0,0)(1,1)(2,0)(1,1)

*(0,0)(1,1)(2,2)

Now we must calculate the difference, also known as the delta. First, we subtract the bad root from the last column.

* (1,1) - (0,0) = (1,1)

* (2,2) - (0,0) = (2,2)

And then we replace the last entry with 0.

* (1,0)

* (1,0)

We evaluate like PrSS, but we add the difference 0 times to the first copy of the bad part, 1 time to the second copy, 2 times to the third copy, etc.

* (0,0)(1,1)(2,0)(1,1)[n] = (0,0)(1,1)(1,0)(2,1)... n times.

* (0,0)(1,1)(2,2)[n] = (0,0)(1,1)(2,1)... n times.

That's it for PSS.

==Bashicu Matrix System==

It's finally time to learn the entirety of BMS. A matrix looks like this: (a,b,c...)(d,e,f...)(g,h,i...)... where a, b, c, d, e, f, g, h, i... are all non-negative integers. The columns can be any finite length.

Everything is the same as PrSS except difference only gets added if one of the column's ancestor is the bad root or to the right of the bad root in BM4. In BM3.3, the difference only gets added if one of the column's ancestors is to the right of the bad root. To define ancestors, we first must define parents. To find a parent of a column, remove all columns after it and find the bad root, which is its parent. An ancestor of a column is either it's a parent or a parent of one of its ancestors.