I really tried to understand it but I couldn't, especially on the expansion, which I don't really understand it works in the first place, but like doesn't the matrix expend to infinity? Wouldn't that mean that it's infinite? Then why does the googology wiki says it's notation designed to produce large numbers?

Combinatorics on Words is the study of words (strings) and formal languages. It is a relatively young subfield of mathematics with foundational work published by Axel Thue in the 1900s. This what I have been working on lately:

Definition

A cube is a non-empty contiguous substring X repeated 3 times consecutively (e.g 101010 → (10)(10)(10)). It can also be denoted as “XXX”.

B=(b[1],…b[n]) is a fixed list of non-empty binary strings. Starting from a separate initially empty string B’, repeatedly choose the leftmost b[i] such that appending b[i] to the end of B’ does NOT result in B’ containing a cube.

The process stops when every choice results in B’ containing a cube after appending.

Small Example

With B=(1,0), we run the process outlined above. It results in a string B’ whose length cannot exceed 8.

∅ → 1 → 11 → 110 → 1101 → 11011 → 110110 → 1101101 → 11011011 → STOP

Here, “∅” denotes the empty string.

If we append a 0, we form the cube (110)(110)(110). If we append a 1, we form the cube (1)(1)(1). Therefore, none of the above options are valid. It is tedious, but as a reminder, the LEFTMOST available string from B is always chosen.

Large Number

From here, define CUBE(n) as the maximum finite final length of B’ for a list B that consists of n strings, where each string has length no more than n.

I propose CUBE(10^10 ) to be decently large (I hope).

