3.1.4 - multi-variable

3.1.4

Multi-Variable Functions,

Arrays,

and

Higher Structures

Introduction

In the last article we explored functions of a single variable, and gained a practical understanding for how functions can be defined and evaluated, through explicit maps, explicit formulas, and piecewise methods. In this article we will broaden our ability to express functions even further by lifting the restriction that the input only contain a single argument. It is not difficult to generalize the concept of a function to allow for any whole number of arguments, and in fact even to define functions of a variable number of arguments. These generalizations bring us one step closer to a theory of recursive functions. Although I will not be introducing recursion in this article, the framework we will establish here will be absolutely fundamental to all of our later exploration of recursive functions.

Multi-Variable Functions

A multi-variable function may have any whole number of arguments, including none at all. The arguments may be listed in a prescribed order using commas between the encapsulation marks of a function. If desired, any non-numeric symbol may be used to separate arguments. Such symbols I refer to as separators. The number of arguments a function uses is known as its arity. Functions of a single-variable have an arity of 1. Functions of two-variables have an arity of 2, and so on.

As an example, say we have a function of two-arguments. Any function of two-arguments is called a binary function, and has an arity of 2. Let the function be called f, and let it's arguments be x and y. The binary function f will be notated as:

f(x,y)

The symbol here is once again broken into two components. The exterior portion "f( )" represents the function. This provides the encapsulation for the arguments. "f(" is the left encapsulation mark, while ")" is the right encapsulation mark for the function. The interior portion "x,y" is the structure, or struct, of the function. The structure contains all of the input of the function, and a distinction should be made between the notion of an argument and a structure. An argument is a single numerical component of any input structure, while a structure is a ordered arrangement of arguments. The notion of a structure will gradually be developed as we progress. In our example we can say that function has a structure consisting of two-order arguments, a first and second.

The value of f(x,y) depends on both the values of x and y. f(x,y) can not be graphed on a plane in the same way that f(x) can because the input is now a two-argument structure. However f(x,y) could be graphed in three dimensions by letting a flat plane represent the input "x,y", and letting the height above any point (x,y) on the plane represent f(x,y).

We can also have a function with no arguments. Such a function is called a nullary function and has an arity of 0. Nullary functions have no structure, and so nothing is written between its encapsulation marks:

g()

Since there can be no more than one possible combination of input, namely the input of the zero-structure, there can only be one possible output. Thus nullary functions can be used to represent constants. As I will show later, with nullary functions it is possible to construct an integer theory of large numbers, which is defined only through functions. This is done by reducing even numbers to functions. Nullary functions are therefore of some limited theoretical interest for us.

Once we have generalized the concept in this manner there is nothing preventing us from having something like a three-argument function: h(x,y,z).

In fact we can generalize the concept in a more formal way. Let "a₁" be the first argument of any function, let "a₂" be the second argument of any function, and in general let "a_k" be the kth argument of any function.

A multi-variable function f, is any function which takes an n-argument structure and produces a single numeric output, where n = {0,1,2,3,4,...}. We can represent the multi-variable function as:

f($)

where $ = a₁,a₂, ... ,a_n

But how does a multi-variable function process the structure, $, and convert it into an output. To explore how this works we will go through the various arities in order, starting this the nullary, and working our way up...

Nullary Functions

Nullary functions can be said to have arity=0. Their input is the 0-structure.

Nullary functions are very easy to define. Since they contain no arguments, and only a single output needs to be defined, we can simply assign the nullary function to any elementary expression involving only constants. For example, let f() be a nullary function. We could define it as:

f() = 2+3^2

To evaluate f() we simply compute 2+3^2= 11. So f() = 11. We could also then just redefine f as:

f() = 11

f() can then be used as merely an alternative "symbol" for 11, in further formulas. So we could say that:

f()+4^3 = 11+64 = 75

Even more radically we may treat decimal expressions as simply function names for nullary functions:

1 = 1()

2 = 2()

3 = 3()

4 = 4()

etc.

In such a way we can reduce a theory of numbers into a theory of pure functions.

Unary Functions

