Array Notation
As I've been studying large numbers, I developed various notations to represent them.  The three main ones I use are:  extended operater notation, array notation, and extended array notation.  The extended operator notation and the array notation are two ways of writing the same thing, the array notation is cleaner looking, but the extended operator notation can give one a feel of how large the numbers get.  The extended array notation leads to unspeakably enormous numbers, so huge that the other notations cant even come close.  Following are the 5 rules to solve the array notation - first use rule 1 if it applies, if not then use rule 2, etc.  If rules 1 through 4 doesn't apply then rule 5 will.
Rule 1: Condition - only 1 or 2 entries - {a}  = a,  {a,b} = a+b. (in other words take the sum of the entries).
Rule 2: Condition - last entry is 1 - {a,b,c,...,k,1}  =  {a,b,c,...,k} (in other words remove trailing 1's).
Rule 3: Condition - 2nd entry is 1 - {a,1,c,d,..,k}  = a.
Rule 4: Condition - 3rd entry is 1 - {a,b,1,..,1,d,e,..,k}  = {a,a,a,..,{a,b-1,1,..,1,d,e,..,k},d-1,e,..,k} - the ".." between the 1's represent 1's - there can be any number of ones, from 1 "1" (3rd entry alone) to a string of 1s - the last 1 of this string is what becomes {a,b-1,1,..,1,d,e,..,k} all entries prior becomes "a".  For an array like this {3,2,1,1,1,5,1,2}  the last 1 in the string is the one before the 5 (not the one after - since it is a different string of 1s).
Rule 5: Condition - Rules 1-4 doesn't apply - {a,b,c,d,...,k} = {a,{a,b-1,c,d,...,k},c-1,d,..,k}.
I usually use angle brackets instead of {}, but angle brackets dont like to show up right on the web site.
I also have names for the various entries.
Consider {a,b,c,d,e,f}

a is the base
b is the extender
c is the operator
d is the level of operators
e is the level of level of operators
f is the level of level of level of operators.
Here are some results:

{a,b,1} = a+b
{a,b,2} = a*b
{a,b,3} = a^b
{a,b,4} = a {4} b (a tetrated to b) = a^(a^(a^(....a^(a^a)..))   or a to the power of itself b times.
{a,b,5} = a tetrated to itself b times = a {4} (a {4} (a {4} ....a)) = a {5} b (a pentated to b).  etc...
My extended operator notation - is related to my array notation in this way:

a {c} b = {a,b,c}, where c=1,2,3,4,5 etc represents adding, multiplying, exponentiation, tetration, pentation, etc. (I first encountered the names tetration, pentation, etc. in a book which I no longer remember the name).

a {{c}} b = {a,b,c,2}
a {{{c}}} b = {a,b,c,3}  etc.

a {{1}} b =  a { a { a....a { a { a } a } a.... a } a } a   (b a's from center out) - I call this a expanded to b
a {{2}} b = a expanded to itself b times (or a multiexpanded to b) = a {{1}} (a {{1}} (a {{1}} (a ....   (b times)
a {{3}} b = a multiexpanded to itself b times (or a powerexpanded to b)
a {{4}} b = a powerexpanded to itself b times (or a expandotetrated to b)
etc.
a {{{1}}} b = a {{ a {{ a ... a {{ a {{ a }} a }} a ...  a }} a }} a ( b a's from center out) - I call this a exploded to b.
a {{{2}}} b = a exploded to itself b times (a multiexploded to b)
a {{{3}}} b = a multiexploded to itself b times (a powerexploded to b)
a {{{4}}} b = a powerexploded to itself b times (a explodotetrated to b)
etc.
a {{{{1}}}} b = a detonated to b = {a,b,1,4}
a {{{{{1}}}}} b = a pentonated to b = {a,b,1,5}
{a,b,1,1,2} = {a,a,a,{a,b-1,1,1,2}} = a {{{{{{{....{{{a}}}....}}}}}}} a (where there are a {{{{{...{{a}}...}}}}} a angle brackets (where there are a {{{{..{{a}}..}}}} a angle brackets ( where there are .......b times ..... (where there are a angle brackets))))))  -  YIKES!!
I have operator notations for up to 8 entry arrays ( i.e. {a,b,c,d,e,f,g,h}), however they will be quite cumbersome to type out - a,b,and c are shown in numeric form, d is represented by angle brackets (as seen above), e is shown by [ ] like brackets, but rotated 90 degrees, where the brackets are above and below (uses e-1 bracket sets), f is shown by drawing f-1 vertical Saturn like rings around it, g is shown by drawing g-1 X-wing brackets around it, while h is shown by sandwiching all this in between h-1 3-D versions of [ ] brackets (above and below) which look like square plates with short side walls facing inwards.
Notice that my array notation uses a 1-D array, I later came up with an extended array notation which involves any number of dimensions in the arrays.

/a,b\   =   {a,a,a,a,a,....,a}  (b-a's)
\2   /  

/a,b\  =  /a,a,a,a,......,a\   (b a's)
\k   /      \k-1                 /

{a,b}       /a,a,a,......,a\
| 2  |  =   |a,a,a,.......,a|   (bxb array of a's)
{    }       |a,a,a,.......,a|   (the 2 is going into 3rd dimension - if it was a k, then it would be reduced to k-1
             |..................|    and still be in the 2nd plane.
             |..................|
              \a,a,a,.....,a/
The extended array notation has 7 rules (use to be 8 rules, but two of them could fuse together), the first 5 rules are similar to the array notation, the 6th rule is similar to what's shown above - these rules will be quite combersome to type out - due to the dimensionality of the brackets.  I'll soon provide a jpeg of these 7 rules to display them better.
Here is a brief description of the 7 rules of extended array notation:

Rule 1:  If there are only one or two entries on the main row and nothing beyond the main row - then take the sum of the entries to solve the array (an extention of rule 1 of the array notation).
Rule 2:  If rule 1 doesn't apply and if there are 1's on the end of any rows, remove them (but leave a placeholder 1 to keep the row from being deleted) - if there are any rows on the end of each plane that consists of a single one, then remove them (leave a place holder 1 for the plane if needed to keep from deleting it) - ... if there are any n-spaces on the end of an n+1-space that consists of a single one, then remove them (leave place holder 1 for the n+1 space to keep from deleting it),... - this rule removes insignificate 1s and is an expansion of rule 2 of array notation.
Rule 3:  If second entry is a 1 and first two rules doesn't apply - then take the base entry as the solution to the array (similar to rule 3 of array notation).
Rule 4:  If third "significate entry" (could be third entry, or an entry on another row, plane,..n-space) is a 1 and rules 1-3 don't apply, then define k as the largest number that the following is true:  the pth significate entry is 1 for all p (3<=p<=k) and the k+1th entry is in the same row as the kth entry - then the kth significate entry becomes entire array with second entry reduced by 1, k+1th significate entry is reduced by 1, entries beyond k+1 remain the same, all significate entries before k becomes the base entry. (extention of rule 4 of array notation).
Rule 5:  If rules 1-4 don't apply and the main row has atleast 3 entries - then the second entry becomes the entire array with the second entry reduced by 1, the third entry is reduced by 1, the base and all entries after the third remain the same.
Rule 6:  If rules 1-5 don't apply and if main row contains only first two entries, and the next significate entry is not a 1 - then the next significate entry would be in the next d-space - d>0 (if d=1, then entry in next row, if d=2 then in next plane, etc.) - solve array as such, the third (next) significant entry is reduced by 1, all entries beyond remain the same, and the main d-space becomes a b^d array of a's (a=base, b=2nd entry).
Rule 7:  If other rules don't apply and the main row has only first two enties, and the third significate entry is a 1 then define k just like in rule 4, but since rule 4 doesn't apply then the kth and k+1th significate entry is not on the same row, so it must be in the next d-space, the kth significate entry would then be the only entry in it's d-space - if not it would of been an insignificate 1 and would of been removed, so it must be a significate place holder 1.  The k+1th significate entry is reduced by 1, entries beyond remain the same, the first k-1 significate entries become the base and the entire d-space where the kth significate entry is becomes a b^d array of a's (a and b are the base and second entries).

Entries are read in "book" order - read first row from left to right, then read next row left to right, until you read the first plane (or page), then read next page, until you finish the "book" (representing realm = 3-space) - then read the next book until the shelf of books are done (representing 4-space) - then read the next shelf, until book case is finished (5-space) - etc.  The main row is the very first row to read, the main n-space is the first n-space to read.
Significance Rules:  Any non-1 entry is significate (entries can be any positive integer) - any row with a non-1 entry is significate, any n-space with a non-1 entry is significate.  Any entry between two significate entries on same row is significate, any row between significate rows in same plane is a significate row, any n-space between two significate n-spaces in the same n+1-space is significate.  First entry on any significate n-space is significate.  First two entries on main row are significate.  Significate 1's are not removed by rule 2, they act as place holders.
Back to home page

 

page created with Easy Designer