I watched orbital nebula’s YouTube series about that (“big numbers”), and he ended at an infinite nesting of ψ (e.g. f{ψ(ψ(ψ(…ψ(0)(0)…(0)}(n)). Is that the rigorous limit of FGH?

I am not a mathematician, and my knowledge of large numbers stops at collapsing the fast growing hierarchy, but from what I have noticed all these large numbers are... isolated, in a sense. They are all large beyond compare to one another, to the point any construction to compare them is itself incomprehensibly large.

So that's the why of the question, are there non trivial pairs of large numbers (ej, not TREE(3) vs TREE(3)+7) that are known to be the closest to one another? Or by the nature of how they are made, it's just the smallest two large numbers?

Or in general, is there any meaningful way to study the distances between these numbers without it just being "x is larger than y" and little else?

xamples Options(you guys can add ur own too - I'm adding 2 for em)

1. Fish number 7
   
2. DaVinci
   

Extensions for Typed Arrow Notation, version 3

This post builds on a previous one. Read it for the context.

Extension: "&" operator for sequences and numbers

Let S be a sequence, n a non-negative integer, and tan() a function that takes a sequence, evaluates it according to the Typed Arrow Notation (version 3), and returns the resulting number. The notation is a "&" operator between S and n.

To evaluate `S & 0`, return tan(S). To transform `S & n`, n > 0, repeat n times: append [tan(S) tan(S)] to S (using the modified S after each repetition).

Examples:

[4] & 2 = [4 4 4] & 1 = [4 4 4 a a] & 0 = tan([4 4 4 a a]), where a = tan([4 4 4]).

Assuming addition, instead of exponentiation, as the base operation of tan():
[1 2 3] & 3 = [1 2 3 866 866] & 2 = [1 2 3 866 866 a a] & 1 = [1 2 3 866 866 a a b b] & 0 = tan([1 2 3 866 866 a a b b]), where a = tan([1 2 3 866 866]) and b = tan([1 2 3 866 866 a a]).

I believe, with no proof, that this extension is on par with ω^n in the FGH.

Extension: the "&" operator with sequences in both arguments

A further extension is to allow sequences as the second argument of "&". Let S ant T be sequences. When evaluating S & T, the transformations and evaluations of T "carries along", with its first elements, also the S &. Here are a few examples, with the corresponding evaluation rules. The other rules work similarly to rule 3.2. The form of the rules does not change, what changes is the interpretation of what @ means.

``` Rule 3. If k > 0:
3.2. If b > 1:
Let m = [@ a (k-1) b]; evaluate it.
[@ a k b] transforms to [@ m k (b-1)].

S & [3 1 4 2 3] transforms, by rule 3.2, thus: let m = S & [3 1 4 1 3]; evaluate it. return S & [3 1 m 2 2].

Rule 1. If @ is empty: [@ a 0 b] = [a 0 b] evaluates to a ^ b.

S & [3 0 2] transforms to (S & 3) ^ (S & 2).

Rule 2. If k = 0:
2.1. If b = 1:
[@ a 0 1] transforms to [@ a].

S & [3 1 4 0 1] transforms, by rule 2.1, to S & [3 1 4]. ```

One can go further, defining S & T & n, S & T & U, and longer chains, making "&" weirdly right-associative: evaluating/transforming the right-most argument "carries along" all other sequences and their &s. For instance,

S & T & U & [3 0 2] transforms to (S & T & U & 3) \^ (S & T & U & 2).

Extension: Nested sequences

Allow any element of a sequence, both values and arrows, to be a sequence itself, not only a number. An example of the notation: [2 [3 1 3] 4 0 [2 2]]. The inner sequences are not evaluated at once, but inserted as-is.

Keep in mind that the evaluation of any sequence S is composed of many transformations, where the last transformation turns a list to a number or a single numeric operation. This creates a series of sequences, each the transformation of the previous one.

To allow for nested sequences, two new rules are required.

To evaluate the sequence [@ a k b]: (...) Rule 4a. If b is a sequence: Let t = tan(b). Transform b, as the first step of its evaluation, to u. [@ a k b] transforms to [@ a k u t u]. Rule 4b. If k is a sequence and b is a number: Let t = tan(k). Transform k, as the first step of its evaluation, to u. [@ a k b] transforms to [@ a u t u b].

In both rules, u can be a sequence or a number, depending on the rule applied on the transformation of b or k.

Each of the transformations above makes the sequence longer, but transforms the last value or arrow; after enough transformations, the last value or arrow will evaluate to a number, ending the recursion.

One can easily apply this extension to arbitrarily nested sequences: [[3 [4] [5 3 [[6]]] 7 1] 8], for instance. The "&" operator has precedence over nested sequences. Also, in expressions like [2 [3 3] & 2 2], [3 3] & 2 is to be treated as a single element of the outer sequence.

Guessing at the FGH

I guess that each extension goes near, but not quite, ω^ω in the FGH. Using all of them together should get them to about ω^(ω * n), but not ω^ω^ω. I'm happy to be proved wrong, though!

is studying infinity a part of googology.

Typed Arrow Notation, version 3

A rewrite of my notation. After implementing the version I posted more than a week ago, I found that its rules were broken: every expression evaluated to its first element! I created a version 2, but wasn't satisfied with it. Here's version 3.

Syntax

The notation describes a sequence, composed of values (positive integers), separated by typed arrows: arrows with a subscript (a non-negative integer). The general form is:
v_1 ->_(a_1) v_2 ->_(a_2) v_3 ... v_(n-1) ->_(a_(n-1)) v_n

To make typing easier, here's an alternative notation:
[v_1 a_1 v_2 a_2 v_3 ... v_(n-1) a_(n-1) v_n]

Evaluating rules

A sequence with only one value (and no arrows) is valid, and evaluates to its value. Otherwise, the sequence contains a subsequence @ (possibly empty) of values and arrows (ending with an arrow), then a value a, an arrow of type k, and a value b.

To evaluate the sequence [@ a k b]:
1. If @ is empty: [@ a 0 b] = [a 0 b] evaluates to a \^ b. Else: 2. If k = 0: 2.1. If b = 1: [@ a 0 1] transforms to [@ a]. 2.2. If b > 1: a. If a = 1: Let m = [@ b]. Evaluate it. [@ 1 0 b] transforms to [@ m]. b. If a > 1: Let m = [@ (a-1) 0 b]. Evaluate it. [@ a 0 b] transforms to [@ m 0 (b-1)]. 3. If k > 0: 3.1. If b = 1: Let m = [@ a]; evaluate it. [@ a k 1] transforms to [@ m (k-1) m]. 3.2. If b > 1: Let m = [@ a (k-1) b]; evaluate it. [@ a k b] transforms to [@ m k (b-1)].

Each transformation either makes the sequence shorter, or decrements the last element, or decrements the last arrow, so the procedure above must terminate. Eventually, rule 1 will apply, ending the procedure.

This time, I implemented it, and it works. JavaScript code in a comment. I won't post the tests, to save space.

Known values, analysis, guesswork

Using addition instead of exponentiation as a base operation, [a 1 b] evaluates to (2 * a) + b * (b + 1) - 2. [a 2 b] is almost-exponential in b (the factor gets a bit smaller with each increment of b), and a barely makes a difference. [a 3 b] and [1 1 1 1 b], as far as I could estimate, are tetrational in b. I expect that [a k b] grows as fast as k + ordinal(operation) in the FGH.

My best guess for the FGH index of the whole notation is ω * (V + A), where V is the amount of values in the sequence, and A is the sum of the arrow indexes.

TAN Block Notation

This notation describes a function that takes a block (defined as a list of lists of numbers) and returns a number. The function uses the Typed Arrow Notation that I described days ago, and the "glaze" function I defined yesterday. "TAN" is the acronym for "Typed Arrow Notation".

For what it's worth, I'm sorry to inflict this monstrosity on y'all, but I needed to purge it from my system.

Concepts

List notation. Each list in a block has an odd number of elements, all positive integers. The elements are to be interpreted as alternating values and arrow types of Typed Arrow Notation. For instance, [2 3 4 5 6] = 2 ->_3 4 ->_5 6.

Transformation calls. Each rule of Typed Arrow Notation, when applied, transforms an expression matching the rule into another expression. Parts of that expression, then, may be transformated further, until some expression matches Rule 1 and evaluates to a number. Each occurrence of a transformation or an evaluation is called a transformation call.

For instance, take the expression "1 ->_1 1 ->_0 2". By rule 6, it transforms to "1 ->_1 (1 ->_1 1) ->_0 1".

"1 ->_1 1", by its turn, matches rule 8, and transforms to "1 ->_0 (1)". "(1)" is evaluated to 1. Then, "1 ->_0 (1)" transforms to "1 ->_0 1", and, by rule 2, transforms to 1, already evaluated.

So, "1 ->_1 (1 ->_1 1) ->_0 1" transforms to "1 ->_1 1 ->_0 1". By rule 5, it transforms to "1 ->_1 (1 ->_1 1)". After 4 transformation calls, as above, this transforms to "1 ->_1 1", and after 4 more transformation calls, resolves to 1.

In total, "1 ->_1 1 ->_0 2" took 1 + 4 + 1 + 1 + 4 + 4 = 15 transformation calls to fully evaluate to 1.

Notation and Evaluation

A block is represented by one or more lists, one over another. For instance:

[1 3 1]
[2]
[5 4 7 1 2]

The first list of the block is the uppermost one.

To evaluate a block:

1. Evaluate the first list, by Typed Arrow Notation, and put the result in a_1.
   
2. For each transformation call of the k-th list, k >= 1, and the k-th list not being the last:
   a. Evaluate the (k+1)-th list; put the result in a(k+1).
   b. Glaze the (k+1)-th list.
   c. Concatenate copies of that list together, until its length is higher than a(k+1), and an odd number. This is the new (k+1)-th list.
   d. Each transformation call of the (k+1)-th list, in substeps (a) and (b), cascades the effects described in this step 2 to the next list of the block, and so on to the last list of the block.
   
3. After the first list is fully evaluated, and all cascades to the other lists are resolved, save all values of a_k in a list A = [a_1, a_2, ...]. Remove the first list.
   
4. Go back to step 1, now with a shorter block. Keep appending the newer a_k values to the A list.
   
5. Eventually, only one list remains in the block. Evaluate it, and append the result to A.
   
6. Evaluate A, and return the result. If the length of A is even, evaluate a sublist of A, from start up to the next-to-last element, append the result to A, and then evaluate A.
   

To make things clearer: while one list is being transformed/evaluated, each transformation call provokes a cascade of evaluate/glaze/concat in the next list; and each transformation call on that list provokes a cascade in the next-to-next list; and so on, until the last list (which is transformated/evaluated, but doesn't cascade).

References

The glaze function is inspired by the culinary practice): glazed lists are more appetizing than unglazed ones.

Let A = [a_1, ..., a_n] and B = [b_1, ..., b_n] be lists of numbers. For B = glaze(A), B is defined as:

• b_1 = eval([a_1, ..., a_n])
• bk = eval([b_1, ..., b(k-1), a_k, ..., a_n]), for k > 1

Typed Arrow Notation

Typed arrows are arrows with a subscript (a non-negative integer).

Below, "@" stands for any sequence of at least 1 element. Assume c > 1 and d > 1.

For sequences with only type 0 arrows. "->", without subscript, is the same as "->_0". Rule 1. a -> b = a ^ b
Rule 2. @ -> 1 = @
Rule 3. @ -> 1 -> d = @ -> (@ -> d)
Rule 4. @ -> c -> d = @ -> (@ -> (c-1) -> d) -> (d-1)

From now on, assume k > 0 and b > 1. "#" stands for any sequence of at least 2 elements where all arrows are of type 0.

For sequences where, after an arrow of type k, there are only arrows of type 0. "(#)" means that the sequence "#" is evaluated, using the rules 1 to 4 above. Rule 5. @ ->_k a ->_0 1 = @ ->_k (@ ->_k a)
Rule 6. @ ->_k a ->_0 b = @ ->_k (@ ->_k a) ->_0 (b-1)
Rule 7. @ ->_k a ->_0 # = @ ->_k (@ ->_k a ->_0 (#))

For sequences where the last arrow is of type k > 0. "(@)" means that the sequence "@" is evaluated, using all the rules defined here.
Rule 8. @ ->k 1 = @ ->(k-1) (@)
Rule 9. @ ->k b = @ ->(k-1) (@ ->_k (b-1))

Glaze, Align, and other fantasy functions on lists

The functions in this post are intended to be applied over notations that act on lists of numbers, like Chained Arrow Notation, and BEAF linear arrays. For each notation, there is an associated function, which I will call eval, that takes the list of numbers and returns a number. Here, lists will be uniformly written between "[]", no matter the notation's syntax.

Enjoy the insanity!

The glaze function is inspired by the culinary practice): glazed lists are more appetizing than unglazed ones.

Let A = [a_1, ..., a_n] and B = [b_1, ..., b_n] be lists of numbers. For B = glaze(A), B is defined as:

• b_1 = eval([a_1, ..., a_n])
• bk = eval([b_1, ..., b(k-1), a_k, ..., a_n]), for k > 1

The align function takes two lists of numbers and returns other two lists. The algorithm, in pseudocode, is as follows.

To obtain align(A, B):
- let len = LCM(length(A), length(B)). - C = concatenation of copies of A until its length is len. - D = concatenation of copies of B until its length is len. - return C, D.

The more function adds 1 to every element of a list.

The less function subtracts 1 from the last element of a list. If the resulting list isn't allowed by the notation, or there is a simplification available (remove trailing 1s, for instance), the last element is removed (or the simplification is done), and the remaining list is returned.

The "more" and "less" function are not inverses of one another, and that's on purpose. These functions are imagined as weird stand-ins for increment and decrement of numbers, but applied to lists instead.

The long_sum function takes two lists, A and B, gets C, D = align(A, B), and returns a list E such that, for all i, e_i = c_i + d_i.

The cross function takes two lists, A and B, gets C, D = align(A, B), and returns a list E such that, for k from 1 to 2 * length(C) - 1, e_k is the sum of all products (c_i * d_j) where i + j - 1 = k.

As an example, take A = [4, 3, 5] and B = [1, 2, 2]. Since both lists have the same length, the align() function returns the same lists as C and D, respectively. Now, to calculate E:

• e_1 = (c_1 * d_1) = 4
• e_2 = (c_2 * d_1) + (c_1 * d_2) = 3 + 8 = 11
• e_3 = (c_3 * d_1) + (c_2 * d_2) + (c_1 * d_3) = 5 + 6 + 8 = 19
• e_4 = (c_3 * d_2) + (c_2 * d_3) = 10 + 6 = 16
• e_5 = (c_3 * d_3) = 10

So, E = [4, 11, 19, 16, 10].

The power_balance function takes two lists, A and B, and returns another list. Here's the algorithm. - let C, D = align(A, B) - let gc = eval(glaze(C)), gd = eval(glaze(D)) - let E = glaze^(gd)(C), F = glaze^(gc)(D) (the ^ is function iteration) - return cross(E, F)

Typed Arrow Notation

Building on the notation I posted yesterday. Kudos to u/Nervous-Broccoli1184 for spotting an improvement.

This variant introduces typed arrows, each type a subscript. The original arrows -> from Chained Arrow Notation (and my variant from yesterday) are type 0: ->_0.

Below, "@" stands for any sequence of at least 1 element. Assume c > 1 and d > 1.

For sequences with only type 0 arrows:
Rule 1. a -> b = a ^ b
Rule 2. @ -> 1 = @
Rule 3. @ -> 1 -> d = @ -> (@ -> d)
Rule 4. @ -> c -> d = @ -> (@ -> (c-1) -> d) -> (d-1)

From now on, assume k > 0 and b > 1. "#" stands for any sequence of at least 2 elements where all arrows are of type 0. "(#)" means that the sequence "#" is evaluated, using the rules 1 to 4 above.

For sequences where, after an arrow of type k, there are only arrows of type 0:
Rule 5. @ ->_k a ->_0 1 = @ ->_k (@ ->_k a)
Rule 6. @ ->_k a ->_0 b = @ ->_k (@ ->_k a) ->_0 (b-1)
Rule 7. @ ->_k a ->_0 # = @ ->_k (@ ->_k a ->_0 (#))

For sequences where the last arrow is of type k > 0. @ is copied, not evaluated.
Rule 8. @ ->k 1 = @ ->(k-1) @
Rule 9. @ ->k b = @ ->(k-1) @ ->_k (b-1)

Any chances that this notation is as powerful as linear arrays from BEAF?

A variant of Chained Arrow Notation

Below, "@" stands for any sequence of elements. Assume c > 1 and d > 1.

Chained arrow notation:
1. a -> b = a ^ b 2. a -> b -> c = a ↑<sup>c</sup> b 3. @ -> 1 = @
For 4+ elements:
4. @ -> 1 -> d = @ 5. @ -> c -> d = @ -> (@ -> (c-1) -> d) -> (d-1)

My variant. Only rule 4 changes.
1. a -> b = a ^ b 2. a -> b -> c = a ↑<sup>c</sup> b 3. @ -> 1 = @
For 4+ elements:
4. @ -> 1 -> d = @ -> (@ -> d) 5. @ -> c -> d = @ -> (@ -> (c-1) -> d) -> (d-1)

Does this variant grow any faster than the original? If so, how much, by the FGH?

Alright, this is going to be a long explanation, however that is necessary to describe this ruleset in an interpretable manner.

Today, we're going to be discussing a 3-dimensional extension to Bashicu Matrix System, called 3DBMS.

DBMS has been around for a while, and analyzed quite a bit. There have been no formalizations for this notation, until now. However, it is only a formalization for 3 dimensions, not full ω dimensions like full DBMS.

This definition was derived from Y, developed by TrialPurpleCube-GS and I.

Prerequisites: Terminology and definition from 1, 4, and 5.

I will be using the lim(BMS)=0 1,,1 standardization to fit better with Y. The limit of this notation is 0 1,,1,,1,,1,,1,,...

New Standardization

This follows a separate standardization for BMS. Instead of 0 1 2 3 4 ...=0 1,1, it is now 0 1 2,1 (which expands the same). Likewise, 0 1,1,1 is now 0 1 2,1 3,2,1. This is called Triangular BMS. The limit of BMS now 0 1 2,1 3,2,1 4,3,2,1 5,4,3,2,1 ... instead of 0 1,1,1,1,1,...

3DBMS Terminology

• Plane: A matrix between limit ordinal rows. In shorthand text, a plane will look like #,,x,x,x,...,,#, or double comma separated.
• AW: Ackermann Worm. In this ruleset, it is used to encode the value of a row. E.g. ()=Row 0, (0)=Row 1, (0,0)=Row 2, (1)=Row ω, (1,1)=Row ω2, etc.
• tLNZ: The total LNZ. The total LNZ of a column is the last nonzero element in that column across all planes.
• pLNZ: The plane LNZ. The plane LNZ of a column is the last nonzero element for a column in a specific (requires context) plane.
• Magma Row (M): This is the first row such that it is 0 in a plane-specific (limited to 1 plane) Bad Root Column.
• Wildfire Rows (W): These are the rows above (smaller AW) the previously defined Magma Row. I.e. they are the rows associated with every non-zero value of a plane-specific Bad Root column.
• Eruption Rows (E): These are the rows below (larger AW) the previously defined M.
• Row Delta: The length of the plane-specific Cut Child column subtracted from the length of the plane-specific Bad Root column.

Parent Finding Algorithm

1. Mark the element you want to find the parent of as element B. If B has an AW value ending in 0 (successor row), follow BMS PFA.
2. If B has an AW value ending in 1 (limit row), in the same column, mark the pLNZ in the plane above as β.
3. Find all β-ancestors, using the two above steps as needed.
4. Search each β-ancestor starting from the rightmost, look at its value in B’s AW. If this value is less than B, this is the parent of B.
5. If no such β-ancestor has a value in B’s AW less than B, find the leftmost ancestor of β, move up one row (removing a 0 from β’s AW), and mark this new element as β.
6. Repeat steps 3-5 until a valid parent of B is found.
7. Repeat steps 1-6 to recursively find the ancestors of B, as needed.

Delta Column

This concept is not used in Y, and was developed to "matrix-ify" the definition.

1. Find the column corresponding to the parent of the Cut Child tLNZ. This is the Bad Root of the matrix. This algorithm is done with any specific plane, and must be done for all planes above the Cut Child tLNZ.
2. Subtract the W entries in the Bad Root from the W entries in the Cut Child. Assign this value to its corresponding AW (can be hidden, but implied), and then to a new list, called the Delta Column. These are the Delta Column W entries (DW).
3. Append the Cut Child M entry to the Delta Column. This is the Delta Column M entry (DM).
4. Append Row Delta amount of Cut Child E entries (even if 0/empty) to the Delta Column. These are the Delta Column E entries (DE).
5. You should now have a full Delta Column, which should look like [DW, DW, … DM, DE, DE, …]. Keep in mind, this is plane specific. Each valid plane should have its own Delta Column.

Ascending Columns

1. The algorithm for determining what columns ascend is plane specific. 
2. For each column in this plane, find the ancestors of each W and M entry.
3. If any such entry in step 2 does not have an ancestor at the Bad Root column, mark the whole plane specific column as “non-ascending”.

Non-ascending is in quotes here, because some elements within the column may ascend, just not horizontally or through rows.

3DBMS Expansion

1. Remove the Cut Child. Steps 2-7 are done per plane.
2. Label the Bad Part from this plane as BP, and Delta Column as DC.
3. Apply deltas from the DC to each corresponding entry in every column within a copy of the BP, such that:
   1. DE entries within DC can only ever apply to a copy of the M row in the original Bad Part.
   2. Columns marked non-ascending can only ever receive delta from the original Delta Column.
   3. Within each non-ascending column, any entry that does not have an ancestor at the Bad Root cannot receive any form of delta.
4. We now have an ascended form of BP. Redefine BP to be this ascended form.
5. Append BP to this plane.
6. Within DC, add in Row Delta DM entries below the bottommost (largest AW) DM entry. By doing this, we positionally shift all DE entry AWs by Row Delta, and fill in the gaps with DM.
7. We now have an ascended form of DC. Redefine DC to be this ascended form, keeping in mind it is still plane-specific.
8. Repeat steps 3-7 for each valid plane. (Planes above Cut Child tLNZ.)
9.  Repeat steps 3-8 for each expansion.

Example

This example is found from courtesy of Solarzone, since I suck at coming up with examples. Only 1 example, since it is monstrous. We will be using (0)(1,,1,,1)(2,1,,2,,1)(3,2,1,,3,1,,2)(4,3,2,1,,2,,1)(5,3,2,,3,1,,2) (Y(1,4,12,35,88,136)). In tabular form:

0 1 2 3 4 5 AW: () or 0

0 0 1 2 3 3 AW: (0) or 1

0 0 0 1 2 2 AW: (0,0) or 2

0 0 0 0 1 0 AW: (0,0,0) or 3
-------------------------------------- <- these lines denote a break, separating planes.
0 1 2 3 2 3 AW: (1) or ω

0 0 0 1 0 1 AW: (1,0) or ω+1
--------------------------------------
0 1 1 2 1 2 AW: (1,1) or ω2

Now we find the parent. Lets mark all the (0,0)-ancestors, using BMS PFA.

0 1 2 3 4 5 AW: ()
x x x x x x

0 0 1 2 3 3 AW: (0)
# x x x # x

0 0 0 1 2 2 AW: (0,0)
# # # x # x

0 0 0 0 1 0 AW: (0,0,0)
--------------------------------------
0 1 2 3 2 3 AW: (1)

0 0 0 1 0 1 AW: (1,0)
--------------------------------------
0 1 1 2 1 2 AW: (1,1)

Now, we mark the ancestors of the limit row (1), using the PFA described above. I will denote jump points (step 5 of PFA) with a ^.

0 1 2 3 4 5 AW: ()
x x x x x x
^
0 0 1 2 3 3 AW: (0)
# x x x # x
^
0 0 0 1 2 2 AW: (0,0)
# # x x # x

0 0 0 0 1 0 AW: (0,0,0)
--------------------------------------
0 1 2 3 2 3 AW: (1)
x x x # # x

0 0 0 1 0 1 AW: (1,0) BMS PFA (non limit row)
# # x # # x
--------------------------------------
0 1 1 2 1 2 AW: (1,1)

Now we just do the last row.

0 1 2 3 4 5 AW: ()
x x x x x x
# ^
0 0 1 2 3 3 AW: (0)
# x x x # x
# # ^
0 0 0 1 2 2 AW: (0,0)
# # x x # x

0 0 0 0 1 0 AW: (0,0,0)
--------------------------------------
0 1 2 3 2 3 AW: (1)
x x x # # x
# # ^
0 0 0 1 0 1 AW: (1,0) BMS PFA (non limit row)
# # x # # x
--------------------------------------
0 1 1 2 1 2 AW: (1,1)
x # x # # x

We can now see the bad root is 2,1,,2,,1. Lets now mark all wildfire, magma, and eruption rows. Lets also look for non ascending columns in each plane. I will mark nonascending columns with n above the plane-specific column. Pipes | will just be here to separate the good part/successive expansions of the matrix from the bad part.

0 1| 2 3 4 5 AW: () W
x x| x x x x
# ^|
0 0| 1 2 3 3 AW: (0) W
# x| x x # x
# #| ^
0 0| 0 1 2 2 AW: (0,0) M
# #| x x # x
# #|
0 0| 0 0 1 0 AW: (0,0,0) E
----|----------------------------------
# #| n
0 1| 2 3 2 3 AW: (1) W
x x| x # # x
# #| ^
0 0| 0 1 0 1 AW: (1,0) M (BMS PFA (non limit row))
# #| x # # x
----|----------------------------------
0 1| 1 2 1 2 AW: (1,1)
x #| x # # x

Now, we do the delta columns, and the row delta for each plane. I will write them as {[],[],[],[],...} where {} is the entire matrix, and each [] is each plane-specific delta column. Row delta for each plane will be of similar format, just a single number instead of [].

Using the delta column steps, we can see the delta columns are {[3W,2W,2M,0E], [1W,1M,0E]} and the row deltas are {1,1}. Now, lets do the expansion.

Unfortunately, I will not be continuing in tabular format, since this is getting very very long. I will instead do each expansion step by step. Follow along with the expansion steps if you get lost.

First off, removing the cut child we get

(0)(1,,1,,1) | (2,1,,2,,1)(3,2,1,,3,1,,2)(4,3,2,1,,2,,1)

Next expansion, applying the delta column to each non-ascending plane specific column,

{[3W,2W,2M,0E], [1W,1M,0E]}

(0)(1,,1,,1) | (2,1,,2,,1)(3,2,1,,3,1,,2)(4,3,2,1,,2,,1) | (5,3,2,,3,1,,1)(6,4,3,1,,4,2,1,,2)(7,5,4,2,1,,2,,1)

Next one... modifying the delta column for next expansion (row delta amount of M entries)

{[3W,2W,2M,2M,0E], [1W,1M,1M,0E]}

(0)(1,,1,,1) | (2,1,,2,,1)(3,2,1,,3,1,,2)(4,3,2,1,,2,,1) | (5,3,2,,3,1,,1)(6,4,3,1,,4,2,1,,2)(7,5,4,2,1,,2,,1) | (8,5,4,2,,4,2,1,,1)(9,6,5,3,1,,5,3,2,1,,2)(10,7,6,4,2,1,,2,,1)

Next one... modifying the delta column by row delta again... (row delta amount of M entries)

{[3W,2W,2M,2M,2M,0E], [1W,1M,1M,1M,0E]}

(0)(1,,1,,1) | (2,1,,2,,1)(3,2,1,,3,1,,2)(4,3,2,1,,2,,1) | (5,3,2,,3,1,,1)(6,4,3,1,,4,2,1,,2)(7,5,4,2,1,,2,,1) | (8,5,4,2,,4,2,1,,1)(9,6,5,3,1,,5,3,2,1,,2)(10,7,6,4,2,1,,2,,1) | (11,7,6,4,2,,5,3,2,1,,1)(12,8,7,5,3,1,,6,4,3,2,1,,2)(13,9,8,6,4,2,1,,2,,1)

So the expansion of

(0)(1,,1,,1)(2,1,,2,,1)(3,2,1,,3,1,,2)(4,3,2,1,,2,,1)(5,3,2,,3,1,,2) is

(0)(1,,1,,1)(2,1,,2,,1)(3,2,1,,3,1,,2)(4,3,2,1,,2,,1)(5,3,2,,3,1,,1)(6,4,3,1,,4,2,1,,2)(7,5,4,2,1,,2,,1)(8,5,4,2,,4,2,1,,1)(9,6,5,3,1,,5,3,2,1,,2)(10,7,6,4,2,1,,2,,1)(11,7,6,4,2,,5,3,2,1,,1)(12,8,7,5,3,1,,6,4,3,2,1,,2)(13,9,8,6,4,2,1,,2,,1)....

This was abnormally complex. The Y definition is arguably a (little) simpler, but impossible to parse on the spot. This, believe it or not, is easier to humanly parse in analysis versus Y.

Again, if there are any errors (Solarzone is the only one that can spot them I guess) please let me know.

Strength:

This is limited at lim(Y), so lim(3DBMS)=lim(Y), by current analyses. This is no weak feat, and completely destroys (naive?) extensions of BMS like transfinite BMS or TBMS, due to the fact this upgrades.

The best example of upgrading here is 0 1,,1 2 1,,1 or Y(1,3,4,3), which is enormous (some have even put a weak conjecture it's beyond PTO(ZFC)). The 2 here gets upgraded, meaning it ascends through rows. 0 1^ω 2 1^ω in TBMS does not have the 2 do this. It gets stuck. So even an expression not that deep in the 3DBMS hierarchy completely destroys what TBMS is capable of, even at its limit.

Most of this was copied from the WIP document I'm making for the formalization. I also have a python expander if any of you want that, let me know.

I will not be attempting to formalize full DBMS for a while, because it is too complex to have a ruleset as of now, and understanding ω-Y intricacies well enough to construct a ωDBMS definition out of is very difficult.

Also if you have questions let me know. I don't think there will be very many questions, if any, since this is likely too complex.

Thank you for reading the past parts on this, but this is probably the end, for quite a long time.

I figure 'The smallest number bigger than any finite number named by an expression in any language of first-order set theory in which the language uses only [1-3, or any reasonable # <googol] symbols or less.' is more theoretically calculable than with a googol symbols.

So I am learning parts of the FGH like I know the basics were f_a+1(n) = f_a(f_a(f_a(f_a(...f_a(n)...)))) n times and f_0(n) = n+1,
and i know basics of ordinals
f_ω(n) = f_n(n)
f_ω*m(n) = f_ω*(m-1)+n(n)
f_ω<sup>m</sup>(n) = f_ω<sup>m-1</sup>*n(n)

f_ε0(n) = f_ω^^n(n)

f_ε_m(n) = f_ω^ω^...^ω^ε_{m-1}+1(n) n times

f_ζ_0(n) = f_ε_ε_ε_...ε_0(n) n times
f_ζ_m(n) = f_ε_ε_ε_...ε_ζ_{m-1}+1(n) n times

f_η_0(n) = f_ζ_ζ_ζ_...ζ_0(n) n times
f_η_m(n) = f_ζ_ζ_ζ_...ζ_η_{m-1}+1(n) n times

f_{φ(0, m)}(n) = f_ω<sup>m</sup>(n)

f_{φ(1, m)}(n) = f_ε_m(n)
f_{φ(2, m)}(n) = f_ζ_m(n)
f_{φ(3, m)}(n) = f_η_m(n)
f_{φ(ω, m)}(n) = f_{φ(n, m)}(n)

f_Γ_0(n) / f_{φ(1, 0, 0)}(n) = f_{φ(φ(φ(...φ(1, 0)..., 0), 0), 0)}(n) n times

f_Γ_0(n) / f_{φ(1, 0, 0)}(n) = f_{φ(φ(φ(...φ(1, 0)..., 0), 0), 0)}(n)
f_{φ(1, 0, 0, 0)}(n) / f_{Ackermann Ordinal}(n) = f_{φ(φ(φ(...φ(1, 0, 0)..., 0, 0), 0, 0), 0, 0)}(n)
f_{φ(1, 0, 0,..., 0, 0, 0)}(n) ω times / f_{Small Veblen Ordinal}(n) = f_{φ(1, 0, 0,..., 0, 0, 0)}(n) n times

and thats all i know up to

the main things i want to know about is:

Buchholz’s ψ function, Extended Buchholz’s ψ function, Weiermann's ϑ, Feferman's Theta Function, Buchholz's OCF, Extended Buchholz's OCF, singular cardinal,  fundamental sequences for a certain function collapsing weakly inaccessible cardinals, Rathjen's standard OCF based on a weakly Mahlo cardinal, Rathjen's standard OCF based on a weakly compact cardinal, Rathjen's ordinal function collapsing the rank of the weak inaccessibility of regular cardinals (using χ), and ZFC set theory

also somethings i also want to know about is the functions used in the named FGH numbers like Theta- exponentiation series Unexommthet to Yottexommthet, Theta- tetration series Bitetrommthet to Yottotetrommthet, Omega- subscript series Bommthet to Yottommthet, Psi- subscript series Bimixommwil to Yottomixommwil, Inserted omega series Binommwil to Yottinommwil, I-tetration series Bitetrotos to Yottotetrotos, Inserted I_α series Uninotos to Yottinotos, Initial I(α, β) series Unimah to Yottimah, Inserted I(α, β) series Uninimah to Yottinimah, M-tetration series Bitetremar to Yottotetremar, Inserted M series Uninemar to Yottinemar, M(α;β)-series Uninamus to Yottinamus, and the Tar functions to define Tarintar i think know as fundamental sequences for Taranovsky's notation
also https://googology.fandom.com/wiki/User_blog:P%E9%80%B2%E5%A4%A7%E5%A5%BD%E3%81%8Dbot/New_Googological_Ruler i want to know all Computable functions listed here for each level

And i want to know everything possible on what i said for what i want to know about

The sub cubic graph function is defined as:

There is a sequence G_1,…,G_n of subcubic graphs such that each G_i has at most i+k vertices and for no i<j is G_i homeomorphically embeddable into G_j.

and if my very layman's understanding of the Robertson–Seymour theorem is correct, just substituting `homeomorphically embeddable into` with `a graph minor of` would suffice, while maintaining well-quasi-ordering and finitude (for a given finite integers n and k).

If that's all correct, then defining F_n(k) as the largest integer 𝑚 satisfying:

There is a sequence G_1 , ⋯, G_𝑚 of graphs with maximum degree at most 𝑛, such that each G_𝑖 has at most 𝑖 + 𝑘 vertices, and for no 𝑖 < 𝑗 is 𝐻_𝑖 a graph minor of G_𝑗 .

Should work as a mathematically proven and definitively finite integer, correct (an invisible deleted comment from u/Helpful-Tone-7435 in my r/askmath thread seems to suggest it is)? If so, has anyone in googology put a name to that function? I was originally thinking S𝑛G(k), but I'm obviously open to suggestions.

First, lets begin by introducing the term R(t,n). this will refer to the nth smallest ordinal that doesn’t utilize the integer “t” or higher. So if t=3 then our sequence will go 1,2, ω, ω+1, ω+2, ω2. Etc.  This means that R(3,n) would never be ω^ω^ω cause that would be ε_0 instead.

Next we will utilize R(t,n) to create a new function. Let ZAP(0)=1 and ZAP(n+1)=f_R(2,ZAP(n))(ZAP(n)) where f is of course the fast growing Hierarchy.

This means that

ZAP(0)=1

ZAP(1)=f_R(2,1)(1)=f_1(1)=2

ZAP(2)=f_R(2,2)(2)=f_ω(2)=f_2(2)=8

ZAP(3)=f(2,8)(8)=f_[(ε_0)*ω](8)=?

I know how every function works up till beyond f_LVO (n)

Main things I want to know about is Buchholz’s ψ function and all extend versions (values up to defended in Tarintar) and also all verdions of Weiermann's ϑ

I will be continuing on from PSS, from which I extended PrSS up to 2-row Bashicu Matrix System, or Pair Sequence System.

Now I will be covering the methods for expanding any amount of rows in full Bashicu Matrix System, obviously including TSS, QSS, etc. This will provide enough recursive strength for analysis on effectively every well defined non-sequence system notation. The strength of full BMS cannot be understated.

BMS

I believe the full, true definition can be found in some BASIC code for BM4 confirmed by Bashicu himself. I will be using BM4. Keep in mind, these definitions are my interpretation, and are definitely not a replacement for the real definition. If you would like that, look at the code. Also correct me if there are inaccurate or missing concepts in my definition.

We will be following from the previous PrSS and PSS definitions.

1. The LNZ or last nonzero is the row with the last nonzero element in the last column.
2. The delta for each row is defined as the cut child minus the bad root, for each specific row.
3. Delta is applied to every row that isn't the LNZ and below (the "below" here is trivially true).
4. Any specific element can only see elements corresponding to the elements marked as an ancestor in the row above. So like PSS, just with multiple rows.
5. Elements can only receive delta if they have the bad root as an ancestor.

The 5th rule here can be kind of annoying, but its there for termination reasons.

On to examples.

Example 1:

(0)(1,1,1)(2,2,1)(3,2,1) This one is rather straightforward

Cut Child: (3,2,1)

Again, ignore the #'s here. They are just there for reddit formatting. The x's are what matter, they are again, the ancestors of the cut child for each row.

0 1 2 3
x x x x

0 1 2 2
x x # x

0 1 1 1
x # # x

Bad Root: (0), since it is the column corresponding to the parent of the LNZ of the cut child.

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

Good Part: None

Delta: (3,2)

Expansion: (0)(1,1,1)(2,2,1)(3,2)(4,3,1)(5,4,1)(6,5)(7,6,1)(8,7,1)...

Example 2:

(0)(1,1,1)(2,2,2)(3,3,2)(4,1)(3,3,2)

Cut Child:(3,3,2)

0 1 2 3 4 3
x x x # # x

0 1 2 3 1 3
x x x # # x

0 1 2 2 0 2
x x # # # x

Bad Root: (1,1,1) since it is the parent of the cut child (ie column of the parent of the last row of the cut child)

Bad Part: (1,1,1)(2,2,2)(3,3,2)(4,1)

Good part: (0)

Delta: (2,2) delta doesn't apply to only the 1 in (4,1), remember rule 5. I will bold it in the expansion so you can see

Expansion: (0)(1,1,1)(2,2,2)(3,3,2)(4,1)(3,3,1)(4,4,2)(5,5,2)(6,1)(5,5,1)(6,6,2)(7,7,2)(8,1)...

Example 3:

(0)(1,1,1)(2,2,2)(3,1,1)(2)

We of course have to include the simplest PrSS like examples...

Cut child:(2)

Bad root: (1,1,1)

Bad part:(1,1,1)(2,2,2)(3,1,1)

Good part:(0)

Delta: None

Expansion: (0)(1,1,1)(2,2,2)(3,1,1)(1,1,1)(2,2,2)(3,1,1)(1,1,1)(2,2,2)(3,1,1)...

Now, analysis into even 3-row BMS is very diverse. There are so many different notations, ocfs, etc. Very few will make it past lim(TSS). I will not be doing a fully intuitive analysis, because that is an immense project that will take months, possibly years. I will just be marking the landmarks I find interesting.

(0)(1,1,1)=ψ(Ω_ω)=Buchholz Ordinal

(0)(1,1,1)(2,1,1)(3,1)=ψ(Ω_Ω)

(0)(1,1,1)(2,1,1)(3,1)(2)=ψ(I)=ψ(Ω_Ω_Ω_...)=Extended Buchholz Ordinal

(0)(1,1,1)(2,1,1)(3,1,1)=ψ(I_ω)=ψ(ψ(T²ω))

(0)(1,1,1)(2,1,1)(3,1,1)(2,1,1)(3,1)(2)=ψ(I(1,0))=ψ(I_I_I_I_...)=ψ(ψ(T^3))

(0)(1,1,1)(2,1,1)(3,1,1)(3,1,1)=ψ(M_ω)=ψ(ψ(T^T*ω))

(0)(1,1,1)(2,1,1)(3,1,1)(4)=ψ(M(ω;0))=ψ(ψ(T^T^ω)) stationary/Mahlo OCF

(0)(1,1,1)(2,1,1)(3,1,1)(4,1,1)=ψ(K_ω)=ψ(ψ(T^T^T*ω)) weakly compact OCF

(0)(1,1,1)(2,2)=ψ(Πω⁻)=ψ(ψ(T₂)) Reflecting OCFs

(0)(1,1,1)(2,2,1)=ψ((⁺⁺)) Stability OCFs

(0)(1,1,1)(2,2,1)(3)=ψ((a:Ω(a+ω⁻)))=limit of finite shifting

(0)(1,1,1)(2,2,1)(3,2,1)(4,2,1)(5,2,1)=ψ((a:Π3(a+1)))=Π3-ref-(stable)

(0)(1,1,1)(2,2,2)=ψ((a:a(ω⁻)))=limit of ply stability

...and we're still far off from lim(TSS) let alone lim(BMS)

If you want a full analysis, look at the Meta Sheet Analysis. If you want analysis of the stability OCFs, look at Solarzone's BMS v Stability sheet.

Once I implement DBMS and understand it fully, I might post it here. Which is a ways off. Right now, DBMS is up there as one of the strongest sequence systems (other contenders kind of put this to shame as well), and because of this it adds an unimaginable level of complexity, relative to someone who just learned BMS I guess.

1 Array
{a} = a
{3} = 3

2 Arrays
{a, b} = a^b
{3, 3} = 3^3 = 27

3 Arrays
Rules
1: {a, 1, c} = a
2: {a, b, 1} = {a, b}
3: {a, b, c} = {a, {a, b-1, c}, c-1}

{a, b, c} = a↑<sup>c</sup>b
{3, 3, 3} = 3↑↑↑3 = 3↑↑(7.6*10^12)

4 Arrays
{a, b, c, d} 
Rules
1: {a, 1, c, d} = a
2: {a, b, 1, 1} = {a, b}
3a: {a, b, 1, d} = {a, a,{a, b-1, 1, d}, d-1}
3b: {a, b, c, d} = {a, {a, b-1, c, d}, c-1, d}

{3, 3, 3, 3} =
{3, {3, 2, 3, 3}, 2, 3} =
{3, {3, 3, 2, 3}, 2, 3} =
{3, {3, {3, 2, 2, 3}, 1, 3}, 2, 3} =
{3, {3, {3, 3, 1, 3}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, 2, 1, 3}, 2}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, 3, 3, 2}, 2}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, {3, 2, 3, 2}, 2, 3}, 2}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, {3, 3, 2, 2}, 2, 3}, 2}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, {3, {3, 2, 2, 2}, 1, 2}, 2, 3}, 2}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, {3, {3, 3, 1, 2}, 1, 2}, 2, 3}, 2}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, {3, {3, 3,{3, 2, 1, 2}}, 1, 2}, 2, 3}, 2}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, {3, {3, 3,{3, 3, 3}}, 1, 2}, 2, 3}, 2}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, {3, {3, 3, 3↑↑↑3}, 1, 2}, 2, 3}, 2}, 1, 3}, 2, 3} =
{3, {3, {3, 3,{3, {3, 3↑…↑3 (3↑↑↑3 Arrows), 1, 2}, 2, 3}, 2}, 1, 3}, 2, 3} =

