User blog:Rgetar/Computer format for ordinals using five symbols

Possibly, I'll use computer format for ordinals using four symbols: "(", ")", ".", "|", "1":

empty string for 0

1 for 1

(a.b.c|d) for Veblen-like function φab(c)d

d is just multiplier.

(b.c|d) = (.b.c|d)

(c|d) = (.1.c|d)

(a.b.c) = (a.b.c|1)

(b.c) = (.b.c|1)

(c) = (.1.c|1)

(a..c|d) = (a.a + 1.c|d)

(a..c) = (a.a + 1.c)

Previously I used computer format with eight symbols: "(", ")", "<", ">", "+", ",", "0", "1".

Since now I use uncountable ordinals instead of arrays, may be used only one type of brackets, and "," may be replaced with "+".

But "+" may be just omitted. I remembered that an anonymous user wrote in my talk page that in my old computer format 11 can be written two ways: "1+1+1+1+1+1+1+1+1+1+1" and "11". But now it can be written only one way: "11111111111" (and "11" is 2).

"0" was used only in 0, and it may be replaced with empty string.

"." is new symbol. It is used to designate superscript and subscript of Veblen-like function.

"|" is also new symbol. It is used to designate multiplier.

(Initially I was going to use "." instead of two symbols ".", "|", and it would be format with four symbols, but then I realized that using additional symbol "|" will make the format simpler and shorter).

In old computer format multiplier was not used. For example, ω3 was

(1)+(1)+(1)

I did not use multipliers to simplify the program.

But in fact, multipliers were used in arrays, for example,

<1>1+1+1

instead of

<1>1,<1>1,<1>1

Difference between Veblen and Veblen-like functions
Difference between Veblen and Veblen-like functions is that variable of Veblen function φ can be any ordinals, and elements of "array" in Veblen-like function φ01 cannot be uncountable ordinals.

For example,

φ(Ω + 1) = ωΩ + 1

φ01(Ω + 1) = ε1

φ(Ω + 1) ≠ φ01(Ω + 1)

So, using Veblen function we can write ωΩ + 1 without multiplier:

ωΩ + 1 = φ(Ω + 1)

But using Veblen-like functions we can write ωΩ + 1 only with multiplier:

ωΩ + 1 = Ωω

So, when we replace Veblen function with Veblen-like functions, we lose something. But we can add left subscript to Veblen function:

cφab

Here Ωb is maximal cardinality of input, Ωa is maximal cardinality of output. If left subscript is absent, then c = a.

cφab(X) = cφad(φdb(X))

If card(X) ≤ a, then cφaa+1(X) = ΩcX

With this two subscript Veblen-like function we can not use multipliers. And now

(a.b.c.d) = aφbc(d)

instead of

(a.b.c|d) = φab(c)d

Currently I do not know which way is better. They both use four parameter inside brackets. But it seems to me that way with multipliers may be better (at least, I think, ordinals will be shorter using multipliers).

Examples
empty string = 0

1 = 1

11 = 2

111 = 3

1111 = 4

11111 = 5

(1) = (11.) = ω

(1)1 = ω + 1

(1)11 = ω + 2

(1)111 = ω + 3

(1|11) = ω2

(1|11)1 = ω2 + 1

(1|111) = ω3

(11) = ω2

(11)1 = ω2 + 1

(11)(1) = ω2 + ω

(11)(1)1 = ω2 + ω + 1

(11)(1|11) = ω2 + ω2

(11)(1|11)1 = ω2 + ω2 + 1

(11|11) = ω22

(11|111) = ω23

(111) = ω3

((1)) = ωω

((1))1 = ωω + 1

((1)|11) = ωω2

((1)1) = ωω + 1

((1|11)) = ωω2

((1|11)) = ωω2

((11)) = ωω 2

(((1))) = ωω ω

(1..1) = (1.111.) = Ω

(1..1)1 = Ω + 1

(1..1)(1) = Ω + ω

(1..1|11) = Ω2

(1..1|(1)) = Ωω

(1..11) = Ω2

(1..(1)) = Ωω

(1..(1..1)) = ΩΩ

(111.) = (11.1) = ε0

(111.)1 = ε0 + 1

(111.)(1) = ε0 + ω

(111.|11) = ε02

((111.)1) = ωε0 + 1

((1..1)1) = ε1

((1..1)11) = ε2

((1..1)(1)) = εω

((1..1)(111.)) = εε 0

((1..1|11)) = ζ0

((1..1|11)1) = ζ1

((1..1|111)) = η0

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

((1..11)) = Γ0

((1..11)1) = Γ1

((1..11)(1..1)) = φ(1, 1, 0)

((1..11|11)) = φ(2, 0, 0)

((1..111)) = φ(1, 0, 0, 0)

