OSA

The Ordinal-System Array is an extension to the FGH, or better said a function that directly defines ordinals for the FGH. It was created by MachineGun.

== Notation ==

We use OSA(x)[n] where "x" is a number in the array which will be transformed into an ordinal, and "n" is the FGH input

== Rules:  ==

&lt;nowiki&gt;*&lt;/nowiki&gt;0's are ignored, except in the 1 argument array

OSA(x)[n] = \(f_{\omega^{x }} (n)\), except if "x" is 0. Then it will turn into \(f_{\omega}(n)\). It seems like if x is 1, it will have the same value.

Now, for multiple entry arrays we have the following rule:

-1's are transformed into \(\omega\)'s (or the corresponding ordinal defined before solving the array, you will see what I mean a bit later)

-A number k>1 will be transformed with the following rule: solving from left to right, we decompose "k" into however many "k-1"'s as entries to the right there are, and we keep decomposing until we reach the last 2 entries which will be decomposed them from right to left, using the same rule. If we have 3 entries, then for the middle entry "m" we decompose it into 2 "m-1"'s (2 total entries on the sides)

Example: \(OSA(3,3,3,3)[n] = OSA(2,2,2,2,2,2,2,2,2,2)[n]\) -> we now decompose into even more 1's.

When reaching the final state of the array, we start to nest the ordinals. (for omega exponentiation, and for the other ordinals index nesting, surely you know what I mean.)

Example: \(OSA(1,1,1,1)[n] = \omega^{\omega^{\omega^{\omega }}} \), because we have 4 1's.

Mixed array:

When not all the numbers are the same, decompose using the same rule, and keep on doing it until you have decomposed everything into 1's. Then and only then you can start calculating the ordinal.

Example: \(OSA(3,4,5)[n] = OSA(2,2,3,3,4,4)[n]\) -> I have decomposed this and trust me there were A LOTTA 1's.

== Attributing different ordinals than \(\omega\) ==