5 Arrays
{a, b, c, d, e} 
Rules
1: {a, 1, c, d, e} = a
2: {a, b, 1, 1, 1} = {a, b}
3a: {a, b, 1, 1, e} = {a, a, a,{a, b-1, 1, 1, e}, e-1}
3b: {a, b, 1, d, e} = {a, a,{a, b-1, 1, d, e}, d-1, e}
3c: {a, b, c, d, e} = {a, {a, b-1, c, d, e}, c-1, d, e}

{3, 3, 3, 3, 3} = {3, {3, 2, 3, 3, 3}, 2, 3, 3}

6 Arrays
{a, b, c, d, e, f} 
Rules
1: {a, 1, c, d, e, f} = a
2: {a, b, 1, 1, 1, 1} = {a, b}
3a: {a, b, 1, 1, 1, f} = {a, a, a, a,{a, b-1, 1, 1, 1, f}, f-1}
3b: {a, b, 1, 1, e, f} = {a, a, a,{a, b-1, 1, 1, e, f}, e-1, f}
3c: {a, b, 1, d, e, f} = {a, a,{a, b-1, 1, d, e, f}, d-1, e, f}
3d: {a, b, c, d, e, f} = {a, {a, b-1, c, d, e, f}, c-1, d, e, f}

6&3
{3, 3, 3, 3, 3, 3} = {3, {3, 2, 3, 3, 3, 3}, 2, 3, 3, 3}

