User blog:Rgetar/FGH-based notation for natural numbers

Three or four months ago I came up with an idea of FGH-based notation for natural numbers.

I thought that we need not only to make up numbers as large as possible, but also to describe diversity of all numbers up to some large numbers. I wanted to create some "scale" or system to navigate among numbers with hierarchy of some "ranges" of numbers, "sub-ranges", etc.

I decided to choose FGH.

Notation
We need a natural number base (for example, base = 10), and a system of fundamental sequences up to some countable ordinal L.

Also we need correspondence "ordinal to natural number" otn(α), where α is ordinal such as α ≤ L, and otn(α) is a natural number.

Let
 * otn(L) = 0

and if
 * α = L[n1][n2][n3]...[nm]

(using given system of fundamental sequences), then
 * otn(α) = max(ni)

But what if α can be represented in form α = L[n1][n2][n3]...[nm] using given system of fundamental sequences in different ways? Then we choose one such form for each α.

We can use something like used in my ordinals-calculating programs: let we have sequence of ordinals
 * α0 < α1 < α2 < α3 < α4 < ... < αk

with gaps between them, that is
 * (gap 0), α0, (gap 1), α1, (gap 2), α2, (gap 3), α3, (gap 4), α4 ..., (gap k), αk

Some gaps may be empty (in this case αi + 1 = αi + 1 or α0 = 0 or αi is a limit ordinal and there is its fundamental sequence in the sequence).

So, for each ordinal αi of the sequence we have a gap, that is we have a pair
 * (gap i), αi

In general case for each αi its fundamental sequence (in given system of fundamental sequences) consists of two parts: the first part lies outside gap i, and the second part lies inside gap i.

We can do such operation: for each αi add second part of its fundamental sequence to the sequence (that is part of its fundamental sequence, which is located within gap i).

Initially the sequence is
 * (gap 0), L

and we do this operation infinite many times until all gaps become empty (that is until the sequence consists of all ordinals less than or equal to L).

And there are two ways to choose one α = L[n1][n2][n3]...[nm] representation for each α.

The first way is to choose such form α = L[n1][n2][n3]...[nm], where only "second part" fs elements are used (because it is unique for each α).

The second way is to transform given system of fundamental sequences into its "cut" version, that is for each α ≤ L delete ("cut") "first part" of its fundamental sequence, that is enumerate its fs element beginning from its "second part" (only if "second part" is not empty, because we can not delete "first part", if all fundamental sequence consists of the "first part"). And then we also use form α = L[n1][n2][n3]...[nm], where only "second part" fs elements are used.

(I call fs systems, which are already "cut", as "cut" fs systems).

So, we defined otn(α).

Numbers less than base are designated using digits (for base = 10: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9).

Larger numbers are designated as
 * (string)

A "string" is sequence of α.n pairs, separated using commas (",").

Strings may be empty.

α.n pair consists of ordinal α and number n with dot (".") between them.

In general case string is sequence
 * α0.n0, α1.n1, α2.n2, ... αk.nk

where
 * α0 > α1 > α2 > ... > αk

Also, for string X, α.n (where X is a string)
 * otn(α) < (X)
 * n < (X)

(string) designation:
 * = base
 * (X, α.n) = fαn((X))

where f is FGH. We can delete α.n pairs with n = 0. Example:
 * (9.0, 8.1, 7.0, 6.0, 5.7, 4.0, 3.0, 2.0, 1.0, 0.1) = (8.1, 5.7, 0.1)

So we get unique way to designate natural numbers.

