## Introduction

This googological form was created with the intent of implementing a curious little "method" I've been thinking about for some time. It pulls inspiration from various array notations, notably from moments where an entire array itself basically goes into an existing entry. The following characteristics are obviously subject to change, but the key aspects explored in DAN should remain.

## Process of developing base rules

On to the mathematics! Consider a modified form of addition, using some arbitrary symbol such as **:**, whereby the entire expression is more or less inserted into itself, progressively from left to right. During such an insertion, all : operators in the inserted expression become regular + operators. Furthermore, as each term becomes embedded, the preceding : operator gets changed to a + sign. Observe the following example,
\begin{array}{rcl}
:1:1:1&=&+(+1+1+1):1:1\\
&\equiv&3:1:1\\
&=&3+(3+1+1):1\\
&\equiv&3+5:1\\
&=&3+5+(3+5+1)\\
&\equiv&3+5+9=17
\end{array}
Note how the final addition expression remained unevaluated so long as any : signs remained. It happens to abide by the expression \(2^x(x-1)+1\), where *x* is the quantity of 1s. This is a very roundabout way of simply embedding an addition expression into itself, but it provides a principal in which a self-embedding sequence can eventually terminate so as to actually evaluate to something.

This idea is **the** driving force behind this notation; to basically duplicate the current sequence of whatever information, from left to right, up to a certain point.

The beginning to DAN will be related to these sequences of 1s according to the following pattern. (\(\langle n\rangle\) is the **seed value**.)
\begin{array}{rcl}
\langle n\rangle[0]&=&n\\
\langle n\rangle[m+1]&=&2^{\langle n\rangle[m]}(\langle n\rangle[m]-1)+1
\end{array}

## Structures in the parent

On to extending the **parent array** (the portion with **[...]**) to further entries. I must begin by describing valid structural types of a DAN array, then demonstrate syntax for such structures.

-The level of structure, denoted with *r*, can be thought of as a nesting of parenthesis (or the parent brackets) which is r-deep.

-An entry is a structure in which r=0, and one or more entries surrounded by parentheses (or the parent brackets) is a 1-structure.

-The elements in an r+1 structure must all be of level r structure. (Example: no entries in a 2-structure without being "wrapped up" in parentheses themselves)

-The parent (& only the parent) uses brackets instead of parentheses merely to avoid confusion with the often multitude of parentheses. (When duplicating the array, the brackets of the to-be-inserted array are changed to parentheses)

-Examples: *[((6))]*, *(((5)))*, and *(((4,3),(2)),((1)))* are all 3-structures, which contain only 2-structures, which contain only... etc.

## First duplication dynamic

Unfortunately I was unable to come up with sensical mathematical definition for this rule, as it involves step-by-step, iterative, fractalic replacements in the entries themselves. That said, a verbal description should be sufficient.

This rule applies iff there are 2 or more entries in the parent array and the **active entry** (rightmost nonzero number) is contained in a 1-structure with two or more entries.
**1-** Decrease the active entry.
**2-** Note all entries in the parent array, sans the active entry.
**3-** From left to right, replace each *noted* entry (and absolutely no others) with the entire expression (including the seed value and the parent).

It is important to recognize how the replacements increase in power as previous entries to the left are now typically much larger and therefore contribute more strongly to the replacements of further entries to the right. Below is a pseudo-expression for what is going on,
\[\langle n\rangle[@,m+1]=\langle n\rangle[\text{replacing}(@),m]\] as well as an example:\begin{array}{rcl}\langle2\rangle[3,2,1]&\Rightarrow&\langle2\rangle[\langle2\rangle[3,2,0],2,0]\\
&\Rightarrow&\langle2\rangle[\langle2\rangle[3,2,0],\langle2\rangle[\langle2\rangle[3,2,0],2,0],0]\\
&=&\langle2\rangle[\langle2\rangle[3,2],\langle2\rangle[\langle2\rangle[3,2],2]]
\end{array}

## Second duplication dynamic

This rule doesn't increase the values in each entry, but rather creates many more without running into termination issues. Again, I cannot create a concise formula, but can only explain the algorithm.

This rule applies iff there are 2 or more entries in the parent array and the active entry is the only entry in its 1-structure (aka, the last remaining entry).
**1-** Decrease the active entry.
**2-** Note the r-value of the structure which contains only the active entry and nothing else.
**3-** Note all r-structures in the parent array, sans the active entry's structure.
**4-** From left to right, replace the r-1 structures within each *noted* r structure with all r-1 structures.

When replacing r-1 structures with themselves, it is important not to include any "outer parenthetical shelling", as that would be equivalent to putting structures greater than r-1 into those very structures. (This would be like trying to put an array (not to be evaluated) into a number; it doesn't make very much sense.) Below is a short, albeit messy example:
\begin{array}{rcl}\langle2\rangle[(3,2),(1)]&\Rightarrow&\langle2\rangle[(3,2,3,2,2),(0)]\\
&=&\langle2\rangle[3,2,3,2,2]\end{array}

## Proof of termination

There are several crucial explanations as to why this notation eventually ends for any jumble of structures and whatnot. Firstly, the active entry *always* decreases, eventually reaching 0, which can then be ignored. Secondly, the index of the highest structure containing the active entry *never* increases, meaning that such a structure eventually does become empty, allowing the next structure to be emptied, and so on, until the final structure is left. Once there is only one structure left of level-r, then the outermost parentheses can be removed and all of the (now numerous) r-1 structures can be emptied. This process repeats until only a single list of entries in the parent array remain, then only one entry, at which point the base case can finally be invoked.

## Conclusion

This is a very *messy* notation I admit, but it seems to lack any major definition issues or termination flaws, as far as I can tell. However, please inform me if you happen to notice anything I couldn't find myself.

The feature I'm the least decided on is the seed value, \(\langle n\rangle\), as it seems less related to the rest of the notation. However, an interesting result through the inclusion of this seed is the inherited domain compatibility with all reals (I just think it's kind of neat).

I am incredibly eager to discuss any and all aspects of this mechanism I came up with. (Constructive) criticisms, questions, and suggestions are very welcome!