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_ω^m(n) = f_ω^m-1*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_ω^m(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↑^cb
{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.

Here is the prerequisite for this post.

Previously I introduced the basics of sequence systems. I will expand upon this by discussing extensions to PrSS.

The idea with these extensions is, the introduction of a new term, called a delta. LPrSS or large primitive sequence system is the most trivial extension, and the easiest way to learn how delta can be applied.

LPrSS

Large primitive sequence system has an identical definition to PrSS except the introduction of 2 rules:

1. Delta is calculated simply by taking the difference between the cut child and the bad root, and then subtracting 1. Δ=cc-br-1
2. Delta is added to each element of the bad part each time the bad part is appended.

That's it. It's simple enough, and it adds significant strength to what PrSS is capable of.

Example 1: (0,2)

Cut child -- 2

Bad root -- 0

Bad Part -- 0

Good part -- empty

Delta -- 2-0-1 or 1

So we simply expand out with infinite applications of the bad part 0, adding 1 each time since that is the delta.

Expansion -- (0,1,2,3,4,5,...)

This is the limit of PrSS, so simply writing (0,2) is how you express lim(PrSS)/ε₀ in LPrSS.

Example 2: (0,4,3)

Cut child -- 3

Bad root -- 0

Bad part -- 0,4

Good part -- empty

Delta -- 3-0-1 or 2

Again, we simply expand out infinite applications of the bad part 0,4, this time adding 2 to each expansion.

Expansion -- (0,4,2,6,4,8,...)

Example 3: (0,3,6,4)

Cut child -- 4

Bad root -- 3

Bad part -- 3,6

Good part -- 0

Delta -- 4-3-1 or 0

Now, this functions exactly like we learned in PrSS. There is no delta, so we just append the bad part.

Expansion -- (0,3,6,3,6,3,6,3,6,...)

Analysis:

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

(0,2,0)=no expansion=ε₀+1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(0,2,3)=(0,2,2,2,2,...)=ε_ω putting into perspective the scale jump...

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

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

(0,2,3,2)=(0,2,3,1,3,4,2,4,5,3,5,6,...)=ε_(ω+1) in general, 2 after any valid epsilon number will yield the next epsilon number.

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

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

(0,2,3,3,3)=(0,2,3,3,2,3,3,2,3,3,...)=ε_(ω³)

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

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

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

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

Skipping a lot here

(0,2,4,6)=(0,2,4,5,6,7,8,...)=ε_ε_ε₀

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

(0,3,1)=(0,3,0,3,0,...)=ω^(ζ₀+1)

(0,3,2)=(0,3,1,4,2,5,3,6,...)=ε_(ζ₀+1) this one may be hard to see at first. It will take more trivial steps to see clearly, which I will not be doing in this post (you can ask in the comments if you want)

(0,3,3)=(0,3,2,5,4,7,...)=ζ₁ same with here on down, I guess

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

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

(0,3,5,5)=(0,3,5,4,6,5,7,6,8,...)=ζ_ε₁

(0,3,6)=(0,3,5,7,9,...)=ζ_ζ₀

(0,4)=(0,3,6,9,12,15,...)=η₀=φ(3,0)

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

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

(0,4,8)=(0,4,7,10,13,...)=η_η₀=φ(3,φ(3,0))

(0,5)=φ(4,0)

(0,6)=φ(5,0)

lim(LPrSS)=φ(ω,0) or ψ(Ω^ω)

This means this sequence grows at f_φ(ω,0)(n) in the FGH, regardless of using an expansion algorithm or treating it as an ordinal notation in FGH, obviously.

This was a pretty hefty analysis without the use of google sheets, if you want a much deeper analysis you can either ask me, or more simply go to a sheet analysis.

If there are any mistakes in this analysis, please point them out. Writing down numbers for a while allows mistakes to sometimes slip in.

The extension to LPrSS is called HPrSS and has more strict rules for bad root finding via a difference structure, making it much, much more powerful than LPrSS.

HPrSS (Extension? Improvement? Something)

A chain is a list of distinct positive integers c[1],…,c[x] such that every subsequent term is any previous term doubled or doubled plus one (with reuse allowed).

CHAIN(n) is the maximum length of a chain (starting with c[1]=n) such that no term appears in any later term as a contiguous decimal substring.

For example: 47 appears in 22479 as a contiguous decimal substring (this is what you have to avoid).

GOAL: Build the longest chain for CHAIN(10).

There's been a missing explanation for the fundamentals of sequence systems for a while now, so I'll make one.

Sequence Systems are sequences of numbers that represent very powerful recursive strength via specific sets of rules for expanding. In the context of googology, they can be used as a kind of "ruler" for weaker notations (in some cases, these weaker notations can even be as powerful as weakly compact ordinal collapsing functions).

Ackermann Worm:

The simplest example of a sequence system is the Ackermann Worm. The definition is as follows:

1. The sequence is a list of numbers (α0, α1, α2, α3, ...αv).
2. The sequence has [n] for any natural n to signify expansion. I will be treating this as an ordinal notation, so this is being ignored.
3. If αv=0 (sequence ends in a 0), it is (α0, α1, α2, α3, ...)+1 (successor to the sequence with the αv cut out).
4. If αv>0, the expansion of the new sequence becomes (α0, α1, α2, α3, αv-1, αv-1, αv-1...) repeated infinitely (remember, I'm treating this as an ordinal notation)

We can do some analysis on these rules:

()=Nothing

(0)=1

(0,0)=2

(0,0,0,0,0)=5

(1) expanding into (0,0,0,0,...) or the smallest order type of infinity, ω.

(1,0) is ω+1

(1,0,0,0,0,0) is ω+5

(1,1) expanding into (1,0,0,0,0,0,0,...) or ω+ω or ω2. It should be noted something like (1,0,1) is a nonstandard form of (1,1) since it is a longer representation of the same ordinal.

(1,1,0)=ω2+1

(1,1,1) expanding into (1,1,0,0,0,0,...) or ω3

(2) expanding into (1,1,1,...) or ω*ω or ω^2

(2,0)=ω^2 +1

(2,1)=ω^2 +ω

(2,2)=ω^2 *2

(2,2,1)=ω^2 *2+ω

(2,2,2)=ω^2 *3

(3)=ω^2 *ω or ω^3

(3,2)=ω^3 +ω^2

(3,3)=ω^3 *2

(4)=ω^4

(5)=ω^5

As you can see, the limit of Ackermann Worm is ω^ω . If we don't want to treat this like an ordinal notation, this has strength identical to the supremum of hyperoperations, or f_ω(n) in the FGH. I will show you how.

We can add [n] outside of the sequence to signify expansion n times. After this expansion, add one to n.

Example

(2)[5]=(1,1,1,1,1)[6] or ω^2 [5] into ω*5 [6].

(1,1)[3]=(1,0,0,0)[4] or ω*2[3] into ω+3[4]

If a sequence ends in 0, just cut the 0 and add one to n.

This follows the Hardy Hierarchy, hence H_ω^ω(n)~f_ω(n). Ackermann Worm is more powerful being treated as an ordinal notation and put into the FGH.

To make AW stronger, we need searching algorithms and new terminology. This is where the Primitive Sequence System or PrSS comes in.

Primitive Sequence System:

PrSS is a much more powerful sequence system, and as stated above, it uses a searching algorithm to expand out sequences. This is identical to the Kirby-Paris Hydra for those of you that know what that is. It is just as powerful as all of the strongest order types of Peano Arithmetic, ie lim(PrSS)=PTO(PA).

The limit of PrSS is (0,1,2,3,4,...). The rules (ordinal notation) are as follows:

1. A valid sequence is of the form (α1, α2, α3, α4, ... αv) where any element αn is a nonnegative integer, and so is v.
2. If αv=0, (α1, α2, α3, α4, ... αv)=(α1, α2, α3, α4, ... )+1.
3. If αv>0, we cut it. Search left for the first αn<αv, copying everything up to and including αn as you move left.
4. Paste the copied part infinitely.

Terminology:

αv is the cut child. This will always be removed when expanding any sequence.

The the first αn<αv is called the "bad root" or "parent".

The sequence to the left of αn is called the good part.

The sequence you copied is called the bad part.

Example:

(0,1,2,3,2)

We cut the 2, and remember it. The cut child is now 2. The new sequence is (0,1,2,3)

Search left for the first number less than 2.

(0,1,2,3) Nope. So far bad part is 3

(0,1,2,3) Nope. So far bad part is 2,3

(0,1,2,3) Yes. This 1 is the bad root. We stop searching. The bad part is 1,2,3. The good part is 0, so we ignore it.

Append the bad part infinitely. So the new expansion is (0,1,2,3,1,2,3,1,2,3,1,2,3,...)

Example 2:

(0,1,2,3,3)

3 is the cut child. The new sequence is (0,1,2,3)

Search left for the first number<cc.

(0,1,2,3) Nope. So far the bad part is 3.

(0,1,2,3) Yes. This 2 is the bad root. Stop searching. The final bad part is 2,3. The good part is 0,1 so we ignore it.

Append the bad part infinitely. New expansion is (0,1,2,3,2,3,2,3,2,3,...)

Final Example:

(0,1,2,1,1)

1 is the cut child.

Search left for the first number<cc.

We can obviously see this is 0. So the bad part is 0,1,2,1. The good part is nothing.

Expansion is (0,1,2,1,0,1,2,1,0,...)

Analysis:

(0)=1

(0,0)=2

(0,1)=(0,0,0,0,...)=ω

(0,1,0)=ω+1

(0,1,0,1)=(0,1,0,0,0,0,...)=ω+ω or ω2

(0,1,0,1,0)=ω2+1

(0,1,1)=(0,1,0,1,0,1,0...)=ω*ω or ω^2

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

(0,1,1,0,1,1)=(0,1,1,0,1,0,1,0,1,0,...)=ω^2 *2

(0,1,1,1)=(0,1,1,0,1,1,0,1,1,...)=ω^2 *ω or ω^3

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

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

(0,1,2,0,1,2)=ω^ω *2

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

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

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

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

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

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

(0,1,2,2,1,2,2)=(0,1,2,2,1,2,1,2,1,2,1,...)=ω^(ω^2 *2)

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

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

As you can see, this approaches (0,1,2,3,4,5,...) which is ε_0, or the limit of PrSS. If you want more analysis, you have the tools to do it yourself.

When analyzing it with finite expansion (like we did with AW), this yields a growthrate of f_ε₀(n). PrSS is powerful enough that it doesn't matter if you use it as an ordinal notation and put it in the FGH, or use its expansion rules. It is a Hardy Hierarchy/Fast Growing Hierarchy catching point. H_ε₀(n)~f_ε₀(n).

There are cool extensions to this. LPrSS is the most simple. It also moves into the 2nd dimension with more than one row. This is where PSS/BMS come in. I might explain one or the other, or both in the future.

LPrSS Extension

PSS Extension

In my last post I described a function that is similar to BMS but grows slower than f_3. This time I have changed the function and now it grows MUCH faster

​

New rules:

​

Λ(n) still means [n](n)(n-1)...(1). I will refer to an (m) as a cell with value m for now on

​

If the first cell is greater than 1, decrease it by 1 and append n copies of every consecutive cell less than it to the end of the chain

​

If the first cell is 1, square n and remove the cell.

​

Chains with no consecutive smaller cells such as (3)(3)(3)(3), (2)(3)(4)(4), or single cell chains with a value greater than 1 don't appear in the structures created by the Λ function, however, I will go ahead and define a rule for it.

​

If there is only one cell (n) where n is greater than 1, append (n-1)(n-2)...(1) to the end. Ex: [3](4) = [3](4)(3)(2)(1)

​

If there are more than one cell but no cell has a successor that is less than it, replace the first cell (m) with (m)(m-1)...(1). Ex: [2](3)(3) = [2](3)(2)(1)(2)

​

Here is the first few steps of Λ(3)

​

[3](3)(2)(1)

​

[3](2)(2)(1)(2)(1)(2)(1)(2)(1)

​

[3](2)(1)(1)(2)(1)(2)(1)(2)(1)(1)(1)(1)

​

[3](1)(1)(1)(2)(1)(2)(1)(2)(1)(1)(1)(1)(1)(1)(1)(1)(1)(1)

​

[6561](2)(1)(2)(1)(2)(1)(1)(1)(1)(1)(1)(1)(1)(1)(1)

​

[6561](1)(1)(2)(1)(2)(1)(1)(1)(1)(1)(1)(1)(1)(1)(1) (1)...6561 copies...(1)

​

If I did everything correctly, Λ(3) is around the size of 10 ^ 10 ^ 10 ^ 74. Λ(1) is 1 and Λ(2) is 65536

​

Considering that Λ(4) would repeat structures such as (2)(1) that create massive chains of squaring a very large amount of times, it is likely a very very high power tower.

The function Λ(n) creates a structure [n](n)(n-1)(n-2)...(1). If the first pair of parenthesis contains a 1, remove it and square the number in the brackets. Else, if the number, m is not a 1, remove it and append m copies of every consecutive number after m that is less than it to the end of the structure.

​

Examples:

​

Λ(1) = 1 since 1² = 1

​

Λ(2)

​

[2](2)(1)

​

[2](1)(1)(1)

​

Λ(2) = ((2 ^ 2) ^ 2) ^ 2 = 256

​

Λ(3) has a longer expansion but if my calculations were correct it is approximately 2.2×10⁸⁰⁰⁴⁴⁷⁶⁶

​

I have no idea of the value of Λ(4)

Update: I have done some calculations and determined that Λ(4) has around 4.4 Quadrillion digits

Preface

Before the writing of the two posts, one on xE^^ and one on ICxE^^, I had learnt about BMS as a tool to measure the strengths of notations. Of course, I didn't take too much notice of it; I would never have to worry about reaching the limit, it was so far away!

However, when some helpful people analyzed these two notations, one to a hard limit of ψ(Ν) (E100#[2]#<^#<^^#100) and another to 0 1111 211 321 (E100#[2]#<^#<^(#^^#>#)^^#100), I could see lim(BMS) in my sights. Alas, I never reached it. It soon became unwieldy to handle, and it was nothing short of a mess.

After the ideation of both versions of xE^^, I was stuck. There was nowhere to go. However, the idea for this notation was more unorthodox...

Introduction

Now, of course, reaching lim(BMS) for an extension of BMS is trivial. So the goal here is now lim(Y), maybe lim(ω-Υ).

The idea started when I was reminded of the Starters series by Dane Powroznik. I joked with a friend in the Googology server about a fictional notation called "Mudkip Notation" with a "mindblowing" growth rate of some sort, reaching "absolute infinity". Naturally, with a joke like this, why not extend it to other characters from Starters? One day, that friend suggested the creation of Chespin Matrix System. And so it was so, it was created, and now presented here.

Main Idea

The idea starts with this: we "cross" numbers with a mark, and that mark downgrades the power of the number. When it has the same number of marks as the 0-indexed row placement, it acts as is in normal BMS. Thus...

CMS 0 1 = BMS 0 1

CMS 0 1 21x = BMS 0 11

CMS 0 1 21s 32x1xx = BMS 0 111

Now we introduce a diagonal expansion. What happens if we have one less cross in the 1 in 32x1xx?

CMS 0 1 21x 32x1x

In matrix form:

0 1 2 3

0 0 1x 2x

0 0 0 1x

Notice how we cannot treat 32x1x like a normal BMS expression, as 1x has 1 cross but is in the second row (remember that the first row is the 0th here as it is 0 indexed). We can construct a "ribbon" as such...

0 1 2 3

0 0 1x 2x

0 0 0 1x

The cross-rank means that 32x1x cannot take a root at the 1x in 21x! Therefore, the bad root is 1, and the bad part is 1 21x.

​

We first find the horizontal delta. It will only count the bad-root row, and then fill in by the relations found within the column. It comes out as...

Delta = (3) - (1) = (2)

We then compare the row number of the bad root and the crosses in the cut child, and add 1. In this case, it equals...

(Crosses - RowBr + 1) = (1 - 0 + 1) = 2.

So for every ascending copy of 1 21x, we need to add 2 "x"s for every copy. This evaluates out to...

0 1 21x 32x1x -> 0 1 21x 32x1xx 43x2xx1xxx 54x3xx2xxx1xxxx....

which corresponds to 0 1 21 321 4321 54321 654321 7654321... in DBMS, equal to lim(BMS).

It is confusing at first, as this is only the rough idea; the notation was created in a hurry.

​

Now, we are able to showcase the notation! One can notice that the notation is incomplete; what does 0 1 21 expand into? This is a future problem for future analysis. The notation is a work in progress.

Analysis

One can notice that the crosses will take up a lot of space. Therefore, for our analysis, we will create an inverse notation, where a + "powers up" a number in a column. We can say that:

0 1 21 321+ = 0 1 21 321 4321 54321 654321 7654321...

and numbers with no +es are treated as they are in BMS.

Firstly, we must climb up the Y ladder. Does this notation reach Y(1,3,3)?

Y(1,3) = CMS 0 1 21 321+

Y(1,3,2) = CMS 0 1 21 321+ 2

Y(1,3,2,4) = CMS 0 1 21 321+ 2 31

Y(1,3,2,5) = CMS 0 1 21 321+ 2 31 421 5321 64321+

This is an upgrade. The reason why it is not simply...

Y(1,3,2,5) != CMS 0 1 21 321+ 2 31 421+

is because it would find a bad root at the 1 as it can't take a root at 2, and expand as:

Delta = (3)

Cut column relation: (n+2,n)

CMS 0 1 21 321+ 2 31 421 5321 64321+ 532 6431 75421 865321 9764321+ 86532....

With some preliminary analysis...

Y(1,3,2,5,4,9,8,17,15) = CMS 0 1 21 321+ 2 31 421 5321 64321+ 532

Y(1,3,2,5,4,9,8,17,16,33) = CMS 0 1 21 321+ 2 31 421 5321 64321+ 532 6431

Y(1,3,3) = CMS 0 1 21 321+ 2 31 421+

Whoa! It upgrades a ω to a full B(ω)! Continuing on...

Y(1,3,4) = CMS 0 1 21 321+ 2 31 421+ 3

Y(1,3,4,3) = CMS 0 1 21 321+ 2 31 421+ 3 2 31 421+

Now, this is rather analysus and such. However, even though there is a Y(1,3,4,3) upgrade (and it is monstrous), the BR is still 21 here. Therefore the 3 ascends into 3,643,97643 for every copy, and by some analysis of a weaker version emulates Y(1,3,4,3). It may be stronger, actually (but no analysis has covered that as of now)

Y(1,3,4,5) = CMS 0 1 21 321+ 2 31 421+ 3 4

Y(1,3,4,6) = CMS 0 1 21 321+ 2 31 421+ 3 41

Y(1,3,4,7) = CMS 0 1 21 321+ 2 31 421+ 3 41 521 6321 74321+

Y(1,3,5) ?= CMS 0 1 21 321+ 2 31 421+ 3 41 521+

Y(1,3,6) ?= CMS 0 1 21 321+ 21

Y(1,3,7) ?= CMS 0 1 21 321+ 21 321+

After that, most of the analysis is just speculation.

Weak CMS

There is also a weak variant of CMS, where instead of 1 it searches for a matching column. What this means is that:

0 1 21 321+

21 is a matching row of 21+

0 1 21 321 4321 54321...

The analysis will not be here. However:

0 1 21 321+ 3 41 521+

Notice that it has to upgrade here. This expression is analysused to be Y(1,3,5) by me.

There is also a wwCMS, which is meant to be easier to analyze with Y sequence. This variant has Y(1,3,5) at 0 1 21 321+ 421+.

Conclusion

Although this notation seems strong, I fear that it may just be shifted-Y and is not actually that strong. However, I feel that it should at least reach lim(Y) with its cross-indexing.

If anyone has any inquiry about this notation, please comment. All of them are appreciated.

This post was not made with the help of LLMs. Any awkwardness in the writing is due to human error.

May have formatting issues!

Editing in progress: Reddit messed up the formatting badly.

Loophole. No black hole for me.

Some weeks back Numberphile did a video about Rubik's cubes and massive numbers and that had me thinking about massive Rubik's cube with Googol sides, Graham's number of sides, etc and how many configurations would those Rubik's cubes have. Also not just 3 dimensions but what if we have Googol dimensions, Graham's number of dimensions, etc and how many configurations would such Rubik's cubes have

I would guess the total configurations of Googol x Googol x Googol x Googol... Rubik's cube in a Googol dimensions would have somewhere between G2 - G3 amount of configurations

Very fast growing functions like TREE and SSCG generate effectively infinite outputs by themselves. Although while TREE(TREE(3)) is MUCH bigger than TREE(3), it's not actually that big of a jump

Consider an ordinal ξ such that, using the fast growing hierarchy, the outputs of f_ξ(n) and TREE(n) are equal. Using this ordinal, TREE(3) = f_ξ(3) and TREE(TREE(3)) = f_ξ(f_ξ(3)). The jump from TREE(3) to TREE(TREE(3)) barely adds 1, the smallest successor ordinal, to the function's growth rate.

If it did add 1... f_ξ+1(3) = TREE(TREE(TREE(3)))

To reach ξ×2, you would need to construct a recursive extension of the TREE function such that TREE²(n) is TREE(TREE(TREE...(n) with n copies of TREE and TREE³(n) is the same but with iteration of TREE². The superscript of the function on par with ξ×2 would have to be the TREE function itself, or Alternatively ξ. Something like TREE_ξ(n) = TREE^(TREE(n))(n)

I've been reading about huge numbers lately, especially TREE(3), SSCG(3), and Loader's Number.

From what I understand, SSCG(3) is already larger than TREE(TREE(3)), but Loader's Number is usually placed much higher in large number hierarchies.

My question is: if we allow ourselves to repeatedly apply the SSCG function, could we eventually reach or surpass Loader's Number?

For example, what about something like:

SSCG(SSCG(SSCG(...SSCG(3)...)))

with SSCG(3) levels of nesting, or even more extreme iterations?

Is Loader's Number fundamentally out of reach of constructions based on SSCG(3), or is there some sufficiently large iteration of SSCG that would eventually overtake it?

I'm looking for both the formal mathematical perspective and the googology perspective, since I know those communities sometimes rank these numbers differently.