User:Vel!/pu/PoundStar

Pound-star notation is a notation made by SuperJedi224. It has a rather unconventional definition.

Start with n=1. Let's try an example:
 * 1) If the last entry is a number, set n equal to the product of the current n and this number, then remove it from the sequence.
 * 2) If the last entry in the expression is a pound sign, replace it with the current value of n.
 * 3) If the last entry is a set:
 * 4) *If the set contains only one entry, replace the set with its remaining entry raised to the power of the current n
 * 5) *If the final element of the set is zero, drop it, incrementing n by 1.
 * 6) *Otherwise, decrement the final element by one and increment the element preceding it by n.
 * 7) Repeat 1-3 until the expression is reduced to a single number.


 * 1) * (1,0,1)*2

n=1, #*(1,0,1)*2

n=2, #*(1,0,1)

n=2, #*(1,2,0)

n=3, #*(1,2)

n=3, #*(4,1)

n=3, #*(7,0)

n=4, #*(7)

n=4, #*2401 (74=2401)

n=9604, #

9604

Let's now resolve #*(10,10)*100. SJ224 calls this Astragol.

n=1, #*(10,10)*100

n=100, #*(110,9)

n=100, #*(210,8)

n=100, #*(310,7)

...

n=100, #*(1010,0)

n=101, #*(1010)

n=101, #*1010101

n=101*1010101, #

101*1010101

What about astrigol?

n=1, #*(10,10,10)*100

n=100, #*(10,10,10)

n=100, #*(10,110,9)

...

n=100, #*(10,1010,0)

n=101, #*(10,1010)

n=101, #*(111,1009)

...

n=101, #*(102020,0)

n=102, #*(102020)

n=102, #*102020102

102*102020102

The wiki says 102*102110102, but it's about the same no matter which is correct.

This seems to have an exponential growth rate as more numbers go into a set.

Bi-astragol = #*(10,10)*(10,10)*100

n=1, #*(10,10)*(10,10)*100

n=100, #*(10,10)*(10,10)

n=100, #*(10,10)*(1010,0)

n=101, #*(10,10)*(1010)

n=101, #*(10,10)*1010101

n=astragol, #*(10,10)

n=astragol, #*(astragol*10+10,0)

n=astragol+1, #*(astragol*10+10)

n=astragol+1, #*x where x = (astragol*10+10)astragol

(astragol+1)(astragol*10+10)astragol

So we have a double exponential. Tri-astragol would give a triple exponential, and so on. In the end, the limit of this notation is tetrational.

New extension: protosets! ((x)) becomes a set of n x's.

So let's see #*((10))*100

n=1, #*((10))*100

n=100, #*((10))

n=100, #*(10,10,...,10,10) with 100 tens.

So this notation will unleash the ultimate power of pound-star notation - #*((x))*y diagonalizes over all pound-star notation!

Now let's look at something else:

n=1, #*((10))*(10,10)*100 (called astrangol-by-astragol)

n=100, #*((10))*(10,10)

n=100, #*((10))*(1010,0)

n=101, #*((10))*(1010)

n=101, #*((10))*1010101

n=astragol, #*((10))

n=astragol, #*(10,10,...,10,10) with astragol entries

Iteration...

n=1, #*((10))*(10,10,10)*100

I believe this would resolve to something equal to #*(10,10,...,10)*astrigol with astrigol entries.

So each protoset adds a new level of recursion to get to pentational growth.

Pound-multistar notation! If the last entry is preceded by n stars, it will be replaced by n copies of itself all preceded by n-1 stars.

So #**((10))*100 resolves like this:

n=1, #**((10))*100

n=100, #**((10))

n=100, #*((10))*((10))*...*((10)) with 100 ((10))'s.

This allows multiple levels of recursion, going from pentational (*), hexational (**), heptational (***) and so on. So the limit is omega.

The separators are given levels: * is 1, ** is 2, *** is 3, which after omega will follow ordinals. This allows us to index the growth rate more easily.