User blog:Rgetar/Ordinals array function

I interested in ordinals, and I asked myself: "Why we use \(\omega\),  \(\omega2\), \(\omega^2\), \(\omega^\omega\), \(\epsilon_0\), \(\zeta_0\), \(\phi(3,0)\), \(\Gamma_0\) etc. instead of \(\omega\uparrow\uparrow\uparrow\omega\), \(\omega\uparrow\uparrow\uparrow\uparrow\omega\) etc.?"

But I realized this doesn't work beyond \(\epsilon_0\) since \(\omega^{\epsilon_0} = \epsilon_0\).

I experimented and created a BEAF-like system, suitable also for ordinals.

It is family of functions [X]a of ordinal a.

Let X - sequence of ordinals (or "negative ordinals", i.e. ordinals with "-" sign before them) with separators.

All zeros we may omit.

All left part only with zeros and any separators we also may omit.

A separator may be written two ways: set of (...) or <...>.

A separator has body and type, which are also sequences of ordinals. For example, <\(X_{type}\)|\(X_{body}\)>. If \(X_{type} = 0\), separator may be written only with body: <|\(X_{body}\)> = <\(X_{body}\)>. (For now, we'll consider only zero types).

(X) is as in BEAF: (1) moves through one row, (2) - through one plane etc. should move through one element.

Easier way is to use : first right element is number of 's, second right is number of (1)'s, third right is number of (2)'s etc.

In particular,

<1> = (X)

> = n (X)'s

<1> = may be written as comma :

<1> =, = = (0)

Examples:

<5> = ,,,,, = ,0,0,0,0,0 = = (0)(0)(0)(0)(0)

<1,2,3,4,5> = (0)(0)(0)(0)(0)(1)(1)(1)(1)(2)(2)(2)(3)(3)(4)

<1,> = <1,0> = <1<1>> = (1)

<1,2> = (1) = (0)(0)(1) = ,,(1) = ,0,0(1)

<2,> = <2,0> = (1)(1)

<1,,> = <1,0,0> = <1<2>> = (2)

<1,,,> = <1,0,0,0> = <1<3>> = (3)

<2,,3,> = <2,0,3,0> = (1)(1)(1)(3)(3)

<3<1,>> = <3<1,0>> = <3<1<1>>> = <3(1)> = (1,)(1,)(1,) = (1,0)(1,0)(1,0)

<> = <0> is empty separator, it doesn't add anything:

X<> = X<0> = X

For example,

1,2,3<> = 1,2,3

<-1> erases one element:

X,n<-1> = X

For example,

1,2,3<-1> = 1,2

(Also, <-n> should erase n elements, <-n,0> should erase n rows, <-n,0,0> - n planes, but this is not used).

X-1 is X with last element decreased by 1.

For example,

X = 1,2,3,4,5

X-1 = 1,2,3,4,4

 is a separator at the right end of X. X* is rest of X. So,

X = X*

For example, if

X = 1,2,3 = 1,2,3<>

then

X* = 1,2,3

X' = 0

If

X = 1(2)2(1)3,0,0,0,0,0 = 1<1<2>>2<1<1>>3<5> = 1<1,,>2<1,>3<5>

then

X* = 1(2)2(1)3 = 1<1<2>>2<1<1>>3 = 1<1,,>2<1,>3

X' = 5

If

X = 1(1)1 = 1<1,0>1<0> = 1<1,>1<>

then

X* = 1<1,>1

X' = 0

X* and X' are also may be represented in this form:

X* = X**

X' = X'*

Always should be

X* = X** = X**<0> = X**

X*' = 0

Hence if

X = 0

then

X* = 0

X' = 0

Any X may be uniquely represented in this form.

[-1] doesn't change anything:

[-1]a = a

X⁰ is X with last element set to zero, if X' = 0 else X⁰ = -1.

For example, if

X = 1,2,3,4,5

then

X⁰ = 1,2,3,4,0

If

X = 1,2,3,4,0

then

X⁰ = -1

If

X = 0

then

X⁰ = 0

So, if last element of X is not zero, X⁰ sets it to zero, and if it is zero, X⁰ = -1 except X = 0 when X⁰ also sets it to zero.

X·a is a function mapping X to other "X", depending on ordinal a.

0·a = -1

If non-zero type separators not used, rules:

1. []а = a + 1

2. [X]a = [X⁰][X·a]a

3. X·a = X*-1<1>a

And, I think, rule for limit ordinals, possibly, may be: if last ordinal in X (including ordinals inside separators) is a limit ordinal \(\alpha\), [X]a is limit of [\(X_i\)]a where \(X_i\) are X with \(\alpha\) replaced by \(\alpha_i\) which limit is \(\alpha\).