User blog:B1mb0w/J Function Sandpit J 8

J Function Sandpit \(J_8\)
The J Function is a work in progress. This sandpit defines a notational function called \(J_8\) which contains ideas that will be used in the final J Function. Click here for the J Function blog.

Summary
The \(J_8\) function is another attempt to create a very fast growing function. It is an algorithm that will be defined using program code to create the notation for a large ordinal up to the size of the Small Veblen Ordinal (SVO). It uses the Unique Ordinal Representation which is defined in another blog.

Unique Ordinal Representation
It is possible to construct a Unique Ordinal Representation of any ordinal up to SVO using a sequence of finite integers. This can be extended to construct a large number (googolism) in the form:

\(f_g^n(p)\) where g is an ordinal up to SVO, and n, p are finite integers.

To illustrate this, lets take the example from the original blog and analyse the structure of the sequence of finite integers \(\) and \( = <,2,4>\)

and finally \( = <,n,p>\) represents a function of the form \(f_g^n(p)\).

The above sequence defines this large number:

\(f_{\omega^{\omega} + \omega.3 + 2}^2(4)\)

Definition of the \(J_8\) function
The \(J_8\) Function uses a very recursive algorithm to define and embed sequences of the form \(\). The rules are as follows:

\(q =\) finite integer.

\(<\lambda> =\) sequence of the form \(<,,,...,>\) but if \(q < 2\) then \(<\lambda> =\) null.

\(m =\) finite integer but when evaluating \( = \) then \(m =\) null.

\( =\) sequence of the form \(\) but if \(q = 0\) then \( =\) null.

\( =\) sequence of the form \(<g>\) but if \(q = 0\) then \(<a> =\) null.

Some Simple Sequences
Here are some simple sequences and the number they evaluate to:

At this point, the \(<g>\) sequence starts to grow and many many large numbers can be generated. The general rule is illustrated as follows:

\(n <= p <= f_{m-1}(n+1)-1\) therefore the range for p is uniquely defined:

Another rule can be explained at this point to illustrate many more examples. The value of n has a lower bound of Min(2,Max(\(<g>\)), i.e. n may equal the largest finite integer in the sequence \(<g>\) if that number is less than 2.

\(Min(2,Max(<g>) <= n <= f_{(m-1)+1}((m-1)+2)-1\) and therefore the range for n is uniquely defined:

Example Sequences
The simple sequences illustrate how to construct a wide range of large numbers using different values of n and p in the sequence \(<f>\). These examples will focus on the sequence \(<g>\) only and will illustrate the construction of various ordinals:

The sequence \(<a>\) is bounded and must be less than the preceeding sequence of integers in \(<g>\) or specifically \(<q,<\lambda>,m,<m-1>,<c>>\). In the last entry of the above examples, we can see:

\(<1,1,2,<0,j>> > <1,1,1,<0,h>,<0,k>>\)

More examples follow, but the sequence \(<a>\) will be ignored because it is well bounded and can be derived if required.

The next example for \(m = 3\) would generate a huge sequence of integers. It will be better to follow the logic using a Pseudo Code Algorithm.

Pseudo Code Algorithm
Following is pseudo code for an algorithm that can generate these ordinals and large numbers. Lets start with a general definition of the \(J_8\) function:

\(J_8(<g>,n,p) = f_g^n(p) = f_{\lambda^{\gamma_{m-1}}.\gamma_c+\gamma_a}^n(p)\)

where

\(<g> == \gamma_m = \lambda^{\gamma_{m-1}}.\gamma_c+\gamma_a\)

and

\(\lambda = \varphi(\gamma_{[q]})\)

The pseudo code follows this logic:

1. Sequence \(<g> = <q,<\lambda>,m,<m-1>,<c>,<a>>\) where g is a finite integer

2. Sequence \(<\lambda> = <g_1,g_2,...,g_q>)\) or null if \(q < 2\) and then
 * \(\lambda\) is null when \(q = 0\)
 * \(\lambda = \varphi(1) = \omega\) when \(q = 1\)

3. Sequence \(<\lambda> = <g_1,g_2,...,g_q> == \lambda = \varphi(\delta_{[q]})\) where
 * \(\delta_1 < \varphi(1, 0_{[q]})\) and
 * \(\delta_2 < \varphi(\delta_1, 0_{[q-1]})\) and
 * \(\delta_3 < \varphi(\delta_1, \delta_2, 0_{[q-2]})\) and
 * \(\delta_q < \varphi(\delta_1, \delta_2, ..., \delta_{q-1}, 0)\)
 * \(\delta_q < \varphi(\delta_1, \delta_2, ..., \delta_{q-1}, 0)\)

4. m is a finite integer or null if \(q = 0\)

5. Sequence \(<m-1> = <g_{m-1}>\) or simply a finite integer if \(q = 0\) or \(m = 1\)
 * In any case the sequence \(<m-1>\) will follow the recursive format of \(<g>\) but without the integer m, so:
 * \(<m-1> = <q,<\lambda>,<m-1>,<c>,<a>>\)

6. m is a finite integer or null if \(q = 0\)