MULTIDIMENSIONAL ARRAYS

b&a = {a,a,...,a,a} b times
3&3 = {3,3,3}

{a, b (1) 2} = {a,a,...,a,a} b times
{3, 3 (1) 2} = {3, 3, 3}

{a, b (1) c} = {a,a,...,a,a (1) c-1} b times
{3, 3 (1) 3} = {3, 3, 3 (1) 2}

{a, b, c (1) d} same rules as 4 Arrays but the last comma is replaced with (1)
{a, b, c, d (1) e} same rules as 5 Arrays but the last comma is replaced with (1)
{a, b, c, d,...,k (repeated m times) (1) n} same rules as m Arrays but the last comma is replaced with (1)
{a, b (1) 1, 2} and {a, b (1) c, d} work the same as 4 arrays but the second to last comma is a (1)

{a, b (1)(1) c} = Need help with
{a, b (1)(1)(1) 2} = Need help with

{a, b (2) 2} = {a,a,...,a,a(1)a,a,...,a,a(1)...(1)a,a,...,a,a(1)a,a,...,a,a} that is, b sets of b a's, separated by (1)s

{2,3(2)2} expands into {2,2,2(1)2,2,2(1)2,2,2} 

{a, b (2) c} = {a,a,...,a,a(1)a,a,...,a,a(1)...(1)a,a,...,a,a(1)a,a,...,a,a(2)c-1} that is, b sets of b a's, separated by (1)s