Unary functions have arity=1. Their input is the 1-structure.

Unary functions, are simply functions of a single variable. These were introduced in the last article. We can notate unary functions simply by placing a single argument within encapsulation marks: f(x).

We can define Unary functions by simply supplying a formula of elementary operations, constants, and the argument of the function. For example we might define:

f(x) = x^2+5x+6

When we compute the value of the function for a particular input, we always substitute for every occurrence of the argument of the function. For example:

f(3) = (3)^2+5(3)+6 = 9+15+6 = 24+6 = 30

The formula may contain any number of occurrences of the argument. In fact, the argument doesn't necessarily have to occur even once in the formula. For example, let:

f(x) = 5

Then we find that:

f(1) = 5

f(2) = 5

f(3) = 5

etc.

In these instances a function becomes something akin to a constant, although we still distinguish it from a nullary function.

Binary Functions

Binary functions have arity=2. Their input is the 2-structure.

Although binary functions might seem unusual at first they are actually quite common in mathematics. All seven of the elementary operations can be thought of as functions of two variables. For example:

x+y

x-y

x*y

x/y

x^y

rt_y(x)

log_y(x)

We can define the following functions to represent these operations:

+(x,y) = x+y

-(x,y) = x-y

*(x,y) = x*y

/(x,y) = x/y

^(x,y) = x^y

rt(x,y) = rt_y(x)

log(x,y) = log_y(x)

The standard function notation which places the operator on the outside of the encapsulation is known as prefix notation. However, in introductory arithmetic courses, infix notation is always used, in which an operator is placed between the two arguments. We may think of an operator, as merely a special case of separator, in which the chosen symbol indicates the function.

So as you can see, the concept of an operator can be subsumed into the concept of a function. The idea of an operator as merely a function will probably help you get a good intuitive understanding of what a function is.

For example let's look at the function +(x,y) = x+y. The output of the function is simply the sum of it's arguments:

ex.

+(2,3) = 2+3 = 5

therefore +(2,3) = 5

So when we "add" numbers we are really just computing the output of a binary function called "addition". We needn't restrict ourselves to the seven elementary functions in our discussion of binary functions. We can use any explicit formula using elementary operators, constants, and the two arguments of the function, to define a binary function. Here are some examples:

f(x,y) = x^2+y^2

g(x,y) = x^3+y^2

h(x,y) = x^y + y^x

etc.

We can easily compute these values by substituting for the appropriate variables. For example:

g(5,4) = 5^3+4^2 = 125 + 16 = 141

Keep in mind that the order of the arguments is important. If we switch the arguments of any binary function, we aren't necessarily going to get the same output:

g(4,5) =! g(5,4)

because

g(5,4) = 141

but

g(4,5) = 4^3 + 5^2 = 64 + 25 = 89

Certain functions however will be defined in such a way that f(x,y) = f(y,x), for all x and y. For example, our first function has this property:

ex.

f(3,4) = f(4,3)

since

f(3,4) = 3^2 + 4^2 = 9 +16 = 25

and

f(4,3) = 4^2 + 3^2 = 16 + 9 = 25

more generally

f(x,y) = f(y,x)

because

f(x,y) = x^2 + y^2 = y^2 + x^2 = f(y,x)

therefore f(x,y) = f(y,x)

When a binary functions arguments can be switched without effecting the input we say the operation/function is commutative. Addition and multiplication are commutative, since x+y = y+x and xy = yx. Exponentiation is not however since x^y does not always equal y^x. For example

3^4 = 81

while

4^3 = 64

The one exception I know to this is that 2^4 = 4^2. I am not sure whether or not this is the only solution to x^y = y^x.

Here's a question, is the function h(x,y) = x^y+y^x commutative or not?

It is, because addition is commutative. Thus h(x,y) = x^y+y^x = y^x + x^y = h(y,x).

Lastly we may define binary functions in which one or both of the arguments have no effect on the outcome:

L(x,y) = 3x+2

C(x,y) = 19

The use of binary functions, in itself, does not improve our ability to express large numbers, since we are still simply using googolically elementary expressions to define our functions. The best we can do is simply get a little more variety in our functions. For example:

