User blog:Rgetar/Fixed program

I fixed v3.0 of my program and created its new version Ordinal Explorer v3.1.

Alphabet
Note: the alphabet is the same as in v3.0.

The notation uses 3 symbols:
 * ]
 * M
 * M

Strings
Note: strings are the same as in v3.0.

There are 3 kinds of strings:
 * M
 * [X]α, where X and α are strings
 * [X]α, where X and α are strings

(Some examples of correspondence "string - ordinal": empty string is 0; "M" is least weakly Mahlo cardinal; "[]" is 1; "" is ω (least infinite ordinal)).

Base
For string [X]α base is α:
 * base([X]α) = α

For empty string and M base is empty string:
 * base =
 * base(M) =

Booster
For string [X]α booster is X:
 * booster([X]α) = X

For empty string and M booster is empty string:
 * booster =
 * booster(M) =

Countable limit
Countable limit of this notation ('Rathjen ordinal') is designated as "L".

Comparison
Note: this comparison algorythm is the same as in v3.0.

Note: this comparison algorythm works only with standard forms (for non-standard form it would work improperly).

Comparison of two strings s1 and s2:

If strings are the same then
 * strings are equal

else if one of strings is empty string then
 * empty string is lesser

else if rightmost symbol of one and only one string is "M" then
 * string with rightmost symbol "M" is larger

else if rightmost symbol of both strings is "M" then
 * delete rightmost symbol ("M") from s1 and s2 and compare them (result of comparison of s1 and s2 is result of this comparison)

else if strings between rightmost "]" and corresponding "[" of s1 and s2 are not the same then
 * compare strings between rightmost "]" and corresponding "[" of s1 and s2 (result of comparison of s1 and s2 is result of this comparison)

else
 * delete all from rightmost "]" to corresponding "[" from s1 and s2 and compare them (result of comparison of s1 and s2 is result of this comparison).

Ltc
"ltc" means less than collapsing cardinal (that is M).

Ltc β of string α (ltc(α) = β):
 * Let β = α
 * While M ≤ β
 * Let β = booster(β)

Cofinality
Note: this cofinality algorythm is the same as in v3.0.

(I determine cofinality of 0 as 0, and cofinality of a successor as 1).

Note: there are 8 cases for cofinality and fundamental sequence algorythms, and these cases are designated with numbers.

Let
 * β = base(α)
 * X = booster(α)

Cofinality of α (cof(α)):

If α is empty string or M then                 (Cases 1, 2)
 * cof(α) = α

else if X is empty string then                 (Case 3)
 * cof(α) = []

else if cof(X) = M > β then                    (Case 4)
 * cof(α) = α

else if [] < cof(X) < α then                     (Case 6)
 * cof(α) = cof(X)

else                                                       (Cases 5, 7, 8)
 * cof(α) =

Fundamental sequence algorythm
Differences with v3.0 are bolded.

Also here is used new designation ("fs") of fundamental sequence elements α[n] (not bolded):
 * fs(α, n) = α[n]

(I determine that 0 has no fundamental sequence, and fundamental sequence of a successor α + 1 has only one (0-th) element α).

Note: there are 8 cases for cofinality and fundamental sequence algorythms, and these cases are designated with numbers.

Let
 * β = base(α)
 * X = booster(α)
 * γ = base(X)
 * δ = base(cof(X))
 * Y = booster(cof(X))
 * W = ltc(X)

n-th element of fundamental sequence of α (α[n]):

If α = L then                                                                                                 (Case of L)
 * fs(α, 0) = 0, fs(α, n + 1) = Zn, where Z0 = M, Zn + 1 = [Zn]M

else if α is empty string then                                                                       (Case 1)
 * α has no fundamental sequence

else if α = M then                                                                                        (Case 2)
 * fs(α, n) = n

else if X is empty string then                                                                      (Case 3)
 * fs(α, n) = β

else if cof(X) = M > β then                                                                         (Case 4)
 * fs(α, n) = n

else if cof(X) = [] then                                                                                 (Case 5)
 * fs(α, 0) = β, fs(α, n + 1) = [γ]fs(α, n)

else if cof(X) < α then                                                                                (Case 6)
 * fs(α, n) = [fs(X, n)]β

else if fs(Y, 0) ≤ X and δ ≤ β then                                                              (Case 7)
 * fs(α, 0) = β, fs(α, n + 1) = [fs(X, fs(α, n))]β

else                                                                                                            (Case 8)
 * fs(α, n) = [fs(X, fs([fs(Y, W)]δ, n))]β

Note: for Case 8 also do work exactly the same way these variants:
 * fs(α, n) = [fs(fs(X, [fs(Y, W)]δ), n)]β
 * fs(α, n) = fs([fs(X, [fs(Y, W)]δ)]β, n)

The latter can be formulated as follows:
 * α = [fs(X, [fs(Y, W)]δ)]β

then compute fs(α, n).

Modified algorythm
I modified this algorythm in order to reduce size of lists. (Both algorythms are working, but the modified algorythm generates lesser lists. Example: pentuple expansion of L consists of 2833 ordinals for the modified algorythm and 7146 ordinals for the "original" algorythm).

Modifications:

for Case 5
 * fs(α, 0) = 0, fs(α, 1) = β, fs(α, n + 2) = [γ]fs(α, n + 1)

for Case 7
 * fs(α, 0) = 0, fs(α, 1) = [fs(X, 0)]β, fs(α, n + 2) = [fs(X, fs(α, n + 1))]β

for Case 8
 * fs(α, 0) = 0, fs(α, 1) = β, fs(α, n + 2) = [fs(X, fs([fs(Y, W)]δ, n))]β

Standard forms
"L" is a standard form; any generated by this algorythm element of fundamental sequence of a standard form is a standard form; base and booster of a standard form are standard forms.

Decryption of strings
Note: here "original" algorythm is considered. Modified algorythm is a bit different for cases 5, 7, 8.

Case L
This is case for L.


 * cof(L) = ω