Examples
For base = 10, L = ω, ω[n] = n
 * 0 = 0
 * 1 = 1
 * 2 = 2
 * 3 = 3
 * 4 = 4
 * 5 = 5
 * 6 = 6
 * 7 = 7
 * 8 = 8
 * 9 = 9
 * = 10
 * (0.1) = 11
 * (0.2) = 12
 * (0.3) = 13
 * (0.4) = 14
 * (0.5) = 15
 * (0.6) = 16
 * (0.7) = 17
 * (0.8) = 18
 * (0.9) = 19
 * (1.1) = 20
 * (1.1, 0.1) = 21
 * (1.1, 0.2) = 22
 * (1.1, 0.3) = 23
 * (1.1, 0.4) = 24
 * (1.1, 0.5) = 25
 * (1.1, 0.6) = 26
 * (1.1, 0.7) = 27
 * (1.1, 0.8) = 28
 * (1.1, 0.9) = 29
 * (1.1, 0.) = 30
 * (1.1, 0.(0.1)) = 31
 * (1.1, 0.(0.2)) = 32
 * (1.1, 0.(0.3)) = 33
 * (1.1, 0.(0.4)) = 34
 * (1.1, 0.(0.5)) = 35
 * (1.1, 0.(0.6)) = 36
 * (1.1, 0.(0.7)) = 37
 * (1.1, 0.(0.8)) = 38
 * (1.1, 0.(0.9)) = 39
 * (1.2) = 40
 * (1.2, 0.1) = 41
 * (1.2, 0.2) = 42
 * (1.2, 0.3) = 43
 * (1.2, 0.4) = 44
 * (1.2, 0.5) = 45
 * (1.2, 0.6) = 46
 * (1.2, 0.7) = 47
 * (1.2, 0.8) = 48
 * (1.2, 0.9) = 49
 * (1.2, 0.) = 50
 * (1.2, 0.(0.1)) = 51
 * (1.2, 0.(0.2)) = 52
 * (1.2, 0.(0.3)) = 53
 * (1.2, 0.(0.4)) = 54
 * (1.2, 0.(0.5)) = 55
 * (1.2, 0.(0.6)) = 56
 * (1.2, 0.(0.7)) = 57
 * (1.2, 0.(0.8)) = 58
 * (1.2, 0.(0.9)) = 59
 * (1.2, 0.(1.1)) = 60
 * (1.2, 0.(1.1, 0.1)) = 61
 * (1.2, 0.(1.1, 0.2)) = 62
 * (1.2, 0.(1.1, 0.3)) = 63
 * (1.2, 0.(1.1, 0.4)) = 64
 * (1.2, 0.(1.1, 0.5)) = 65
 * (1.2, 0.(1.1, 0.6)) = 66
 * (1.2, 0.(1.1, 0.7)) = 67
 * (1.2, 0.(1.1, 0.8)) = 68
 * (1.2, 0.(1.1, 0.9)) = 69
 * (1.2, 0.(1.1, 0.)) = 70
 * (1.2, 0.(1.1, 0.(0.1))) = 71
 * (1.2, 0.(1.1, 0.(0.2))) = 72
 * (1.2, 0.(1.1, 0.(0.3))) = 73
 * (1.2, 0.(1.1, 0.(0.4))) = 74
 * (1.2, 0.(1.1, 0.(0.5))) = 75
 * (1.2, 0.(1.1, 0.(0.6))) = 76
 * (1.2, 0.(1.1, 0.(0.7))) = 77
 * (1.2, 0.(1.1, 0.(0.8))) = 78
 * (1.2, 0.(1.1, 0.(0.9))) = 79
 * (1.3) = 80
 * (1.4) = 160
 * (1.5) = 320
 * (1.6) = 640
 * (1.7) = 1280
 * (1.8) = 2560
 * (1.9) = 5120
 * (2.1) = 10240
 * (2.1, 0.1) = 10241
 * (2.1, 1.1) = 20480
 * (2.1, 1.1, 0.1) = 20481
 * (2.1, 1.2) = 40960
 * (2.1, 1.3) = 81920
 * (2.1, 1.4) = 163840
 * (2.1, 1.5) = 327680
 * (2.1, 1.6) = 655360
 * (2.1, 1.7) = 1310720
 * (2.1, 1.8) = 2621440
 * (2.1, 1.9) = 5242880
 * (2.1, 1.) = 10485760
 * (2.2) = 10 * 210250
 * (2.3) = 10 * 210250 + 10 * 2 10250
 * (2.4) = 10 * 210250 + 10 * 2 10250 + 210250 + 10 * 2 10250
 * (2.5) = 10 * 210250 + 10 * 2 10250 + 210250 + 10 * 2 10250 + 10 * 210250 + 10 * 2 10250 + 210250 + 10 * 2 10250

