DeepLineMadom's Array Notation, also shortened to DLMAN, is a notation made by googology wiki user DeepLineMadom. It has the format a[#]b where # is an array. It comes in multiple parts. An example of a valid array is 10[1,3,5]4. The notation is defined similarly to the Username5243's Array Notation.

Unfortunately, the creator semi-abandoned this notation on June 5, 2022.

## Parts

We explain parts of notations together with the creator's expectation of the limits.

• Basic Array Notation (BAN): hardly even an array notation! Just the expression a[c]b, which equal to the hyper operators starting from addition, multiplication, exponentiation, and so on. The limit of this is approximated to $$\omega$$ in the fast-growing hierarchy.
• Linear Array Notation (LAN): takes linear arrays. Close equivalent with BEAF and Strong array notation. The limit of this is approximated to $$\omega^{\omega}$$ in the fast-growing hierarchy.
• Extended Array Notation (XAN): uses planar, dimensional, hyperdimensional, and nested arrays. The limit of this is approximated to $$\varepsilon_0$$ in the fast-growing hierarchy.
• First-order Array Notation (FoAN): adds a separator called the first-order hyperseparators (/ is the shorthand for 1 or <1> hyperseparator). The limit of this is approximated to $$\Gamma_0$$ in the fast-growing hierarchy.
• Extended First-order Array Notation (XFoAN): adds inner hyperseparators to extend the first-order hyperseparators. The limit of this is approximated to $$\psi_0(\varepsilon_{\Omega+1}) = \psi_0(\Omega_2)$$ with respect to the (extended) Buchholz's function in the fast-growing hierarchy.
• Second-order Array Notation (SoAN): adds a separator called the second-order hyperseparators. The limit of this is approximated to $$\psi_0(\varepsilon_{\Omega_2+1}) = \psi_0(\Omega_3)$$ with respect to the (extended) Buchholz's function in the fast-growing hierarchy.
• Higher-order Array Notation (HoAN): adds some higher-order hyperseparators. The limit of this is approximated to $$\psi_0(\Omega_{\omega})$$ with respect to the (extended) Buchholz's function in the fast-growing hierarchy.
• Primitive Expanding Array Notation (PExpaAN): adds some ranking separators, which play the role similarly to the strong array notation. The limit of this is approximated to $$\psi_0(\Phi_1(0))$$ with respect to the extended Buchholz's function in the fast-growing hierarchy.
• Extended Expanding Array Notation (XExpaAN): allowing the ranking separators to be expanded further. The limit of this is approximated to $$\psi(M(2;0))$$ using fundamental sequences for the function collapsing $$\alpha$$-weakly Mahlo cardinals, given according to the creator.

For parts beyond XExpaAN, the creator clarifies that he or she intends to create at least twelve other parts in the site and later semi-abandoned by the creator:

• Exploding Array Notation (ExplAN)
• Detonating Array Notation (DetAN)
• Nuclear Array Notation (NAN)
• Solar Array Notation (SolAN)
• Stellar Array Notation (SteAN)
• Celestial Array Notation (CAN)
• Supernova Array Notation (SupAN)
• Neutron Array Notation (NeuAN)
• Galactic Array Notation (GaxAN)
• Hypergalactic Array Notation (HGAN)
• Universal Array Notation (UAN)
• Multiversal Array Notation (MAN)

## Definition

The basic array notation uses pretty much the same rules as arrow notation, except it starts at addition (ab) first, then multiplication (ab), then exponentiation (ab); as well as ab equals to a+1, it is effectively just a different notation for the same function.

• Successor Rule: ab = a+1
• Base Rule: ab = a+b, ab = ab, ab = a^b
• Prime Rule: a[c]1 = a
• Recursion Rule: a[c]b = a[c-1](a[c](b-1))

Note that according to the list of numbers, arrays always solve from right to left. The second part adds some new rules and revises previous rules:

• Base Rule: ab = a+1, ab = a+b, ab = ab, ab = a^b
• Tailing Rule: a[#,1]b = a[#]b
• Prime Rule: a[%]1 = a
• Recursion Rule: a[c%]b = a[c-1%](a[c%](b-1))
• If none of them apply, do the following process:
• Case A: If the first entries are 1, replace the 1's with strings of a's followed by b, and replace b inside iterator with a (i.e. a[1,1,...,1,1,c,d%]b = a[a,a,...,a,b,c-1,d%]a).
• Case B: If the first entries are greater than 1, do the recursion rule above (i.e. a[c,d,e,...,n%]b = a[c-1,d,e,...,n%](a[c,d,e,...,n%](b-1)).

The third part adds some new separators, which are denoted with the numbers inside curly brackets, {}. Commas indicate {1} separator.

• Reuse the rules for linear arrays to that row (after separators other than commas).
• If there is a comma before it, then decrease it by one, change the previous entry to the iterator, and change the iterator to the base.
• If there is a {2} before it, decrease it by one, then change 1{2}m to 1,1,...,1,2{2}m-1 with the iterator ones, then change the iterator to the base. End the process.
• If there is {n} before it where n ≥ 2, replace the previous 1{n}m with 1{n-1}1{n-1}1{n-1}...{n-1}2{n}m-1 with the iterator ones, then change the iterator to the base. End the process.

In hyper-dimensional and nested arrays, the rules are the same as each other, arrays with separators that merely contain commas as separators inside {} separator are called hyper-dimensional arrays. Again, all that changes is case B.

• If there is a comma before it, then decrease it by one, change the previous entry to the iterator, and change the iterator to the base.
• If there is {m,n%} before it where n ≥ 1, replace the previous 1{m,n%}x with 1{m-1,n%}1{m-1,n%}1{m-1,n%}...{m-1,n%}2{m,n%}x-1 with the iterator zeroes, then change the iterator to the base. End the process.
• For nested arrays, do the same rules as the previous rules in that part.

On the other hand, this notation is only defined for any natural numbers a and b greater than or equal to 1, and only the basic notation is defined for # = 0.

## Issues

The original definition for the basic notation (and, by extension, all later parts of the original definition of the notation) was ill-defined as the domain for a, b, and c is not declared.

However, the current definition has been fixed by specifying the domain for a as positive integers, b and c as non-negative integers for the basic notation, as well as adding the conditions that b >= 1 and c >= 0 to the recursion rule.