This page is just for random functions that don't make the cut for the main page.
Short for Graphs of Square States.
GOSS(n) = Amount of possible n x n grids using n+1 colors.
Examples: GOSS(1) = 2, since it is a single square, which can be one of two colors.
GOSS(2) = 81, as there are 81 possible grids if the the grid is 2x2 and there are 3 colors.
Here are numbers I've made:
GOSS(100) = Centigoss
GOSS(200) = Ducentigoss
GOSS(300) = Tricentigoss
GOSS(1,000,000) = Megagoss
GOSS(GOSS(1,000)) = Kilogosogoss (pronounced kill-oh-gohs-oh-gahs)
MGOSS(n) is to apply GOSS to n, n times. Example: MGOSS(3) = GOSS(GOSS(GOSS(3))) = GOSS(GOSS(262,144))
[1]GOSS(n) = GOSS(n)
[2]GOSS(n) = MGOSS(n)
[3]GOSS(n) = MGOSSn(n)
[x]GOSS(n) = [x-1]GOSSn(n)
EXTENSION:
[x, 2]GOSS(n) = [[[...[[x]GOSS(n)]GOSS(n)...]GOSS(n)]GOSS(n)]GOSS(n) with x nestings
[x, a]GOSS(n) = [[[...[[x, a-1]GOSS(n), a-1]GOSS(n)..., a-1]GOSS(n), a-1]GOSS(n), a-1]GOSS(n) with x nestings
N-FOLD(n) takes n copies of n, and concatenates them together.
Examples: N-FOLD(2) = 22
N-FOLD(3) = 333
N-FOLD(4) = 4,444
N-FOLD(5) = 55,555
N-FOLD(10) = 10,101,010,101,010,101,010
PDF(n) = n^the amount of digits in n.
PDF(3) = 3^1 = 3
PDF(10) = 10^2 = 100
PDF(500) = 500^3 = 12,50,00,000
PDF(1,000,000) = 1,000,000^7 = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000
PDF(PDF(1,000,000)) = 1,000,000,000,000,000,000,000,000,000,000,000,000,000,000^57
Mega CLAN function. MCLAN(n) the largest number possible with MCLAN(n-1) letters applied to MCLAN(n-1) in CLAN. MCLAN(1) = the largest number possible with 10 letters applied to 10 in CLAN.
DEN(n) The largest finite number possibly definable using n*10 letters, creating only real words from the 2025 Oxford English Dictionary.
ESoCC(n) = The largest (finite) number possible in SoCC using at most n symbols. Pairs of parenthesis count as 1 symbol, ..(c).. counts as 2, commas don't count. [0]ESoCC(n) = ESoCC(n)
None of the numbers below are confirmed or proven
ESoCC(1) = | = 1
ESoCC(2) = |~ = || = 2
ESoCC(3) = ||~ = ||| = 3
ESoCC(4) = |||| = 4
ESoCC(5) = ||||| = 5
ESoCC(6) = |||||| = 6
ESoCC(7) = ||||||| = 7
ESoCC(8) = |||~~~|| = |||~~||| = 9
ESoCC(9) = |||~~~~|| = |||~~~||| = |||~~|||~~||| = |||~~||||||||| = 27
ESoCC(10) = |||~~~~~|| = |||~~~~||| = |||~~~|||~~~||| = |||~~~||||||||||||||||||||||||||| = |||~~~27 = 3^27 ≈ 7.6*10^12
ESoCC(11) = |||~~~~~~|| = |||~~~~~||| = |||~~~~|||~~~~|||
ESoCC(19) = H||||||,WHa:a~~..(a)..~~a = ||||||~~~~~~||||||
ESoCC(20) = H|||||||,WHa:a~~..(a)..~~a = |||||||~~~~~~~|||||||
ESoCC(28) = H||||,WHa:a~~..(H(a~°|))..~~a,WH|:| = ||||~~..(|||~~~~|||)..~~||||
[x]ESoCC(n) = [x-1]ESoCC([x-1]ESoCC(...[x-1]ESoCC([x-1]ESoCC(n))...)) with n [x-1]ESoCC()'s
[ω]ESoCC(n) = [n]ESoCC(n)
[ω+1]ESoCC(n) = [ω]ESoCC([ω]ESoCC(...[ω]ESoCC([ω]ESoCC(n))...)) with n nestings
[ω+a]ESoCC(n) = [ω+(a-1)]ESoCC([ω+(a-1)]ESoCC(...[ω+(a-1)]ESoCC([ω+(a-1)]ESoCC(n))...)) with n nestings
[ω+ω]ESoCC(n) = [ω2]ESoCC(n) = [ω+(n-1)]ESoCC([ω+(n-1)]ESoCC(...[ω+(n-1)]ESoCC([ω+(n-1)]ESoCC(n))...)) with n nestings
[ω2]ESoCC(3) = [ω+2]ESoCC([ω+2]ESoCC([ω+2]ESoCC(3)))
[ω3]ESoCC(n) = [ω+ω+ω]ESoCC(n) = [ω+ω+(n-1)]ESoCC([ω+ω+(n-1)]ESoCC(...[ω+ω+(n-1)]ESoCC([ω+ω+(n-1)]ESoCC(n))...)) with n nestings
[ω3]ESoCC(3) = [ω+ω+2]ESoCC([ω+ω+2]ESoCC([ω+ω+2]ESoCC(3)))
[ω^2]ESoCC(n) = [ω*ω]ESoCC(n) = [ωn]ESoCC(n)
[ω^2]ESoCC(3) = [ω3]ESoCC(3) = [ω+ω+2]ESoCC([ω+ω+2]ESoCC([ω+ω+2]ESoCC(3)))
[ω^b]ESoCC(n) = [ω*ω*ω...ω*ω*ω]ESoCC(n) with b ω's
[ω^ω]ESoCC(n) = [ω^^2]ESoCC(n) = [ω*ω*ω...ω*ω*ω]ESoCC(n) with n ω's
and so on, ω being able to be modified by any operator or function.
PSF(n) = π * (10^n)
PSF(0) = π
PSF(1) = 31.41592...
PSF(2) = 314.15926...
PSF(3) = 3141.59265...
PSF(PSF(1)) = 8.1859648e+31
PSF(PSF(PSF(1))) = π * 10^(8.1859648e+31)
# is any or empty array. Examples are provided under the more complicated parts of the definition.
Ulthomegra(n, #) = ULTM(n, #)
ULTM(0) = Biggams
ULTM(n) = 3[⎔]ω[⎔]ω...ω[⎔]ω[⎔]ω with ULTM(n-1) ω's in THOM
ULTM(n, 1, 1, 1...(k 1's)...1, 1, 1) = ULTM(n, n...(k-1 n's)...n, n, n, ULTM(n, n...(k-1 n's)...n, n, n, ...ULTM(ULTM(n, n, n...(k n's)...n, n, n))...) with ULTM(n) nestings
ULTM(3, 1) = ULTM(ULTM(ULTM(3)))
ULTM(5, 1, 1, 1) = ULTM(5, 5, ULTM(5, 5, ULTM(5, 5, ULTM(5, 5, ULTM(5, 5, 5)))))
ULTM(n, a, #) = ULTM(ULTM(...ULTM(ULTM(n, a-1, #), a-1, #)..., a-1, #), a-1, #) with n nestings
ULTM(3, 2) = ULTM(ULTM(ULTM(3, 1), 1), 1)
ULTM(n, 1, 1, 1...(k 1's)...1, 1, 1, a, #) = ULTM(n, n, n, n...(k n's)...n, n, ULTM(n, n, n, n...(k n's)...n, n, ......ULTM(n, n, n, n...(k n's)...n, n, ULTM(n, n, n, n...(k+1 n's)...n, n, n, a-1, #), a-1, #)......, a-1, #), a-1, #) with n nestings. What would have been the k+1th n in each nesting is replaced with the nest.
ULTM(3, 1, 2) = ULTM(3, ULTM(3, ULTM(3, 3, 1), 1), 1)
ULTM(4, 1, 1, 1, 3) = ULTM(4, 4, 4, ULTM(4, 4, 4, ULTM(4, 4, 4, ULTM(4, 4, 4, 4, 2), 2), 2), 2)
ULTM([n]) = ULTM(n, n, n...n, n, n) with n n's
BULTM(0) = Biggams
BULTM(n) = BULTM(n-1)[⎔]ω[⎔]ω...ω[⎔]ω[⎔]ω with BULTM(n-1) ω's in THOM
Everything else is the same as ULTM.
n⇶ka = n⇶⇶...(k)...⇶⇶a
n⇶10 = n{n}n
n⇶k0 = n⇶k-1n⇶k-1n...n⇶k-1n⇶k-1n with n n's
n⇶k-1n⇶k-1n...n⇶k-1n⇶k-1n is worked through in a similar way to arrow notation, right to left.
3⇶3⇶3⇶3 is the same as 3⇶(3⇶(3⇶3)), 4⇶⇶3⇶⇶5⇶⇶2 is the same as 4⇶⇶(3⇶⇶(5⇶⇶2)).
n⇶ka = ((...(n⇶ka-1)⇶ka-1...)⇶ka-1)⇶ka-1 with n nestings
n⇶[0] = n⇶nn
n⇶[a] = ((...(n⇶[a-1])⇶[a-1]...)⇶[a-1])⇶[a-1] with n nestings
# is any or empty array
0⤳0 = 2
n⤳ka = n⤳⤳...(k)...⤳⤳a
n⤳10 = 2^n
n⤳k0 = n⤳k-1n⤳k-1n...n⤳k-1n⤳k-1n with n n's
n⤳ka# = ((...(n⤳ka-1#)⤳ka-1#...)⤳ka-1#)⤳ka-1# with n nestings
n⤳k0⤳k0⤳k0...(g 0's)...0⤳k0⤳k0 = n⤳kn⤳kn...(g-1 n's)...n⤳kn⤳k(n⤳kn⤳kn⤳...(g-1 n's)...n⤳kn⤳k(...n⤳kn⤳kn...(g-1 n's)...n⤳kn⤳k(n⤳kn⤳kn...(g n's)...n⤳kn⤳kn)...)) with n nestings
n⤳k0⤳k0⤳k0...(g 1's)...0⤳k0⤳ka = n⤳kn⤳kn...(g n's)...n⤳kn⤳k(n⤳kn⤳kn⤳...(g n's)...n⤳kn⤳k(...n⤳kn⤳kn...(g n's)...n⤳kn⤳k(n⤳kn⤳kn...(g+1 n's)...n⤳kn⤳kn⤳ka-1)⤳ka-1...)⤳ka-1)⤳ka-1 with n nestings
n⤳[0] = n⤳nn⤳nn...n⤳nn⤳nn with n n's
n⤳[a] = ((...(n⤳[a-1])⤳[a-1]...)⤳[a-1])⤳[a-1] with n nestings
a⇃ = (((a-1)⇃ + (a-1)⇃) * (a-1)⇃)^(a-1)⇃
where 1⇃ = 1 and 2⇃ = ((1 + 1) * 1)^1 = 2
3⇃ = ((2 + 2) * 2)^2 = 64
4⇃ = ((64 + 64) * 64)^64 ~ 2.86389e+250
Hyparporial
a↾ = (...(((((a-1)↾ + (a-↿)↾) * (a-1)↾)^(a-1)↾)^^(a-1)↾)^^^(a-1)↾...)^^^...(a)...^^^(a-1)↾
where 1↾ = 1 and 2↾ = 2
3↾ = ((((2 + 2) * 2)^2)^^2)^^^2 = (64^^2)^^^2
n[!] = n!
n[[...[[!]]...]] = (n-1)[[...[[!]]...]] * 3n where 1[[...[[!]]...]] = 1
n[!!!...(k !'s)...!!!] = n[[..[[!!!...(k-1 !'s)...!!!]]...]] with n sets of []
n[[...[[!!!...(k !'s)...!!!]]...]] with x sets of [] = ((...(n[[...[[!!!...(k !'s)...!!!]]...]])[[...[[!!!...(k !'s)...!!!]]...]]...)[[...[[!!!...(k !'s)...!!!]]...]])[[...[[!!!...(k !'s)...!!!]]...]] with n nestings, with x-1 sets of [] in each
GF(1) = 1
GF(2) = 2
GF(n) = n!GF(n-1) in nested factorial notation.
Where # is any or empty array:
G(n) = f[f[...f[f[ω](ω)](ω)...](ω)](n) in the fast-growing hierarchy with n nestings, where [...] means subscript.
G(1) = f[ω](1) = 2
G(2) = f[f[ω](ω)](2) = f[f[ω](2)](2) = f[8](2)
...
G(n, 0) = G(G(...G(G(n))...)) with n nestings
G(n, a, #) = G(G(...G(G(n, a-1, #), a-1, #)..., a-1, #), a-1, #)) with n nestings
G(n, 0, 0, 0...(a 0's)...0, 0, 0) = G(n, n, n...(a-1 n's)...n, n, G(n, n, n...(a-1 n's)...n, n, ...G(n, n, n...(a-1 n's)...n, n, G(n, n, n...(a n's)...n, n, n))...)) with n nestings
G(n, 0, 0, 0...(a 0's)...0, 0, 0, b, #) = G(n, n, n...(a n's)...n, n, G(n, n, n...(a n's)...n, n, ...G(n, n, n...(a+1 n's)...n, n, n, b-1, #)..., b-1, #), b-1, #) with n nestings
G([n]) = G(n, n, n...n, n, n) with n n's
GCS(n, x, c, k, j, h) is a sequence. Step 1 is each integer from n down to 1 listen in descending order. Each step after, an operator is applied to each integer, and 1 is subtracted from the rightmost entry. Only apply the operators to entries that have not been subtracted from. Apply operator directly to numbers, and write it out. Apply direct operators to written out operators. After subtracting from 1, rather than being zero, the entry is removed. Entries are also added to the front of the chain every step depending on what k and j are. They are what the leftmost entry would be in the next step, except keeping the same operators as the rest of the chain. In GCS(n, x, c, k, j, h), the n is the main number, or the starting number. The x is the number used by the operator, which c. If c = 1, then the operator is addition. If it is 2, then multiplication, and so on. j is the operator used for the number of entries added, and k is the operand. For example if k is 2 and j is 3, the number of entries would square each time. h says for how far to add new entries (to ensure termination), as in after the full decay of h entries, stop adding more. GCS(n) = GCS(n, n, n, n, n, n, n). GCS([n]) = GCS(GCS(...GCS(GCS(n))...)) with n nestings. GCS([[...[[n]]...]]) with x sets of brackets = GCS([[...GCS([[......GCS([[...GCS([[...[[n]]...]])...]])...]]...)...]]) with n nestings with x-1 sets of brackets in each. GCS({n}) = GCS([[...[[n]]...]]) with n brackets.
Examples:
GCS(3, 2, 2, 1, 1, 2):
3, 2, 1
12*2, 6*2, 4*2, 1
48*4*2, 24*4*2, 12*4*2, 8*4*2
192*8*4*2, 96*8*4*2, 48*8*4*2, 24*8*4*2, 1022
...
GCS(3, 1, 1, 2, 2, 1)
3, 2, 1
7+1, 6+1, 5+1, 4+1, 3+1, 2
14+2+1, 13+2+1, 12+2+1, 11+2+1, 10+2+1, 9+2+1, 8+2+1, 7+2+1, 6+2+1, 5+2+1, 4+2+1, 1
...