10,818 Pages

## J Function Sandpit $$J_0$$

The J Function is a work in progress. This sandpit defines a function called $$J_0$$ which contains ideas that will be used in the final J Function. Click here for the J Function blog.

## Definition

$$J_0$$ uses an algorithm to generate ascending ordinal values based on the value of its input parameters. A simple illustration of the algorithm is the following expression:

$$J_0(n,n^n) = f_{\epsilon_0}(n)$$

The general $$J_0$$ function uses two input parameters n (an integer) and r (a real number). These are transformed by the algorithm to general an ordinal $$\mu$$ and a power m for the FGH function. The integer n is passed directly into the FGH function.

$$J_0(n,r) = f_{\mu}^{m}(n)$$ where n is an integer and r can be a real number

Program code of the algorithm is provided at the end of this blog. Note however, that values of $$r < n^n$$ will generate (almost any) ordinal $$\mu < \epsilon_0$$.

## Calculated Examples up to $$J_0(m,n)$$

$$J_0(0,0) = 0$$

$$J_0(1,0) = 1$$

$$J_0(1,1) = f_{\omega}(1) = f_{\epsilon_0}(1)$$

$$J_0(2,0.5) = f_{0}(2)$$

$$J_0(2,1) = f_{1}(2)$$

$$J_0(2,2) = f_{\omega}(2)$$

$$J_0(2,3) = f_{\omega + 1}(2)$$

$$J_0(2,4) = f_{\omega^{\omega}}(2) = f_{\epsilon_0}(2)$$

$$J_0(3,3.75) = f_{\omega + 1}^{2}(3) > f_{\omega + 1}^{2}(2) = f_{\omega + 2}(2) = f_{\omega.2}(2) = f_{\omega^2}(2) = f_{\omega^{\omega}}(2) = f_{\epsilon_0}(2)$$

$$J_0(3,4) = f_{\omega + 2}(3)$$

$$J_0(3,5) = f_{\omega.2}^{2}(3)$$

$$J_0(3,7) = f_{\omega^{2} + \omega + 2}^{2}(3)$$

$$J_0(3,9) = f_{\omega^{\omega}}(3)$$

$$J_0(3,12) = f_{\omega^{\omega + 2}}(3)$$

$$J_0(3,15) = f_{\omega^{\omega.2}.2 + 2}^{2}(3)$$

$$J_0(3,18) = f_{\omega^{\omega^{2}}}(3)$$

$$J_0(3,21) = f_{\omega^{\omega^{2} + \omega + 2}.2 + 2}^{2}(3)$$

$$J_0(3,27) = f_{\omega^{\omega^{\omega}}}(3) = f_{\epsilon_0}(3)$$

$$J_0(4,41) = f_{\omega^{\omega^{2}.2 + \omega.2 + 3}}(4) > f_{\omega^{\omega^{2}.2 + \omega.2 + 3}}(3) = f_{\omega^{\omega^{2}.2 + \omega.3}}(3) = f_{\omega^{\omega^2.2 + \omega^2}}(3) = f_{\omega^{\omega^2.3}}(3) = f_{\omega^{\omega^3}}(3) = f_{\omega^{\omega^{\omega}}}(3) = f_{\epsilon_0}(3)$$

$$J_0(4,42) = f_{\omega^{\omega^{2}.2 + \omega.3 + 2}}(4)$$

$$J_0(4,44) = f_{\omega^{\omega^{2}.3 + \omega}}(4)$$

$$J_0(4,48) = f_{\omega^{\omega^{3}}}(4)$$

$$J_0(4,52) = f_{\omega^{\omega^{3} + \omega^{2}.3}}(4)$$

$$J_0(4,60) = f_{\omega^{\omega^{3}.3 + \omega^{2}}}(4)$$

$$J_0(4,68) = f_{\omega^{\omega^{\omega}.3 + 1}}(4)$$

$$J_0(4,84) = f_{\omega^{\omega^{\omega + 3}.3 + \omega^{2}}}(4)$$

$$J_0(4,100) = f_{\omega^{\omega^{\omega.2 + 2}.3 + \omega}}(4)$$

$$J_0(4,132) = f_{\omega^{\omega^{\omega^{2} + 3}}}(4)$$

$$J_0(4,164) = f_{\omega^{\omega^{\omega^{2}.2 + \omega.2 + 3}}}(4)$$

$$J_0(4,196) = f_{\omega^{\omega^{\omega^{3} + \omega.3}}}(4)$$

$$J_0(4,228) = f_{\omega^{\omega^{\omega^{3}.2 + \omega^{2}.2 + \omega.3}}}(4)$$

$$J_0(4,244) = f_{\omega^{\omega^{\omega^{3}.3 + \omega^{2} + \omega.3}}}(4)$$

$$J_0(4,252) = f_{\omega^{\omega^{\omega^{3}.3 + \omega^{2}.3 + \omega}}}(4)$$

$$J_0(4,256) = f_{\omega^{\omega^{\omega^{\omega}}}}(4) = f_{\epsilon_0}(4)$$

WORK IN PROGRESS

## Some Observations

The examples above give some idea of how easy it is to fine-tune the inputs to generate any ordinal for FGH and for any value of n. The $$J_0$$ function however does not enforce an ascending sequence of results so that $$J_0(a) > J_0(b)$$ when $$a > b$$. This feature has been used in the latest examples of the $$\alpha$$ function in my other main blog that I am working on.