OSA 0 (#)[n] has 1 = \(\omega\).

The strenght of OSA 0 (1,1,1,....,1,1,1)[n] with a 1s is \(\omega\)↑↑a

Strength of OSA_0(2,2,2,...,2,2,2)[n] with a 1s might be w^^round(0.75*a^2)?

OSA 1 (#)[n] has 1 = \(\varepsilon_n\)

OSA m (#)[n] has 1 = \(\varphi(m,n)\)

So for example: OSA 0 (1,1,1)[3] = \(f_{\omega^{\omega^{\omega }}} (3)\)

OSA 1 (1,1,1)[3] = \(f_{\varepsilon_{\varepsilon_{\varepsilon_{3 }}} }(3)\).

* When creating ordinals with OSA and you have multiple entries, there will be no "n" to apply to the ordinals when having 1's. To solve that, we can just have "0" indexed.

etc.

If in OSA 0 just a single number meant omega exponentiation, in OSA bigger than 0 a single entry array means indexing x to the corresponding ordinal.

Eg: OSA 0 (x)[n] has a growth rate of \(f_{\omega^{x }} (n)\)

OSA 1 (x)[n] has a growth rate of \(f({\varepsilon_{x }} ,n)\)

If not, then the other rules apply.

* Instead of numbers, you can also just index the ordinal itself, for example OSA 0(n) = OSA\(\omega\) (n)

Define the rule OSA([x,a])[n] = OSA(x,x,x,....,x,x,x)[n] with a x's.

== Another notational change ==

This can also be used as a pure ordinal creating function, that is if we don't include the FGH input.

== Multiple row array ==

Define OSA(m)(m)[n] as OSA OSA OSA ... OSA m(m)[n] (m)[n]   (m)[n], with "m" OSA's

OSA(m)(x)[n] = "m" iterations of OSA, with the last one being indexed with "x"

Rules for more than 2 rows

OSA(m)(m)(m)[n] = OSA(OSA(m)(m)[n])(OSA(m)(m)[n])[OSA(m)(m)[n]]

OSA(a)(b)(c)(d)(...(x)(y)[n] with "l" rows = OSA(OSA(a)(b)(c)(.....(x)[n])(OSA(a)(b)(c)(.....(x)[n](...(OSA(a)(b)(c)(.....(x)[n])[OSA(y)(y)(...(y)[n], "l-1" rows] with "l-1" rows

Examples:

OSA(m)(x)(m)[n] = OSA(OSA(m)(x)[n])(OSA(m)(x)[n])[OSA(m)(m)[n]]

OSA(a)(b)(c)[n] = OSA(OSA(a)(b)[n])(OSA(a)(b))[OSA(c)(c)[n]]

OSA(a)(b)(c)(d)(e)[n] = OSA(OSA(a)(b)(c)(d)[n])(OSA)(a)(b)(c)(d)[n])[OSA(e)(e)(e)(e)[n]]

== Hyper Rows ==

OSA((m))[n] = OSA(m)(m)(m)(m)(....(m)(m)[n], with "m" rows

OSA((a))((b))((c))((d))(...((x))((y))[n] with "m" rows = OSA((a))((b))((d))((...((x))[OSA((y))((y))((y))((y))((...((y))[n]], with m-1 rows] with m-1 rows

OSA{m}[n] = OSA((m))((m))((m))((...((m))[n] with m rows

Same iteration rules as the ()

Then we can have stuff like OSA{ 2 m}[n], and this would break into an iteration of the {}'s (with the same rules as before)

Then OSA{ 3 m}[n], iteration of OSA{ 2 m}[n]

We can define OSA&m[n] = OSA{ {{sub|OSA{ m}}m}[n] m}[n]

OSA&&m[n] = OSA&OSA&m[OSA&m[...OSA&m[n]]..]]] with m iterations.

OSA&&&m[n] -> iteration of OSA&& the same way

OSA/m[n] = OSA&&&...&&&m[n] with m &'s.

== OSA+ and Matrix OSA ==

OSA+ is an updated OSA which can produce even larger numbers.

OSA+(1)[n] = OSA/n[n]

OSA+(1,1)[n] = OSA+(1)[OSA+(1)[...[OSA+(1)[n]]..]]], iterated n times

For OSA+(1,1,1)[n] just change the amount of 1's in the bracket to 2, and for "a+1" 1's decompose with "a" 1's in the bracket.

For higher numbers like 2,3,4,... we break them down just like how we did in normal OSA.

== Matrix OSA (OSA++)  ==

Matrix OSA (Or OSA++) is yet another updated OSA.

Rules:

* For a 1-row matrix of 1's, a single "1" will be transformed into OSA+(n,n,n,...,n,n)[n] with n n's.

So \(OSA++\begin{pmatrix}

1\end{pmatrix}[n]\) = OSA+(n,n,n,...,n,n)[n] with n n's (can also be written as OSA+([n,n])[n]).

* For multiple 1's, follow the next rules:

\(OSA++\begin{pmatrix}

1 & 1\end{pmatrix}[n]\) = \(OSA++\begin{pmatrix}

1\end{pmatrix}[OSA++\begin{pmatrix}

1\end{pmatrix}[OSA++\begin{pmatrix}

1\end{pmatrix}[...OSA++\begin{pmatrix}

1\end{pmatrix}[n]]]..]]\), with n iterations.

\(OSA++\begin{pmatrix}

1 & 1 & 1\end{pmatrix}[n]\) = \(OSA++\begin{pmatrix}

1 & 1\end{pmatrix}[OSA++\begin{pmatrix}

1 & 1\end{pmatrix}[OSA++\begin{pmatrix}

1 & 1\end{pmatrix}[...OSA++\begin{pmatrix}

1 & 1\end{pmatrix}[n]]]..]]\), with n iterations.

Basically for a 1-row matrix with "a" 1's, it will be an iteration of a 1-row matrix with "a-1" 1's.

Now for 2's.

\(OSA++\begin{pmatrix}

2\end{pmatrix}[n]\) = \(OSA++\begin{pmatrix}

1 & 1 & 1 & 1 & \cdots & 1\end{pmatrix}[n]\) with n 1's.

Now for multiple 2's the iterations are the same as with multiple 1's.

And this means that the general rule is: An "a" will be broken into n "a-1's"

As for multiple rows, let's start simple:

\(OSA++\begin{pmatrix}

1\\

1\\\end{pmatrix}[n]\) = \(OSA++\begin{pmatrix}

n & n & n & n &. . . & n\end{pmatrix}[n]\), with n n's.

\(OSA++\begin{pmatrix}

1 & 1\\

1 & 1\\\end{pmatrix}[n]\) = \(OSA++\begin{pmatrix}

1\\

1\\\end{pmatrix}[OSA++\begin{pmatrix}

1\\

1\\\end{pmatrix}[OSA++\begin{pmatrix}

1\\

1\\\end{pmatrix}[...OSA++\begin{pmatrix}

1\\

1\\\end{pmatrix}[n]..]]]\), with n iterations.

And for 2 rows "a" 1's will be an iteration of "a-1" 1's, you know what I mean.

\(OSA++\begin{pmatrix}

2\\

2\\\end{pmatrix}[n]\) = \(OSA++\begin{pmatrix}

1 & 1 & 1 & ...\\

1 & 1 & 1 & ...\\\end{pmatrix}[n]\) with n 1's on both rows (Oh, and also, a rule states that we must have the same number of elements on all rows.)

And the same story for multiple 2's, the same iteration that the multiple 1's did.

And this means that an "a" will be broken into n "a-1's".

\(OSA++\begin{pmatrix}

1\\

1\\

1

\end{pmatrix}[n]\) = \(OSA++\begin{pmatrix}

n & n & n & ...\\

n & n & n & ...\\\end{pmatrix}[n]\), with n n's on both rows..

And the rules are just like the 2-row matrix, reread the rules and you'll understand what I mean.

And this just happens to be the case for multiple rows too. Yes, a complicated notation but if you understand how it works you'll also understand its power.

There's a final notation:

OSA+++[n] = \(OSA++\begin{pmatrix}

n & n & n & ... & n \\

n & n & n & ... & n \\

\vdots & \vdots& \vdots& \vdots& \vdots \\

n & n & n & ... & n

\end{pmatrix}[n]\) with n rows and n elements on each one.

We also use OSA+++[m,n,p] to denote a matrix with "p" rows, with the element "m" "n" times on each one.

OSA++++[n] = an array with n n's on the x axis,n n's on the y axis, and n n's on the z axis usin OSA+++

we can define OSA+ n [n] as an n dimensional array with n n's on each axis

== Old Notation Extension ==

Define \(\alpha + 1\) as some ordinal

The # denotes anything

OSA \(\alpha+1\)(#)[n] = OSA\(\alpha\)(#)[OSA\(\alpha\)(#)[....[OSA\(\alpha\) (#)[n]]..]], with n iterations.

For example

OSA \(\Gamma_0+1\) (1,1,1)[3] = OSA \(\Gamma_0\)(1,1,1)[OSA\(\Gamma_0\)(1,1,1)[OSA\(\Gamma_0\) (1,1,1)[3]]]

AKA a successor iterates the previous one