Googology Wiki
Register
Advertisement
Googology Wiki

This summer I experimented with "Buff function".

In my "base-booster" system I used 7 rules:

  1. No booster rule
  2. Empty booster rule
  3. Successor booster rule
  4. Regular rule
  5. Reduction rule
  6. Main rule
  7. Cascade rule

(Earlier I mentioned 10 rules, but I considered rules for "c" and for empty string as 2 different rules instead of single No booster rule; Special reduction rule, which turned out to be only a special case of Reduction rule, but still useful for optimization; and Limit rule, but technically it is not rule for base-booster strings, since it is rule for special string "Limit").

The most problematic rule was Cascade rule, for example, I noticed that for Cascade rule cases cofinality is not always ω, so I had to do cascade transformation to find cofinality.

This summer I solved this problem and made "tunnel" version of base-booster, and for Cascade rule cases cofinality was always ω, and the program started to work much faster.

But still I did not like Cascade rule since it was not "straightforward", and I wanted backward compatibility of base-booster system with its simplified versions.

Backward compatibility[]

(Base-booster system uses strings α = β[X]; β = base(α); X = booster(α), but some strings such as "c" or empty string have not booster. cof(α) is cofinality of α; fs(α, n) is n-th element of fundamental sequence of α; comparison of strings is lexicographical).

No booster rule[]

For example, initialy we have only empty string, empty alphabet and only one rule - No booster rule:

if α ≠ β[X] then cof(α) = α and fs(α, n) = n

The upper limit of this ruleset is 1 since we have only empty string = 0.

Empty booster rule[]

Next step: add two new symbols ("[" and "]", where "]" < "[") and Empty booster rule:

if α = β[] then cof(α) = 1 and fs(α, n) = β

that is β[] = β + 1.

This ruleset leads up to ω. (So far we have backward compatibility).

Successor booster rule[]

Next step: add Successor booster rule:

if α = β[X] and cof(X) = 1 then cof(α) = ω and fs(α, 0) = β, fs(α, n + 1) = fs(α, n)[base(X)]

that is β[Y + 1] = β[Y][Y][Y][Y][Y][Y]...

This ruleset leads up to ωω.

Reduction rule[]

Next step: add Reduction rule:

if α = β[X] and 1 < cof(X) < α then cof(α) = cof(X) and fs(α, n) = β[fs(X, n)]

This ruleset leads up to ε0.

Main rule[]

Next step: add Main rule:

if α = β[X] and cof(X) = least uncountable cardinal above α then cof(α) = ω and fs(α, 0) = β, fs(α, n + 1) = β[fs(X, fs(α, n))]

But how to designate "least uncountable cardinal above α"? We need new symbols, for example "Ω" for least uncountable cardinal. Now we have 3-symbol alphabet: "]" < "[" < "Ω".

By the way, for "Ω" string we use No booster rule, as for empty string, that is cof(Ω) = Ω and fs(Ω, n) = n.

So we use Main rule if α = β[X] < Ω and cof(X) = Ω.

This ruleset leads up to BHO.

More symbols[]

Next step: extend alphabet with more symbols for uncountable cardinals:

"]" < "[" < "Ω" < "Ω2" < "Ω3" < "Ω4" < "Ω5" < "Ω6" < ...

Now the ruleset leads up to Buchholz's ordinal.

Regular rule[]

Next step: use new symbol to replace "Ω" symbols and make alphabet finite 3-symbol again:

"]" < "[" < "c"
Ω = [c]
Ωn + 1 = Ωn[c]

And add Regular rule:

if α = β[X] < c and cof(X) = c then cof(α) = α and fs(α, n) = n

Now we have Ωn also for infinite n, for example

[c + 1] = Ωω
[c + 1][c] = Ωω + 1

but still we can't go beyond Buchholz's ordinal [Ω[Ω23456[...]]]]]]].

Cascade rule[]

Next step: add Cascade rule for α = β[X] and cof(X) > least uncountable cardinal above α. For example, we can replace

BHO = [Ω[Ω2]] → [Ω2]
[Ω[Ω23]]] → [Ω3]
[Ω[Ω234]]]] → [Ω4]
...

so Buchholz's ordinal will be [Ωω].

