User blog:Rgetar/Designations of arrays

Recently I was thinking about further generalization of Veblen function, and there is a problem to avoid transfinitely long expressions (Alemagno12 wrote about this in comments).

Specifically, I introduced Veblen-like functions φ1(X2), φ2(X3), φ3(X4), ..., and there are ordinals expressed as

φ(X)

φ(φ1(X2))

φ(φ1(φ2(X3)))

φ(φ1(φ2(φ3(X4))))

...

But what if we use φω(Xω + 1), φω + 1(Xω + 2), ...? We should write transfinitely many Veblen-like functions?

In comments I wrote that instead of φ(φ1(X2)), maybe, it will be something like φ(X2), that is argument of Veblen function will be not only array of ordinals, but also array of arrays of ordinals, array of arrays of arrays of ordinals etc. (there is something like this in OCFs). But then I came up with a slightly different way.

But first designations.

Orders of arrays
Array of order 0 is ordinal.

Array of order 1 is array of ordinals.

Array of order 2 is array of arrays of ordinals.

Array of order 3 is array of arrays of arrays of ordinals.

...

So, array of order α + 1 is array of arrays of order α.

And if α is limit ordinal?

General rule (for both limit and successor α): array of order α is array of any arrays of orders less than α.

(Note: array of order α may be considered as array of any order larger than α, but all elements are empty, except, maybe, element at higher-order coordinates 0. For example, ε0 is ordinal, that is array of order 0. But ε0 may be also considered as array of order 1, that is ..., 0, 0, 0, 0, 0, ε0, as array of order 2, that is ..., (0), (0), (0), (..., 0, 0, 0, 0, 0, ε0), as array of order 3, etc).

Designations of arrays
We need to designate order ("o"), coordinates ("c"), element ("e") and separators between elements.

For order 1 I was using designations

⟨c⟩e

and

ce

with separator ","

(ce is ⟨c⟩e with "⟨" replaced by " ", and "⟩" replaced by " ").

For higher orders I tried many variants such as

⟨o|c|e⟩

⟨o.c.e⟩

⟨o|c⟩e

⟨o.c⟩e

⟨o|c⟩(e)

⟨o.c⟩(e)

oe

o.ce

o(e)

o.c(e)

oce

oc(e)

Ωoce

Ωoc(e)

Variants of separators, if e is not inside ⟨⟩ or :

⟨/o⟩

⟨/o⟩,

⟨/o⟩+

⟨.o⟩

⟨.o⟩,

⟨.o⟩+

⟨o.⟩

⟨o.⟩,

⟨o.⟩+

If e is inside ⟨⟩ or, then we may use some general separator:

,

+

or even without any separator.

In this blog I'll use Ωoce (for e with one non-zero element) and Ωoc(e) (for e with more than one non-zero elements) with general separator "+".

This is similar to designation of large ordinals in OCFs, but here Ωo is just designation of arrays, not large ordinals. But Ωo can be considered as some "very large" ordinals, no matter, which, for example, uncountable, and since we are using "+" separators, we can designate arrays in ordinal-like way and apply to them ordinal arithmetic.

If o = 1, then o may be omitted, and if c = 1, then c may be omitted:

Ωc = Ω1c

Ωo = Ωo1

Ω = Ω11

Designation for order 1:

Ωce

with separator "+".

For example,

1, 0 = 11 = Ω

1, 1 = Ω + 1

1, ω = Ω + ω

2, 0 = 12 = Ω2

1, 0, 0 = 21 = Ω2

1, 2, 3, 4, 5 = Ω4 + Ω32 + Ω23 + Ω4 + 5

ω1 = Ωω

11 1 = ΩΩ

11 1 1 = ΩΩ Ω

11 1 1 1 = ΩΩ Ω Ω

For "computer format" I'll use some another designation of arrays, maybe, ⟨o.c.e⟩ with "+" separators.

More Veblen-like functions
For Veblen function φ(X) argument (X) is array of order 1, and value is ordinal, that is array of order 0.

For Veblen-like function φ1(X2) argument (X2) is array of order 2, and value is array of order 1.

For φ2(X3) argument (X3) is array of order 3, and value is array of order 2.

Etc.

So, for φα(Xα + 1) argument (Xα + 1) is array of order α + 1, and value is array of order α, and Xα is array of order α.

We can define more Veblen-like functions, which argument is array of order β, and value is array of order α. I'll designate β as superscript of φ:

φαβ(Xβ)

Definition of φαβ(Xβ) for β > α + 1:

φαβ(Xβ) = φαγ(φγβ(Xβ)), α < γ < β

Definition of φαα + 1(Xγ) for γ < α + 1, α > 0:

φαα + 1(Xγ) = Ωα + 1Xγ

(For γ = α + 1 φαα + 1(Xγ) is defined similarly to Veblen function).

If β is omitted, then β = α + 1:

φα(Xα + 1) = φαα + 1(Xα + 1)

If α is omitted, then α = 0:

φβ(Xβ) = φ0β(Xβ)

Veblen function:

φ(X) = φ01(X)

Examples:

φ2(X2) = φ01(φ12(X2)) = φ(φ1(X2))

φ2(0) = φ(φ1(0)) = φ(Ω0) = φ(1) = ω

φ2(1) = φ(φ1(1)) = φ(Ω1) = φ(Ω) = φ(1, 0) = ε0

φ2(2) = φ(φ1(2)) = φ(Ω2) = φ(1, 0, 0) = Γ0

φ2(3) = φ(φ1(3)) = φ(Ω3) = φ(1, 0, 0, 0)

φ2(ω) = φ(Ωω) = φ(ω1) = SVO

