Plexation is, of short, a googological method I have came up with lately, in an attempt to create big numbers, REALY big numbers.

It's simple, easily definable, and sets the basis for the quite powerful Terminal array Notation.

The basic defenition is this,

Where Z0=n
And Zn+1=Zn^ZnZn

For starters, I'll name the very first number you can get by setting a integer at "n"


Now, this number is small, very small, and is equal to (You guessed it), 1.

The second number, )2(, or a Biplex is the first interesting case in which plexation takes a small number, and inevitably, turns it into a large one.

A Biplex is equal to 4^^^^4, or, aproximated in Hyper-E-notation, E1##1##(1#1#154).

Wow. that's big. And to think that all we used was 2. Clearly a Triplex, or a Quadraplex would be much, much, greater.

This starting function has a mere growth speed of f[omega+1] (n).

(For those of you BEAF users, the entire thing can be simplified to this:

)n( = 3&(3&(3&...&(3&n)))))))) (n 3's).

Terminal string Notation

We're finally past plexation, and now, with our base function defined, we can at last move on to the main purpose of this blog.

TsN is, in short, a multi-dimensional string of numbers with define a recursive line of nested functions (depending what our base function is), that will cascadingly grow in ways only the definition can tell.

] - represents the beggining of the entire string

[ - represents the end of the entire string

n - can be any integer, and represents a member. Once it becomes 0, it is no longer am member, and is removed from the string. (eg. ](n {x} n) {x} 0[ = ]n {x} n[

{m} - represents a m'th dimansional gap in the string, THIS IS NOT A MEMBER

The definition of one dimentional strings is as follows, take the last two numbers in the entire string, reduce the last member by one and apply the base function on the second last member (we will call solved numbers "members" for now).


...n {1} m[ = ...)))...)))n(((...((([ with m nested functions.

Eventually, we will reduse all but the first member to 0, and at that point, we get our final value, the last remaining member.

For example, ]3 {1} 3 {1} 3[ = ]3 {1} )3( {1} 2[ = ]3 {1} )))3((([ = )))))...( )))3((( times)...)))3(((...( )))3((( times)...(((.

In more-than-1 dimentional strings, the rule is simply this, take the last and second last member of a n'th dimentioal string, reduce the last by one, and (given the second last member is x) make a (n-1) dimentional string of x's x members long, in the place the second-last member previously was.


...n {x} m[ = ...(n {x-1} n {x-1} n {x-1}... (n members) ... {x-1} n) {x} m-1[

For example, ]4 {4} 4[ = ](4 {3} 4 {3} 4 {3} 4) {4} 3[ = and so on...

I lower bounded ]n {n} 1[ as f[(omega^2)] (n).

Alternate versions

If we want to be a bit more crafty, we can replace the base function (Zn+1=Zn^ZnZn) with a few variants in order to get more powerful, simple,or aesthetic results.

  • Zn! This is obviously weaker, yet simpler to solve and understand.
  • Zn+1

=Zn^ZnZn , yet here, we use the slightly weaker variant of arrow notation.

  • Zn+1

=Zn&ZnZThis is a form of recursion, defined as: <0;0;1> (I'll get to that later).

But most importantly,

  • Zn+1

=]Zn {ZnZn[ This will be important for the next stage of TsN.

Higher-order Terminal string Notation

HoTsN is to be expressed as follows: ]a {b(c)} 1[

a represents the base integer, which we will perform most functions on.

b represents the dimension, or hyper-dimension (read above to see what it means).

c represents the dimensional order, and will serve as the key factor in most of the following variants of TsN.

HoTsN is solved in an identical way to TsN, only we replace the base-function, Zn+1=Zn^ZnZn, with the following: ]Zn {Zn(c-1)Zn[

As you can see, this function is one order below the expresion we started with. How do we solve it? Presicely in the way we solved ]a {b(c)} 1[.

(the folowing are uncertain, and depend heavily on definition)

]n {n(1)} 1[ has a growth speed of f[(omega^2)+omega] (n)

]n {n(2)} 1[ has a growth speed of f[(omega^2)+omega*2] (n)

]n {n(n)} 1[ has a growth speed of f[(omega^2)*2] (n)

Multiple order-levels

If we want to bring it further, we can add an additional order, or: ]a {b(c,d)} 1[.

Same as before, only this time, we replace the base-function with: ]Zn {Zn(Zn,d-1)Zn[

The same logic can be applied on: ]a {b(c,d,e)} 1[, ]a {b(c,d,e,f)} 1[, ]a {b(c,d,e,f,g,h,...)} 1[

Now, if you've been listening so far, you might notice that the previous orders becomes obsolete, and will have no effect on the outcome. Hence, we can express ]a {b(c,d,e,f,g,h,...)} 1[ as ]a {b([n]x)} 1[, where x is the last order, and n is the number of obsolete orders.

]n {n([1]n)} 1[ has a growth speed of f[(omega^3)*2] (n)

]n {n([2]n)} 1[ has a growth speed of (uncertain) f[(omega^4)*2] (n)

]n {n([n]n)} 1[ (n orders) has a growth speed of f[(omega^omega)*2] (n)

(Again, I could be wrong, comment below if you think I made a mistake.)

Multiple-order-hyper-level Terminal string Notation

MohlTsN is the first advancment after HoTsN, and is pretty much the same as it's predecesor, only representing the amount of orders using a function similar to TsN itself.

For starters, lets define the folowing:

]n {n(n,1)} n[ = ]n {n([n]n)} n[


]n {n(n,m)} n[ = ]n {n(([n]n),,m-1)} n[

I would like to note that in order (heh, order) to solve the order set: ((n,n,n,n,...,n),,m-1) we have to ignore the ,,m-1 bit until we reduce all the other orders, and have only one left, or until the second normal brackets are no longer needed.

This logic can be applied to any number of brackets (For example, (n,,,5)=((n,,n,,n,,n,,...,,n),,,4) ).

Now, if you have a migrane by now, I don't blame you. I have one as well. If you do, the folowing bit might help things settle a bit better.

Lets try to solve ]2 {1(2,2)} 2[.

]2 {1(2,,2)} 2[ = ]X {1(2,2)} 1[ = ]X {1(([2]2),1)} 1[

Where X = Z2

and Z = 2

and Zn+1 =]Zn {Zn(([2]1),1)Zn[

So in this case, Z1 =]2 {2(([2]1),1)} 2[

]2 {2(([2]1),1)} 2[ = ]C {2(([2]1),1)} 1[

Where C Z2

and Z = 2

and Zn+1 =]Zn {Zn(2,1)Zn[

So in this case, Z1 =]2 {2(2,1)} 2[

]2 {2(2,1)} 2[ = ]2 {2([2]2)} 2[.

The rest of the solution is quite long, so I don't think it would make much sense if I went on solving it.

I don't know what growth speed this new form of the function inhibits, and would gladly appreciate any suggestions.

Ad blocker interference detected!

Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.