User blog:B1mb0w/Sequence Generating Code Version 5

Alpha Function - Sequence Generating Code
The Alpha Function has been defined using program code shown below.

A separate blog will be written to explain how Sequence Generator Code is compiled and executed using a normal programming language ... Work in Progress.

Sequence Generating Code Version 5
Version 5 of the Sequence Generating Code will create long finite integer strings to define large Veblen ordinals and FGH functions (up to the size of SVO). Refer to my other blogs on Unique Ordinal Representation and Program Code Version 4 for more information.

Key Changes to Version 4 Code
Version 5 will extend Program Code Version 4 code in two specific ways:

Extend \(n_0\) sequence to support Veblen ordinals of the form:
 * \(\varphi(\alpha,\varphi(\beta,0) + \gamma)\) where \(\beta > \alpha\) and \(\gamma < \varphi(\beta,0)\)
 * The \(n_0\) sequence, i.e.:
 * \(n(q) = (Q(0:,g_{[Q]}(Q),S,n_1(Q)))\)
 * can only generate Veblen ordinals of the form:
 * \(\varphi(\alpha,\varphi(\beta,0) + 1)\) where \(\beta > \alpha\) by definition

Extend \(f_{\gamma}^U(V)\) sequence to explicitly allow \(U\) and \(V\) to become very big integers. Version 4 implicitly allows \(U\) and \(V\) to be any integer up to \(\omega\), however, in practice, it is rare for Version 4 to generate a number \(> 20\).
 * This is not due to a bug in the code, but instead, the Alpha Number (real number) required to generate the necessary sequences would be so finely tuned to a prohibitive number of decimal places, that, it could not be calculated without computer code to handle high precision numbers, and could not be printed on a blog, even if it was calculated.
 * Therefore Version 5 will use sequences as substitutions to allow \(U\) and \(V\) to grow rapidly (at the growth rate of Small Veblen Ordinal).

Version 5 Code
We start with the general Version 4 generating rules as follows:

\(g(q) = (q,q(0:a,q(1:,m_0(q)),T,g_E(q),g_C(q),g_a(q)))\)

\(m(q) = (p,R,g_F(q),g_{[q]}(q),n_0(q))\)

\(n(q) = (Q,Q(0:,g_{[Q]}(Q),S,n_1(Q)))\)

Then we need to extend the \(n(q)\) sequence definition, and, explicitly define a complete sequence for the (underlying \(J_8\) Function for the) Alpha Function as follows:

\(\alpha(2) = J_8(<0,2>,2,8) = J_8(w_0) = f_2^2(8) = f_{\gamma}^U(V)\)

The new sequence definition required is:

\(w(q) = (g_0,U,V)\)

This sequence definition must now be extended to support further sequences of the form:

\(w(q) = (g_0,w_U,w_V)\)

The \(n(q)\) sequence definition must be extended to support one further sequence of the form:

\(n(q) = (Q,Q(0:,g_{[Q]}(Q),g_X,S,n_1(Q)))\)

The sequence generating rules that will apply are:
 * \(w(q) = (g_0(q),w_U(q),w_V(q))\)
 * \(q =\) any finite integer
 * \(g_0 =\) a generated \(g\) sequence smaller than \((q + 1)\)
 * \(w_U =\) a generated \(g\) sequence smaller than \(f_{g_0 + 1}(g_0(a) + 2)\) i.e: this sequence:
 * \(g_0,g_0(a))\)
 * where \(g_0(a)\) is the integer value of
 * \(g_a\) in \(g_0\) assuming \(g_a = (0,a)\) or
 * \(g_a(a)\) equal to the recursive \(g_a\) in this \(g_a\) assuming this \(g_a = (0,a)\) or
 * else recursively repeat the previous step
 * \(w_V =\) a generated \(g\) sequence smaller than \(f_{g_0}(max(g_0(a) + 1,w_U + 2))\) i.e: this sequence:
 * \((g_0,-1,(max(g_0(a),w_U)+1)\) WORK IN PROGRESS

and


 * \(n_k(q) = (Q(0:,g_{[Q]}(Q),g_X,S,n_{k+1}(Q)))\)
 * similar generating rules as before
 * \(g_X =\) a generated \(g\) sequence smaller than: \((q-n_{[k-1]})\)

For completeness the Version 5 sequence generating code is as follows:
 * \(w(q) = (g_0(q),w_U(q),w_V(q))\)
 * \(g(q) = (q(0:a,q(1:,m_0(q)),T,g_E(q),g_C(q),g_a(q)))\)
 * \(m(q) = (p,R,g_F(q),g_{[q]}(q),n_0(q))\)
 * \(n_k(q) = (Q(0:,g_{[Q]}(Q),g_X,S,n_{k + 1}(Q)))\)

Example Sequences \(\alpha(1)\) to \(\alpha(30)\)
The following example sequences have been generated by the Alpha Function for input values of 1 to 30.

\(\alpha(1) = (<0,0>,0,0) = 0\)

\(\alpha(2) = (<0,2>,2,8)\)

WORK IN PROGRESS

Test Bed for Version 5
Below is the test bed and various results using version 5.

These are the valid \(w\) sequences that are generated using the sequence generating rules above:

WORK IN PROGRESS