hypf(x,y) = x^(x^(x^y))

hypf(3,2) = 3^(3^(3^2)) = 3^(3^9) = 3^19,683 ~ 10^9391

hypf(10,2) = 10^(10^(10^2)) = 10^(10^100)

etc.

Ternary Functions

Almost all the functions used on a day to day basis in mathematics have an arity of 2 or less. Only in certain fields such as recursion theory and computer science, are higher arities seen on a regular basis. Googology makes free use of very high arities, as we will see.

Ternary functions, as the name implies have an arity of 3. They use a 3-structure as their input.

An obvious example of a Ternary function is one that simply takes the sum of 3 arguments:

f(x,y,z) = x+y+z

Note that the order of the arguments is unimportant to the output and we can say that:

f(x,y,z) = f(y,x,z) = f(x,z,y) = f(z,x,y) = f(y,z,x) = f(z,y,x)

When any pair of arguments in an n-ary function maybe switched without effecting the output we say that the function is n-ary commutative. This is the more general concept of commutativity which can apply to arities = {2,3,4,5,6, ...}. It is rather pointless to call a function unary commutative, since there are is no pair of arguments to switch. In a sense, all unary functions are unary commutative, but this renders the distinction meaningless. Therefore commutativity is a property of functions with at least two arguments. We can come up with a few ternary commutative functions:

g(x,y,z) = x*y*z

h(x,y,z) = (x+y)(y+z)(x+z)

etc.

We can also easily come up with non-commutative ternary functions:

F(x,y,z) = x*y+z

exp(x,y,z) = x^(y^z)

etc.

As an example note that:

F(2,3,4) = 2*3+4 = 6+4 = 10

F(4,3,2) = 4*3+2 = 12+2 = 14

exp(2,3,4) = 2^(3^4) = 2^81 = 2,417,851,639,229,258,349,412,352

exp(4,3,2) = 4^(3^2) = 4^9 = 2^18 = 262,144

Note that, to prove that a function is non-commutative, we need only 1 counter-example. These examples are therefore enough to say the functions are non-commutative. It should be obvious that when x=y=z, the switching of arguments will have no effect on the output, so every function can be said to be commutative over a limited set of circumstances.

You should now have a pretty good idea of how arity works. Let's procede then to the general case...

Multi-Variable Functions

We can use the following terms for the first few arities, from 0 to 10.

Some of these names can be found in professional literature, but as you might expect, their use is infrequent and as a result there is some variation in their spellings. There is a tendency in professional mathematics to shy away from such linguistic subtlies and instead use generic terms such as 1-ary, 2-ary, 3-ary, etc. with the obvious meanings. This is particularly blatant in higher geometries, where a 4-dimensional sphere, referred to as a glome by polytope hobbyists, is referred to as a 3-sphere in official literature due to it's 3-dimensional surface. On the other hand Googologists, who are more hobbyists than profesionals, don't tend to shy away from linguistic games, but rather embrace them along with the mathematical constructions. Personally, I'm not too concerned about the precise spellings of these terms for our purposes, but it is nice to have terms that roll off the tongue easily and give the field character. The googological impulse exists somewhere between art and science. It is both creative and exacting.

In any case we can now see that generalizing to any arity is fairly straight forward. For an n-ary function we simply need n variables to represent the n arguments within the explicit formula used to define the function. But what if we run out of letters? What should we use after x,y, and z? We might opt to begin at the beginning of the alphabet for arities greater than 3:

F(a,b,c,d)

F(a,b,c,d,e)

F(a,b,c,d,e,f)

etc.

What happens when we inevitably run out of letters? For this we can adopt the subscript notation. Let a_k be the kth argument. The choice of "a" is obvious as it stands for argument. By using subscript notation we can assign as sequence of numeric designations to indicate order. Conventionally the order reads from left to right, with the first argument to the left and the last argument to the right. This is not a neccessity, but almost all the common large number functions follow this order. If "( )" are our encapsulation marks, we can say that the generic n-ary function looks something like this:

(a₁,a₂,...,a_n)