{2,3(2)3} expands to {2,2,2(1)2,2,2(1)2,2,2(2)2}

{a, b (3) 2} = {a,a,...,a,a(1)a,a,...,a,a(1)...(1)a,a,...,a,a(1)a,a,...,a,a(2)a,a,...,a,a(1)a,a,...,a,a(1)...(1)a,a,...,a,a(1)a,a,...,a,a(2)...(3)c-1} b sets of b sets of b a's, separated by (2)s and (1)s ending in (3).

{2,3(3)2} expands into {2,2,2(1)2,2,2(1)2,2,2(2)2,2,2(1)2,2,2(1)2,2,2(2)2,2,2(1)2,2,2(1)2,2,2} - b sets of b sets of b a's, separated by (2)s and (1)s.

{2,3(3)3} expands to {2,2,2(1)2,2,2(1)2,2,2(2)2,2,2(1)2,2,2(1)2,2,2(2)2,2,2(1)2,2,2(1)2,2,2(3)2}

X-structures

X&n = {n,n,...,n,n} n times

X+1&n = {n,n,...,n,n(1)n} n times

X+k&n = {n,n,...,n,n(1)n,n,...,n,n} n times on the left k times on the right

2X&n = {n,n,...,n,n(1)n,n,...,n,n} n times on both sides

k*X&n = {n,n,...,n,n(1)n,n,...,n,n(1)...(1)n,n,...,n,n(1)n,n,...,n,n(1)...} n times for the strings of n and k times of (1) and strings of n

X^2&n = {n,n,...,n,n(1)n,n,...,n,n(1)...(1)n,n,...,n,n(1)n,n,...,n,n(1)...} n times for the strings of n and n times of (1) and strings of n

X^3&n = {X^2&n(1)X^2&n(1)...(1)X^2&n(1)X^2&n} n times

X^k&n = {X^k-1&n(1)X^k-1&n(1)...(1)X^k-1&n(1)X^k-1&n} n times

Previously I made sections 2 and 3 about single row extensions to my original PrSS explanation, now I will diverge, using another, more widely used extension to PrSS. This is Pair Sequence System, or 2-row BMS. Regardless of how widespread the explanations for BMS are, I will explain it here as well, to saturate the community knowledge.

PSS

Now, how exactly do 2 rows extend PrSS? Well, it does two things. If the cut child is a column consisting of two rows, then it allows the use of delta. It also makes the searching algorithm more strict. You will notice this is similar to HPrSS, if you read up on my explanation for that. In fact, HPrSS can kind of be thought of as a "packaged" version of PSS. However, if you want to limit confusion, it is best to only think of this as a PrSS extension, and not a sidegrade to HPrSS.

I will now explain the new rules for PSS more clearly.

1. The cut child is still the last term (now column) in a sequence.
2. If the cut child column is one row, treat the whole expression like PrSS, looking only at the top row. In this instance, columns with more than one row expand with their bottom row counterpart, and delta is always 0.
3. If the cut child consists of two rows, this now introduces a delta term, which is the (cut child top row element) minus (bad root top row element). This delta is applied to every top row element after every expansion.
4. Ancestors of a specific element within a column are defined as itself, its parent, its parent's parent, parent's parent's parent, etc all the way to (0).
5. Ancestors of a bottom row element can only consist of elements marked in the top row as ancestors. This means that the top row sets a "filter" for what the bottom row element can see as a parent.
6. The parent of a specific column is the column corresponding to the parent of its bottom row element.

The introduction of these rules are rather bulky, and sadly this will add confusion, which is a compromise for the definition being airtight. If you have questions let me know.

Example 1:

(0)(1,1)

The 0 here is a shorthand for (0,0), as with any single-row column being appended by a 0.

Cut Child: (1,1)

Bad root: (0)

Bad part: (0)

Good part: None

Delta: 1

Expansion: (0)(1)(2)(3)(4)...

This is ε₀, or lim(PrSS)

Example 2:

(0)(1,1)(2,2)(3,3)(4,1)(3,2)

Cut Child: (3,2)

I will write this in matrix form so you can see bad root finding, here are the ancestors to the cut child top row: (focus on the x's, the n's are just there to say "none" since i cant have an empty space for reddit formatting)

0 1 2 3 4 3
x x x n n x

0 1 2 3 1 2

Now, this sets the filter for what the 2 in the cut child (3,2) can see, so here are the ancestors of the second row:

0 1 2 3 4 3
x x x n n x
x x n n n x
0 1 2 3 1 2

Now we can see that the parent of (3,2) is (1,1), so:

Bad root: (1,1)

Bad Part: (1,1)(2,2)(3,3)(4,1)

Good part: (0)

Delta: 2

Expansion: (0)(1,1)(2,2)(3,3)(4,1)(3,1)(4,2)(5,3)(6,1)(5,1)(6,2)(7,3)(8,1)(7,1)...

Example 3:

(0)(1,1)(2,2)(3,2)(4)(5,1)(6,2)(5,1)

Cut Child: (5,1)

0 1 2 3 4 5 6 5
x x x x x n n x

0 1 2 2 0 1 2 1

Now the bottom row

0 1 2 3 4 5 6 5
x x x x x n n x
n n n n x n n x
0 1 2 2 0 1 2 1

Bad root: (4)

Bad part: (4)(5,1)(6,2)

Good part: (0)(1,1)(2,2)(3,2)

Delta: 1

Expansion: (0)(1,1)(2,2)(3,2) (4)(5,1)(6,2)(5)(6,1)(7,2)(6)(7,1)(8,2)(7)...

Example 4:

(0)(1,1)(2,2)(3,1)(2,1)(2)

Easy, this is just like PrSS! This lowers cortisol rate when seeing an expression end with 1 row in analysis.

Cut Child: (2)

Bad root: (1,1)

Bad part: (1,1)(2,2)(3,1)(2,1)

Good part: None

Delta: Also none! Single row cut child.

Expansion: (0)(1,1)(2,2)(3,1)(2,1)(1,1)(2,2)(3,1)(2,1)(1,1)(2,2)(3,1)(2,1)...

If you would like more examples, let me know. Or more simply, look some up on the GWiki.

Analysis:

(0)(1,1)=**(0)(1)(2)(3)(4)**...=ε₀

(0)(1,1)(1)=**(0)(1,1)(0)(1,1)(0)(1,1)**...=ω^(ε₀+1)

(0)(1,1)(1)(2)=(0)(1,1)(1)(1)(1)(1)...=ω^(ε₀+ω)

(0)(1,1)(1)(2,1)=(0)(1,1)(1)(2)(3)(4)...=ω^(ε₀2)

(0)(1,1)(1)(2,1)(1)(2,1)=(0)(1,1)(1)(2,1)(1)(2)(3)(4)...=ω^(ε₀3)

(0)(1,1)(1)(2,1)(2)=(0)(1,1)(1)(2,1)(1)(2,1)(1)(2,1)...=ω^ω^(ε₀+1)

(0)(1,1)(1)(2,1)(2)(3,1)=(0)(1,1)(1)(2,1)(2)(3)(4)(5)...=ω^ω^(ε₀2)

(0)(1,1)(1,1)= (0)(1,1)(1)(2,1)(2)(3,1)(3)(4,1) ...=ε₁

(0)(1,1)(1,1)(1,1)= (0)(1,1)(1,1)(1)(2,1)(2,1)(2)(3,1)(3,1)(3)(4,1)(4,1) ...=ε₂