φ2(Ω) = φ(ΩΩ) = φ(11 1) = LVO

φ2(ΩΩ) = φ(ΩΩ Ω ) = φ(11 1 1)

φ2(ΩΩ Ω ) = φ(ΩΩ Ω Ω ) = φ(11 1 1 1)

φ2(ΩΩ Ω Ω ) = φ(ΩΩ Ω Ω Ω   ) = φ(11 1 1 1 1)

φ2(Ω2) = BHO

φ3(X3) = φ01(φ12(φ23(X3))) = φ(φ1(φ2(X3)))

φ3(0) = φ(φ1(φ2(0))) = φ(φ1(Ω20)) = φ(φ1(1)) = φ2(1) = ε0

φ3(1) = φ(φ1(φ2(1))) = φ(φ1(Ω21)) = φ(φ1(Ω2)) = φ2(Ω2) = BHO

φ4(X4) = φ01(φ12(φ23(φ34(X4)))) = φ(φ1(φ2(φ3(X4))))

φ4(0) = φ(φ1(φ2(φ3(0)))) = φ(φ1(φ2(Ω30))) = φ(φ1(φ2(1))) = φ3(1) = BHO

Generally,

φα(1) = φα + 1(0)

φα(Ωα) = φα + 1(1)

Now instead of

φ(0) = 1

φ(φ1(0)) = ω

φ(φ1(φ2(0))) = ε0

φ(φ1(φ2(φ3(0)))) = BHO

φ(φ1(φ2(φ3(φ4(0)))))

φ(φ1(φ2(φ3(φ4(φ5(0))))))

...

?????

we can write

φ(0) = 1

φ2(0) = ω

φ3(0) = ε0

φ4(0) = BHO

φ5(0)

φ6(0)

...

φω(0)

And what is φω(1)?

Here are ordinals larger than φω(0):

φω(0) + 1

φ(φ1ω(0) + 1)

φ2(φ2ω(0) + 1)

φ3(φ3ω(0) + 1)

φ4(φ4ω(0) + 1)

φ5(φ5ω(0) + 1)

...

I think, limit of this may be φω(1) = φω + 1(0), φω(2) is limit of

φω(1) + 1

φ(φ1ω(1) + 1)

φ2(φ2ω(1) + 1)

φ3(φ3ω(1) + 1)

φ4(φ4ω(1) + 1)

φ5(φ5ω(1) + 1)

...

Generally,

φω(α + 1) is limit of

φω(α) + 1

φ(φ1ω(α) + 1)

φ2(φ2ω(α) + 1)

φ3(φ3ω(α) + 1)

φ4(φ4ω(α) + 1)

φ5(φ5ω(α) + 1)

...

And can we define φαβ(Xγ) for γ > β?

I think, we can: if γ > β, and Ωγ ≤ Xγ < Ωγ + 1 then

φαβ(Xγ) = φαγ(Xγ)

For example,

φ(X2) = φ2(X2), Ω2 ≤ X2 < Ω3

φ(X3) = φ3(X3), Ω3 ≤ X3 < Ω4

φ(X4) = φ4(X4), Ω4 ≤ X4 < Ω5

φ(X5) = φ5(X5), Ω5 ≤ X5 < Ω6

etc.

I suspect that, possibly, in OCFs is used something like this: in OCFs there are functions with subscripts, but without superscripts.

So, we can use Veblen-like functions without superscripts, but I'd use them with both subscripts and superscripts, because, in my opinion, this is simpler and more clear, since if use Veblen-like functions without superscripts, then instead of single functions there are actually many functions, for example

φ(X) is Veblen function for < Ω2

φ(X) = φ2(X) for Ω2 ≤ X < Ω3

φ(X) = φ3(X) for Ω3 ≤ X < Ω4

...

and we do not see, for example,

φ2(X) for X < Ω2

φ3(X) for X < Ω3

φ4(X) for X < Ω4

...

(But, I think, these functions are interesting, because they are like Veblen function (that is theirs arguments are arrays of some orders, and theirs values are ordinals), but they grow much faster, see examples above).

What about "computer format"?

For Veblen function φ(X) I used computer format (X). For Veblen-like functions φαβ(X), I think, computer format will be (α.β.X) or something. For α = 0, maybe, (β.X), for β = α + 1 (α..X), for α = 0 and β = 1 still (X).

X{·}α
I used X{·}α for definition of both family of functions [X]α and generalized Veblen function. (X{·}α is function of array of order 1 X and ordinal α, and its value is set of arrays of order 1).

But it is not applicable for arrays X larger or equal to φ1(Ω2): φ1(Ω2){·}α contains only one element - φ1(Ω2) itself and does not depend on α. So, X{·}α is not applicable to define Veblen function of φ1(Ω2) and larger arrays.

Maybe, definition of X{·}α can be modified to use large arrays X, but it is still not applicable for [X]α family of functions: I first introduced X{·}α to create fast-growing functions [X]α, where α is ordinal, but if α is finite ordinal, then value of [X]α also should be finite. So, if use current definition of X{·}α, then [φ1(Ω2)]α is nonsence:

[φ1(Ω2)]α = [φ1(Ω2)]α

And if we try to use modified definition of X{·}α, then for any finite α > 1

[φ1(Ω2)]α = ω

But when I created [X]α, my intention was to create functions of finite numbers with also finite, not transfinite, values.

Possible ways: to modify something in definition of X{·}α, and/or of Veblen and Veblen-like functions, and/or of [X]α, or use different sets for definitions of Veblen and [X]α functions instead of single set X{·}α, or even make up completely different family of fast-growing functions with finite values and arguments.