User blog:Rgetar/Creating FGH for transfinite ordinals

Here is FGH:


 * 1. f0(x) = x + 1


 * 2. fα + 1(x) = fαx(x)


 * 3. fα(x) = fα[x](x) iff α is limit  (actually it is implied that α is also countable) 

Here x is a finite number. How to generarize FGH for transfinite x?

Transfinite function iteration
Here is function iteration for a function f(x):
 * f0(x) = x


 * fα + 1(x) = f(fα(x))

In the Rule 2 of FGH "fαx(x)" is used, but we want transfinite x. So, we need to define function iteration fα(x) for a function f(x) also for transfinite α:


 * f0(x) = x


 * fα + 1(x) = f(fα(x))


 * fα(x) = sup(fβ(x)) for β < α, iff α is limit  (that is fα(x) is least ordinal larger than fβ(x) for any β < α) 

FGH for countable ordinals
Let x is a countable ordinal. Then
 * f0(x) = x + 1 (without changes)


 * fα + 1(x) = fαx(x) (now transfinite iteration is used)


 * fα(x) = fα[x](x) iff cof(α) = Ω

But what if cof(α) = ω? For this case we need another rule:


 * fα(x) = sup(fβ(x)) for β < α, iff cof(α) = ω

General case
FGH for finite, or countable, or uncountable x:
 * 1. f0(x) = x + 1


 * 2. fα + 1(x) = fαx(x)


 * 3. fα(x) = sup(fβ(x)) for β < α, iff 1 < cof(α) ≤ x


 * 4. fα(x) = fα[x](x) iff card(x) = Ωn and cof(α) = Ωn + 1

Rule for cof(α) > Ω n + 1
What if card(x) = Ωn and cof(α) = Ωn + 1? For this case we can use another rule:
 * fα(x) = ff α(Ωm) (x) iff card(x) = Ωn and cof(α) = Ωm + 1 > Ωn + 1

So, the rule set:
 * 1. f0(x) = x + 1


 * 2. fα + 1(x) = fαx(x)


 * 3. fα(x) = sup(fβ(x)) for β < α, iff 1 < cof(α) ≤ x


 * 4. fα(x) = fα[x](x) iff card(x) = Ωn and cof(α) = Ωn + 1


 * 5. fα(x) = ff α(Ωm) (x) iff card(x) = Ωn and cof(α) = Ωm + 1 > Ωn + 1

Inaccessibles
What about weakly inaccessible cardinals, that is what if card(x) = Ωn and cof(α) > Ωn + 1, but there is no m such as cof(α) = Ωm + 1? So far I have no rules for such cases, but I think that if we do not use cardinals larger than least weakly inaccessible cardinal I, then we can use something like
 * fI(x) = Ωn + 1, where card(x) = Ωn, iff x < I

Cofinality
Rules for computing cofinality:
 * 1. cof(0) = 0


 * 2. cof(I) = I  (if we use the rule for I) 


 * 3. cof(f0(x)) = 1


 * 4. cof(fI(x)) = fI(x) iff x < I  (if we use the rule for I) 


 * 5. cof(fαβ(x)) = cof(β) iff β is limit


 * 6. cof(fα(x)) = cof(α) iff 1 < cof(α) ≤ x

And other cases can be reduced to theses cases using FGH rules.

Fundamental sequence algorythm
For FGH we also need system of fundamental sequences.

Rules for computing elements a[n] of fundamental sequences of a, n < cof(a):
 * 1. 0 has no fundamental sequence


 * 2. I[n] = n  (if we use the rule for I) 


 * 3. f0(x)[n] = x  (n = 0) 


 * 4. fI(x)[n] = n iff x < I  (if we use the rule for I) 


 * 5. fαβ(x)[n] = fαβ[n](x) iff β is limit


 * 6. fα(x)[n] = fα[n](x) iff 1 < cof(α) ≤ x

And other cases can be reduced to theses cases using FGH rules.

Standard forms
But this fundamental sequence algorythm is not yet a system of fundamental sequences, since it can produce different fundamental sequences for the same ordinal, expressed using FGH in different ways. So we should choose one FGH standard form for an ordinal.

We can use rule: forms, produced by the fundamental sequence algorythm applied to standard forms, are also standard. And we should define that some expressions of large ordinals are standard forms. (But it still does not quarantee unique fundamental sequences for ordinals).

We can try to use such rules (for ordinals less than Ωω):
 * 1. Finite numbers in decimal form are standard forms


 * 2. Ωn for finite n are standard forms


 * 3. fΩ m (Ωn) for finite n, m, m > n, are standard forms


 * 4. The fundamental sequence algorythm applied to standard forms produces standard forms