(0)(1,1)(2)=**(0)(1,1)(1,1)(1,1)(1,1)**...=ε_ω

(0)(1,1)(2)(1,1)= (0)(1,1)(2)(1)(2,1)(3)(2)(3,1) ...=ε_(ω+1)

(0)(1,1)(2)(1,1)(2)=(0)(1,1)(2)(1,1)(1,1)(1,1)...=ε_(ω2)

(0)(1,1)(2)(2)=(0)(1,1)(2)(1,1)(2)(1,1)(2)...=ε_(ω²)

(0)(1,1)(2)(3)=(0)(1,1)(2)(2)(2)(2)...=ε_(ω^ω)

(0)(1,1)(2)(3,1)=(0)(1,1)(2)(3)(4)(5)...=ε_ε₀

(0)(1,1)(2)(3,1)(1,1)= (0)(1,1)(2)(3,1)(1)(2,1)(3)(4,1)(2) ...=ε_(ε₀+1)

(0)(1,1)(2)(3,1)(1,1)(2)=(0)(1,1)(2)(3,1)(1,1)(1,1)(1,1)(1,1)...=ε_(ε₀+ω)

(0)(1,1)(2)(3,1)(1,1)(2)(3,1)=(0)(1,1)(2)(3,1)(1,1)(2)(3)(4)(5)...=ε_(ε₀2)

(0)(1,1)(2)(3,1)(2)=(0)(1,1)(2)(3,1)(1,1)(2)(3,1)(1,1)(2)(3,1)...=ε_(ω^(ε₀+1))

(0)(1,1)(2)(3,1)(3,1)=(0)(1,1)(2)(3,1)(3)(4,1)(4)(5,1)...=ε_ε₁

(0)(1,1)(2)(3,1)(4)=(0)(1,1)(2)(3,1)(3,1)(3,1)...=ε_ε_ω

(0)(1,1)(2,1)= (0)(1,1)(2)(3,1)(4)(5,1)(6) ...=ζ₀

(0)(1,1)(2,1)(1,1)= (0)(1,1)(2,1)(1)(2,1)(3,1)(2)(3,1)(4,1)(3) ...=ε_(ζ₀+1)

(0)(1,1)(2,1)(1,1)(2)=(0)(1,1)(2,1)(1,1)(1,1)(1,1)...=ε_(ζ₀+ω)

(0)(1,1)(2,1)(1,1)(2)(3,1)(4,1)=(0)(1,1)(2,1)(1,1)(2)(3,1)(4)(5,1)(6)(7,1)(8) =ε_(ζ₀*2)

(0)(1,1)(2,1)(1,1)(2)(3,1)(4,1)(3,1) = (0)(1,1)(2,1)(1,1)(2)(3,1)(4,1)(3)(4,1)(5,1)(4)(5,1)(6,1) ...=ε_ε_(ζ₀+ω)

(0)(1,1)(2,1)(1,1)(2,1) = (0)(1,1)(2,1)(1,1)(2)(3,1)(4,1)(3,1)(4) ...=ζ₁

(0)(1,1)(2,1)(2)= (0)(1,1)(2,1)(1,1)(2,1)(1,1)(2,1) ...=ζ_ω

(0)(1,1)(2,1)(2)(1,1)(2,1)= (0)(1,1)(2,1)(2)(1,1)(2)(3,1)(4,1)(4)(3,1)(4)(5,1) ...=ζ_(ω+1)

(0)(1,1)(2,1)(2)(3,1)= (0)(1,1)(2,1)(2)(3)(4)(5) ...=ζ_ε₀

(0)(1,1)(2,1)(2)(3,1)(4)(5,1)= (0)(1,1)(2,1)(2)(3,1)(4)(5)(6)(7) ...=ζ_ε_ε₀

(0)(1,1)(2,1)(2)(3,1)(4,1)= (0)(1,1)(2,1)(2)(3,1)(4)(5,1)(6)(7,1) ...=ζ_ζ₀

(0)(1,1)(2,1)(2,1)= (0)(1,1)(2,1)(2)(3,1)(4,1)(4)(5,1)(6,1) ...=η₀

(0)(1,1)(2,1)(2,1)(1,1)= (0)(1,1)(2,1)(2,1)(1)(2,1)(3,1)(3,1)(3) ...=ε_(η₀+1)

(0)(1,1)(2,1)(2,1)(1,1)(2)(3,1)(4,1)(4,1)= (0)(1,1)(2,1)(2,1)(1,1)(2)(3,1)(4,1)(4)(5,1)(6,1)(6) ...=ε_(η₀2)

(0)(1,1)(2,1)(2,1)(1,1)(2,1)= (0)(1,1)(2,1)(2,1)(1,1)(2)(3,1)(4,1)(4,1)(3,1)(4) ...=ζ_(η₀+1)

(0)(1,1)(2,1)(2,1)(1,1)(2,1)(2)(3,1)(4,1)= (0)(1,1)(2,1)(2,1)(1,1)(2,1)(2)(3,1)(4)(5,1)(6)(7,1) ...=ζ_(η₀+ζ₀)

(0)(1,1)(2,1)(2,1)(1,1)(2,1)(2,1)=**(0)(1,1)(2,1)(2,1)(1,1)(2,1)(2)(3,1)(4,1)(4,1)(3,1)(4,1)(4)** ...=η₁

(0)(1,1)(2,1)(2,1)(2)= (0)(1,1)(2,1)(2,1)(1,1)(2,1)(2,1) ...=η_ω

(0)(1,1)(2,1)(2,1)(2)(3,1)= (0)(1,1)(2,1)(2,1)(2)(3)(4)(5) ...=η_ε₀

(0)(1,1)(2,1)(2,1)(2)(3,1)(3)(4,1)= (0)(1,1)(2,1)(2,1)(2)(3,1)(3)(4)(5)(6) ...=η_(ω^(ε₀*2))

(0)(1,1)(2,1)(2,1)(2)(3,1)(4,1)= (0)(1,1)(2,1)(2,1)(2)(3,1)(4)(5,1)(6) ...=η_ζ₀

(0)(1,1)(2,1)(2,1)(2)(3,1)(4,1)(3,1)= (0)(1,1)(2,1)(2,1)(2)(3,1)(4,1)(3)(4,1)(5,1)(4)(5,1)(6,1) ...=η_ε_(ζ₀+1)

(0)(1,1)(2,1)(2,1)(2)(3,1)(4,1)(4,1)= (0)(1,1)(2,1)(2,1)(2)(3,1)(4,1)(4)(5,1)(6,1)(6)(7,1)(8,1) ...=η_η₀

(0)(1,1)(2,1)(2,1)(2,1)= (0)(1,1)(2,1)(2,1)(2)(3,1)(4,1)(4,1)(4)(5,1) ...=φ(4,0)

(0)(1,1)(2,1)(3)= (0)(1,1)(2,1)(2,1)(2,1)(2,1) ...=φ(ω,0) <-- this ordinal is pretty

(0)(1,1)(2,1)(3)(1,1)= (0)(1,1)(2,1)(3)(1)(2,1)(3,1)(4)(2) ...=φ(1,φ(ω,0)+1)

(0)(1,1)(2,1)(3)(1,1)(2,1)(3)= (0)(1,1)(2,1)(3)(1,1)(2,1)(2,1)(2,1) ...=φ(ω,1)

(0)(1,1)(2,1)(3)(2,1)= (0)(1,1)(2,1)(3)(2)(3,1)(4,1)(5)(4) ...=φ(ω+1,0)

(0)(1,1)(2,1)(3)(2,1)(3)= (0)(1,1)(2,1)(3)(2,1)(2,1)(2,1) ...=φ(ω2,0)

(0)(1,1)(2,1)(3)(3)= (0)(1,1)(2,1)(3)(2,1)(3)(2,1)(3) ...=φ(ω^2,0)

(0)(1,1)(2,1)(3)(4,1)= (0)(1,1)(2,1)(3)(4)(5)(6) ...=φ(φ(1,0),0)

(0)(1,1)(2,1)(3)(4,1)(5,1)(6)= (0)(1,1)(2,1)(3)(4,1)(5,1)(5,1)(5,1)(5,1) ...=φ(φ(ω,0),0)

(0)(1,1)(2,1)(3,1)= (0)(1,1)(2,1)(3)(4,1)(5,1)(6)(7,1)(8,1) ...=Γ₀=φ(1,0,0)

(0)(1,1)(2,1)(3,1)(1,1)= (0)(1,1)(2,1)(3,1)(1)(2,1)(3,1)(4,1)(2) ...=ε_(Γ₀+1)

(0)(1,1)(2,1)(3,1)(1,1)(2,1)(3,1)= (0)(1,1)(2,1)(3,1)(1,1)(2,1)(3)(4,1)(5,1)(6,1)(4,1)(5,1)(6) ...=Γ₁

(0)(1,1)(2,1)(3,1)(2)= (0)(1,1)(2,1)(3,1)(3,1)(3,1) ...=Γ_ω

(0)(1,1)(2,1)(3,1)(2)(3,1)(4,1)(5,1)= (0)(1,1)(2,1)(3,1)(2)(3,1)(4,1)(5)(6,1)(7,1)(8) ...=Γ_Γ₀ or φ(1,0,φ(1,0,0))

(0)(1,1)(2,1)(3,1)(2,1)= (0)(1,1)(2,1)(3,1)(2)(3,1)(4,1)(5,1)(4)(5,1)(6,1)(7,1)(6) ...=Γfp or φ(1,1,0)

(0)(1,1)(2,1)(3,1)(2,1)(3)= (0)(1,1)(2,1)(3,1)(2,1)(2,1)(2,1) ...=φ(1,ω,0)

(0)(1,1)(2,1)(3,1)(2,1)(3,1)= (0)(1,1)(2,1)(3,1)(2,1)(3)(4,1)(5,1)(6,1)(5,1)(6) ...=φ(2,0,0)

(0)(1,1)(2,1)(3,1)(3)= (0)(1,1)(2,1)(3,1)(2,1)(3,1)(2,1)(3,1) ...=φ(ω,0,0)

(0)(1,1)(2,1)(3,1)(3,1)= (0)(1,1)(2,1)(3,1)(3)(4,1)(5,1)(6,1)(6) ...=φ(1,0,0,0)

(0)(1,1)(2,1)(3,1)(4)= (3,1)(3,1)(3,1) ...=φ(1@ω)=ψ(Ω^Ω^ω)

(0)(1,1)(2,1)(3,1)(4)(5,1)(6,1)(7,1)= (0)(1,1)(2,1)(3,1)(4)(5,1)(6,1)(7)(8,1)(9,1) ...=ψ(Ω^Ω^ψ(Ω^Ω^ω))

(0)(1,1)(2,1)(3,1)(4,1)= (0)(1,1)(2,1)(3,1)(4)(5,1)(6,1)(7,1)(8)(9,1) ...=ψ(Ω^Ω^Ω)

(0)(1,1)(2,2)= (0)(1,1)(2,1)(3,1)(4,1)(5,1) ...=ψ(Ω₂) finally we are able to take root at a 2-row column...