The $$J_0$$ function does not enforce this sequence and produces a broad range of results for different values of n (integer) and s (real) parameters. This flexibility may be useful to start exploring big numbers beyond $$f_{\epsilon_0}(n)$$. For example:

$$J_1(7.95) = J_0(3,27) = f_{\omega^{\omega^{\omega}}}(3) = f_{\epsilon_0}(3)$$

$$J_1(8) = J_0(4,27) = f_{\omega^{\omega.3} + 3}(4)$$

In between these two comparisons, we can explore what happens to $$J_0(3,27)$$ when we increase 27 but leave 3 unchanged.

$$J_0(3,27.1) = f_{\omega^{\omega^{\omega}}}^{2}(3) (= f_{\epsilon_0}^2(3)$$ to be defined)

$$J_0(3,27.15) = f_{\omega^{\omega^{\omega}} + 1}(3) (= f_{\epsilon_0 + 1}(3)$$ to be defined)

$$J_0(3,27.2) = f_{\omega^{\omega^{\omega}} + 1}^{2}(3) (= f_{\epsilon_0 + 1}^2(3)$$ to be defined)

$$J_0(3,27.3) = f_{\omega^{\omega^{\omega}} + 2}(3) (= f_{\epsilon_0 + 2}(3)$$ to be defined)

$$J_0(3,27.35) = f_{\omega^{\omega^{\omega}} + 2}^{2}(3) (= f_{\epsilon_0 + 2}^2(3)$$ to be defined)

$$J_0(3,27.4) = f_{\omega^{\omega^{\omega}} + \omega}(3) (= f_{\epsilon_0 + \omega}(3)$$ to be defined)

However, another approach to exceeding epsilon_0 and exploring the Veblen hierarchy is documented in the Sandpit $$J_4$$ blog.

## VBA Program Code

The following is VBA visual basic code and will run as a macro in Microsoft Excel. This function creates a string literal of a $$J_0$$ Function. Example results are listed above.

Option Explicit

Dim jBase As Integer, jReal As Double

Type jArray
jLevel As Integer
jMult As Integer
jValue(0 To 100) As Integer
End Type

Dim jTower As Integer, jOrdinal(0 To 100) As jArray

Function jString(m As Integer, n As Double) As String

Dim i As Integer, j As Integer, k As Integer, s As String, t As String

Select Case m
Case 0
jString = "0"
Exit Function
Case 1
If n <= 0 Then jString = "1" Else jString = "f_{\omega}(1)"
Exit Function
Case Else
jString = m
End Select

i = jLog(m, n)

If i = 0 Then s = jGet(True) Else s = jOmega(i)

j = jGet(s = "0")
If j > 0 Then
jString = "(" & m & ")"
If j > 1 Then jString = "^{" & j & "}" & jString
jString = "f_{" & s & "}" & jString
End If
End Function
Function jOmega(i As Integer) As String

Dim j As Integer, k As Integer, s As String, t As String

jTower = i

For j = jTower To 0 Step -1
With jOrdinal(j)
If j = jTower Then
.jLevel = 0
Else
.jLevel = IIf(k > 0, k - 1, 0)
.jMult = jGet(False)
End If

For k = .jLevel To 0 Step -1
.jValue(k) = jGet((j <> jTower) Or (k <> .jLevel))
Next k

k = .jValue(.jLevel)
End With
Next j

jOmega = ""
For j = jTower To 0 Step -1
With jOrdinal(j)
s = ""
For k = .jLevel To 0 Step -1
If .jValue(k) > 0 Then
If s <> "" Then s = s & " + "
If k = 0 Then
s = s & .jValue(k)
Else
s = s & "\omega"
If k > 1 Then s = s & "^{" & k & "}"
If .jValue(k) > 1 Then s = s & "." & .jValue(k)
End If
End If
Next k

If jOmega = "" Then
jOmega = s
Else
jOmega = "\omega" & IIf(jOmega = "1", "", "^{" & jOmega & "}")
If .jMult > 1 Then jOmega = jOmega & "." & .jMult
If s <> "" Then jOmega = jOmega & " + " & s
End If
End With
Next j
End Function
Function jLog(j As Integer, l As Double) As Integer

Dim k As Double

jBase = j

jLog = 0
If l < jBase Then
jReal = l / jBase
Else
k = l
While k >= jBase
k = k / jBase
jLog = jLog + 1
Wend

k = jBase ^ jLog
jReal = (l - k) / k / (jBase - 1)
End If
End Function
Function jGet(z As Boolean) As Integer

jReal = jReal * (jBase + IIf(z, 0, -1))

jGet = Int(jReal)
jReal = jReal - jGet

If Not z Then jGet = jGet + 1
End Function


How the Function Works

A description of how the code works will be provided here ... Work in Progress.

• VBA Constants
• VBA Data Structures
• VBA Functions
• jString Function - This function generates a 'string literal' of an FGH function. It does not calculate a mathematical expression equal to the FGH function. Think of it as a tool to generate the LaTeX script for FGH functions with fine-grained ordinals of various sizes. More information will be provided.
• jOmega Function
• jLog Function
• jGet Function - This function extracts an integer from a real number by repeatedly multiplying the real by the constant jBase. The integer part of the result is used and the decimal part is multiplied again when the function is next called.
• Work In Progress