User blog:Ytosk/Trying to define TBMS

There were complaints about TBMS being ill-defined, because i just wrote a finite amount of examples. I decided that before i finish the superscript extension, i should define the previous things.

Rules 1 and 2 are the same as in BMS - if the matrix has no columns, the output is the current input ([n]=n), if the last column is empty, remove it and square the input (SZ[n]=S[n2]), but then we need to know how to compare columns. Finite columns compare in the same way as in BMS. If m and l are natural numbers, n1, n2... up to nm are natural numbers, x is a finite column and y is a transfinite column of the form (n1, n2... nm, l...), and "..." either means completing an obvious sequence or that there can be anything that doesn't cause a syntax error, then x>y if and only if for all i, the i-th entry of x has a 0 before it, or, if i>m, it is greater than l, or it is greater than ni otherwise. y>x if we change every appearance of "greater" to "less" in the conditions of x>y.

To continue to comparing transfinite columns with transfinite columns, we need to know the syntax and what it means. Any sequence of brackets without subscripts and inside a column represents a transfinite amount of some natural number. The default is 1, which we don't need to write, but if we want a transfinite amount of a different number, we write it immediately before the sequence of brackets that represents the amount, in the form "n...". A single number, unless it's the first in its column, has to be separated by "," from both sides. If it is the first in its column, then it has a "," only after it, because a "(" is before it. We don't need to write a number, if there is a transfinite amount of the same number immediately after it. Bracket sequences with subscripts always have a bracket without a subscript immediately before them. If the first number of a subscript is greater than 1, the bracket has to be inside another bracket with the same subscript except the first number is 1 less. Subscripts can contain anything a column can.

We also need to compare transfinite lengths represented by bracket sequences. For sequences without subscripts, we compare them by choosing a natural number n greater than 1, changing the sequences into matrices and solving them with n as input. The sequence with the bigger output represents a larger transfinite length. If the output is the same, then the sequences represent the same transfinite length. For sequences with subscripts, we first compare subscripts, which is done by first comparing the lengths of the subscripts. The longer subscript is greater. If they have the same length, we compare each of the numbers from the end, in the same way as when comparing transfinite columns, but not all numbers have to be larger, one larger number is enough to know that the subscript containing the larger number is larger. If a bracket sequence x has a subscript larger than all subscripts in a bracket sequence y, then x is greater than y. If both x and y have the same maximum subscript, we compare them by taking the sequences of brackets with the maximum subscript, ignoring the existence of the subscript, changing them into matrices, choosing a natural number n greater than 1 and solving the sequences with n as their input. The sequence with the bigger output represents a larger length. If the output is the same, then we compare the sequences by comparing the second largest subscipts, if those are the same, we compare the sequences with those subscripts, that are after the maximum subscript ones, then the sequences with the second largest subscripts before them, then the third largest subscripts, the same stuff with those, etc. Brackets with subscripts are automatically larger than brackets without subscripts.

For transfinite columns x and y, x>y if for all i, the i-th entry of x has a 0 before it, or it is greater than the i-th entry of y, and if there is a transfinite amount α of a number n, we find the largest previous bracket sequence z0, then if z0 is in y only after a larger sequence or z0 isn't in y at all, we only need n to be bigger than all the numbers repeated transfinitely by the bracket sequences starting from the first sequence in y larger than z0, up to the first sequence in y representing a length more than or equal to α. If z0 is in y before any larger sequence, then we find the largest sequence after z0, but before the transfinite amount of n, we will call it z1, and if it isn't before any larger sequence, we only need n to be bigger than all the numbers repeated by the bracket sequences after z0, that are between the first such sequence bigger than z1 and the first such sequence representing a length larger than or equal to α. Similarly, we get z2, z3... zm, until there are no bracket sequences left. In that case, we need n to be larger than all numbers transfinitely repeated after zm, that are not after the first sequence which represents a length larger than or equal to α. Also, if we define l as the amount of single numbers immediately after zm in x, n also has to be larger than the single numbers after zm in y that are after the l-th such single number (single numbers are the numbers that are not repeated transfinitely). This might look like a lot of meaningless conditions, but it's just saying that, for x to be larger than y, every number in x until the first 0 has to be bigger than the number in the same place in y.

The difference of 2 columns could probably be defined in a similar way, so i'll update that when i think of a way and i have time. For now, the difference of x and y is just going to be explained as a column, in which every entry is the difference of the entries in the same place in x and y, if there is no 0 until the next entry in the larger of the columns x and y, and 0 otherwise (the same as in BMS). Addition is also the same as in BMS: x+y is a column where every entry is the sum of the entries in the same place in x and y.

Now we know how to compare columns, so we can get to rule 3. If there is no column smaller than the last column of the matrix, change the last column to and apply rule 2. If there is at least 1 column smaller than the last column, call the rightmost such column L, call the difference between L and the last column D, delete the last column, call L and all the columns to the right of it B0, and define Bn+1 as Bn but every column x is changed to x+D. Now, call the input n and put B1, B2... Bn2 at the end of the matrix. Then, square the input. If N is the last column in the original matrix and S is everything to the left of L in the original matrix, you should now get this expansion:

SB0N[n]=SB0B1B2...Bn2[n2]

I also noticed a little problem with the subscripts - there is no way of writing anything after a bracket sequence with subscripts. For example, if i wanted to write the limit of (11)(211)(311)..., i can't, because adding it after the bracket with 1 in its subscript would be the limit of ((((...)11)11)11), which is much more powerful. That's why i'm now adding / to the set of symbols. / means going back to the level where you just add numbers to the column. The above example would be written as (11/1). That's because brackets with subscripts change the function of the following entries - they are not actually entries in the column, somewhere beyond all the transfinitely repeating stuff, they are just numbers that decrease everytime the brackets with subscripts are used. The / cancels that effect. I currently don't have the time to formalize that, so i'll do it later.

I hope this wasn't too hard to understand, and formal enough to not be ill-defined (probably not, but i hope). Also, i hope i didn't make a mistake and it is consistent with the examples and explanations i gave in my other posts.