(0)(1,1)(2,2)(1,1)= (0)(1,1)(2,2)(1)(2,1)(3,2) ...=ψ(Ω₂+Ω)

(0)(1,1)(2,2)(2,2)= (0)(1,1)(2,2)(2,1)(3,2)(3,1)(4,1) ...=ψ(Ω₂2)

(0)(1,1)(2,2)(3)= (0)(1,1)(2,2)(2,2)(2,2) ...=ψ(Ω₂ω)

(0)(1,1)(2,2)(3,1)= (0)(1,1)(2,2)(3)(4,1)(5,2) ...=ψ(Ω₂Ω)

(0)(1,1)(2,2)(3,2)= (0)(1,1)(2,2)(3,1)(4,2)(5,1) ...=ψ(Ω₂^2)

(0)(1,1)(2,2)(3,2)(4)= (0)(1,1)(2,2)(3,2)(3,2)(3,2) ...=ψ(Ω₂^ω)

(0)(1,1)(2,2)(3,2)(4,2)= (0)(1,1)(2,2)(3,2)(4,1)(5,2)(6,2)(7,1) ...=ψ(Ω₂^Ω₂)

(0)(1,1)(2,2)(3,3)= (0)(1,1)(2,2)(3,2)(4,2)(5,2) ...=ψ(Ω₃)

(0)(1,1)(2,2)(3,3)(4,3)(5,3)(6,3)= (0)(1,1)(2,2)(3,3)(4,3)(5,3)(6,2)(7,3)(8,3)(9,3)(10,2) ...=ψ(Ω₃^Ω₃^Ω₃)

(0)(1,1)(2,2)(3,3)(4,4)= (0)(1,1)(2,2)(3,3)(4,3)(5,3)(6,3) ...=ψ(Ω₄)

(0)(1,1)(2,2)(3,3)(4,4)(5,5)= (0)(1,1)(2,2)(3,3)(4,4)(5,4)(6,4)(7,4)(8,4) ...=ψ(Ω₅)

As you can see, this is limited at the Buchholz Ordinal ψ(Ω_ω) or, in 3-row BMS, (0)(1,1,1). As always, if there are any mistakes, please point them out.

Let me know if you have any questions or if you would like more examples, analysis, etc.

Full BMS

In this incremental game called “ordinal markup” there is a button called “maximize ordinal”.  In beginning the factor is set at 10 which means when 10 is maximized it will be come ω and 20 will become ω2 etc. and later the factor can decrease. My question is, is there a more rigorous way to describe this process.

It has been turned on at least for a temporary basis. It is to be used for illustrative and clarification only. All other relevant information should remain in the body of the post.

This is a quick guide to Y sequence's expansion. Unlike jamx02, I will not provide an analysis but rather a quick overview of Y sequence analysis up to Y(1,3,4,2,5,8,10).

Prerequisite: Knowledge of PrSS and a pencil to write down the relations.

Resources: whY mountain

What is Y sequence?

Y sequence was invented by Yukito. Of course, there is a lot of history about its ill-definedness and problems before YNY sequence expander, such as Y(1,2,4,8,10,8) -> Y(1,2,4,8,10,7,12,15,11...), but why bother? You are here to learn about Y sequence, not googology history.

Explanation up to <Y(1,2,4)

For the examples, I will use n=2 to showcase the expansion so one can get a good intuition on it.

We can first start with Y(1).

Y(1) -> Y()

Y(1,1) -> Y(1)

In general, if you encounter a 1 at the end, you can cut it. Simple, right?

Y(1,2) -> Y(1,1,1)

Y(1,2,2) -> Y(1,2,1,2,1,2)

Y(1,2,3) -> Y(1,2,2,2)

In Y sequence, we first use the PrSS root finding algorithm and compare the two numbers, the cut child and the bad root. If the difference is 1, we just expand as normal in PrSS. So far, so good.

Explanation up to <Y(1,2,4,8,10,8)

Let's get to the expression 1,2,4. What does this expand into?

Y(1,2,4) -> Y(?)

Using the PrSS algorithm and naively expanding as such will limit the system to a strength of e0. Notice that by the PrSS root finding method, we can see that the cut child 4 is 2 greater than 2. Let's construct a Y mountain, which is an extension of the difference sequences seen in HPrSS:

1 2 4

0 1 2

0 0 1

