FANDOM


Here we extend pentational arrays to include all up-arrow operators. We will call the arrays "hyper-operator arrays", and the associated structures "hyper-operator structures".

Much of the definition will be the same as for pentational structures; I have highlighted the new rules in bold.

Definition of hyper-operator structures

We define the set \(PE\) of structure expressions as follows.

\(PE\) is the smallest set such that

0, 1, X are in \(PE\). If f and g are in \(PE\) and n is in \(\mathbb{N}\), then f + g, f * g, X {n} f are in \(PE\).

Note that different expressions for structures can express the same structure.

We define the equivalence relation ~ as follows.  Given that f and g are in \(PE\):

f + g ~ g + f 

f + 0 ~ f

f * g ~ g * f 

f * 0 ~ 0

f * 1 ~ f

X {n} 0 ~ 0

X {n} 1 ~ 1

X {1} (f + g) ~ (X {1} f) * (X {1} g)

X {n} (X {n+1} f) X {n+1} (f+1)

~ is the smallest equivalence relation that satisfies the above expressions.

The set \(P\) of structures is defined as the set \(PE\) modulo ~.  That is, \(P\) is the set of structure expressions where expressions that are related by ~ are considered the same structure.

Call f a successor structure if f is of the form g+1 for some g.

Call f a limit structure if f is neither a successor structure nor 0.

Ordering on hyper-operator structures

We need to order the structures.  For a structure f, define N(f) to be the minimum number of symbols in an expression for f.  We will define the comparison between f and g by induction on max {N(f), N(g)}.

Case 1: 0 < g is true for all g not equal to 0.

Case 2: 1 < g is true for all g not equal to 0 or 1.

Case 3: f < 0 is false for all f.

Case 4: f < 1 is false unless f = 0.

Case 5: At least one of f or g is the sum of two or more expressions.

Let \(f = f_1 + f_2 + \ldots + f_m\) where \(f_1 \ge f_2 \ge \ldots \ge f_m\). (Note that \N(f_i) < \N(f)\) so we can assume by induction that comparisons for the \(f_i\) have already been defined.)

Let \(g = g_1 + g_2 + \ldots + g_n\) where \(g_1 \ge g_2 \ge \ldots \ge g_n\).

\(f < g \Leftrightarrow \exists i (f_i < g_i \wedge \forall j < i (f_j = g_j)) \vee (\forall i \le m (f_i = g_i) \wedge n > m) \).

(In other words, we compare the summands term by term, starting from the largest, until we find a pair that are different.  Whichever summand is greater will belong to the greater sum.)

Case 6: At least one of f or g can be written as the product of two or more expressions.

Let \(f = f_1 * f_2 * \ldots * f_m\) where \(f_1 \ge f_2 \ge \ldots \ge f_m\), and no \(f_i)\) is of the form \(X^{a+b}\) where a and b are nonzero.

Let \(g = g_1 * g_2 * \ldots * g_n\) where \(g_1 \ge g_2 \ge \ldots \ge g_n\), and no \(g_i)\) is of the form \(X^{a+b}\) where a and b are nonzero.

Then as before,

\(f < g \Leftrightarrow \exists i (f_i < g_i \wedge \forall j < i (f_j = g_j)) \vee (\forall i \le m (f_i = g_i) \wedge n > m) \).

Case 7: f = X {n} F, g = X {n} G

f < g \(\Leftrightarrow\) F < G.

Case 8: f = X {n} F, g = X {n+1} G

Choose G' so that G = G' + 1 if G is a successor structure; otherwise let G' = G. Then f < g if and only if F < X {n+1} G'.

Case 9: f = X {n+1} F, g = X {n} G

Choose F' so that F = F' + 1 if F is a successor structure; otherwise let F' = F. Then f < g if and only if X {n+1} F' < G.

Case 10: f = X {m} F, g = X {n} G, n > m+1

Then f < g if and only if F < g.

Case 11: f = X {m} F, g = X {n} G, m > n+1

Then f < g if and only if f < G.

This completely defines the comparison relation.

Standard form for hyper-operator structures

We define the standard form for a hyper-operator structure f.

If f is a nontrivial sum, order the summands from largest to smallest, and express each summand in standard form.

If f is of the form X {1} (g+h) express it in the form (X {1} g) * (X {1} h), and express g and h in standard form.

If f is a nontrivial product, order the factors from largest to smallest, and express each factor in standard form.

If f is of the form X {n+1} (g + m) for some natural number m, express it in the form X {n} (X {n} ... (X {n+1} g)...) with m 'X {n}'s, with g expressed in standard form.

Fundamental sequences for hyper-operator structures

Given f expressed in standard form, define f[n], the nth element of the fundamental sequence for f, as follows:

Case 1: If f = 0, f[n] = 0.

Case 2: If f = g+1, f[n] = g.

Case 3: If \(f = f_1 + f_2 + \ldots + f_m\), then \(f[n] = f_1 + f_2 + \ldots + f_m[n]\).

Case 4: If \(f = f_1 * f_2 * \ldots * f_m\), then \(f[n] = f_1 * f_2 * \ldots * f_m[n]\).

Case 5: If f = X, f[n] = n.

Case 6: If f = X {1} g,

Case 6.1 If g = X {m} h, then f[n] = g * g * g ... * g (n times).

Case 6.2 Otherwise, f[n] = X {1} (g[n]).

Case 7: If f = X {m} g with m > 1,

Case 7.1 If g = X {k} h with k > m, then f[n] = X {m-1} (X {m-1} (X {m-1} ... (X {m-1} g)...)), with n "X {m-1}"s.

Case 7.2 Otherwise, f[n] = X {m} (g[n]).


Prime blocks for hyper-operator structures

We will use the same definition for the prime blocks as used by FB100Z in his Ordinal BEAF notation.

Define \(P_p (\alpha) \), the prime block of \(\alpha\), as follows:

\(P_p(0) = \lbrace \rbrace\).

\(P_p(f + 1) = \lbrace f \rbrace \cup P_p (f) \).

If f is a limit structure, \(P_p (f) = P_p (f[p])\).

Hyper-operator Arrays

Having defined prime blocks for structures, we are now ready to define arrays.  An array is a map from structures to the natural numbers; we can notate this as

\(\lbrace (\alpha_1, n_1), (\alpha_2, n_2), \ldots, (\alpha_m, n_m) \rbrace\), where the \(\alpha_i\) are increasing.  The 0 structure will map to the base number, and the 1 structure will map to the prime number.  The pilot P will be the smallest structure greater than 1 mapping to a positive number, and the copilot CP will be the structure such that P = CP+1, if such a structure exists.  The definition of BEAF is the usual one.

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.