The function can then be defined via a formula involving none, some, or all of these variables, a₁ through a_n. For technical reasons, the first argument will sometimes be labeled a₀. The first argument is sometimes just, "a", or just "b". When the first argument is labeled "b", it is used to signify that the first argument has a special status as the "base" of the function. This is sometimes further emphasized by placing the base argument outside the main encapsulation marks, to show that the "base" represents a particular mode of the function, or in fact is part of the functions name. The logarithm is an example of this, where the "base" is written write after "log" the function designator:

log_b(a)

We might think of the logarithm as a binary function of a and b, but we can also think of the logarithm of base b, as a unary function of a. In fact, b is usually omitted completely when b=10, so that log(x) can indeed be seen as a unary function of x.

At this point it shouldn't be difficult to devise a function of any number of variables, using formulas composed of elementary operations. The simplest way to create such a function is simply to take the sum of all the arguments.

(a₁,a₂,...,a_n) = a₁ + a₂ + ... + a_n

We could also say that an n-ary function simply returns the value of one of its arguments:

(a₁,a₂,...,a_n) = a_k

Such a function is known as a projection in recursive theory. These kinds of functions will mostly be of only theoretical interest to us. They can be used in a theory reducing all numbers and operations to functions, but will be of no use in generating large numbers on their own. We need more than projection functions to generate large numbers. We need functions that actually modify the arguments in some way (usually, we will make them larger). Restricting ourselves only to the operations of addition, subtraction, multiplication, and exponentiation however, we won't be able to create numbers any larger than we could with unary functions no matter how many arguments we use. The greater arity mainly serves to produce a greater flexiability in what we can express.

What would be the next logical step after this? Note that, so far we have only discussed functions in which the number of arguments is a fixed whole number, {0,1,2,3,4,...}. Is it possible to have a function which can vary in the number of arguments it accepts? It is, and we'll look at these functions under the next heading...

Arrays

Functions which can take a variable number of arguments, rather than a fixed number, are known as variadic functions in the professional literature. Within the context of googology however I will use the term Array to refer to functions of a variable number of arguments. Here is a formal definition:

An Array is a computable function which takes an ordered list of numeric arguments as input and produces a single signature numeric output.

The first googologist to use the term array was Jonathan Bowers' when defined his infamous array notation. An array however is already a term used in computer science to refer to an ordered list of memory storage locations. The two concepts are closely related, the main difference between them being that an array in computer science, is merely an input structure, and does not compute anything, where as an array in the googolical sense, is something which does some sort of computation on the input structure. When we get deeper into the subject we will want to properly distinguish an array, from a input structure, but we needn't get too technical here.

We can make a distinction between two types of arrays: fixed arrays, and scalable arrays. A fixed array must receive a fixed number of arguments to perform a computation, where as a scalable array may take any whole number of arguments, and still perform a computation. A restricted scalable array, may not be able to compute if the number of arguments is too low. For example a scalable array may not be defined for arity=0, but defined for any arity>0. In this case we would say this was a restricted scalable array.

When I use the term array in general however, I will mean a scalable array. So what kinds of array's can we define using only elementary functions. Admittedly, the possibilities are rather limited. We might as always, take the sum of all the arguments. For convenience we'll say that if there are no arguments the sum = 0. We can define the Array, A, as follows:

Let A be an array, A(a₁,a₂,...,a_k), where a₁ through a_k are integers, and the number of arguments, k, may be any whole number.

A is then defined as follows:

A(a₁,a₂, ... ,a_k) = 0 + a₁ + a₂ + ... + a_k

This function is fairly straight forward. For example we can say that:

A(1,2,3) = 0 + 1 + 2 + 3 = 6

A(-5,6,-19,4) = 0 + (-5) + 6 + (-19) + 4 = -14

A(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1) = 20

A() = 0

A(0,0,0) = 0 + 0 + 0 + 0 = 0

etc.

Array A may take any n-structure and produce a definite output. This generality is helpful. In some ways, an array can really be thought of as an infinite succession of multi-variable functions rolled into one. For example we might say that:

f₀() = 0

