#Bowers Exploding Array Function

[mathandnumberystuff]

Bowers Exploding Array Function discussion part 1: Linear and planar arrays

Well, it's been another full year without me making a post about people's attempts at formally defining Jonathan Bowers' Exploding Array Notation. This post is the first in an attempted series to discuss the rules for some subsystems of BEAF and the various ways that people have interpreted Bowers’ unformalized ideas of “array spaces.”

I begin by introducing arrays in a somewhat non-traditional way, which is similar to the description from Bowers' Spaces page (Some people have trouble loading the page so the Internet Archive link should also work: http://web.archive.org/web/20201102164403/http://www.polytope.net/hedrondude/spaces.htm). My goal is to emphasize the structure of the space the array lives in, rather than the array itself. I won't spend much time going over example calculations to give a sense of how unimaginably large the numbers get, either. There is a good explanation on Googology Wiki of how BEAF easily creates numbers that surpass Graham's number, as well as the most common large number generating functions, such as up-arrow notation and chained arrow notation: https://googology.wikia.org/wiki/Introduction_to_BEAF.

Linear arrays

To understand linear arrays, just imagine an infinite row of boxes where positive integers can be placed. The row has a beginning but no end. Each box is indexed by an integer, and for the purpose of this discussion we will say these indices start at 0. The default value for a box is 1, and all but finitely many boxes must contain the value 1. When we write an array like this: {a, b, c...}, the values in the brackets are in sequential positions starting from entry 0, and all remaining entries are 1, so the array is inside an infinite sea of 1's. In general, an array can be considered a collection of numbers at various positions inside an infinite (hyper-)dimensional space of 1's.

Bowers has a lot of terms for various entries in the array which he uses when he defines his rules. Definitions:

Entry 0 is called the base.

Entry 1 is called the prime.

The first entry after the prime that is not 1 is called the pilot.

The entry right before the pilot is called the copilot.

The array is solved into an integer by means of applying a series of steps repeatedly until either the base rule or prime rule applies, and then a value is returned.

Rules

Let b be the base and p be the prime.

Base rule: If every entry besides the base and the prime is 1, the array evaluates to b^p.

Prime rule: If p = 1, the value b is returned.

Catastrophic rule: If neither of the above rules apply, the array is changed in the following way:

The pilot is decreased by 1.

The copilot becomes the value of the original array, but with the prime decreased by 1.

Besides the copilot, every entry before the pilot changes to b.

Planar arrays

The next step is to stack the numbers on top of each other. The array can be imagined as an infinite plane of boxes of positive integers. This time, the positions in the array can be described by two coordinates: (a, b) is the value in the a-th row and b-th column (and a and b both start from 0). 1's are still the default value, so for a valid array, all but finitely many entries are 1's.

Bowers still uses commas to separate the entries of the array, and uses the separator (1) to move to the first entry on the next row. Thus, an array such as {3, 3, 3 (1) 3, 4, 5, 6} means the following structure in space: 3   3   3   1   1   1... 3   4   5   6   1   1... 1   1   1   1   1   1...

...

Most of the rules and definitions we gave above still work. The base and prime are now the entries at positions (0, 0) and (0, 1) respectively (i.e., on the first row). The pilot may not be on the first row anymore; it may be on the second row, third row, or beyond. If the pilot is the first entry on its row, the copilot doesn't even exist.

There are two important things to understand about the definition of the pilot: "The first entry after the prime entry that is not 1." First, it requires that all the positions of space have an ordering. The ordering is just the standard top-to-bottom left-to-right reading order: (w, x) > (y, z) if w > y, or if w = y and x > z. Second, the entries must be well-ordered; that is, each non-empty set of space positions must contain one that comes first in the ordering. If the entries were not well-ordered (for example, if the second coordinate were always non-positive instead of non-negative), we would not be able to ensure that the set of entries after a certain position contains an earliest entry (for example, the position (1, 0)), and thus we could not speak of the first non-1 entry after the prime. This well-ordering requirement must apply to all extensions of BEAF and it will force the different levels of array space into a hierarchy that is unavoidable, up to isomorphism.

The only rule that needs to change is the catastrophic rule. First, we need a minor tweak to the second part of the rule in case the copilot doesn't exist:

The copilot (if it exists) becomes the value of the original array, but with the prime decreased by 1.

The third part of the rule no longer works either:

Besides the copilot, every entry before the pilot changes to b.

This is because, if the pilot is on the second row or beyond, an infinite number of entries on the first row must become b. This violates the requirement that only a finite number of entries can be non-1. Instead, Bowers decides that for all rows above the pilot, the first p entries change to b. The rest of the rows' entries (which are all 1's anyway) stay the same.

This means that if the pilot is at (y, z), a chunk of y*p + z prior entries take on the value b. Bowers calls the p entries on each row the prime block of the row. However, we can speak of the prime block of any position in array space as all of the entries that would be filled if the pilot or copilot was at that space (Bowers also calls these entries the "airplane"). Because the size of the prime block is a linear polynomial of p, the positions themselves are often expressed as polynomials, with position (y, z) described as y*X + z. The prime block itself can be represented by [y*X + z](p).

In fact, if the pilot is 2, and every other entry besides the base and prime is 1, the array evaluates into just a prime block and nothing else (besides trailing 1′s). This is how Bowers constructs many of his larger named numbers, which are usually written as {b, p (separator) 2} or as f(p) & b (where f is a function identifying a space by the size of its prime block, and & means "array of").

[mathandnumberystuff]

Updated Bowers Exploding Array Function program

