**REPLACED**

This blog has been replaced. A new Alpha Function blog should be referred to instead. The blog can be found here.

**(old) Alpha Function**

The Alpha Function is a relatively simple function with only one parameter: \(\alpha(r)\) where r is any real number. It is derived from the Strong D Function with a variable number of input parameters. I have included Visual Basic code at the end of this blog to define the Alpha function exactly.

**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(1)\) for example can be used to reference the number 2. Therefore 1 is the Alpha Index for the number 2. Alpha needs to reference big numbers very quickly to be useful, therefore it uses the Strong D Function for this purpose. Alpha should also be strictly hierarchical and for every number a > b: a must reference larger numbers so that \(\alpha(a) >> \alpha(b)\) in all cases. The function is finely grained. It accepts a real number input and offers some finesse to locate large big numbers. Here is an example:

\(\alpha(4.141) >>\) Graham's number \(>> \alpha(4.140)\)

**Examples of Alpha Notation numbers**

\(\alpha(0) = D() = 0\)

\(\alpha(1) = D(0) = 1\)

\(\alpha(1.5) = D(1) = 2\)

\(\alpha(2) = D(1,0) = 3\)

\(\alpha(2.2) = D(1,2) = 5\)

\(\alpha(3.3) = D(3,3) = 1697\)

\(\alpha(3.5) = D(4,0) >>\) Googol

\(\alpha(3.6) = D(4,1) >> f_{\omega}(3)\)

\(\alpha(3.7) = D(4,2) >>\) Googolplex

\(\alpha(4.001) = D(1,0,1) >> g_2\) where \(g_{64}\) is Graham's number

\(\alpha(4.141) >> \alpha(4.140138409) = D(1,9,9) >>\) Graham's number

\(\alpha(4.2501) = D(2,0,0) >> f_{\omega+1}^2(3)\)

\(\alpha(4.2509) = D(2,0,1) >> f_{\omega+2}(3)\)

\(\alpha(4.501) = D(3,0,1) >> f_{\omega.2}(3)\)

\(\alpha(TBA) >> f_{\omega^2}(3)\)

**Towards Epsilon_0**

\(\alpha(4.752) = D(4,0,2) >> D(3,D(4,0,1),D(4,0,1)) >>\) to be investigated

\(\alpha(5) = D(5,0,0) = D(4,D(4,5,5),D(4,5,5)) >>\) to be investigated

\(\alpha(6) = D(9,0,0) = D(8,D(8,9,9),D(8,9,9)) >>\) to be investigated

\(\alpha(TBA) >> f_{\omega^{\omega}}(3)\)

\(\alpha(TBA) >> f_{\omega^{\omega.2}}(3)\)

\(\alpha(TBA) >> f_{\omega^{\omega^2}}(3)\)

\(\alpha(8) = D(1,0,0,0) = D(D(1,1,1),D(1,1,1),D(1,1,1))\)

\(>> D(f_{\omega}(f_{\omega+1}(3),f_{\omega}(f_{\omega+1}(3),f_{\omega}(f_{\omega+1}(3))\)

\(\alpha(10) = D(17,0,0,0) = D(16, D(16,17,17,17), D(16,17,17,17), D(16,17,17,17)) >>\) to be investigated

\(\alpha(14.9) = D(56,13107,26214,52430) >>\) to be investigated

\(\alpha(15) = D(57,0,0,0) >>\) to be investigated

\(\alpha(15.1) = D(57,52429,39322,13106) >>\) to be investigated

**To Be Investigated - Tree(3)**

I hope to calculate the Alpha index for Tree(3) next. It will be interesting to see where this lands.

**Comments and Questions**

I am new to Googology but look forward to comments and questions and I hope to learn a lot by contributing.

B1mb0w.

**Alpha Function Definition**

The following is VBA visual basic code and will run as a macro in Microsoft Excel. This function creates a string literal a Strong D Function equal to the Alpha function with any Real number input. The function does not attempt to evaluate the Strong D Function and the run time is therefore very fast.

Function Alpha(r As Double) As String Dim d As Double, e As Double, i As Integer, j As Integer, k As Integer d = Int(r) i = 0 While d >= 1 d = Int(d) / 2 If d >= 1 Then i = i + 1 Wend e = 2 For j = 1 To i e = 2 ^ e Next j Alpha = "D(" If r >= 0.5 Then d = (r - 2 ^ i) * 2 ^ i j = Int(d) Alpha = Alpha & (j + 1) d = d - j For j = 1 To i d = d * (e + 1) Alpha = Alpha & "," & Int(d) d = d - Int(d) Next j End If Alpha = Alpha & ")" End Function

**How the Alpha Function Works**

The Alpha Function and the VBA code is only used to generate D() strings with multiple number of input variables. The function needs to be refined and will be tweaked over time. There are three parts to the code.

**a.** The integer part of r (called d) is tested and is used to calculate the number of input variables (called i) that will be allowed. The maths to do this is \(2^{i-1} <= d\). You can see that from \(\alpha(1)\) it starts generating D(n) strings, from \(\alpha(2)\) we get D(m,n) strings, from \(\alpha(4)\) we get D(l,m,n) strings, and so on.

**b.** The value of the first input parameter is calculated in a roundabout way, so that the only values that will be allowed are from 1 to \(2^{i}\) . The code to do this was painful and is not elegant. When the function is tweaked, I will try to simplify how this is done.

The *only* reason this number is restricted is to avoid Alpha index numbers getting out of sequence when we get to D(4) >> D(1,0) and D(5,0) >> D(1,0,0) so the code avoids using 5 for 2 input variable D functions and starts to generate 3 input variable D functions instead.

Interestingly will never happen again for 4 (or greater) input variable D functions, because D(1,0,0,0) = D(D(1,1,1),D(1,1,1),D(1,1,1)) and there is no computer that could evaluate the code to calculate D(1,1,1).

**c.** Finally, the remaining input variables are generated using the full real value of the Alpha input. The code is restricted to only generating strings up to D(2) and D(4,4) for the reason explained above. After this there is no need to try to restrict the values of these inputs.

The variable called e is used to calculate the number 2^^(i+1). Note that i=0 gives e=2, i=1 gives e=4, an then it grows quickly, i=2 gives e=16 and so on.

The actual value of each input parameter is based on multiplying r by e. The integer part of the result is taken for the 2nd input parameter. The decimal part of the result is then multiplied by e again to generate the next input parameter. The same loop works for all the input parameters required.

This part should be tweaked to allow e to grow much faster. I don't plan to change the code yet because even with these smaller e numbers, the VBA code basically crashes after r > 16.