Fundamental sequence:


 * empty string = 0
 * [[M]&#93; = [Ω] = ε0
 * [M]M = [[M2]&#93; = [I]
 * [[M]M]M = M2 = [I(1, 0 ,0)]
 * [[[M]M]M]M = MM
 * [[[[M]M]M]M]M = MM M

Case 1
This case is for 0.
 * α = 0
 * cof(0) = 0
 * 0 has no fundamental sequence

Case 2
This case is for M (least weakly Mahlo cardinal).
 * α = M
 * cof(M) = M
 * fs(M, n) = n

Fundamental sequence:
 * 0
 * 1
 * 2
 * 3
 * ω
 * ω + 1
 * ω + 2
 * Ω
 * I
 * Ω
 * I
 * I

(that is all ordinals less than M)

Case 3
This case is for successors.
 * α = [X]β = []β

that is
 * X = empty string = 0
 * cof(α) = 1
 * fs(α, 0) = β

Fundamental sequence:
 * β

[]β is successor of β:
 * []β = β + 1

Case 4
This case is for reqular cardinals less than M.
 * α = [X]β
 * cof(X) = M > β
 * cof(α) = α
 * fs(α, n) = n

(that is fundamental sequence consists of all ordinals less than α)

For β < M
 * [M]β is next uncountable cardinal after β, for example
 * [M] = [M]0 = Ω
 * [M][M] = [M]Ω = Ω2
 * [M][M][M] = [M]Ω2 = Ω3
 * [M][[]M] = [M][M + 1] = [M]Ωω = Ωω + 1
 * [M][MM] = [M][[Ω]M] = [M][M + Ω] = [M]ΩΩ = ΩΩ + 1
 * [M][[[[M]MM]]M] = [M][M + IM] = [M][M + ΩΩ Ω . ..   ] = [M]ΩΩ Ω . ..    = [M]Φ(1, 0) = ΩΦ(1, 0) + 1
 * [M][[M]M] = [M][M2] = [M]I = ΩI + 1
 * [M][[M][M]M] = [M][M3] = [M]I(2, 0) = ΩI(2, 0) + 1
 * [[M]M]β = [M2]β is next weakly inaccessible cardinal after β, for example
 * [[M]M] = [M2] = I
 * [[M]M][[M]M] = [M2][M2] = [M2]I = I2
 * [[M]M][[M]M][[M]M] = [M2][M2][M2] = [M2]I2 = I3
 * [[M]M][[M][M]M] = [M2][M3] = [M2]I(2, 0) = II(2, 0) + 1
 * [[M][M]M]β = [M3]β is next weakly 1-inaccessible cardinal after β, for example
 * [[M][M]M] = [M3] = I(2, 0)
 * [[M][M]M][[M][M]M] = [M3][M3] = [M3]I(2, 0) = I(2, 1)
 * [[M][M][M]M]β = [M4]β is next weakly 2-inaccessible cardinal after β, for example
 * [[M][M][M]M] = [M4] = I(3, 0)
 * [[M][M][M]M][[M][M][M]M] = [M4][M4] = [M4]I(3, 0) = I(3, 1)
 * [[[M]M]M]β = [M2]β is next weakly hyperinaccessible cardinal after β, for example
 * [[[M]M]M] = [M2] = I(1, 0, 0)
 * [[[M]M]M][[[M]M]M] = [M2][M2] = [M2]I(1, 0, 0) = I(1, 0, 1)
 * [[M][M][M]M][[M][M][M]M] = [M4][M4] = [M4]I(3, 0) = I(3, 1)
 * [[[M]M]M]β = [M2]β is next weakly hyperinaccessible cardinal after β, for example
 * [[[M]M]M] = [M2] = I(1, 0, 0)
 * [[[M]M]M][[[M]M]M] = [M2][M2] = [M2]I(1, 0, 0) = I(1, 0, 1)
 * [[[M]M]M][[[M]M]M] = [M2][M2] = [M2]I(1, 0, 0) = I(1, 0, 1)

Case 5
This case is for successor X.
 * α = [X]β = [[]γ]β = [γ + 1]β
 * X = []γ = γ + 1
 * cof(α) = ω
 * fs(M, n) = n

Fundamental sequence:
 * β
 * [γ]β
 * [γ][γ]β
 * [γ][γ][γ]β
 * [γ][γ][γ][γ]β
 * [γ][γ][γ][γ][γ]β

Example:
 * α = = [1] = [1]0 = [X]β
 * β = 0
 * X = [] = [0] = [0]0 = 1 = []γ
 * γ = 0

Fundamental sequence:
 * 0
 * [0]0 = [] = 1
 * [0][0]0 = [][] = []1 = 2
 * [0][0][0]0 = [][][] = []2 = 3
 * [0][0][0][0]0 = [][][][] = []3 = 4
 * [0][0][0][0][0]0 = [][][][][] = []4 = 5
 * [0][0][0][0][0][0]0 = [][][][][][] = []5 = 6
 * α = = ω
 * α = = ω

Case 6
This case is for limit X, when we do not need collapsing.
 * cof(X) < α
 * cof(α) = cof(X)
 * fs(α, n) = [fs(X, n)]β

Patterns for cases 3 — 6
Note: I use designations with limits, that is
 * Iω is supremum of I, I2, I3, ...
 * I(2, ω) is supremum of I(2, 0), I(2, 1), I(2, 2), ...
 * I(ω, 0) is supremum of I, I(2, 0), I(3, 0), ...
 * I(ω, 1) is supremum of II(ω, 0) + 1, I(2, I(ω, 0) + 1), I(3, I(ω, 0) + 1), ...

If it is Case 3 or Case 4 or Case 5 or Case 6 then
 * Let V < M > β. Then
 * α = [V]β = β + ωV
 * α = [M + V]β = Ωμ + ωV, where Ωμ + 1 is next uncountable cardinal after α
 * α = [M2 + V]β = Iμ + ωV, where Iμ + 1 is next weakly inaccessible cardinal after α
 * α = [M3 + V]β = I(2, μ + ωV), where I(2, μ + 1) is next weakly 1-inaccessible cardinal after α
 * α = [M4 + V]β = I(3, μ + ωV), where I(3, μ + 1) is next weakly 2-inaccessible cardinal after α
 * Let M ≤ β. Then
 * α = [X]β = β + ωX
 * α = [X]β = β + ωX

Examples:
 * [] = [0] = ω0 = 1
 * [][] = [0][0] = [0]1 = 1 + ω0 = 1 + 1 = 2
 * [][][] = [0][0][0] = [0]2 = 2 + ω0 = 2 + 1 = 3
 * = [1] = ω1 = ω
 * [] = [0][1] = [0]ω = ω + ω0 = ω + 1
 * [][] = [0][0][1] = [0](ω + 1) = ω + 1 + ω0 = ω + 1 + 1 = ω + 2
 * = [1][1] = [1]ω = ω + ω1 = ω2
 * = [1][1][1] = [1]ω2 = ω2 + ω1 = ω3
 * ][ = [2] = ω2
 * []][ = [0][2] = [0]ω2 = ω2 + 1
 * ][ = [1][2] = [1]ω2 = ω2 + ω1 = ω2 + ω
 * ][][ = [2][2] = [2]ω2 = ω2 + ω2 = ω22
 * ][][ = [3] = ω3
 * [] = [ω] = ωω
 * ][[] = [ω + 1] = ωω + 1
 * [] = [ω2] = ωω2
 * [][] = [ω2] = ωω 2
 * [[]] = [ωω] = ωω ω
 * [M] = Ω0 + ω0 = Ω0 + 1 = Ω
 * [][M] = [0]Ω = Ω + ω0 = Ω + 1
 * [][][M] = [0](Ω + 1) = Ω + 1 + ω0 = Ω + 1 + 1 = Ω + 2
 * [M] = [1]Ω = Ω + ω1 = Ω + ω
 * [][M] = [ω]Ω = Ω + ωω = Ω + ωω
 * [[M]&#93;[M] = [Ω]Ω = Ω + ωΩ = Ω + Ω = Ω2
 * [[M]&#93;[[M]&#93;[M] = [Ω][Ω]Ω = [Ω]Ω2 = Ω2 + ωΩ = Ω2 + Ω = Ω3
 * ][M[M] = [Ω + 1]Ω = Ω + ωΩ + 1 = ωΩ + 1 = Ωω
 * [M[M]][M] = [Ω2]Ω = Ω + ωΩ2 = ωΩ2 = Ω2
 * [[M]&[M]][M] = [Ω2]Ω = Ω + ωΩ 2 = ωΩ 2 = ΩΩ
 * [M][M] = [M]Ω = Ω1 + ω0 = Ω1 + 1 = Ω2
 * [][M][M] = Ω2 + 1
 * [][][M][M] = Ω2 + 2
 * [M][M] = [1][M][M] = Ω2 + ω
 * [[M]&#93;[M][M] = [Ω][M][M] = Ω2 + Ω
 * M][M[M][M] = [Ω2][M][M] = Ω22
 * M][MM][M[M][M] = [Ω2][Ω2][M][M] = Ω23
 * ][M][M[M][M] = [Ω2 + 1][M][M] = Ω2ω
 * [M[M][M]][M][M] = [Ω2 + Ω][M][M] = Ω2Ω
 * [M][M[M][M]][M][M] = [Ω22][M][M] = Ω22
 * [[M][M[M][M]][M][M]][M][M] = [Ω22][M][M] = Ω2Ω2
 * [M][M][M] = [M]Ω2 = Ω2 + ω0 = Ω2 + 1 = Ω3
 * [[]M] = [M + 1] = Ω0 + ω1 = Ω0 + ω = Ωω
 * [M][[]M] = [M][M + 1] = [M]Ωω = Ωω + ω0 = Ωω + 1
 * [M][M][[]M] = [M][M][M + 1] = Ωω + 2
 * [[]M][[]M] = [M + 1][M + 1] = Ωω + ω1 = Ωω + ω = Ωω2
 * [[]M][[]M][[]M] = [M + 1][M + 1][M + 1] = Ωω3
 * [[][]M] = [M + 2] = Ω0 + ω2 = Ωω2
 * [M][[][]M] = [M][M + 2] = Ωω2 + 1
 * [[]M][[][]M] = [M + 1][M + 2] = Ωω2 + ω
 * [[][][]M] = [M + 3] = Ω0 + ω3 = Ωω3
 * [M] = [M + ω] = Ω0 + ωω = Ωωω
 * [[[[M]&#93;M] = [[[Ω]M] = [M + Ω] = Ω0 + ωΩ = ΩΩ
 * [[M]M] = [M2] = I0 + ω0 = I0 + 1 = I
 * [][[M]M] = []I = I + 1
 * [[M]&#93;[[M]M] = [Ω]I = I + Ω
 * [M][[M]M] = [M][I] = ΩI + ω0 = ΩI + 1
 * [[M]M][[M]M] = [M2]I = I1 + ω0 = I2
 * [[][M]M] = [M2 + 1] = I0 + ω1 = Iω
 * []M = M + 1
 * [][]M = M + 2
 * M = [1]M = M + ω
 * []M = [0][1]M = M + ω + 1
 * M = [1][1]M = M + ω2
 * ][M = [2]M = M + ω2
 * []M = [ω]M = M + ωω
 * [[M]&#93;M = [Ω]M = M + ωΩ = M + Ω
 * [M]MM = [I]M = M + ωI = M + I
 * [M]M = [M]M = M + ωM = M + M = M2
 * [[M]M]M = [M2]M = M + ωM2 = ωM2 = M2

Case 7
This case is for "direct" collapsing.
 * α = [X]β
 * cof(X) = [Y]δ
 * fs(Y, 0) ≤ X and δ ≤ β
 * cof(α) = ω
 * fs(α, 0) = β, fs(α, n + 1) = [fs(X, fs(α, n))]β

Сase 7 arises when cof(X) is not "too large", that is
 * X < M and cof(X) is next uncountable cardinal after β
 * M ≤ X < M2 and cof(X) is next weakly inaccessible cardinal after β
 * M2 ≤ X < M3 and cof(X) is next weakly 1-inaccessible cardinal after β
 * M3 ≤ X < M4 and cof(X) is next weakly 2-inaccessible cardinal after β

Examples:

Let α = [X]β = [[M]&#93; = [Ω]
 * β = 0
 * X = Ω
 * cof(X) = Ω
 * fs(X, n) = n
 * fs(α, 0) = β = 0
 * fs(α, 1) = [fs(X, fs(α, 0))]β = [fs(α, 0)]β = [0]0 = [] = 1
 * fs(α, 2) = [fs(X, fs(α, 1))]β = [fs(α, 1)]β = [1]0 = = ω
 * fs(α, 3) = [fs(X, fs(α, 2))]β = [fs(α, 2)]β = [ω]0 = [] = ωω
 * fs(α, 4) = [fs(X, fs(α, 3))]β = [fs(α, 3)]β = [ωω]0 = [[]] = ωω ω
 * fs(α, 5) = [fs(X, fs(α, 4))]β = [fs(α, 4)]β = [ωω ω ]0 = [[[]]] = ωω ω ω
 * α = ε0
 * α = ε0

Let α = [X]β = [[M]&#93;[[M]&#93; = [Ω]ε0
 * β = ε0
 * X = Ω
 * cof(X) = Ω
 * fs(X, n) = n
 * fs(α, 0) = β = ε0
 * fs(α, 1) = [fs(X, fs(α, 0))]β = [fs(α, 0)]β = [0]ε0 = []ε0 = ε0 + 1
 * fs(α, 2) = [fs(X, fs(α, 1))]β = [fs(α, 1)]β = [ε0 + 1]ε0 = ε0 + ωε0 + 1 = ωε0 + 1 = ε0ω
 * fs(α, 3) = [fs(X, fs(α, 2))]β = [fs(α, 2)]β = [ωε0 + 1]ε0 = ωω ε0 + 1
 * fs(α, 4) = [fs(X, fs(α, 3))]β = [fs(α, 3)]β = [ωω ε0 + 1 ]ε0 = ωω ω ε0 + 1
 * fs(α, 5) = [fs(X, fs(α, 4))]β = [fs(α, 4)]β = [ωω ω ε0 + 1 ]ε0 = ωω ω ω ε0 + 1
 * α = ε1
 * α = ε1

Generally, if β < Ω then [Ω]β is next ε number after β. And if V < Ω then [Ω + V]β = εμ + ωV, where εμ + 1 is next ε number after β. Let α = [X]β = [M[M]] = [Ω2]
 * β = 0
 * X = Ω2
 * cof(X) = Ω
 * fs(X, n) = [n][M] = [n]Ω = Ω + ωn
 * fs(α, 0) = β = 0
 * fs(α, 1) = [fs(X, fs(α, 0))]β = [Ω + ωfs(α, 0)]β = [Ω + ω0] = [Ω + 1] = εω
 * fs(α, 2) = [fs(X, fs(α, 1))]β = [Ω + ωfs(α, 1)]β = [Ω + ωεω] = [Ω + εω] = εε ω
 * fs(α, 3) = [fs(X, fs(α, 2))]β = [Ω + ωfs(α, 2)]β = [Ω + ωεε ω] = [Ω + εε ω ] = εε ε ω
 * α = ζ0
 * α = ζ0

Generally, if β < Ω then [Ω2]β is next ζ number after β. And if V < Ω then [Ω2 + V]β = ζμ + ωV, where ζμ + 1 is next ζ number after β. Let α = [X]β = M][M[M] = [Ω2]Ω
 * β = Ω
 * X = Ω2
 * cof(X) = Ω2
 * fs(X, n) = n
 * fs(α, 0) = β = Ω
 * fs(α, 1) = [fs(X, fs(α, 0))]β = [fs(α, 0)]β = [Ω]Ω = Ω2
 * fs(α, 2) = [fs(X, fs(α, 1))]β = [fs(α, 1)]β = [Ω2]Ω = Ω2
 * fs(α, 3) = [fs(X, fs(α, 2))]β = [fs(α, 2)]β = [Ω2]Ω = ΩΩ
 * α = εΩ + 1
 * α = εΩ + 1

Generally,
 * if β < Ω then [Ω]β is next ε number after β
 * if Ω ≤ β < Ω2 then [Ω2]β is next ε number after β
 * if Ω2 ≤ β < Ω3 then [Ω3]β is next ε number after β
 * if Ω3 ≤ β < Ω4 then [Ω4]β is next ε number after β
 * if Ω4 ≤ β < Ω5 then [Ω5]β is next ε number after β
 * if β < Ω then [Ω2]β is next ζ number after β
 * if Ω ≤ β < Ω2 then [Ω22]β is next ζ number after β
 * if Ω2 ≤ β < Ω3 then [Ω32]β is next ζ number after β
 * if Ω3 ≤ β < Ω4 then [Ω42]β is next ζ number after β
 * if Ω4 ≤ β < Ω5 then [Ω52]β is next ζ number after β
 * if Ω4 ≤ β < Ω5 then [Ω52]β is next ζ number after β

Let α = [X]β = [[M]MM] = [M2M] = [[I]M] = [M + I]
 * β = 0
 * X = M + I
 * cof(X) = I
 * fs(X, n) = [[n]M] = [M + ωn]
 * fs(α, 0) = β = 0
 * fs(α, 1) = [fs(X, fs(α, 0))]β = [M + ωfs(α, 0)]β = [M + ω0] = [M + 1] = Ωω
 * fs(α, 2) = [fs(X, fs(α, 1))]β = [M + ωfs(α, 1)]β = [M + ωΩω] = [M + Ωω] = ΩΩ ω
 * fs(α, 3) = [fs(X, fs(α, 2))]β = [M + ωfs(α, 2)]β = [M + ωΩΩ ω] = [M + ΩΩ ω ] = ΩΩ Ω ω
 * α = ΩΩ Ω . ..   = Φ(1, 0)
 * α = ΩΩ Ω . ..   = Φ(1, 0)

Let α = [X]β = [[M]MM][[M]MM] = [M + I][M + I] = [M + I]Φ(1, 0)
 * β = Φ(1, 0)
 * X = M + I
 * cof(X) = I
 * fs(X, n) = [[n]M] = [M + ωn]
 * fs(α, 0) = β = Φ(1, 0)
 * fs(α, 1) = [fs(X, fs(α, 0))]β = [M + ωΦ(1, 0)]Φ(1, 0) = [M + Φ(1, 0)]Φ(1, 0) = ΩΦ(1, 0) + ωΦ(1, 0) = ΩΦ(1, 0)2
 * fs(α, 2) = [fs(X, fs(α, 1))]β = [M + ωΩΦ(1, 0)2]Φ(1, 0) = [M + ΩΦ(1, 0)2]Φ(1, 0) = ΩΩ Φ(1, 0)2
 * fs(α, 3) = [fs(X, fs(α, 2))]β = [M + ωΩΩ Φ(1, 0)2]Φ(1, 0) = [M + ΩΩ Φ(1, 0)2 ]Φ(1, 0) = ΩΩ Ω Φ(1, 0)2
 * α = Φ(1, 1)
 * α = Φ(1, 1)

Generally, for V < I
 * if β < I then [M + I + V]β = Φ(1, μ + ωV), where Φ(1, μ + 1) is next ordinal α after β such as α = Ωα
 * if I ≤ β < I2 then [M + I2 + V]β = Φ(2, μ + ωV), where Φ(2, μ + 1) is next ordinal α after β such as α = Φ(1, α)
 * if I2 ≤ β < I3 then [M + I3 + V]β = Φ(3, μ + ωV), where Φ(3, μ + 1) is next ordinal α after β such as α = Φ(2, α)

Case 8
This case is for "indirect" collapsing.
 * α = [X]β
 * cof(X) = [Y]δ
 * W = ltc(X)
 * cof(α) = ω
 * fs(α, n) = [fs(X, fs([fs(Y, W)]δ, n))]β

This case arises when cof(X) is larger than for Case 7. Since cof(X) is too large, we need to use some intermediate cardinal less than cof(X), and eventually collapsing becomes "direct". This intermediate cardinal is δ < cof(X) = [Y]δ.

Too generate fundamental sequence we need to replace X in α = [X]β with fs elements of X:
 * [X]β → [fs(X, nX)]β

Number of fs elements should not be larger than cofinality, so
 * nX < cof(X) = [Y]δ

To make sure of it we can replace Y with fs elements of Y:
 * [Y]δ → [fs(Y, nY)]δ

nY should depend on X (for collapsing), but nY must be less than cof(Y), but cof(Y) is always M. So
 * nY < cof(Y) = M

But sometimes M ≤ X. That's why we use W = ltc(X) instead of X. So
 * nY = W = ltc(X) < M

We get
 * [fs(Y, W)]δ

Cofinality of this is ω. So we can take n-th fs element of it as nX:
 * nX = fs([fs(Y, W)]δ, n)
 * fs(α, n) = [fs(X, fs([fs(Y, W)]δ, n))]β

Examples:

Let α = [X]β = M][M = [Ω2]
 * β = 0
 * X = Ω2
 * W = ltc(X) = Ω2
 * cof(X) = Ω2 = [M][M] = [M]Ω
 * δ = Ω
 * Y = M
 * fs(X, n) = n
 * fs(Y, n) = n
 * nX = fs([fs(Y, W)]δ, n) = fs([fs(Y, Ω2)]δ, n) = fs([Ω2]Ω, n) = fs(εΩ + 1, n)
 * fs(α, n) = [fs(X, fs(εΩ + 1, n))]β = [fs(εΩ + 1, n)]
 * fs(α, 0) = [fs(εΩ + 1, 0)] = [Ω] = ε0
 * fs(α, 1) = [fs(εΩ + 1, 1)] = [Ω2] = ζ0
 * fs(α, 2) = [fs(εΩ + 1, 2)] = [Ω2] = Γ0
 * fs(α, 3) = [fs(εΩ + 1, 3)] = [ΩΩ] = LVO
 * α = [εΩ + 1] = BHO
 * α = [εΩ + 1] = BHO

Let α = [X]β = [M]M = [I]
 * β = 0
 * X = I
 * W = ltc(X) = I
 * cof(X) = I = [[M]M] = [M2]
 * δ = 0
 * Y = [M]M = M2
 * fs(X, n) = n
 * fs(Y, n) = [n]M = M + ωn
 * nX = fs([fs(Y, W)]δ, n) = fs([fs(Y, I)]δ, n) = fs([M + ωI], n) = fs([M + I], n) = fs(Φ(1, 0), n)
 * fs(α, n) = [fs(X, fs(Φ(1, 0), n))]β = [fs(Φ(1, 0), n)]
 * fs(α, 0) = [fs(Φ(1, 0), 0)] = [0] = 1
 * fs(α, 1) = [fs(Φ(1, 0), 1)] = [Ωω] = ψ(Ω_ω)
 * fs(α, 2) = [fs(Φ(1, 0), 2)] = [ΩΩ ω ]
 * fs(α, 3) = [fs(Φ(1, 0), 3)] = [ΩΩ Ω ω ]
 * α = [Φ(1, 0)] = ψ(ψᵢ(0))
 * α = [Φ(1, 0)] = ψ(ψᵢ(0))

Lists of ordinals
I decided to post lists of ordinals in a separate blog.

Source code
Source code of Ordinal Explorer v3.1.

For comparison see function compare, for cofinality see function cof, for fundamental sequence modified algorythm see function fs (for "original" algorythm see function fs_).

In function cof and function fs 8 cases are designated with numbers.

unit Ord;

interface

uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, StrUtils, Math, ScktComp;

type TForm1 = class(TForm) Button1: TButton; Label1: TLabel; Label2: TLabel; Label3: TLabel; ServerSocket1: TServerSocket; Label4: TLabel; Label5: TLabel; Label6: TLabel; Label7: TLabel; Label8: TLabel; Edit1: TEdit; Edit2: TEdit; procedure Button1Click(Sender: TObject); procedure Serversocket1ClientRead(Sender: TObject; Socket: TCustomWinSocket); procedure Form1Create(Sender: TObject); procedure Form1Destroy(Sender: TObject); end;

lis=array of record s{,i}: string; c,l: integer; end; rar=array[0..19] of string;

var Form1: TForm1; st,st1,bo,cout,qhost,fa,col: string; s: lis; f: textfile; b,bn,g,er: boolean; cn,cl,sl,br: integer; duq,uq,bro,brc: rar; implementation

{$R *.dfm}

// get position of last symbol p of string st (if l=true then first) function getls(st,p:string; l:boolean=false):integer; var e,np: integer; begin if length(st)=0 then result:=ifthen(l,1,0) else begin if l then e:=0 else e:=length(st)+1; np:=0; repeat if l then inc(e) else dec(e); if st[e]='[' then dec(np); if st[e]=']' then inc(np); until (not l and (e=1)) or (l and (e=length(st))) or ((st[e]=p) and (np=0)); if not l and (e=1) and (st[1]<>p) then e:=0 else if l and (e=length(st)) and (st[e]<>p) then e:=length(st)+1; result:=e; end; end;

// get base of string st function base(st:string):string; begin result:=copy(st,getls(st,']',true)+1,length(st)); end;

// get booster of string st function booster(st:string):string; begin result:=copy(st,2,getls(st,']',true)-2); end;

// get successor of ordinal st function suc(st:string):string; begin result:='[]'+st; end;

// get X from successor ordinal st = X + 1 function pred(st:string):string; begin result:=copy(st,3,length(st)); end;

// finite ordinal string st to number function fostn(st:string):integer; begin if st='' then result:=0 else result:=(length(st)+1) div 2; end;

// finite ordinal e from integer to computer format function cf(e:integer):string; begin result:=''; while e>0 do  begin dec(e); result:=suc(result); end; end;

// compare standard forms of ordinals st1, st2 (if st1st2 then 1) function compare(st1,st2:string):shortint; var q1,q2,l1,l2:integer; begin if st1=st2 then result:=0 else if st1='' then result:=-1 else if st2='' then result:=1 else if (rightstr(st1,1)=col) and (rightstr(st2,1)<>col) then result:=1 else if (rightstr(st2,1)=col) and (rightstr(st1,1)<>col) then result:=-1 else if rightstr(st1,1)=col then result:=compare(leftstr(st1,length(st1)-1),leftstr(st2,length(st2)-1)) else repeat l1:=length(st1); l2:=length(st2); q1:=getls(st1,'['); q2:=getls(st2,'['); delete(st1,l1,1); delete(st2,l2,1); result:=compare(copy(st1,q1+1,l1),copy(st2,q2+1,l2)); if result=0 then begin delete(st1,q1,l1); delete(st2,q2,l2); if st1='' then result:=-1 else if st2='' then result:=1; end; until result<>0; end;

// get less than col part of string st function ltc(st:string):string; begin while compare(col,st)<1 do  st:=booster(st); result:=st; end;

// get cofinality of ordinal st function cof(st:string):string; var c:string; begin if (st='') or (st=col) then                              // 1, 2 result:=st else begin c:=cof(booster(st)); if c='' then                                          // 3 result:='[]' else if (c=col) and (compare(col,st)=1) then          // 4 result:=st else if (compare(c,'[]')=1) and (compare(st,c)=1) then // 6 result:=c else                                                  // 5, 7, 8 result:=''; end; end;

// get n-th element of fs of ordinal st function fs(st,n:string):string; var c,s,x,y,z:string; i:integer; begin result:=n; if st='L' then                                                // L   begin if n<>'' then begin z:=col; for i:=2 to fostn(n) do        z:='['+z+']'+col; result:=bro[br+2]+z+brc[br+2]; end; end else if st<>col then                                          // 2 begin x:=booster(st); c:=base(st); s:=cof(x); if (s<>col) or (compare(col,c)<1) then                     // 4 if s='[]' then                                             // 5 begin if n<>'' then begin x:=pred(x); for i:=2 to fostn(n) do           c:='['+x+']'+c; result:=c; end; end else if compare(st,s)=1 then                               // 6 result:='['+fs(x,n)+']'+c else begin y:=booster(s); z:=base(s); if n<>'' then if (compare(z,c)<1) and (compare(fs(y,''),x)<1) then    // 7 begin s:=''; for i:=1 to fostn(n) do           s:='['+fs(x,s)+']'+c; result:=s; end else                                                    // 8 begin if n='[]' then result:=c else result:='['+fs(x,fs('['+fs(y,ltc(x))+']'+z,pred(pred(n))))+']'+c; //result:='['+fs(fs(x,'['+fs(y,ltc(x))+']'+z),pred(pred(n)))+']'+c; //result:=fs('['+fs(x,'['+fs(y,ltc(x))+']'+z)+']'+c,pred(pred(n))); end; end; end; end;

// get n-th element of fs of ordinal st function fs_(st,n:string):string; var c,s,x,y,z:string; i:integer; begin result:=n; if st='L' then                                                // L   if n<>'' then begin z:=col; for i:=2 to fostn(n) do        z:='['+z+']'+col; result:=bro[br+2]+z+brc[br+2]; end else else if st<>col then                                          // 2 begin x:=booster(st); c:=base(st); s:=cof(x); if (s<>col) or (compare(col,c)<1) then                     // 4 if s='[]' then                                             // 5 begin x:=pred(x); for i:=1 to fostn(n) do        c:='['+x+']'+c; result:=c; end else if compare(st,s)=1 then                               // 6 result:='['+fs(x,n)+']'+c else begin y:=booster(s); z:=base(s); if (compare(z,c)<1) and (compare(fs(y,''),x)<1) then    // 7 begin s:=c; for i:=1 to fostn(n) do           s:='['+fs(x,s)+']'+c; result:=s; end else                                                    // 8 result:='['+fs(x,fs('['+fs(y,ltc(x))+']'+z,n))+']'+c; end; end; end;

function convert(st:string;z:boolean=false):string; begin result:=st; end;

// small expansion of pair c > l function se(c,l:string; yn:integer; var n:string):string; var u:integer; begin n:=''; repeat result:=fs(c,n); n:=suc(n); if length(n)>35 then er:=true; until er or (l='-') or (compare(result,l)=1); if er then begin form1.Label8.Caption:='fs is less than or equal to low element of pair'; form1.Edit1.Text:=c; form1.Edit2.Text:=l; end else begin for u:=3 to yn do     n:=suc(n); if yn>1 then result:=fs(c,n); end; end;

// levelup (q - number of levelups, yn - number of fs elements, inserted in last levelup) procedure levelup(q:integer; yn:integer=0); var e,i,y,u,j: integer; n,l,p,a,c: string; begin inc(yn); while not er and (q>0) do begin dec(q); if q>0 then j:=1 else j:=yn; e:=0; c:=s[e].s; i:=s[e].c; y:=0; form1.Label2.Caption:=inttostr(cn)+'                      '; form1.Label2.Refresh; repeat begin n:=''; if i=-1 then begin l:='-'; p:=''; end else begin l:=s[i].s;     p:=suc(l); end; if (c<>'L') and (compare(c,p)=0) then begin e:=i; if e>-1 then begin c:=s[e].s;        i:=s[e].c;         if i=-1 then e:=i; end; dec(cn); form1.Label2.Caption:=inttostr(cn)+'                      '; form1.Label2.Refresh; end else begin a:=se(c,l,j,n); u:=0; if (c<>'L') and (compare(c,a)<1) then begin er:=true; if compare(c,a)=0 then form1.Label8.Caption:='fs element is equal to its argument' else form1.Label8.Caption:='fs element is larger than its argument'; form1.Edit1.Text:=c; form1.Edit2.Text:=a; end; if not er then while ulength(s) then setlength(s,length(s)*2); form1.Label1.Caption:=inttostr(sl); form1.Label1.Refresh; e:=y; s[e].c:=i; s[e].s:=a; s[e].l:=ifthen(u=j,cl,cl+1); if u<>j then begin n:=pred(n); a:=fs(c,n); end; end; c:=a; end; end; until er or (e=-1); cn:=y; inc(cl); end; end;

function ruq(st:string;uq:rar):rar; var e,i:integer; begin st:=st+'='; result:=uq; while (st<>'=') and (st<>'') do  begin e:=system.ord(st[1])-48; delete(st,1,1); i:=pos('=',st); result[e]:=leftstr(st,i-1); delete(st,1,i); end; end;

function wuq(st:string):string; var e:integer; huq:rar; begin huq:=ruq(st,uq); result:=''; for e:=0 to length(uq)-1 do  if huq[e]<>duq[e] then begin if result<>'' then result:=result+'='; result:=result+chr(e+48)+huq[e]; end; end;

// get html link s, displaying string st function getrefs(s, st: string):string; begin result:=''+st+''; end;

procedure ads(st:string); begin if g then cout:=cout+st else writeln(f,st); end;

procedure starthtml; begin cout:=''; st:='  a {text-decoration: none; color: blue;} a:hover {text-decoration: underline;} a:visited {color: blue;} '; st:='sup {font-size: 0.83rem;}'+st; st:='sub {font-size: 0.83rem;}'+st; st:=' '+st; ads(st); end;

procedure endhtml; begin if g then begin st:=#13#10#13#10#13#10+' Formats:'; st:=st+' ['+getrefs(wuq('9'+ifthen(uq[9]=,'0',)),ifthen(uq[9]=,,'not ')+'computer format')+']'; st:=st+' ['+getrefs(wuq('8'+ifthen(uq[8]=,'0',)),ifthen(uq[8]='','without','with')+' &#949;, &#950;, &#951;, &#913;, &#914;, &#915;, &#916;, v, V, H')+']'; st:=st+' ['+getrefs(wuq(';'+ifthen(uq[11]=,'0',)),ifthen(uq[11]='','without','with')+' &#969;, &#937;')+']'; st:=st+' ['+getrefs(wuq(':'+ifthen(uq[10]=,'0',)),ifthen(uq[10]='','without','with')+' finite subscripts of &#966;')+']'; st:=st+' ['+getrefs(wuq('5'+ifthen(uq[5]=,'0',)),ifthen(uq[5]='','with','without')+' infinite multipliers')+'] '; ads(st); st:=#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10; ads(st); st:=#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10#13#10; ads(st); st:=#13#10#13#10+' ['+getrefs(wuq('3'+ifthen(uq[3]=,'0',)),ifthen(uq[3]='','hide','show')+' [expand]s')+']'; st:=st+' ['+getrefs(wuq('6'+ifthen(uq[6]=,'0',)),ifthen(uq[6]='','hide','show')+' ordinal links')+'] '; ads(st); end else begin ads(' '); st:='Total '+inttostr(sl)+' ordinals. ';  ads(st); end; ads(' '); end;

function ors(st:string;b:boolean=true):string; begin result:=convert(st,true); if g and b and (uq[6]='') then result:=getrefs(wuq('0'+st+'=1-=20=40=7'+duq[7]),result); end;

// create output list procedure createlist; var e,i,j:integer; st:string; begin if not er then begin cl:=0; if not g then begin st:='D:\Delphi\Ord5\1.htm'; assignfile(f,st); rewrite(f); end; starthtml; e:=0; i:=s[0].c; j:=-1; while i>-1 do  begin s[e].c:=j; j:=e; e:=i; i:=s[e].c;  end; i:=e; s[e].c:=j; if g and (uq[3]=) and (s[i].s<>) then begin st:=wuq('0'+s[i].s+'=1-=21'); st:=' ['+getrefs(st,'expand')+'] '; ads(st); end; while i>-1 do  begin st:=ors(s[i].s); if s[i].l>0 then st:=''+st+''; while s[i].l>cl do     begin st:=''+st; inc(cl); end; while s[i].l'+st; dec(cl); end; ads(st); e:=i; i:=s[i].c;  if g and (i>-1) and (leftstr(s[i].s,2)<>'[]') then begin if uq[3]='' then begin st:=wuq('0'+s[i].s+'=1'+s[e].s+'=21'); st:='<li style="list-style-type: none"> ['+getrefs(st,'expand')+'] </li></ul>'; end else st:=#13#10; ads(st); end else if g then begin st:=#13#10; ads(st); end; end; if g then begin ads(#13#10+' '+#13#10); st:=inttostr(sl)+' ordinal'+ifthen(sl=1,'','s')+' '; ads(st); st:=wuq('2'+inttostr(strtoint(uq[2])+1)); st:=#13#10+'['+getrefs(st,'expand all')+']'; if uq[2]<>'0' then st:=st+' ['+getrefs(wuq('20'),'collapse all')+']'; ads(st); end; endhtml; if not g then closefile(f); end; end;

// reset list of ordinals procedure resetlist; begin cl:=1; cn:=1; form1.Label1.Caption:='                                                    '; form1.Label1.Refresh; form1.Label2.Caption:='                                                    '; form1.Label2.Refresh; sl:=ifthen(uq[1]='-',1,2); setlength(s,sl); s[0].s:=uq[0];                        // ordinal s[0].c:=sl*2-3;                       // lesser element s[0].l:=0; if sl=2 then begin s[1].s:=uq[1]; s[1].c:=-1; s[1].l:=0; end; end;

// start procedure TForm1.Button1Click(Sender: TObject); begin g:=false; uq[0]:=bo; uq[9]:='*'; resetlist; levelup(5); createlist; end;

// client request procedure TForm1.Serversocket1ClientRead(Sender: TObject; Socket: TCustomWinSocket); var e,i:integer; cin,url:string; begin // cin - client request, cout - server response cin:=Socket.ReceiveText; e:=pos(' ',cin)+1; url:=copy(cin,e,posex(' ',cin,e)-e); delete(url,1,1); e:=pos('Host: ',cin)+6; qhost:=copy(cin,e,posex(#13#10,cin,e)-e);

if url='favicon.ico' then Socket.SendText(fa) else begin g:=true; cl:=1; cn:=1; uq:=ruq(url,duq);

if uq[4]='' then begin resetlist; for e:=1 to strtoint(uq[2]) do        levelup(1); createlist; end else begin starthtml; if (uq[3]=) and (uq[0]<>) then begin st:=wuq('0'+uq[0]+'=1-=21=4'); st:='<li style="list-style-type: none"> ['+getrefs(st,'expand')+'] </li></ul>'; ads(st); end; ads(+ors(uq[0],false)+); ads(#13#10#13#10#13#10#13#10+'Elements of fundamental sequence:'+#13#10#13#10); if uq[0]='' then i:=-1 else if leftstr(uq[0],2)='[]' then i:=0 else i:=strtoint(uq[7]); for e:=0 to i do        ads(inttostr(e)+'. '+ors(fs(uq[0],cf(e)))+#13#10#13#10); if uq[0]='' then ads((empty)+#13#10#13#10) else if leftstr(uq[0],2)<>'[]' then ads(' +getrefs(wuq('7'+inttostr(strtoint(uq[7])+1)),'(more) )+#13#10#13#10); endhtml; end;

Socket.SendText(cout); end; Socket.Close; form1.Label4.Caption:=''; form1.Label5.Caption:=''; form1.Label6.Caption:=''; form1.Label7.Caption:=''; form1.Label4.Refresh; form1.Label5.Refresh; form1.Label6.Refresh; form1.Label7.Refresh; end;

// open program procedure TForm1.Form1Create(Sender: TObject); var e:integer; begin er:=false; br:=0; bn:=true; bo:='L'; col:='M'; duq[0]:=bo;           // larger ordinal duq[1]:='-';          // lesser ordinal duq[2]:='0';          // number of expansion levels duq[3]:='';           // show / hide [expand]s duq[4]:='';           // mode (list / fs) duq[5]:='';           // without / with multipliers duq[6]:='';           // show / hide ordinal links duq[7]:='4';          // number of fs elements in fs mode duq[8]:='';           // with / without letters except phi, omega, Omega duq[9]:='1';          // human / computer format duq[10]:='';          // without / with subscripts of phi duq[11]:='';          // with / without omega, Omega

bro[0]:=''; brc[0]:=''; for e:=1 to 19 do  begin bro[e]:=bro[e-1]+'['; brc[e]:=brc[e-1]+']'; end;

fa:='#0#0#1#0#1#0#32#32#4#0#0#0#0#0$e8#2#0#0#22#0#0#0#40#0#0#0#32#0#0#0#64#0#0#0#1#0#4#0#0#0#0#0#0#2#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0'; fa:=fa+'#0$80#0#0$80#0#0#0$80$80#0$80#0#0#0$80#0$80#0$80$80#0#0$80$80$80#0$c0$c0$c0#0#0#0$ff#0#0$ff#0#0#0$ff$ff#0$ff#0#0#0$ff#0$ff'; fa:=fa+'#0$ff$ff#0#0$ff$ff$ff#0$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff'; fa:=fa+'$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff'; fa:=fa+'$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0'; fa:=fa+'#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0'; fa:=fa+'#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0'; fa:=fa+'#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff'; fa:=fa+'#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff'; fa:=fa+'#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff#0#0#0#0#0#0#0#0#0#0#0#0#0#0$ff$ff'; fa:=fa+'$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff'; fa:=fa+'$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff'; fa:=fa+'$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$fe#3$e0$7f$f8#1$80#31$f8#0'; fa:=fa+'$80#15$f0#0#0#7$e0$70#15#7$e0$f8#31#7$c0$f8#31$83$c0$fc#31$83$c1$fc#31$83$c1$fc#63$83$c1$fc#63$83$c1$fc#63$83$c1$fc'; fa:=fa+'#63$83$c1$fc#63$83$c0$ff$ff$83$e0$ff$ff$83$e0$ff$ff#7$e0$ff$ff#7$f0$7f$ff#7$f0$7f$fe#15$f8#63$fe#15$f8#63$fc#31$ff'; fa:=fa+'$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff$ff'; ServerSocket1.open; end;

// close program procedure TForm1.Form1Destroy(Sender: TObject); begin ServerSocket1.Close; end;

end.