In preparation for my upcoming posts where I discuss the task of formally defining Bowers Exploding Array Function, I have just made an update to my 2016 Python program displaying the steps of evaluating an array. The current version is available on my GitHub here. It is currently written in Python 2, but I plan to rewrite it in Python 3 soon.

I plan to update it a lot more in the coming weeks. As of March 26, 2020, I have made the following changes:

Updated notation for the planar arrays to match what Bowers writes (e.g. {3, 3, 3(1)2})

Added a class “Bowersarray” so the arrays are treated as their own type of object in the code, with special functions for evaluation.

Made a special function for the “canonization” step (removing 1′s from the end of rows and rows from the end of the array).

Here are some updates I have planned for the future:

Support higher dimensional arrays and beyond.

Allow the user to skip to the end of long, predictable sequences of steps.

Add code to support numbers too large for all digits to be stored, so that the program can go a little longer before freezing when encountering a number too large.

Allow the user to skip to the end of the evaluation of some intermediate array, even if they don’t understand the immensity of the resulting value, and have the program describe the next steps of the evaluation in terms of that value.

[mathandnumberystuff]

Bowers Exploding Array Function revisited

Today (November 27) is Jonathan Bowers’ 50th birthday! In 2016, I made a post about his legendary function for generating large numbers, Bowers Exploding Array Function (or BEAF for short). I wrote Python code to solve the first few steps of a 2D Bowers array, to show how the function was defined recursively. I promised updates to my code but I never delivered. However, within the next few days (or weeks, or months...) I think I will do just that.

First, I would like to present an overview of the different array structures of BEAF arrays. These are the most confusing part of BEAF; the recursive rule is quite easy to apply once the array structures are known.

Linear arrays: these are vectors of a finite number of positive integers, which can be indexed from 0 to some positive integer n.

Planar arrays: these are vectors of linear arrays, which can be of different lengths (or empty). Each entry can be indexed by a linear polynomial with non-negative coefficents, a*X + b.

Dimensional arrays: each entry can be indexed by a polynomial of arbitrary degree with non-negative coefficients, a*X^n + b*X^(n - 1) + ... + k. Polynomials are ordered by comparing the most significant coefficients that are different.

Tetrational arrays: these are indexed by “hypernomials”; the exponents are allowed to be polynomials themselves (and, recursively, they are allowed to be earlier-constructed hypernomials). After the ordering of the exponents is established, one can compare hypernomials by size. Thus, by induction, all hypernomials can be ordered. These correspond to transfinite ordinals below epsilon_0. An example is 3*X^X^(X+2)+2*X^X^X+X^(X^3+X)+X^X+X^5+3*X+4.

Pentational arrays: the idea of hypernomials is extended by allowing the height of the tower of X’s to be a hypernomial. Using ^^ for tetration, we can define X^^X, X^^(X + 1), X^^X^2, X^^X^^X, .... Unfortunately, the rules for these expressions were never formalized and it is unknown what kind of expressions come between X^^X and X^^(X + 1), for example.

Hexational arrays and beyond: these are even less obvious to work with. When fully formalized (and I do believe it will happen some day), the expressions will be things like X^^^X, {X, X, X}, {X, X (1) 2}, tetrational arrays of X’s, pentational arrays of X’s, etc.

Legion arrays and beyond: Bowers develops a new kind of recursion for legion arrays -- adding an argument to his function to denote the number of times an array is filled with X’s and used to make the space for a larger array. Unfortunately, there is no formal definition of these, despite toiling efforts of many parties on Googology Wiki. Jonathan Bowers used legion arrays to ��define” his legendary number “meameamealokkapoowa oompa.”

[mathandnumberystuff]

Jonathan Bowers‘ birthday, plus a program

Today (November 27) is the 47th birthday of a really great mathematician named Jonathan Bowers. He is a mathematician who specializes in studying large numbers and higher dimensional polytopes. Among his many achievements in the study of polytopes were discovering the majority of the known uniform polychora (4-dimensional polytopes) and an even higher percentage of the known uniform higher-dimensional polytopes. He also investigates facet-transitive polytopes and curved objects known as polytwisters. His website can be found here: http://polytope.net/hedrondude/home.htm

He also invented a notation for describing very large numbers, called “infinity scrapers”. This notation, called Bowers Exploding Array Function, takes the form of a linear or multidimensional array (or even above multidimensional and into more abstract spaces, which collapse down to a number of dimensions determined by a value in an intermediate stage in an array’s evaluation). Its rules are as follows:

The first entry is called the base.

The second entry is called the prime entry.

Ones are the default (and smallest) array entry, and each array can be thought of as lying in a multidimensional space each of whose unspecified entries is a 1. For example,

{3, 3, 3} = {3, 3, 3, 1, 1, 1, 1} =

{3, 3, 3, 1, 1, 1, 1... {1, 1, 1, 1, 1... {1, 1, 1, 1... {1... ...

If the prime entry is 1, the entire array evaluates to the base.

The first entry after the prime entry that is not 1 is called the pilot.

The entry right before the pilot is called, if it exists, the copilot.

In each step, the copilot (if it exists) gets replaced by the value of the original array, except with the prime entry decremented.

Also in each step, the pilot of the original array gets decremented.

Every entry before the pilot gets replaced by the base value.

If there are any rows/ spaces before the pilot, they get filled w/th a hypercube of the same dimension of edge length equal to the prime entry, w/th one corner at the first entry of the space.

This continues until the original array consists of just a base and a prime entry. The final value is the base to the power of the prime entry.

I am writing a Python program (currently in development) to “evaluate” an array, except that most of their values are too big to even express in this universe! Here is the link to the code: https://github.com/ericbinnendyk/bowersarray