Modified FGH
Disadventage of this notation is that we used to use hundreds, thousands, millions, bilions, etc. rather than such numbers as 10240.

To make the notation more "decimal" we need to modify FGH:
 * f0(n) = n + 1
 * fα + 1(n) = fα(base - 1)*n(n)
 * fα(n) = fα[(base - 1)*n](n) forr limit α

For base = 10
 * f0(n) = n + 1
 * fα + 1(n) = fα9n(n)
 * fα(n) = fα[9n](n) forr limit α

So
 * f0(n) = n + 1
 * f1(n) = n + 9n = n*10
 * f2(n) = n*109n

Also we need to modify rules
 * otn(α) < (X)
 * n < (X)

New rules:
 * otn(α) < (base - 1)*(X)
 * n < (base - 1)*(X)

For base = 10
 * otn(α) < 9*(X)
 * n < 9*(X)

Examples

 * 0 = 0
 * 1 = 1
 * 2 = 2
 * 3 = 3
 * 4 = 4
 * 5 = 5
 * 6 = 6
 * 7 = 7
 * 8 = 8
 * 9 = 9
 * = 10
 * (0.1) = 11
 * (0.2) = 12
 * (0.3) = 13
 * (0.4) = 14
 * (0.5) = 15
 * (0.6) = 16
 * (0.7) = 17
 * (0.8) = 18
 * (0.9) = 19
 * (0.) = 20
 * (0.(0.1)) = 21
 * (0.(0.2)) = 22
 * (0.(0.3)) = 23
 * (0.(0.4)) = 24
 * (0.(0.5)) = 25
 * (0.(0.6)) = 26
 * (0.(0.7)) = 27
 * (0.(0.8)) = 28
 * (0.(0.9)) = 29
 * (0.(0.)) = 30
 * (0.(0.(0.1))) = 31
 * (0.(0.(0.2))) = 32
 * (0.(0.(0.3))) = 33
 * (0.(0.(0.4))) = 34
 * (0.(0.(0.5))) = 35
 * (0.(0.(0.6))) = 36
 * (0.(0.(0.7))) = 37
 * (0.(0.(0.8))) = 38
 * (0.(0.(0.9))) = 39
 * (0.(0.(0.))) = 40
 * (0.(0.(0.(0.1)))) = 41
 * (0.(0.(0.(0.2)))) = 42
 * (0.(0.(0.(0.3)))) = 43
 * (0.(0.(0.(0.4)))) = 44
 * (0.(0.(0.(0.5)))) = 45
 * (0.(0.(0.(0.6)))) = 46
 * (0.(0.(0.(0.7)))) = 47
 * (0.(0.(0.(0.8)))) = 48
 * (0.(0.(0.(0.9)))) = 49
 * (0.(0.(0.(0.)))) = 50
 * (0.(0.(0.(0.(0.1))))) = 51
 * (0.(0.(0.(0.(0.2))))) = 52
 * (0.(0.(0.(0.(0.3))))) = 53
 * (0.(0.(0.(0.(0.4))))) = 54
 * (0.(0.(0.(0.(0.5))))) = 55
 * (0.(0.(0.(0.(0.6))))) = 56
 * (0.(0.(0.(0.(0.7))))) = 57
 * (0.(0.(0.(0.(0.8))))) = 58
 * (0.(0.(0.(0.(0.9))))) = 59
 * (0.(0.(0.(0.(0.))))) = 60
 * (0.(0.(0.(0.(0.(0.1)))))) = 61
 * (0.(0.(0.(0.(0.(0.2)))))) = 62
 * (0.(0.(0.(0.(0.(0.3)))))) = 63
 * (0.(0.(0.(0.(0.(0.4)))))) = 64
 * (0.(0.(0.(0.(0.(0.5)))))) = 65
 * (0.(0.(0.(0.(0.(0.6)))))) = 66
 * (0.(0.(0.(0.(0.(0.7)))))) = 67
 * (0.(0.(0.(0.(0.(0.8)))))) = 68
 * (0.(0.(0.(0.(0.(0.9)))))) = 69
 * (0.(0.(0.(0.(0.(0.)))))) = 70
 * (0.(0.(0.(0.(0.(0.(0.1))))))) = 71
 * (0.(0.(0.(0.(0.(0.(0.2))))))) = 72
 * (0.(0.(0.(0.(0.(0.(0.3))))))) = 73
 * (0.(0.(0.(0.(0.(0.(0.4))))))) = 74
 * (0.(0.(0.(0.(0.(0.(0.5))))))) = 75
 * (0.(0.(0.(0.(0.(0.(0.6))))))) = 76
 * (0.(0.(0.(0.(0.(0.(0.7))))))) = 77
 * (0.(0.(0.(0.(0.(0.(0.8))))))) = 78
 * (0.(0.(0.(0.(0.(0.(0.9))))))) = 79
 * (0.(0.(0.(0.(0.(0.(0.))))))) = 80
 * (0.(0.(0.(0.(0.(0.(0.(0.1)))))))) = 81
 * (0.(0.(0.(0.(0.(0.(0.(0.2)))))))) = 82
 * (0.(0.(0.(0.(0.(0.(0.(0.3)))))))) = 83
 * (0.(0.(0.(0.(0.(0.(0.(0.4)))))))) = 84
 * (0.(0.(0.(0.(0.(0.(0.(0.5)))))))) = 85
 * (0.(0.(0.(0.(0.(0.(0.(0.6)))))))) = 86
 * (0.(0.(0.(0.(0.(0.(0.(0.7)))))))) = 87
 * (0.(0.(0.(0.(0.(0.(0.(0.8)))))))) = 88
 * (0.(0.(0.(0.(0.(0.(0.(0.9)))))))) = 89
 * (0.(0.(0.(0.(0.(0.(0.(0.)))))))) = 90
 * (0.(0.(0.(0.(0.(0.(0.(0.(0.1))))))))) = 91
 * (0.(0.(0.(0.(0.(0.(0.(0.(0.2))))))))) = 92
 * (0.(0.(0.(0.(0.(0.(0.(0.(0.3))))))))) = 93
 * (0.(0.(0.(0.(0.(0.(0.(0.(0.4))))))))) = 94
 * (0.(0.(0.(0.(0.(0.(0.(0.(0.5))))))))) = 95
 * (0.(0.(0.(0.(0.(0.(0.(0.(0.6))))))))) = 96
 * (0.(0.(0.(0.(0.(0.(0.(0.(0.7))))))))) = 97
 * (0.(0.(0.(0.(0.(0.(0.(0.(0.8))))))))) = 98
 * (0.(0.(0.(0.(0.(0.(0.(0.(0.9))))))))) = 99
 * (1.1) = 100
 * (1.1, 0.1) = 101
 * (1.1, 0.2) = 102
 * (1.1, 0.3) = 103
 * (1.1, 0.4) = 104
 * (1.1, 0.5) = 105
 * (1.1, 0.6) = 106
 * (1.1, 0.7) = 107
 * (1.1, 0.8) = 108
 * (1.1, 0.9) = 109
 * (1.1, 0.) = 110
 * (1.1, 0.(0.1)) = 111
 * (1.1, 0.(0.2)) = 112
 * (1.1, 0.(0.3)) = 113
 * (1.1, 0.(0.4)) = 114
 * (1.1, 0.(0.5)) = 115
 * (1.1, 0.(0.6)) = 116
 * (1.1, 0.(0.7)) = 117
 * (1.1, 0.(0.8)) = 118
 * (1.1, 0.(0.9)) = 119
 * (1.1, 0.(0.)) = 120
 * (1.1, 0.(0.(0.1))) = 121
 * (1.1, 0.(0.(0.2))) = 122
 * (1.1, 0.(0.(0.3))) = 123
 * (1.1, 0.(0.(0.4))) = 124
 * (1.1, 0.(0.(0.5))) = 125
 * (1.1, 0.(1.1)) = 200
 * (1.1, 0.(1.1, 0.1)) = 201
 * (1.1, 0.(1.1, 0.2)) = 202
 * (1.1, 0.(1.1, 0.3)) = 203
 * (1.1, 0.(1.1, 0.4)) = 204
 * (1.1, 0.(1.1, 0.5)) = 205
 * (1.1, 0.(1.1, 0.6)) = 206
 * (1.1, 0.(1.1, 0.7)) = 207
 * (1.1, 0.(1.1, 0.8)) = 208
 * (1.1, 0.(1.1, 0.9)) = 209
 * (1.1, 0.(1.1, 0.)) = 210
 * (1.1, 0.(1.1, 0.(1.1))) = 300
 * (1.1, 0.(1.1, 0.(1.1, 0.(1.1)))) = 400
 * (1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1))))) = 500
 * (1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1)))))) = 600
 * (1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1))))))) = 700
 * (1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1)))))))) = 800
 * (1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1, 0.(1.1))))))))) = 900
 * (1.2) = 1000
 * (1.3) = 10000
 * (1.4) = 100000
 * (1.5) = 1000000
 * (1.6) = 10000000
 * (1.7) = 100000000
 * (1.8) = 1000000000
 * (1.9) = 10000000000
 * (1.) = 100000000000
 * (1.(0.1)) = 1000000000000
 * (1.(0.2)) = 10000000000000
 * (1.(0.3)) = 100000000000000
 * (1.(0.4)) = 1000000000000000
 * (1.(0.5)) = 10000000000000000
 * (1.(0.6)) = 100000000000000000
 * (1.(0.7)) = 1000000000000000000
 * (1.(0.8)) = 10000000000000000000
 * (1.(0.9)) = 100000000000000000000
 * (1.(0.)) = 1000000000000000000000
 * (1.(0.(0.9))) = 1030
 * (1.(0.(0.(0.9)))) = 1040
 * (1.(0.(0.(0.(0.9))))) = 1050
 * (1.(0.(0.(0.(0.(0.9)))))) = 1060
 * (1.(0.(0.(0.(0.(0.(0.9))))))) = 1070
 * (1.(0.(0.(0.(0.(0.(0.(0.9)))))))) = 1080
 * (1.(0.(0.(0.(0.(0.(0.(0.(0.9))))))))) = 1090
 * (2.1) = 1091
 * (2.1, 0.1) = 1091 + 1
 * (2.1, 0.2) = 1091 + 2
 * (2.1, 0.3) = 1091 + 3
 * (2.1, 1.1) = 1092
 * (2.1, 1.1, 0.1) = 1092 + 1
 * (2.1, 1.2) = 1093
 * (2.1, 1.3) = 1094
 * (2.1, 1.4) = 1095
 * (2.1, 1.5) = 1096
 * (2.1, 1.6) = 1097
 * (2.1, 1.7) = 1098
 * (2.1, 1.8) = 1099
 * (2.1, 1.9) = 10100
 * (2.1, 1.) = 10101
 * (2.2) = 1091 + 9*10 91
 * (2.3) = 1091 + 9*10 91 + 9*1091 + 9*10 91
 * (2.4) = 1091 + 9*10 91 + 9*1091 + 9*10 91 + 9*1091 + 9*10 91 + 9*1091 + 9*10 91
 * (2.5) = 1091 + 9*10 91 + 9*1091 + 9*10 91 + 9*1091 + 9*10 91 + 9*1091 + 9*10 91 + 9*1091 + 9*10 91 + 9*1091 + 9*10 91 + 9*1091 + 9*10 91 + 9*1091 + 9*10 91
 * (2.6)
 * (2.7)
 * (2.8)
 * (2.9)
 * (2.)
 * (2.(0.1))
 * (2.(0.2))
 * (2.(0.3))
 * (2.(0.4))
 * (2.(0.5))
 * (2.(0.6))
 * (2.(0.7))
 * (2.(0.8))
 * (2.(0.9))
 * (2.(0.))
 * (2.(0.(0.9)))
 * (2.(0.(0.(0.9))))
 * (2.(0.(0.(0.(0.9)))))
 * (2.(0.(0.(0.(0.(0.9))))))
 * (2.(0.(0.(0.(0.(0.(0.9)))))))
 * (2.(0.(0.(0.(0.(0.(0.(0.9))))))))
 * (2.(0.(0.(0.(0.(0.(0.(0.(0.9)))))))))
 * (3.1)
 * (3.2)
 * (3.3)
 * (3.4)
 * (3.5)
 * (3.6)
 * (3.7)
 * (3.8)
 * (3.9)
 * (3.)
 * (3.(0.1))
 * (3.(0.2))
 * (3.(0.3))
 * (3.(0.4))
 * (3.(0.5))
 * (3.(0.6))
 * (3.(0.7))
 * (3.(0.8))
 * (3.(0.9))
 * (3.(0.))
 * (3.(0.(0.9)))
 * (3.(0.(0.(0.9))))
 * (3.(0.(0.(0.(0.9)))))
 * (3.(0.(0.(0.(0.(0.9))))))
 * (3.(0.(0.(0.(0.(0.(0.9)))))))
 * (3.(0.(0.(0.(0.(0.(0.(0.9))))))))
 * (3.(0.(0.(0.(0.(0.(0.(0.(0.9)))))))))
 * (4.1)
 * (5.1)
 * (6.1)
 * (7.1)
 * (8.1)
 * (9.1)
 * (.1)
 * ((0.1).1)
 * ((0.2).1)
 * ((0.3).1)
 * ((0.4).1)
 * ((0.5).1)
 * ((0.6).1)
 * ((0.7).1)
 * ((0.8).1)
 * ((0.9).1)
 * ((0.).1)
 * ((0.(0.9)).1)
 * ((0.(0.(0.9))).1)
 * ((0.(0.(0.(0.9)))).1)
 * ((0.(0.(0.(0.(0.9))))).1)
 * ((0.(0.(0.(0.(0.(0.9)))))).1)
 * ((0.(0.(0.(0.(0.(0.(0.9))))))).1)
 * ((0.(0.(0.(0.(0.(0.(0.(0.9)))))))).1)
 * (ω.1)