But here we lose backward compatibility: we used "[Ω[Ω2]]" for BHO and it worked, but now we replace it with "[Ω2]". And to compute fs([Ω2], n) first we need replace [Ω2] with [Ω[Ω2]] and then compute fs([Ω[Ω2]], n). (That's why I named the rule "Cascade").

Buff function[]

But I thought: what if do not change designation for BHO, and use "[Ω2]" for Buchholz's ordinal instead of BHO?

At first I rejected this idea since I thought it is too complex, but then I noticed it eliminates the need for Cascade rule (and possibly simplifies Reduction rule, at least currently I use only Special reduction rule instead its "full version", but I am not sure). Instead of Cascade rule we need modified Main rule, so we have 6 rules instead of 7.

Let

Ω0 = 0
Σn(0) = Ωn
Σn(a + 1) = Σn(a)[Σn + 1(a)[Σn + 2(a)[Σn + 3(a)[Σn + 4(a)[Σn + 5(a)[Σn + 6(a)[...]]]]]]]

So

Buchholz's ordinal = Σ0(1) = [Σ1(1)] = [Ω[Σ2(1)]] = [Ω[Ω23(1)]]] = [Ω[Ω234(1)]]]] = ...

So, the idea is to designate Σn(a + 1) as Σn(a)[Ωn + 2]. Examples:

Σ0(1) = [Ω2] = [Ω[Ω2345[...]]]]]]
Σ1(1) = Ω[Ω3] = Ω[Ω23456[...]]]]]]
Σ2(1) = Ω24] = Ω234567[...]]]]]]
Σ3(1) = Ω35] = Ω345678[...]]]]]]
Σ4(1) = Ω46] = Ω456789[...]]]]]]
Σ0(2) = [Ω2][Ω2] = Σ0(1)[Σ1(1)[Σ2(1)[Σ3(1)[Σ4(1)[...]]]]] = [Ω2][Ω[Ω3][Ω24][Ω35][Ω46][...]]]]]

Similarly

3] = [Ω246810[...]]]]]]
Ω[Ω4] = Ω[Ω357911[...]]]]]]
Ω25] = Ω24681012[...]]]]]]
Ω36] = Ω35791113[...]]]]]]
4] = [Ω3691215[...]]]]]]
5] = [Ω48121620[...]]]]]]
6] = [Ω510152025[...]]]]]]
7] = [Ω612182430[...]]]]]]

Modified Main rule[]

if α = β[X] and α < cof(X) < c then cof(α) = ω and fs(α, 0) = β, fs(α, n + 1) = β[fs(X, buff(p, fs(α, n)))]

where

buff(p, a) is a with all Ωx replaced with Ωp + x
p is largest ordinal such as buff(p, fs(α, n)) < cof(X)

(This is an approximate wording of Main rule, it may work at the beginning, but currently I use another its version).

Buff version of my web page[]

In December I tried to make buff function in the program, and today I published it at my Github as new version of Ordinal Explorer Online:

rgetar.github.io

Currently I made It work only up to [I] = [[c[c]]], so I left the old version and indicated a link in the new version:

rgetar.github.io/Ordinal Explorer (February 2020).html

Also I added some new designations:

Φ(...), for example Φ(1, 0) = ΩΩΩΩΩ...
I...
I-Φ(...), for example I-Φ(1, 0) = IIIII... (this designation was made up by me, inspired by "M-I(...)" designations I saw at Scorcher007' web site).

Today I replaced string

let s=bb(beta,fs(x,base(c)));

with

let s=beta;

because it simplifies some fundamental sequences, but I do not remember why I made that version, maybe it was important, but I did not found any problems.

Also I made some other changes, for example, swapped base and booster, and comparison of ordinals became very simple (just comparison of strings), it made the program almost twice faster, but I had to replace "]" with "!" for calculations (not for displaying), since now "]" < "[" < "c", but in Unicode "]" goes after "["; position of text near cursor now depends on position of cursor; added sidebar; fixed some bugs.

Also I have many other ideas for future, for example, make no alignment and fundamental sequence alignment options in addition to expansion alignment, that is

0
1
2
3
4
5
6

instead of

0
1
2
3
4
5
6

as now (but single expansions will be skewed from left bottom to right top corner).

Or to replace double, triple, etc. expansions with single expansions applied to selected pair of ordinals with all ordinals between them for gradually expansion of selected pair of ordinals — single, double, etc.

Enjoy!

(And report bugs, of course).

Update: it seems I already found bugs: fs([Ωω + 2], 2) = [Ωω + 1ω2 + 2]], but I expected [Ωω + 1ω2 + 1]]; and very strange fundamental sequence of [Ωω2 + ω + 1].

Update: fixed. And yes, that string was important.

(To do: option of lists of uncountable ordinals; directly input ordinals and compute functions of them).

Update: fs([ΩΩ2], 1) = [ΩΩ[ΩΩ + 1]], but I expect [ΩΩ[ΩΩ2]].

Update: another bug: 0 absents.

Advertisement