User blog:B1mb0w/Beta Function Code Version 1

Beta Function - Sequence Generating Code
The Beta 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 1
The Beta Function is a significant re-design of the code used by the Alpha Function and will create long finite integer strings to define every large Veblen ordinals and FGH functions for every finite integer (up to the size of \(f_{SV0}(2)\)). Refer to my other blogs on Unique Ordinal Representation and Program Code Version 4 for more background information.

Beta Function Description
 * \(\beta(r,v) = h^m(v)\) where
 * \(h^0(v) = f_{\gamma_0}^{u_0}(v)\) where \(u_0 < v\)
 * \(h^{n + 1}(v) = f_{\gamma_{n + 1}}^{u_{n + 1}}(h^n(v))\) where
 * \(u_{n + 1} < h^n(v)\)
 * \(\gamma_{n + 1} < \gamma_n\)
 * \(\gamma_m = 0\)

The Beta Function can then be uniquely represented by a sequence of finite integers as follows:

\(\beta(r,v) == \)

Version 1 Code
The Sequence Generating RuleSet is as follows:
 * \(h = (d,b(0),d(0:,1:b(U),e,e(0:,1:h_1)))\)
 * \(b(x) = (f,f(0:g_x,1:h_x))\)
 * \(g = (q,p,R,g_{[q]},n_0,t_0(a))\)
 * \(n = (Q,t_0(A),P,g_{[Q]},S,n_1)\)
 * \(t(x) = (T,g_E,g_C,g_x)\)

The convention used for the parameters is:
 * Sequence function (e.g. \(h\)) defines the substitution sequences to replace any instance of the sequence function.
 * Instance of a Sequence function (e.g. \(g_0\)) is denoted by a lowercase letter with a subscript.
 * Lower case letter (e.g. \(q\)) with no subscript, denotes a finite integer greater or equal to 0
 * Upper case letter (e.g. \(R\)) with no subscript, denotes a finite integer greater or equal to 1

These rulesets are intended to be generated in a recursive way beginning with an initial h sequence. For example, a typical start for generating a sequence is:
 * \(v,h_0)\)
 * \(v,d,b(0),d(0:,1:b(U),e,e(0:,1:h_1)))\)
 * Let \(d = 1\)
 * \(v,1,b(0),b(U),e,e(0:,1:h_1))\)
 * \(v,1,(f,f(0:g_0,1:h_0)),b(U),e,e(0:,1:h_1))\)
 * Let \(f = 0\)
 * \(v,1,(0,g_0),b(U),e,e(0:,1:h_1))\)
 * \(v,1,(0,(q,p,R,g_{[q]},n_0,t_0(a))),b(U),e,e(0:,1:h_1))\)
 * \(v,1,(0,(q,p,R,g_{[q]},(Q,t_0(A),P,g_{[Q]},S,n_1),t_0(a))),b(U),e,e(0:,1:h_1))\)
 * \(v,1,(0,(q,p,R,g_{[q]},(Q,(T,g_E,g_C,g_A),P,g_{[Q]},S,n_1),t_0(a))),b(U),e,e(0:,1:h_1))\)

The sequences explode quickly as seen in this example:
 * \(v,1,(0,(q,p,R,g_{[q]},(Q,(T,g_E,g_C,g_A),P,g_{[Q]},S,n_1),t_0(a))),b(U),e,e(0:,1:h_1))\)
 * Let \(q = 2\)
 * \(v,1,(0,(2,p,R,g_{[2]},(Q,(T,g_E,g_C,g_A),P,g_{[Q]},S,n_1),t_0(a))),b(U),e,e(0:,1:h_1))\)
 * \(v,1,(0,(q,p,R,g_1,g_2,(Q,(T,g_E,g_C,g_A),P,g_{[Q]},S,n_1),t_0(a))),b(U),e,e(0:,1:h_1))\)
 * \(v,1,(0,(q,p,R,(q,p,R,g_{[q]},n_0,t_0(a)),g_2,(Q,(T,g_E,g_C,g_A),P,g_{[Q]},S,n_1),t_0(a))),b(U),e,e(0:,1:h_1))\)

The sequences are guaranteed to be finite because of sequence limiting rules:
 * \(h = (d,b(0),d(0:,1:b(U),e,e(0:,1:h_1)))\) which limits the sequence as follows:
 * \(d = 0\) then \(h = (0,b(0))\)
 * \(d = 1\) then \(h = (1,b(0),b(U),e,e(0:,1:h_1))\)
 * \(e = 0\) then \(h = (1,b(0),b(U),0)\)
 * \(e = 1\) then \(h = (1,b(0),b(U),1,h_1)\)
 * \(b(x) = (f,f(0:g_x,1:h_x))\) which limits the sequence as follows:
 * \(f = 0\) then \(b(x) = (0,g_x))\)
 * \(f = 1\) then \(b(x) = (1,h_x))\)
 * \(g = (q,q(0:a,q(1:,p,R,g_{[q]},n_0),t_0(a)))\) which limits the sequence as follows:
 * \(q = 0\) then \(g = (0,a)\)
 * \(q = 1\) then \(g = (1,t_0(a))\)
 * else \(g = (q,p,R,g_{[q]},n_0,t_0(a))\)
 * \(n = (Q,Q(1:,t_0(A),P,g_{[Q]},S,n_1))\)
 * \(Q = 0\) then \(n = (0)\)
 * else \(n = (Q,t_0(A),P,g_{[Q]},S,n_1)\)

WORK IN PROGRESS

Valid Sequence Counts
WORK IN PROGRESS

Example Sequences \(\beta(100,2)\) to \(\beta(300,2)\)
The following example sequences have been generated by the Beta Function for input values of 100 to 300.

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

WORK IN PROGRESS

Granularity Examples of this Version
Version 1 makes it possible to access Veblen functions of the form:
 * \(\varphi(\alpha,(\varphi(\beta,0)\uparrow\uparrow t)^{\gamma_e}.{\gamma_c} + \gamma_a)\) where
 * \(\beta > \alpha\)
 * \(0 < \gamma_e < \varphi(\beta,0)\uparrow\uparrow 2\)
 * \(0 < \gamma_c < \varphi(\beta,0)\uparrow\uparrow t\)
 * \(0 < \gamma_a < (\varphi(\beta,0)\uparrow\uparrow t)^{\gamma_e}.{\gamma_c}\)

Using the following Real Number inputs into the Beta Function generates these ordinals:

WORK IN PROGRESS

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

WORK IN PROGRESS