f₁(a₁) = a₁

f₂(a₁,a₂) = a₁+ a₂

f₃(a₁,a₂,a₃) = a₁ + a₂ + a₃

etc.

Then we can define A as:

A(a₁,a₂, ... ,a_k) = f_k(a₁,a₂, ... ,a_k) if k>0, otherwise

A() = f₀()

So arrays are something like piecewise functions of a variable number of arguments. In some sense however, arrays are something very different than the multi-variable functions. Note that we are not actually using a single formula to describe what the array does. Rather we have the notion of a generic formula which takes n arguments and finds it's sum. There is little difficulty here however because the concept is fairly simple in this example. When we develop more complex arrays however we'll see that a single rule is not sufficient to describe complex behavior. For now however, we can still think of functions as being defined by a single formula, or rule.

So is an array the most general concept of a function we will be using. No. We will find that in our goal to define larger and larger numbers through functions, we will need to develop an even more general concept of a function, than even that of variadic functions. This is where the concept of a structure comes to the forefront, and something very interesting emerges...

Higher Structures

In professional mathematics, the variadic functions represent the most general concept of a function used in almost all fields, including computer science. It is at this point that googology departs from mainstream mathematics and forges on ahead. Key to the further development of functions is the concept of a structure of arguments.

In both multi-variable and variadic functions, we have arguments arrayed in a successor relation, with a first and last member. If we were to remove the numerical concept of the arguments, and only consider the way they arranged, we would have the skeletal framework, the Structure, of the input. Is putting the arguments in succession the only way to structure them? We might consider other possible structures. For example, we might imagine a matrix of arguments, in which some arguments are above, below, to the left, and to the right, of any argument:

( a a a a ... a )

... ... ...

(a a a a ... a )

A Matrix Structure can be understood as a series of sequential rows, each which itself is a series of sequential arguments. Here we can give a formal definition:

A Matrix is an ordered list of Arrays where an Array is an ordered list of arguments.

So basically a Matrix is an array of arrays. But is this really a new structure? If a Matrix is just an array of arrays couldn't we just list the arguments in this order: list the arguments of the first array, followed by the arguments of the second array, and continue until you've listed all the arrays in the Matrix.

If the arguments could be arranged as an array without effecting how the structure works, then we can say that the Matrix is not really a new structure. However if the structure can not be reduced without effecting it's operation, then it truly is a new and radically different kind of structure.

So consider the following. Imagine we define a Matrix which is computed by first taking the sum of each row, to obtain a series of row totals, and then we take the product of all row totals to obtain the output of the matrix. We will agree in advance every row must contain at least one argument, and the matrix must contain at least one row. The rows aren't required to be the same length. We can label the arguments as "a_i,j" where this is the ith argument of the jth row. So we can use the following general definition for our array:

( a_1,1 a_2,1 a_3,1 a_4,1 ... a_i1,1 )

( a_1,2 a_2,2 a_3,2 a_4,2 ... a_i2,2 )

( a_1,3 a_2,3 a_3,3 a_4,3 ... a_i3,3 )

( a_1,4 a_2,4 a_3,4 a_4,4 ... a_i4,4 )

... ... ... ... ... ...

( a_1,j a_2,j a_3,j a_4,j ... a_ij,j )

= +

( a_1,1+a_2,1+a_3,1+ ... +a_i1,1 )( a_1,2+a_2,2+a_3,2+...+a_i2,2 ) ... ( a_1,j+a_2,j+a_3,j+ ... +a_ij,j )

So as an example:

(3 2 4)

(1 2 3)

(5 6 2)

(3+2+4)(1+2+3)(5+6+2) = 9*6*13 = 54*13 = 702

If we rewrite this structure as an array in the previously prescribed order then we would have:

(3,2,4,1,2,3,5,6,2)

Offhandedly we might assume there is no ambiguity involved here and we could easily compute this array and obtain the result of 702, but now consider this alternative matrix:

(3 2 4 1 2)

(3 5 6 2)

(3+2+4+1+2)(3+5+6+2) = 12*16 = 192

If we were to convert this into an array we would also obtain:

(3,2,4,1,2,3,5,6,2)

Both Matrices are being mapped to the same array. How then do we know what Matrix the Array is representing? We need some way to demarcate the boundaries between rows. We can do this by using a semi-colon, ";". So the first Matrix can be represented by the array:

(3,2,4;1,2,3;5,6,2)

and the second can be represented by the array:

(3,2,4,1,2;3,5,6,2)

The problem is that these are no longer arrays, in that the structures are no longer just an ordered set of arguments. We must also take into consideration the separators between the arguments. So we conclude that there are structures beyond arrays that have radically different properties which are non-reducible.

So if there are structures beyond arrays, are there structures beyond Matrices? How far do such structures extend? How would we describe them? What are the general properties of all such structures? These are the questions for many chapters to come, yet we are not quite prepared to answer those questions just yet. As we progress with recursive functions we will gain a more and more clear picture of what a structure is, and how they work.

However we can begin with a provisional definition. A basic assumption of the theory of such structures is that they can always be reduced to what Chris Bird calls an inline form. For example, we could imagine extending Matrices to the third dimension. Is it possible to reduce such 3-dimensional spaces to a linear form? Yes. All we need to do is have 3 separators: one for arguments in a row, a second for separating rows within a plane, and a third for separating planes within the space. So we can see that the main feature of structures is that they are an ordered list of arguments which are separated by a predefined set of separators.

For example, we might use the separators:

, ; #

to represent the operations of addition, multiplication, and exponentiation respectively. We further require that all additions must be carried out amongst adjacent arguments, before multiplications, and these must be carried out before exponentiations. Exponentiations then must be carried out from right to left, meaning start with the last two arguments first, and work your way gradually to the left. For example we could evaluate the following:

(3,2;1,3#3,2;2,1#1,1;1,1)

((3+2);(1+3)#(3+2);(2+1)#(1+1);(1+1))

(5;4#5;3#2;2)

((5*4)#(5*3)#(2*2))

(20#15#4)

(20#(15^4))

(20#50625)

20^50625

4.4E65,864

What this implies is that when we carry out ordinary arithmetic, it can not be interpreted merely as a function which takes series of arguments and produces an output. The operations involved must also be signified in someway. So a class of functions greater than even arrays is needed to express what goes on when we resolve arithmetic expressions. This example also implies that it is possible to reduce complex mathematical expressions into an inline format.

There are a few reasons to strongly suspect that any mathematical idea can be expressed as a string of symbols. First and foremost, Turing Machines, of which we will learn more of much later, are said to be able to express anything which is computable. Yet Turing Machines operate on a simple string of 1s and 0s. Secondly, Godel's work on the incompleteness theorems were founded on the idea of converting any mathematical statement about the positive integers into a string of symbols which could be encoded back into the positive integers. Obviously Godel felt pretty confident that this could be done in more than just theory, but practice, otherwise his argument wouldn't have much weight. So there is definitely supporting evidence in academia, that mathematicians implicitly believe strings of symbols are sufficient to describe any mathematical truth, even though using superscripts, subscripts, etc. might be more convenient for anything but a computer. Another compelling reason outside of academia, is that Jonathan Bowers' Array Notation, extended the notion of spatial notation to an utterly absurd degree, ... and yet Chris Bird was still able to reduce it to an inline form. We will therefore begin with the working assumption that our theory of structures can be understood entirely using strings of symbols. Put more dramatically, we will work on the assumption that any structure, no matter how complex, can be described by a string of symbols.

So we will begin by defining a structure as follows:

A Structure is anything which can be expressed as a string of numeric, and non-numeric symbols:

ex.

&*(4*89484789$49664897^489&^*(493569##&*

A Structure has no "meaning" in and of itself, and must be interpreted in some way by an interpreter. An argument is defined by any sub-sequence of digits, so in the above example we have the arguments:

89484789

49664897

489

493569

Everything else is considered a non-numeric symbol. These act like punctuation marks between nouns (arguments). Just like the arguments, these punctuation marks, which we will call delimiters, are defined by any sub-sequence of non-numeric symbols. So our example we have the delimiters:

&*(

&^*(

##&*

Note that two delimiters will only be considered the same if they are exactly the same sequence of non-numeric symbols.

The interpreter takes the structure, interprets the punctuation along with the arguments and produces some kind of output. For our purposes here the interpreter will output a single numeric output.

If a structure begins with a delimiter, this delimiter is called the left-end encapsulation mark. Such a mark is optional. If a structure ends with a delimiter, this delimiter is called the right-end encapsulation mark. This is also optional.

Note that regardless of what string we would consider, we could break it up into an alternating sequence of non-numeric and numeric symbols. In other words, every structure is simply an alternating sequence of arguments and delimiters:

&*(4*89484789$49664897^489&^*(493569##&*

Here the arguments have been highlighted in blue, and the delimiters in red. So we can simplify our definition of a structure, and yet provide a much more useful definition:

A Structure is an alternating sequence of arguments and delimiters.

We can notate this symbolically. We will use a_i to represent the ith argument, and /_i to represent the ith delimiter. Let S be the symbol for any structure. We can now say that:

S = (/₀)a₁/₁a₂/₂a₃/₃... a_n-1/_n-1a_n(/_n)

The parenthesis around the first and last delimiter signifies that these are optional. These encapsulation marks, are usually part of the function notation, where as everything in-between them is the input string. The term that I use for the input string is the struct (short for structure). The concept of a struct is defined as follows:

A Struct, $, is an alternating sequence of arguments and delimiters, that begins and ends with an argument, or is the empty string.

Symbolically we can say:

$ = a₁/₁a₂/₂a₃/₃... a_n-1/_n-1a_n

The struct consisting of no arguments or delimiters, is the empty struct. Note that this definition already would include arrays. Simply replace all delimiters with commas. It would also include matrices; simply let there be two kinds of delimiters.

The idea of a struct as an alternating sequence of arguments and delimiters gives us a pretty good idea of what to expect as we progress forward. However, even this is somewhat incomplete. Consider how we might expand upon this basic idea.

We could imagine that the delimiters /₁ through /_n-1 are chosen from a finite list of predefined non-numeric strings. But what about having an infinite number of such delimiters? Is that possible?

Yes it is. For example we might use the infinite series of delimiters:

#, ##, ###, ####, ...

It should be noted that delimiters have a definite rank, in a delimiter hierarchy. This hierarchy must be determined in advance. Can we go further still? Yes. First we replace such strings with a simple numeric index:

###...### w/n #s = #[n]

We now have the delimiter sequence:

#[1], #[2], #[3], #[4], ...

To add more delimiters, we simply come up with a delimiter which appears nowhere on the above this, ... even if it were extended without limit. We could use #[1,2] for example. This can not occur anywhere on the above list. But notice what we now have, our delimiters are now themselves structures, with an internal struct. These are not functions, because we don't evaluate them in isolation, but they are structurally identical to the function notation. So we revise our definition of a struct to accommodate this idea, using a clever recursive definition:

General Definition of a Struct

$ = a₁/₁a₂/₂a₃/₃... a_n-1/_n-1a_n

Where /_ican be chosen from the set of delimiters := {d₁,d₂,d₃, ... }

or /_i may itself be a encapsulated struct, S

This will be our working definition of a Structure, and a Struct, going forward.

What we want to study, moving forward, is how define functions of the form f($) which generate extremely large outputs.

This very general definition of a function however, is not in itself sufficient to generate very large numbers! If we merely restrict ourselves to elementary formulas, we will not generate anything larger than what we could have done without structures!! Why then have I bothered to elaborate on the concept?! Because, with one additional ingredient, structures come alive and will generate numbers much much larger than you probably ever dared to imagine. That extra ingredient is : recursion. You can think of structures as a mountain of dynamite, innocuous in and of itself. Adding Recursion is then like lighting a match and tossing it on the dynamite! The result is an explosion huge enough to be seen across the universe!!!

Now that we have reached our most general notion of a function, as something which interprets a structure, we will explore how new functions can be generated from the elementary functions. This will lead us directly to recursion.