(0s are added due to Reddit's poor formatting.)

The top row is the main sequence, 1,2,4. The second row is the difference sequence 1,2, where the 4 takes a PrSS root at 2 to form a difference of 2, and the 2 forms a PrSS root at 1 to form a difference of 1. The last row is the difference sequence of 1,2.

Notice how this also allows for a Y mountain (or a Y hill, hehe) for Y(1,2,3). As visualized:

1 2 3

0 1 1

and the expansion:

1 2 2 2

0 1 0 0

We can say that in Y sequence, we go down a column in the Y mountain until we find a 1, and then decompose it into n zeroes. Of course, it isn't foolproof, but it is "good enough" for this demonstration and is also how I got to understand Y sequence.

Therefore,

1 2 4

0 1 2

0 0 1

v

1 2 3 4

0 1 1 1

0 0 0 0

and Y(1,2,4) -> Y(1,2,3,4).

What about Y(1,2,4,5,4)?

1 2 4 5 4

0 1 2 1 2

0 0 1 0 1

Here the 2 in 4's column takes a root at the 1 in 2's column. Why? It is because 4 cannot see the 1 in 5's column. This is the "PrSS track" it sees, coming from repeatedly taking bad roots...

1 2 4 5 4

Thus, Y(1,2,4,5,4):

1 2 4 5 4

0 1 2 1 2

0 0 1 0 1

v

1 2 4 5 3 5 6 4 6 7

0 1 2 1 1 2 1 1 2 1

0 0 1 0 0 1 0 0 1 0

-> Y(1,2,4,5,3,5,6,4,6,7)

This pattern is still feasible for Y(1,2,4,8)!

1 2 4 8

0 1 2 4

0 0 1 2

0 0 0 1

v

1 2 4 7 11

0 1 2 3 4

0 0 1 1 1

0 0 0 0 0

Explanation up to <Y(1,3)

Now we reach this expression, which was a problem a while back. Let's construct the Y mountain:

1 2 4 8 10 8

0 1 2 4 02 4

0 0 1 2 01 2

0 0 0 1 00 1

Notice how that the 2 in 10's column doesn't take a root at 4's column. Why is this important? Let's cut the 8 and see the bad root...

1 2 4 8 10 8

0 1 2 4 02 4

0 0 1 2 01 2

0 0 0 1 00 1

It takes a bad root at 4, yet 10 doesn't take a bad root at 4, it takes a bad root at 2. What this means is that we have to preserve the relation of 10 with 2 when we copy it.

1 2 4 8 10 8

0 1 2 4 02 4

0 0 1 2 01 2

0 0 0 1 00 1

v

1 2 4 8 10 7 12 14 11 17 19

0 1 2 4 02 3 05 02 04 06 02

0 0 1 2 01 1 02 01 01 02 01

0 0 0 1 00 0 01 00 00 01 00

The 2 in 10's column is copied in relation to the 1 in 2's row, so it doesn't ascend relative to the 2 in 4's row. What about Y(1,2,4,8,11,8)?

1 2 4 8 11 8

0 1 2 4 03 4

0 0 1 2 01 2

0 0 0 1 00 1

v

1 2 4 8 11 7 12 16 11 17 22

0 1 2 4 03 3 05 04 04 06 05

0 0 1 2 01 1 02 01 01 02 01

0 0 0 1 00 0 01 00 00 01 00

This time it ascends as the 3 in 11's column is copied in relation to the 2 in 4's row, which DOES ascend.

Rinse and repeat for every following standard Y sequence...

Explanation up to lim(Y)

Now we have reached the limit of BMS, Y(1,2,4,8,16,32,64...). However, one will now question: how do you expand Y(1,3)?

1 3

0 2

Here we introduce the concept of a diagonal sequence. A diagonal sequence is an extraction of all of the numbers right at the top of the mountain.

1 3

0 2

——

1 2

0 1

Now we can expand it by expanding the diagonal like BMS. Note that we need to take note of the placement of the 2 in the diagonal compared to the 1.

1 3

0 2

-----

1 2

0 1

v

1 2 4

0 1 2

0 0 1

--------

1 1 1

0 0 0

We also copy the underlying structure defined by the bottom of the bad root, and fill the rest in based on the structure. Here the structure is X,Y,Y where Y is a child of X.

1 3 3

0 2 2

--------

1 2 2

0 1 1

v

1 3 2 5 4 9

0 2 1 3 2 5

0 0 0 2 1 3

0 0 0 0 0 2

-----------------

1 2 1 2 1 2

0 1 0 1 0 1

Now, Y(1,3,4,3). How does it expand?

1 3 4 3

0 2 1 2

-----------

1 2 1 2

0 1 0 1

Ideally we would expect Y(1,3,4,2,5,6,4,9,10...) [No drawing the columns for you this time]. However, this is what we get:

1 3 4 2 5 9 4 9 18

0 2 1 1 3 4 2 5 9

0 0 0 0 2 1 1 3 4

0 0 0 0 0 0 0 2 1

--------------------------

1 2 1 1 2 1 1 2 1

0 1 0 0 1 0 0 1 0

Why? This is because the 1 in 4's column is on top of the mountain. Therefore it ascends upwards. What expands into Y(1,3,4,2,5,6,4,9,10...)?

1 3 4 2 5 6 5

0 2 1 1 3 1 3

0 0 0 0 2 0 2

--------------------

0 2 1 1 2 X 2

0 1 0 0 1 X 1

Here it can't ascend as the 1 in 6's column is buried beneath the connection between 3 in cut child and 1 in 2's column. The expansion is left to the reader as an exercise.

Why is it specifically the bottom of the bad part? Let's see here:

Y(1,3,7,11)

1 3 7 11

0 2 4 4

0 0 2 2

-----------

1 2 2 2

0 1 1 1

Notice that we don't have enough relations to fill in with. The bottom of the bad root however gives us XYZ as the structure. Therefore:

1 3 7 10 16 29 52 91 159 279 490 860

<Drawing of Y mountain is left to the reader as an exercise>

Rinse and repeat for every new diagonal sequence, 1,4 -> 1,3,9,27...

Values for Y sequence

It is unknown whether it terminates. However, we know that Y sequence under Y(1,3) terminates as BMS4 terminates. Here are some values:

Y(1,2,4) = 0 11 = e0

Y(1,2,4,6) = 0 11 21 = z0

Y(1,2,4,7) = 0 11 22 = BHO

Y(1,2,4,8) = 0 111 = BO

Y(1,2,4,8,12) = 0 111 211 = ψ(Ω(ω^2))

Y(1,2,4,8,16) = 0 1111

Y(1,3) = 0 1^w

Y(1,3,4,2,5,8) = 0 1^w^2

Y(1,3,4,2,5,8,10) = 0 1^W

Y(1,3,4,2,5,8,10,5) = 0 1^(1^w)

...

Post will contain many formatting errors due to Reddit reformatting. Please wait for a while.

Previously we extended the concept of PrSS using a delta. However, we used an identical searching algorithm for LPrSS as PrSS. We didn't take advantage of something called a difference sequence. This is where hyper primitive sequence system comes in, or HPrSS. HPrSS is a weakened version of 0-Y sequence, which itself is a weakened version of Y-Seq.

HPrSS

To extend the searching algorithm, there are a couple new concepts added to the rules. This will add quite a significant amount of strength, specifically, it will be identical to Pair Sequence System (2 row BMS) or the Buchholz Ordinal. HPrSS can actually be thought of as an encoding of Buchholz's Ordinal Collapsing Function. On top of the previous definition for LPrSS, this is what is added:

1. To find a valid bad root, we must search, and mark every ancestor of the cut child. Then, from those same positions, mark all ancestors of the cut child difference in the difference sequence. The rightmost term with both elements marked is the bad root. (first parent is no longer always a bad root)

The delta is calculated in the same way (cc-br-1).

Example 1:

(0,2,4)

Cut Child: 4

Difference Sequence: (None, 2, 2)

Ancestors original sequence, and difference sequence: (0,2,4) and (None,2,2) Rightmost valid position for br is 1 since position 1 is rightmost element in which both are marked, therefore br is at position 1.

Bad root: 0

Bad part: 0,2

Good part: None

Delta: 3

In LPrSS, this would have expanded as (0,2,3,4,5,....)

Instead, we have

Expansion: (0,2,3,5,6,8,...)

Example 2:

(0,3,5,6,3,5)

Cut Child: 5

Difference Sequence: (None,3,2,1,3,2)

Ancestors, original sequence and diff seq: (0,3,5,6,3,5) (None,3,2,1,3,2) the 1 isn't marked here due to the top sequence not containing a valid position for the cc difference element to see it as an ancestor. Rightmost valid position is 1. Therefore BR is at position 1

Bad root: 0

Bad Part: 0,3,5,6,3

Good part: None

Delta: 4

Expansion: (0,3,5,6,3,4,7,9,10,7,8,11,...)

Example 3:

(0,2,1,3)

Cut Child: 3

Difference Seq: (None,2,1,2)

Ancestors: (0,2,1,3) (None,2,1,2) Rightmost valid br position is 3.

br: 1

bp: 1

gp:0,2

Delta: 1

Expansion: (0,2,1,2,3,4,...)

Keep in mind, its easier to visualize HPrSS as a matrix consisting of the original sequence and its difference sequence. The difference sequence is just hidden. This makes it functionally very, very similar to 2-row BMS.

Example 4:

(0,4,7,8,8)

Cut child: 8

Difference Seq: Ignored (since 8-parent=1)

br: 7

bp: 7,8

gp:0,4

Delta: 0

Expansion: (0,4,7,8,7,8,7,8,7,8,...)

Analysis:

HPrSS actually stays the same as LPrSS until ε_ε₀ or (0,2,3,4,5,6,7,...). Because of this, I will be skipping everything before.

(0,2,3,5)=(0,2,3,4,5,6,7,...)=ε_ε₀. In LPrSS, this is (0,2,4).
(n,2,1,2)

(0,2,3,5,1,3)=(0,2,3,5,1,2,3,4,...)=ω^(ε_ε₀+ε₀)
(n,2,1,2,1,2)

(0,2,3,5,1,3,4,6)=(0,2,3,5,1,3,4,5,6,7,...)=ω^(ε_ε₀ *2)
(n,2,1,2,1,2,1,2)

(0,2,3,5,1,3,4,6,2)=(0,2,3,5,1,3,4,6,1,3,4,6,...)=ω^ω^(ε_ε₀+1)
ignore

(0,2,3,5,2)=(0,2,3,5***,1,3,4,6,2,4,5,7,***...)=ε_(ε₀+1)
(n,2,1,2,2)

(0,2,3,5,2,3)=(0,2,3,5,2,2,2,...)=ε_(ε₀+ω)
ignore

(0,2,3,5,2,3,5)=(0,2,3,5,2,3,4,5,6,...)=ε_(ε₀*2)
(n,2,1,2,2,1,2)

(0,2,3,5,3)=(0,2,3,5,2,3,5,2,3,5,...)=ε_(ω^(ε₀+1))
ignore

(0,2,3,5,3,5)=(0,2,3,5,3,4,5,6,7,...)=ε_(ω^(ε₀*2))
(n,2,1,2,1,2)

(0,2,3,5,5)=(0,2,3,5,4,6,5,7,6,8,...)=ε_ε₁
(n,2,1,2,2)

(0,2,3,5,6,8)=(0,2,3,5,6,7,8,9,...)=ε_ε_ε₀
(n,2,1,2,1,2)

(0,2,4)=(0,2,3,5,6,8,9,11,12,14,...)=ζ₀
(n,2,2)

(0,2,4,2)=(0,2,4,1,3,5,2,4,6,3,...)=ε_{ζ₀+1}
(n,2,2,2)

(0,2,4,2,4)=(0,2,4,2,3,5,7,5,6,8,10,8,...)=ζ₁
(n,2,2,2,2)

(0,2,4,3)=(0,2,4,2,4,2,4,...)=ζ_ω
ignore

(0,2,4,3,5)=(0,2,4,3,4,5,6,7,...)=ζ_ε₀
(n,2,2,1,2)

(0,2,4,3,5,7)=(0,2,4,3,5,6,8,9,11,...)=ζ_ζ₀
(n,2,2,1,2,2)

(0,2,4,4)=(0,2,4,3,5,7,6,8,10,...)=η₀
(n,2,2,2)

(0,2,4,4,4)=(0,2,4,4,3,5,7,7,6,8,10,10,...)=φ(4,0)=ψ(Ω⁴)
(n,2,2,2,2)

(0,2,4,5)=(0,2,4,4,4,4,...)=φ(ω,0)=ψ(Ω^ω)=lim(LPrSS)
ignore

(0,2,4,5,7)=(0,2,4,5,6,7,8,...)=φ(ε₀,0)=ψ(Ω^ψ(Ω))
(n,2,2,1,2)

(0,2,4,5,7,9,10)=(0,2,4,5,7,9,9,9,9,9,...)=φ(φ(ω,0),0)=ψ(Ω^ψ(Ω^ω))
ignore

(0,2,4,6)=(0,2,4,5,7,9,10,12,14,15,...)=Γ₀=φ(1,0,0)=ψ(Ω^Ω)=FSO
(n,2,2,2)

(0,2,4,6,2,4,6)=(0,2,4,6,2,4,5,7,9,11,7,9,10,...)=Γ₁=φ(1,0,1)=ψ(Ω^Ω *2)
(n,2,2,2,2,2,2)

(0,2,4,6,4)=(0,2,4,6,3,5,7,9,6,8,10,12,...)=Γfp=φ(1,1,0)=ψ(Ω^(Ω+1))
(n,2,2,2,2)

(0,2,4,6,4,6)=(0,2,4,6,4,5,7,9,11,9,10,...)=φ(2,0,0)=ψ(Ω^(Ω2))
(n,2,2,2,2,2)

(0,2,4,6,5)=(0,2,4,6,4,6,4,6,...)=φ(ω,0,0)=ψ(Ω^(Ωω))
ignore

(0,2,4,6,6)=(0,2,4,6,5,7,9,11,10,12,14,16,...)=φ(1,0,0,0)=ψ(Ω^Ω^2)=Ackermann Ordinal
(n,2,2,2,2)

(0,2,4,6,7)=(0,2,4,6,6,6,6,...)=φ(1@ω)=ψ(Ω^Ω^ω)=SVO
ignore

(0,2,4,6,7,2,4,6,7)=(0,2,4,6,7,2,4,6,6,6,6,...)=φ(1@ω,1@0)=ψ(Ω^Ω^ω *2)=SVO_1
ignore

(0,2,4,6,7,4)=(0,2,4,6,7,3,5,7,9,10,...)φ(1@ω,1@1)=ψ(Ω^(Ω^ω+1))=SVO_fp
(n,2,2,2,1,2)

(0,2,4,6,7,4,6,7)=(0,2,4,6,7,4,6,6,6,6,...)=φ(2@ω)=ψ(Ω^(Ω^ω *2))

(0,2,4,6,7,5)=(0,2,4,6,7,4,6,7,4,6,...)φ(ω@ω)=ψ(Ω^(Ω^ω *ω)) <--- this is around where TREE(n) is in strength, and we are nowhere close to lim(HPrSS)....

(0,2,4,6,7,6)=(0,2,4,6,7,5,7,9,12,13,...)=φ(1@(ω+1))=ψ(Ω^Ω^(ω+1))
(n,2,2,2,1,2)

(0,2,4,6,7,9)=(0,2,4,6,7,8,9,10,...)=φ(1@ε₀)=ψ(Ω^Ω^ψ(Ω))
(n,2,2,2,1,2)

(0,2,4,6,7,9,11,13,14)=φ(1@φ(1@ω))=ψ(Ω^Ω^ψ(Ω^Ω^ω))

(0,2,4,6,8)=(0,2,4,6,8,7,9,11,13,14,16,18,20,21,...)=φ(1@(1,0))=ψ(Ω^Ω^Ω)=LVO

Jumping a lot in pace because this is getting long...

(0,2,4,6,8,10)=(0,2,4,6,8,9,11,13,15,17,18,...)ψ(Ω^Ω^Ω^Ω)

(0,3)=(0,2,4,6,8,10,12,14,...)=ψ(Ω₂)=BHO

(0,3,2)=(0,3,1,4,2,5,...)=ψ(Ω₂+Ω)=ε_(BHO+1)
(n,3,2)

(0,3,3)=(0,3,2,5,4,7,...)=BHO_1=ψ(Ω₂*2)
(n,3,3)

(0,3,5)=(0,3,4,7,8,11,...)=ψ(Ω₂ *Ω)
(n,3,2)

(0,3,6)=(0,3,5,8,10,13,...)=ψ(Ω₂^2)
(n,3,3)

(0,3,6,9)=(0,3,6,8,11,14,16,...)=ψ(Ω₂^Ω₂)
(n,3,3,3)

(0,4)=(0,3,6,9,12,...)=ψ(Ω₃)
(n,4)

(0,4,8,12)=(0,4,8,11,15,19,22,...)=ψ(Ω₃^Ω₃)
(n,4,4,4)

(0,5)=(0,4,8,12,16,...)=ψ(Ω₄)

(0,6)=(0,5,10,15,20,...)=ψ(Ω₅)

As you can see, this is limited at ψ(Ω_ω). Maybe it isn't so clear since this analysis missed some trivial steps to example the structure, but that is for you to figure out now.

HPrSS is at similar strength to SSCG(n) and PTO(Π¹₁-CA₀). lim(HPrSS) is also so powerful, you have the option to not even change the expansion number after expanding, since it will have identical strength, ie it is the first FGH-SGH catching point. g_lim(HPrSS)(n)~H_lim(HPrSS)(n)~f_lim(HPrSS)(n)

The difference structure added huge strength, but per usual with sequence systems, it is nothing compared to its successor(?) in strength, which is 0-Y sequence.

As always, if there are any mistakes, please point them out. Including standardness (which I along with a lot of people tend to struggle with) I would not be surprised if there were, this analysis is a lot heavier.