Examples

 * f0(ω) = ω + 1


 * f02(ω) = ω + 2


 * f03(ω) = ω + 3


 * f04(ω) = ω + 4


 * f05(ω) = ω + 5


 * f1(ω) = ω2


 * f12(ω) = ω4


 * f13(ω) = ω8


 * f14(ω) = ω16


 * f15(ω) = ω32


 * f2(ω) = ω2


 * f22(ω) = ωω


 * f23(ω) = ωω ω


 * f24(ω) = ωω ω ω


 * f25(ω) = ωω ω ω ω


 * f3(ω) = ε0


 * f32(ω) = εε 0


 * f33(ω) = εε ε 0


 * f34(ω) = εε ε ε 0


 * f35(ω) = εε ε ε ε 0


 * f4(ω) = ζ0


 * f42(ω) = ζζ 0


 * f43(ω) = ζζ ζ 0


 * f44(ω) = ζζ ζ ζ 0


 * f45(ω) = ζζ ζ ζ ζ 0


 * f5(ω) = η0


 * f52(ω) = ηη 0


 * f53(ω) = ηη η 0


 * f54(ω) = ηη η η 0


 * f55(ω) = ηη η η η 0


 * f6(ω) = φ(4, 0)


 * f62(ω) = φ(4, φ(4, 0))


 * f63(ω) = φ(4, φ(4, φ(4, 0)))


 * f64(ω) = φ(4, φ(4, φ(4, φ(4, 0))))


 * f65(ω) = φ(4, φ(4, φ(4, φ(4, φ(4, 0)))))


 * f7(ω) = φ(5, 0)


 * f72(ω) = φ(5, φ(5, 0))


 * f73(ω) = φ(5, φ(5, φ(5, 0)))


 * f74(ω) = φ(5, φ(5, φ(5, φ(5, 0))))


 * f75(ω) = φ(5, φ(5, φ(5, φ(5, φ(5, 0)))))


 * fΩ(ω) = φ(ω, 0)


 * fΩ2(ω) = φ(φ(ω, 0), 0)


 * fΩ3(ω) = φ(φ(φ(ω, 0), 0), 0)


 * fΩ4(ω) = φ(φ(φ(φ(ω, 0), 0), 0), 0)


 * fΩ5(ω) = φ(φ(φ(φ(φ(ω, 0), 0), 0), 0), 0)


 * ff 0(Ω) (ω) = Γ0


 * ff 0(Ω) 2(ω) = φ(1, 0, Γ0)


 * ff 0(Ω) 3(ω) = φ(1, 0, φ(1, 0, Γ0))


 * ff 0(Ω) 4(ω) = φ(1, 0, φ(1, 0, φ(1, 0, Γ0)))


 * ff 0(Ω) 5(ω) = φ(1, 0, φ(1, 0, φ(1, 0, φ(1, 0, Γ0))))


 * ff 02(Ω) (ω) = φ(1, 1, 0)


 * ff 02(Ω) 2(ω) = φ(1, 1, φ(1, 1, 0))


 * ff 02(Ω) 3(ω) = φ(1, 1, φ(1, 1, φ(1, 1, 0)))


 * ff 02(Ω) 4(ω) = φ(1, 1, φ(1, 1, φ(1, 1, φ(1, 1, 0))))


 * ff 02(Ω) 5(ω) = φ(1, 1, φ(1, 1, φ(1, 1, φ(1, 1, φ(1, 1, 0)))))


 * ff 03(Ω) (ω) = φ(1, 2, 0)


 * ff 03(Ω) 2(ω) = φ(1, 2, φ(1, 2, 0))


 * ff 03(Ω) 3(ω) = φ(1, 2, φ(1, 2, φ(1, 2, 0)))


 * ff 03(Ω) 4(ω) = φ(1, 2, φ(1, 2, φ(1, 2, φ(1, 2, 0))))


 * ff 03(Ω) 5(ω) = φ(1, 2, φ(1, 2, φ(1, 2, φ(1, 2, φ(1, 2, 0)))))


 * ff 04(Ω) (ω) = φ(1, 3, 0)


 * ff 04(Ω) 2(ω) = φ(1, 3, φ(1, 3, 0))


 * ff 04(Ω) 3(ω) = φ(1, 3, φ(1, 3, φ(1, 3, 0)))


 * ff 04(Ω) 4(ω) = φ(1, 3, φ(1, 3, φ(1, 3, φ(1, 3, 0))))


 * ff 04(Ω) 5(ω) = φ(1, 3, φ(1, 3, φ(1, 3, φ(1, 3, φ(1, 3, 0)))))


 * ff 05(Ω) (ω) = φ(1, 4, 0)


 * ff 05(Ω) 2(ω) = φ(1, 4, φ(1, 4, 0))


 * ff 05(Ω) 3(ω) = φ(1, 4, φ(1, 4, φ(1, 4, 0)))


 * ff 05(Ω) 4(ω) = φ(1, 4, φ(1, 4, φ(1, 4, φ(1, 4, 0))))


 * ff 05(Ω) 5(ω) = φ(1, 4, φ(1, 4, φ(1, 4, φ(1, 4, φ(1, 4, 0)))))


 * ff 1(Ω) (ω) = φ(1, ω, 0)


 * ff 1(Ω) 2(ω) = φ(1, φ(1, ω, 0), 0)


 * ff 1(Ω) 3(ω) = φ(1, φ(1, φ(1, ω, 0), 0), 0)


 * ff 1(Ω) 4(ω) = φ(1, φ(1, φ(1, φ(1, ω, 0), 0), 0), 0)


 * ff 1(Ω) 5(ω) = φ(1, φ(1, φ(1, φ(1, φ(1, φ(1, ω, 0), 0), 0), 0), 0), 0)


 * ff 2(Ω) (ω) = φ(ω, 0, 0)


 * ff 2(Ω) 2(ω) = SVO


 * ff 3(Ω) 2(ω) = BHO

Other formats
Also I was thinking about other formats for designation of FGH, for example, (α0.n0, α1.n1, α2.n2, ... αk.nk) format, used in FGH-based notation for finite numbers in my previous blog, or "booster-base" format, like used in my programs, but this time "double booster" is used:


 * [X.Y]α = fXY(α)

By the way, I already was thinking about transfinite number of boosters, since I thought that ω is used in my notation too often, but then I rejected that idea, because I thought that it would complicate the notation. But now I am not sure, which notation is simpler - with "single boosters", or "double boosters": "double boosters" are simpler because
 * [X][X][X][X][X][X][X]α

can be replaced with
 * [X.7]α

Also it is stronger, since there can be
 * [X.ω]α
 * [X.ω + 1]α

which is impossible in "single boosters", but "single boosters" are simpler, since they use only one entry in a booster, and do not use ".".