User blog:PlantStarAlpineer0/Introducing Lightspeed Slash Notation

I’d like to introduce perhaps one of the fastest notations ever invented, called “Lightspeed Slash Notation”. It adopts Chris Bird’s notations to create a new, fast notation. Here are some rules:

Suppose that @1 is a string of n-1 1’s and @2 is a string of n-1 2’s:

{10,10[@1[2/n2]@2]2} = /n /{10,10[@1[2/n2]@2]2} = /0,n /a,{10,10[@1[2/n2]@2]2} = /a+1,n /{10,10[@1[2/n2]@2]2},0 = /0,0,n

There is a pattern here. Suppose that @3 is any string of terms:

/@3,{10,10[@1[2/n2]@2]2} = /@3+1,n where 1 is added to the last term in the string if the term is not {10,10[@12/n2]@2]2}

Here is where we hit another ceiling. No matter, we can come up with another delimiter with further rules. Let’s define the “letter A” delimiter as coming after all numbers that obey the above rules. Let’s also suppose that @4 is any string of 0’s that is {10,10[@1[2/n2]@2]2} terms long:

/@4 = /An /A@4 = /Bn /B@4 = /Cn

Here we have another pattern. Suppose that @L is any letter in the English alphabet:

/@L@4 = /(@L+A)n

But what happens if we hit the end of the letter Z? Well, let’s suppose that we can add letters like we would with basic addition:

/Z+@L@4 = /Z+(@L+A)n

From here, let’s say we can multiply, exponentiate, tetrate, etc. these letters. Suppose that @L2 is any string of Z’s and b is a letter corresponding to the number of Z’s in said string:

/@L2+@L2n = /Zbn /@L2@L2n = /Zbn

Suppose that @O is the minimum number of Z’s needed to reach a successive operation, c is the number of operations needed to reach said successive operation, and # is the number of ^’s in the result, if any:

/@Ocn = /Z#bn

What’s next? Let’s define the “double slash” delimiter as coming after all operations that obey the above rules. Let’s also suppose that @L3 is any string of letters in any operation that has {10,10[@1[2/a2]@2]2} ^’s:

/@L3n = //n

Note that all above rules apply to multiple-slashed numbers:

//@L3n = ///n ///@L3n = ////n

Here is yet another pattern. Suppose that @S is any string of slashes:

@S@L3n = (@S+/)n

If there are {10,10[@1[2/a2]@2]2} slashes, we can begin using the aforementioned operations on these slashes. Suppose that @S2 is any string of {10,10[@1[2/a2]@2]2} slashes and d is the last exponent of the result:

@S2@S2n = /dn

Suppose that @O2 is the minimum number of slashes needed to reach a successive operation:

@O2cn = /#dn

Where do we go from here? COMING SOON

These rules will be on my website soon.