n=0
0 in α.n pair (that is α.0) do not change anything, so such a pair may be omitted, for example
 * (2.1) = (2.1, 1.0) = (2.1, 0.0) = (2.1, 1.0, 0.0) = (3.0, 2.1) = (3.0, 2.1, 1.0, 0.0)

I think that it is analogue of zeros in decimal numbers:
 * 3 = 03 = 003 = 3.0 = 3.00 = 0003.000

Approximations
In googology we need approximations, since exact value of a large number expressed using some notation may be physically impossible to write down, because it may be too large.

For example, if we do arithmetical operations with large numbers and if input expression is not very large in used notation, output expression can be too large to write down (or store in computer memory). So we need to find approximate values with any required accuracy.

Here "accuracy" is more likely size of expression than accuracy in strict sence, since the larger the number, the lower the accuracy. Very different numbers mean very different degrees of accuracy.

In decimal numbers we can use "...", for example,
 * 3 ≤ 3.0... < 3.01

Here zeros can be useful, since they can express accuracy:
 * 3 ≤ 3.00... < 3.001
 * 3 ≤ 3.000... < 3.0001
 * 3 ≤ 3.0000... < 3.00001

We also can use "..." and zeros, for example
 * (2.1) = 1091 ≤ (2.1, ...) < (2.2) = 1091 + 9*10 91
 * (2.1) = 1091 ≤ (2.1, 1.0, ...) < (2.1, 1.1) = 1092

So, despite exact values (2.1) and (2.1, 1.0) are the same, approximate values (2.1, ...) and (2.1, 1.0, ...) differ in accuracy.

We use integer numbers and numbers with floating point of different sizes, for example, 8-bit, 16-bit, 32-bit, 64-bit. Similarly we can also use strings of fixed size for this notation and compute large numbers with this "accuracy". (If expression is less than this fixed size, then we can fill rest of string with zeros).

For ordinals we can use my 3-symbol notation (for example, with "[", "]", "M"). (The ordinal notation can be modified to incorporate designations of large numbers. But I currently do not know what to do with such things as ω↑↑n for very large n, maybe use some designation for function iteration..?). I think that we can omit ".", since it may be always clear when an ordinal ends and a natural number begins. So, we can use 16 symbols for this notation ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "[", "]", "M", "(", ")", ",") and store 2 symbols in 1 byte.

Or we can use binary version of this notation (with base = 2 and "original" FGH) and use 8 symbols ("0", "1", "[", "]", "M", "(", ")", ","), storing 1 symbol in 3 bits.