User blog:B1mb0w/Alpha 0 Ruler Function

\(\alpha_0\) Ruler Function
The Alpha Function can generate every finite integer up to a very large number. The Alpha Function has a growth rate faster than \(f_{LVO}(n)\) for any n.

The Alpha Function has one parameter: \(\alpha(r)\) where r is any real number. The real number is manipulated by Sequence Generator Code (see references) to create a finite sequence of finite integers. The sequences can be translated to represent every unique finite integer (up to the size of \(f_{LVO}(n)\) for any n).

See the references section for Granularity Examples of the Alpha Version 8 blog that illustrate how finely tuned the functions are to access any and every finite integer (up to the size of \(f_{LVO}(n)\) for any n).

What is the Alpha Function
My motivation to create this function was to develop a finely grained number notation system for really big numbers. \(\alpha(2)\) for example can be used to reference the number 8. Therefore 2 is the Alpha Index for the number 8. Alpha needs to reference big numbers very quickly to be useful, therefore it uses The S Function for this purpose. Alpha should also be monotonically increasing and every input real \(a > b\), results in a larger output number, where \(\alpha(a) >= \alpha(b)\) in all cases. The function is finely grained. It accepts a real number input and depending upon the precision of the real number, it can locate any and every big number up to the size of \(f_{LVO}(v)\) for any n.

The Alpha Function therefore has a growth rate greater than the Large Veblen Ordinal (LVO).

High Level Description
The Alpha Function is 'calibrated' to accept real number inputs up to 10,000 and generate unique S function outputs representing any and every big number up to the size of \(f_{LVO}(v)\) for any n.

Refer to my Alpha Version 8 blog for more information.

Some Calculations
Refer to my Version 8 blog for more examples:

\(\alpha(0.00) = S(0,0,0) = 0\)

\(\alpha(1.00) = S(1,0,0) = 1\)

\(\alpha(2.00) = S(2,T(0),1) = f_2(2) = 8\)

\(\alpha(e) = \alpha(2.71828182845905) = S(S(2,T(0),1),0,S(2,0,1)) = 11\)

\(\alpha(3.00) = S(S(2,T(0),1),1,1) = f_1(f_{\omega}(2)) = 16\)

\(\alpha(\pi) = \alpha(3.14159265358979) = S(S(2,T(0),1),1,1) + S(2,T(0),1) + 1\)

\(= S(8,1,1) + 8 + 1 = 25\)

\(\alpha(4.00) = S(2,T(0) + 1,1) = f_{\omega + 1}(2) = 2048\)

\(\alpha(4.407) = S(S(2,T(0) + 1,1),1,9) = 2048.2^9 = 1048576 >>\) One Million

\(\alpha(4.4300604) = S(S(2,T(0) + 1,1),1,S(8,1,5) + S(8,1,3) + 2)\)

\(= 2048.2^{8.2^5 + 8.2^3 + 2} = 2048.2^{256 + 64 + 2} = 17.10^{99} >>\) Googol

WORK IN PROGRESS

\(\alpha(\) TBA \ = f_2^4(4) = f_3(4) >>\) Googolplex

\(\alpha(\) TBA \ = f_3^3(4) >> g_1\) where \(g_{64} = G\) is Graham's number

\(\alpha(5.7059746) = S(S(2,T(0) + 1,1),T(0),S(8,1,2) + S(8,1,1) + 8 + 4 + 3)\)

\(= S(S(2,T(0) + 1,1),T(0),32 + 16 + 15) = f_{\omega}^{63}(f_{\omega + 1}(2))\)

\(= f_{\omega}^{63}(f_{\omega}(8)) = f_{\omega}^{64}(8) >> f_{\omega}^{64}(4) >> g_{64} = G\) is Graham's number

\(\alpha(10) = S(2,T(1) + 1,1) = S(2,T(1),2) = S(S(2,T(1),1),T(1),1)\)

\(= S(S(2,T(1),1),S(T(0),T(0),1),1)\)

\(= S(S(2,T(1),1),S(T(0),2,1),1) = f_{\varphi(\omega,0)}^2(2) >> f_{\varphi(\omega,0)}(3)\)

\(\alpha(10000^{.5}) = \alpha(31.6227766016838) = f_{svo}^2(2) >> f_{svo}(3)\)

\(\alpha(100) = S(2,T(T(1)) + 1,1) = f_{LVO}^2(2) >> f_{LVO}(3) >>\) TREE(3)

\(\alpha(10000) = S(2,T^{\omega}(0),1)\) by definition

tree and TREE Functions
The Alpha function grows faster than \(f_{LVO}(n)\) for any n. This means it is faster than the TREE function.

Refer to my blogs on The S Function and Comparison Table of Ordinal Collapsing Functions for more information.

Ruler Functions
I have started work on a set of Ruler Functions based on the Alpha function that will be useful to measure the size of very large numbers.

A rough sketch of how this will look is:

\(\alpha_0(100) = \alpha(31.6) >> f_{svo}(3)\) approximately

\(\alpha_1(100) = \alpha(5.7059746) = f_{\omega + 1}(64) >> g_{64} = G\) is Graham's number

\(\alpha_2(100) = \alpha(\) TBA \ = f_3(4) >>\) Googolplex

\(\alpha_3(100) = \alpha(4.4300604) = f_1^{322}(f_{\omega + 1}(2)) >>\) Googol

These functions will be calibrated to align with some famous googology numbers, so that 100 on each ruler will equal one of these famous numbers (approximately).

The \(\alpha_3\) function is intended to be identical to Scientific Notation (in base 10), therefore the following will be true by definition:

\(\alpha_3(100) = 10^{100} =\) Googol

WORK IN PROGRESS

Sequence Generator Code
The Alpha Function uses Sequence Generator Code to create a finite sequence of finite integers that can be translated into a unique combination of Verben ordinals and FGH functions. See references section for more information.

Comments and Questions
Look forward to comments and questions.

Cheers B1mb0w.