((1..(1))) = SVO

((1..(1..1))) = LVO

(11..1) = (11.1111.) = Ω2

(11..1)1 = Ω2 + 1

(11..1)(1) = Ω2 + ω

(11..1)(1..1)= Ω2 + Ω

(11..1|11) = Ω22

(11..1|(1)) = Ω2ω

(11..1|(1..1)) = Ω2Ω

(11..11) = Ω22

(11..(1)) = Ω2ω

(11..(1..1)) = Ω2Ω

(11..(11..1)) = Ω2Ω2

(111..1) = Ω3

(1111..1) = Ω4

(11111..1) = Ω5

((1)..1) = Ωω

((1..1)..1) = ΩΩ

(((1..1)..1)..1) = ΩΩ Ω

(1111.) = (111.1) = BHO

((1).) = BO

((1)111.) = ((1)11.1) = TFB

((1..1).) = φ0Ω(0)

(((1..1)..1).) = φ0Ω Ω (0)

((((1..1)..1)..1).) = φ0Ω Ω Ω (0)

(((((1..1)..1)..1)..1).) = φ0Ω Ω Ω Ω  (0)

((((((1..1)..1)..1)..1)..1).) = φ0Ω Ω Ω Ω Ω   (0)

...

Decimal numbers
Since we use multipliers, it is no more need to write natural numbers as sums of 1's. And we can write natural numbers in decimal form. Ordinals will be shorter. Now there are 14 symbols.

The above list of examples with natural numbers in decimal form:

empty string = 0

1 = 1

2 = 2

3 = 3

4 = 4

5 = 5

(1) = (2.) = ω

(1)1 = ω + 1

(1)2 = ω + 2

(1)3 = ω + 3

(1|2) = ω2

(1|2)1 = ω2 + 1

(1|3) = ω3

(2) = ω2

(2)1 = ω2 + 1

(2)(1) = ω2 + ω

(2)(1)1 = ω2 + ω + 1

(2)(1|2) = ω2 + ω2

(2)(1|2)1 = ω2 + ω2 + 1

(2|2) = ω22

(2|3) = ω23

(3) = ω3

((1)) = ωω

((1))1 = ωω + 1

((1)|2) = ωω2

((1)1) = ωω + 1

((1|2)) = ωω2

((1|2)) = ωω2

((2)) = ωω 2

(((1))) = ωω ω

(1..1) = (1.3.) = Ω

(1..1)1 = Ω + 1

(1..1)(1) = Ω + ω

(1..1|2) = Ω2

(1..1|(1)) = Ωω

(1..2) = Ω2

(1..(1)) = Ωω

(1..(1..1)) = ΩΩ

(3.) = (2.1) = ε0

(3.)1 = ε0 + 1

(3.)(1) = ε0 + ω

(3.|2) = ε02

((3.)1) = ωε0 + 1

((1..1)1) = ε1

((1..1)2) = ε2

((1..1)(1)) = εω

((1..1)(3.)) = εε 0

((1..1|2)) = ζ0

((1..1|2)1) = ζ1

((1..1|3)) = η0

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

((1..2)) = Γ0

((1..2)1) = Γ1

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

((1..2|11)) = φ(2, 0, 0)

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

((1..(1))) = SVO

((1..(1..1))) = LVO

(2..1) = (2.4.) = Ω2

(2..1)1 = Ω2 + 1

(2..1)(1) = Ω2 + ω

(2..1)(1..1)= Ω2 + Ω

(2..1|2) = Ω22

(2..1|(1)) = Ω2ω

(2..1|(1..1)) = Ω2Ω

(2..2) = Ω22

(2..(1)) = Ω2ω

(2..(1..1)) = Ω2Ω

(2..(2..1)) = Ω2Ω2

(3..1) = Ω3

(4..1) = Ω4

(5..1) = Ω5

((1)..1) = Ωω

((1..1)..1) = ΩΩ

(((1..1)..1)..1) = ΩΩ Ω

(4.) = (3.1) = BHO

((1).) = BO

((1)3.) = ((1)2.1) = TFB

((1..1).) = φ0Ω(0)

(((1..1)..1).) = φ0Ω Ω (0)

((((1..1)..1)..1).) = φ0Ω Ω Ω (0)

(((((1..1)..1)..1)..1).) = φ0Ω Ω Ω Ω  (0)

((((((1..1)..1)..1)..1)..1).) = φ0Ω Ω Ω Ω Ω   (0)

...

Possible extensions
To go further, we need extend this format. Possibly, by adding fifth parameter:

(a.b.c.d|e)

and more complex rules using the new parameter. Then we can add sixth parameter and even more complex rules, and so on. So that first ordinal using infinite many parameters of this format and infinite complex and long rules should be Church-Kleene ordinal.