FANDOM


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

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.