User blog comment:Planetn9ne/What do you need to create an OCF?/@comment-32213734-20181124170530

As for me, OCFs are ways to write out array of numbers as single larger number. Some googological notations (for example, BEAF) use arrays of variables, and such arrays can be written as single, much larger (maybe, infinite) number.

Let you want to create some fast-growing function, which input and output are natural numbers. You define But this function is not so fast-growing. How to make it more powerful? Add another variable! So, you define It becomes more powerful. Then add one more variable then even more variables So, you get array of natural numbers as input. How to go further? Add second dimension! That is make your input array 2D. (Since it is difficult to write out two-dimentional array, let ";" will be separator between "rows" of the array). Then similar way you make your array 3D, then 4D, 5D, then 2-trimensional, 3-trimensional, 2-quadromensional, 2-pentamensional, ...
 * f(n) = 10 + n, where n is natural number
 * f(1, 0) = f(10) = 20
 * f(1, 1) = f(f(1, 0)) = f(20) = 30
 * f(1, 2) = f(f(1, 1)) = f(30) = 40
 * f(1, 3) = f(f(1, 2)) = f(40) = 50
 * f(2, 0) = f(1, 10) = 120
 * f(2, 1) = f(1, f(2, 0)) = f(1, 120) = 1230
 * f(3, 0) = f(2, 10)
 * f(4, 0) = f(3, 10)
 * f(5, 0) = f(4, 10)
 * f(4, 0) = f(3, 10)
 * f(5, 0) = f(4, 10)
 * f(1, 0, 0) = f(10, 0)
 * f(1, 0, 1) = f(f(1, 0, 0), 0)
 * f(1, 0, 2) = f(f(1, 0, 1), 0)
 * f(1, 1, 0) = f(1, 0, 10)
 * f(1, 1, 1) = f(1, 0, f(1, 1, 0))
 * f(1, 1, 2) = f(1, 0, f(1, 1, 1))
 * f(1, 2, 0) = f(1, 1, 10)
 * f(2, 0, 0) = f(1, 10, 0)
 * f(1, 2, 0) = f(1, 1, 10)
 * f(2, 0, 0) = f(1, 10, 0)
 * f(1, 0, 0, 0) = f(10, 0, 0)
 * f(1, 0, 0, 0, 0) = f(10, 0, 0, 0)
 * f(1;) = f(1,  ) = f(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 * f(1; 1) = f(1, )
 * f(1; 2) = f(1, )
 * f(1; 1, 0) = f(1; 10)
 * f(1; 1, 1) = f(1; f(1; 1, 0))
 * f(1; 2, 0) = f(1; 1, 10)
 * f(1; 1, 0, 0) = f(1; 10, 0)
 * f(2;) = f(1; 1,  ) = f(1; 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
 * f(1, 0;) = f(10;)
 * f(1, 1;) = f(f(1, 0;);)
 * f(1, 0, 0;) = f(10, 0;)
 * f(1;;) = f(1,  ;) = f(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0;)
 * f(1;;;) = f(1,  ;;) = f(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0;;)

Arrays and rules become too complex. But you can replace all array with one ordinal. Choose an ordinal larger than all possible values of the function's variables. Since all variables here are natural numbers, you can choose least infinite ordinal ω. Now you can replace all array with one ordinal, for example, this way:

1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5 →

ω14 + ω13 + ω12 + ω112 + ω102 + ω92 + ω83 + ω73 + ω63 + ω54 + ω44 + ω34 + ω25 + ω5 + 5

Now you can describe Generally, you replace
 * any 1D array with one ordinal less than ωω,
 * any 2D array with one ordinal less than ωω 2 ,
 * any 3D array with one ordinal less than ωω 3 ,
 * any 1-trimensional array with one ordinal less than ωω ω ,
 * any 2-trimensional array with one ordinal less than ωω ω 2 ,
 * any 1-quadromensional array with one ordinal less than ωω ω ω ,


 * f() → f(α)

where α is countable or finite ordinal. And this is OCF! It is called "collapsed", since its input is much larger than output in most cases (α can be infinite, but f(α) is allways finite. However, if α is finite, then f(α) > α).

Also, you do the same with BEAF, but there is a problem - BEAF contains infinite many "invisible" ones, which is not ok for ordinals, since Cantor normal form of an ordinal can contain only finite number of non-zero terms. But we can reduce all elements of BEAF array by one. Also, we should reverse BEAF array, since its "stronger" elements are on right. Example:


 * {1, 2, 3, 4, 5}

Array:


 * 1, 2, 3, 4, 5

Reduce by one:


 * 0, 1, 2, 3, 4

Reverse:


 * 4, 3, 2, 1, 0

Replace with ordinal:


 * ω44 + ω33 + ω22 + ω

So, we get BEAF written using OCF!


 * {1, 2, 3, 4, 5} → {ω44 + ω33 + ω22 + ω}OCF

Next step: write countable ordinals as fast-growing function f1(x), and now f1(x) is countable ordinal, and x is countable or finite ordinal. You can do similar thing, that is add more variables: then more dimensions of variables, etc. So, you get something like Veblen function.
 * f1(1, 0)
 * f1(1, 0, 0)

Then you can replace array of ordinals with one much larger ordinal. You can choose some large ordinal (since all ordinals of the array are finite or countable, you can choose least uncountable ordinal Ω), and replace array with one ordinal, for example, this way:

5, ω, 0, ωω, ω + 1, ε0, ωω ω →

Ω65 + Ω5ω + Ω3ωω + Ω2(ω + 1) + Ωε0 + ωω ω

So, you replace


 * f1() → f1(α)

where α is ordinal cardinality no larger than Ω.

Then ordinals of cardinality no larger than Ω you can designate using function


 * f2()

and replace it with OCF


 * f2(α)

where α is ordinal cardinality no larger than Ω2.

Then you use similar way larger cardinalities Ω3, Ω4, Ω5, ... Ωω, Ωω + 1, Ωε 0, ... ΩΩ, ΩΩ 2 , ..., ΩΩ Ω , ΩΩ Ω Ω , ... I, etc.

You can get very large natural numbers such as


 * f(f1(f2(f3(f4(f5(f6(f7(f8(f9(f10(0)))))))))))

and larger.