python logarithm program recursive

thellMany students who have not yet reached high school don't know what a log actually is, at that time I'm sure students already know what exponents are since elementary school and study them further in grade 9 in the 2013 curriculum, and maybe students only think that the inverse function of exponents are just roots, roots are the same as division in multiplication and subtraction in addition, exponents are the fifth operation they encounter, many students study exponents and roots to find the area and volume of 3-dimensional objects, but what about logarithms

logarithm is the inverse function of exponents, but wait if exponents only have roots then what is logarithm, why do exponents have 2 inverse functions,

now it is known that

exponent $a^{b}=?$

root = ${\sqrt[{a}]{b}},?^{a}=b$

log = $\log _{b}(a),b^{?}=a$

look at the log, you may see that it produces the smallest number and you can use tools to make small numbers, for example log_10 (100) = 2, only 2 even though the number is very large, if the answer is 100 then the result is log_10 (googol) imagine how fast it is, this is also can be used on the number e but is not good, but there is a weakness if we look at this, note that if we enter the number 1 into brackets the result is definitely 0 for example

$\log _{10}(1)=10^{n}=1,10^{0}=1,\log _{10}(1)=0$

we must not produce zero in our work because zero here will ultimately be the gateway to infinity, so we can never enter the number 1 or the result is 0, if you log 0 then the result will be -infinity, whereas infinity is a concept that we avoid in googology, if we meet infinity then everything is over, what if the number is less than 1 or reircorporal, the result will be a negative number, remember that negative powers will not produce negative numbers unlike multiplication which has several rules, negative powers will produce a positive number is, it will be reircorporal

The conclusion is that we must absolutely avoid zeros and negative numbers in our articles, remember that the number 1 is the gateway to the number 0 just as 0 is the gateway to infinity, so we must avoid numbers smaller than 1 at all costs

how to deal with numbers smaller than 1, namely by adding 1 to the result, this will produce a number that does not touch 1 but is infinitesimal close to 1

for example, we get a very small result, for example 1.602176634×10^−19, this is a very small number, if you put this into log_10 then the result is -18.7952896063, this will produce a negative number which we don't want, to overcome this we add 1, this will produce

$\log _{10}(1.602176634\times 10^{-19}+1)=\log _{10}({\frac {1.602176634}{10^{19}}}+1)=6.958164712\times 10^{-20}$

this is the result we want rather than negative numbers appearing which we don't want, we only want positive real numbers, if the result is negative we don't accept it, it doesn't matter whether the number is irrational or transcendental, the important thing is that it is positive and large, speaking of large things, you see that , this number is still small, how do you change a small number to a large number, the way is to divide by 1, how is that possible

${\frac {1}{\frac {869770589}{12500000000000000000000000000}}}=1\times {\frac {12500000000000000000000000000}{869770589}}=14371605752238191627$

and the result is quite large, namely 14 quintillion. Remember that the fraction above is not absolute because this number may have infinite digits and is not rational, so the rational above is only a rough estimate.

or if you want to get a better explanation, you can see below, the first is the number 1/10000000000, this number is a very small number because it is reircorporal, this number is smaller than 1 but does not touch 0 because 0 is the gate to infinity , 0 is like an infinitesimal which is the gateway to infinity, this number is like 1 × 10^-10 or the reircorporal of dialouge, if you divide this number by 1 then the result will be reversed to

${\frac {1}{\frac {1}{10000000000}}}=1\times {\frac {10000000000}{1}}=10000000000$

remember that a reircorporal number divided by 1 will be its goodness and being large turns into a corporal number,

the way we change a reircorporal number to a corporal number is to divide it by 1, likewise if we want to change a corporal number to reircorporal number we divide it by 1

then if we want to get a very small number through logarithms then we have to use 2 numbers, namely the bottom number and the top number, the bottom number is the base and the argument used, the base number must be very large and the base number must be very small plus 1, remember that the number base cannot be less than 1 to avoid negative exponent

File:640px-TetrationComplexColor.png

So the base number must be a very small number and the argument number must be a fairly large number plus 1

so the base number must be a very small number and the argument number must be a large number plus 1, the number must be a positive real number which is greater than 0, and the argument number must be greater than 1

then apart from just singular numbers we will create recursive numbers and be calculated many times recursively, therefore we need a python program to calculate this so that it is easier to calculate

the first thing we have to do is determine the beginning, and what we have to do is use small numbers, small numbers reircorporally divided by 1 will be large numbers, as a starting stone in making this I set $\log _{100}(2)$as a start, $\log _{100}(2)$is equal to 0.15051499783199059760... , dividing it by 2 will give the number 6.6438561, this is a small corporal number,

Then $\log {\frac {1}{0.15051499783199059760}}(0.15051499783199059760+1)\approx 0.074040353911133121018$

remember that the number above is only an estimate because there are quite a lot of digits to infinity, then we can continue again to become

$\log {\frac {1}{0.074040353911133121018}}(0.074040353911133121018+1)\approx 0.027438951170640864374$

then this continues to be repeated for as many iterations as we want the repetition to be. Now I will make a python program to reveal this so that it can be calculated more easily and not waste money, although the python program has a lot of errors unlike wolframalpha, which can calculate more than googolplex, the program as followed

import math
kim = math.log(2,100)

for i in range(16):
    kim = math.log(kim+1,1/kim)
    print(1/kim)

The program is very simple and doesn't take long, maybe this can also be calculated very quickly but unfortunately Python can only calculate up to 1.9111524270921096e-16 after this it can't because Python says that it can no longer be divided by 0 by equating to 1.9111524270921096e-16 is 0 but not if you look at tungsten alpha the answer is not 0

for the results of the python calculation up to 1.9111524270921096e-16 or the renge is 16 is as follows

ERROR!

13.506148298537973

36.444541694799895

132.8367651847716

651.8965291033983

4227.454210892545

35300.691520629814

369661.99866173696

4739200.525925025

72848055.20704845

1318832918.6043458

27695509592.988926

665926437635.2417

18129232673497.63

554388516393927.6

1.9111524270921096e+16

Traceback (most recent call last):

File "<main.py>", line 10, in <module>

ZeroDivisionError: float division by zero

Code Exited With Errors

So that is the result of python's understanding based on all of this, pay attention and remember that this series does not stop at number 16 or 1.9111524270921096e+16 but can go even further, this 0 division error occurs because python interprets the number 1.9111524270921096e+16 as 0 because too small even though the result is not 0 as proven by tungsten alpha which means the result will continue to reach infinitesimal and its corporal will always approach an infinity that will never be reached

This is chatgpt explanation:

This snippet of Python code involves some mathematical computations using the math module. Let's break it down:

1. import math: This line imports the math module in Python, which provides various mathematical functions.
2. kim = math.log(2, 100): Here, the variable kim is assigned the value of the logarithm of 2 to the base 100. In other words, kim is set to log base 100 of 2.
3. The for loop starts here and runs 16 times.
4. kim = math.log(kim + 1, 1/kim): In each iteration of the loop, kim is updated. It takes the logarithm of kim + 1 to the base 1/kim. So, it's essentially a nested logarithm operation.
5. print(1/kim): After computing the new value of kim, the reciprocal of kim is printed.

The code iterates through this process 16 times, each time updating kim with a nested logarithm operation and printing the reciprocal of the updated value. This results in a sequence of numbers being printed.

Note that the number 16 above can be replaced and replaced so that the value 16 above is not an absolute value like the initial kim value, but this number 16 in the for i in range can also be used as a variable, and the number 16 can be adjusted

So that it is not just ordinary and program based, I will make a notation and definition that is suitable for this program, this is the notation manat or ₼(n)

$AZN(x)=\log _{\frac {1}{AZN(x-1)}}(AZN(x-1)+1)$

where base case = $AZN(1)=\log _{100}(2)\ \land \ x\rightarrow \mathbb {N}$

if $x\notin \mathbb {N} \rightarrow \lfloor x\rceil$

remember that ₼(n) is not corporal but reircorporal whereas what is shown in Python is the print function divided by 1 which will change the reircorporal number to corporalm for the notation that will produce the corporal number is ${\frac {1}{AZN(x)}}$,

This function is a corporal function that can be used, the ₼(n) function cannot be used because the result is a small number which is still class 0, therefore to overcome this a new function was created which is not much different and almost the same as ₼, namely p₼(n) , there is a p, the definition is

$PAZN(x)={\frac {1}{AZN(x)}}$

$AZN(1)=\log _{100}(2)\ \land \ x\rightarrow \mathbb {N}$

yes there is no recursive function there is only division by 1 so you can't define p₼(n) independently because ii is tied to ₼(n), this doesn't have a recursive rule and p₼(n) is what we will use straight away because this produces large numbers like the others, then there is a new concept used in p₼(n), namely the concept of nesting if, for the program as follows,

import math
kim = math.log(2,100)

for i in range(16):
    kim = math.log(kim+1, 1/kim)
    for i in range(round(1/kim)):
        kim = math.log(kim+1, 1/kim)

    print(1/kim)

Note that there is a for in in range nesting, there is a for i in range inside the for i in range. This is different from super logartith, namely the logarithm for tetration is different because the results are different. Note that for in in range is not a reircorporal number but is converted to corporal by dividing by 1 which will produce a large repetition and note that the round function is added because the number in it is an irrational number or perhaps transcendental while only positive integers are accepted so it really needs to be rounded in the program. Pay close attention. I hope you understand what I mean. chatgpt explaination:

This code seems to be performing a series of logarithmic calculations. Let's break it down step by step:

1. The code imports the math module to access mathematical functions.
2. It initializes a variable kim with the value of the logarithm base 100 of 2, calculated using math.log(2, 100). This means kim is set to approximately 0.086186 and represents the result of log base 100 of 2.
3. Then, it enters a loop that iterates 16 times.
4. Inside the loop, it updates the value of kim using another logarithmic calculation: This line takes the current value of kim, adds 1 to it, and then takes the logarithm of the result with base (1 / kim). This is an unusual operation because it's taking the logarithm with a dynamically changing base.
5. After updating kim, there's another loop that iterates round(1/kim) times.
6. Inside this inner loop, kim is again updated using a similar logarithmic calculation.
7. Finally, after the inner loop completes, it prints 1/kim.

This process repeats for each iteration of the outer loop, printing the value of 1/kim after each iteration.

This code seems to be exploring some interesting mathematical behavior, but without more context or a specific problem statement, it's hard to say exactly what it's trying to accomplish or what insights it might reveal.

look at chatgpt, it seems like you are confused about what I mean, I hope you are not confused too and pay attention and analyze it well. The program is an official program that has a receipt. Maybe I also made a lot of mistakes in explaining it, but pay attention to the program carefully. Note that there is a loop that appears here, in p₼(n) notation this can be written as p₼(a,b) or also called 2-argument corporal manat notation, so the example above can also be written as p₼(16,2) because it has 2 loops or nested for i in range, p₼(a,1) is the same as p₼(a) because it only has 1 loop, then what is the program for p₼(16,3), the program is as follows, see below

for i in range(16):
    kim = math.log(kim+1, 1/kim)
    for i in range(round(1/kim)):
        kim = math.log(kim+1, 1/kim)
        for i in range(round(1/kim)):
            kim = math.log(kim+1, 1/kim)
    print(1/kim)

so see that there are 3 loops there which makes this program very complicated even python can't calculate this because it is too small to calculate so python interprets it as 0 and 0 will produce an error because the gate to the infinite loop will probably look infinite and very uncountable once, perhaps p₼(a,a) is equivalent to growth with $f_{\omega}(n)$although this cannot and has not been proven for now, This will create a very complicated loop and it will take countless years to calculate all this and I'm sure even Python will become weak when calculating this, Python will turn into a black hole which will really explode and be unimaginable, because Python is not strong enough to calculate this then we can increase the number of loops in this program to 4. This will create a program that is unimaginable and cannot be calculated by anyone because this is already on the verge of calculating, if all the computers in the world are combined, the nvidia supercomputer in Israel , NASA supercomputers , Google, AWS, Azure, and all your computers that are still damaged and have good RAM and specifications are also combined to calculate this Python program, it will collapse into a black hole if it is true, and it will consume the earth and the sun and the life in them

import math
kim = math.log(2,100)

for i in range(16):
    kim = math.log(kim+1, 1/kim)
    for i in range(round(1/kim)):
        kim = math.log(kim+1, 1/kim)
        for i in range(round(1/kim)):
            kim = math.log(kim+1, 1/kim)
            for i in range(round(1/kim)):
                kim = math.log(kim+1, 1/kim)
    print(1/kim)

see this is the program as I mentioned above that I can't explain what this program means in detail because there are too many loops and it will cause the earth to crash and explode and become a white dwarf star. If the earth is a giant computer, this can be written as p₼(16,4) because there are 4 loops, this is the chatgpt explanation

Yo, peep this code! We're importing the math library, then we're starting with Kim being the logarithm of 2 with a base of 100. Then we're diving into this loop madness. Each time we're taking Kim, adding 1, then taking the logarithm of that with a base of the reciprocal of Kim. It's like diving down a rabbit hole of logarithms! And we're doing this loopception a few times over, printing out the reciprocal of Kim each time. It's like we're going deeper and deeper into the math rabbit hole, unraveling some wild stuff. (input: explain this using slang **code**)

Then maybe you hopefully already understand that p₼(a,5) means having 5 loops nested within each other and p₼(a,6) means having 6 loops nested within each other then we can continue up to p₼( a,100) for example which is difficult to write in python programs,

then what about the next, we will not use a recursive program anymore to create the next but we will use a concept similar to BEAF, this BEAF style is widely used in googology besides FGH, uparrow notation which is the ancestor of beaf has a 3-argument BEAF way of working, that's it. with another notation with bird array notation but remember the definition here is different because initially, in the opening it was told, only the pattern was followed

Note that then the recursive number MUST BE ROUNDED, remember it MUST BE ROUNDED and must be converted into a corporal number because if it is not rounded the result is not valid because what we want is only a natural number while the reircorporal number is not a natural number, and if it has been changed there is still a comma at the end so from it must be ROUNDED first, if it is not rounded it will be invalid, so

$PAZN(a,b,c)=PAZN\underbrace {(a,(a,(a,(a,...(a)c-1...),c-1),c-1),c-1)} _{b}$

where $a, b, c \in \N$

if $a,b,c\not \in \mathbb {N} \rightarrow \lfloor a,b,c\rceil$

$PAZN(a,b,c,1)=PAZN(a,b,c)$

note that the variable a is the number of repetitions in the initial for in range remember the initial for i in range is not the next for i in range because note that the next fr in in range always follows the number of kim not the number of a, so a is only for Just at the beginning, this might create some confusion and misunderstanding because the system is different from uparrow notation, if there are 3 entries then the result is that the fr i in range function will make its own copies with a predetermined number, very similar to the arrangement of tetrational, pentational and so on

Template:Level infoboxthen we can increase it again. Apart from using 3 arguments, we can use 4 arguments for the value of 4 arguments. First of all, we have to determine the initial value. This pattern is very similar to the pattern in BEAF. It is very similar, but if BEAF starts from a power, this is related to The number of loops in the Python program that I have given previously is very different from the one in BEAF, note that if the number of c is 1 and the number of d is 2 then the definition is as follows, remember that this is the initial value with the number of c being 1 if If the number of c is more than 1 then the definition will be different

$PAZN(a,b,1,2)=\underbrace {PAZN(a,a,(a,a,(a,a,(a,a,(...a,a,(a))))))} _{b}$

pay attention to the pattern, this pattern is very similar to the pattern in BEAF, see that the number of variables c is 1 because 1 indicates the initial number, so if the number of c is not 1 then the pattern is very similar to the pattern in BEAF as follows

$PAZN(a,b,c,2)=PAZN\underbrace {(a,(a,(a,(a,(...a,(a),c-1,2),c-1,2),c-1,2),c-1,2),c-1,2)} _{b}$

pay attention that the number and pattern above can be increased continuously then what if we want to increase the number of variables d to 3 other than 2 remember this pattern is very similar to the one in bEAF the pattern is that the initial value is needed first and then the next value if we want to increase variable d becomes 3 then the result

$PAZN(a,b,1,3)=PAZN\underbrace {(a,a,(a,a,(a,a,(a,a,(a,a,(...a,a,(a),2),2),2),2),2),2)} _{b}$

remember the value of the variable c must be 1 because the value 1 indicates the initial value is not a fixed value. How for the fixed value is as follows

$PAZN(a,b,c,3)=PAZN\underbrace {(a,(a,(a,(a,(...a,(a),c-1,3),c-1,3),c-1,3),c-1,3),c-1,3)} _{b}$

so that's the pattern, hopefully you understand what I mean, so there are 2 values here, namely the initial value and the fixed value for the initial value, which is the value where b is changed to a certain value, but u for variable c is only 1 and not a value greater than 1, whereas A fixed value is a value where the variable d remains the same but the variable c is changed. For a complete definition of these 2 values, see below.

Initial value, $PAZN(a,b,1,d)=PAZN\underbrace {(a,a,(a,a,(a,a,(a,a,(...a,a,(a),d-1),d-1),d-1),d-1),d-1)} _{b}\rightarrow c=1$

Fixed value $PAZN(a,b,c,d)=PAZN\underbrace {(a,(a,(a,(a,(a,(...a,(a),c-1,d),c-1,d),c-1,d),c-1,d),c-1,d),c-1,d)} _{b}\rightarrow c>1\in \mathbb {N}$

and that is the definition for these two values, see in the second definition that the number of variables d does not change, the only thing that changes is variable c minus 1 and this is related to the number of variables b in the definition, whereas for the initial value c is 1 and cannot be more

then next we can increase the number of variables as we like, if we use 5 entries then the definition is not much different from 4 entries but the fifth entry is related to variable d or the fourth variable is like variable d is related to variables c and b in BEAF but still the growth not exceeding $f_{\omega^\omega}(n)$To mark the number of arguments in this notation, I will create an operator that is similar to the operator & in Beaf, namely the shekel or a₪b operator, for writing in Mathjax because it does not support the shekel symbol (₪), you can use ILS letters as the currency code, for example

$a(ILS)b=PAZN(\underbrace {a,a,a,a,a,a,a,a,a,...,a} _{b})\rightarrow a\land b\in \mathbb {N}$

Note that the variable a is the variable you want to make a copy in p₼(n) notation and b is the number of notations that will be repeated in baev. This pattern is written as a₪b. This is similar to the array operator in BEAF, the pattern is very similar, then pay close attention that this is just the beginning because we have to start over from the beginning, for people who can think, they will think of a₪b which is similar in pattern to a^b even though this is very wrong but we can start from the beginning, let's just say I wouldn't use it without exponentiation but remember this is not official

$a(ILS)(ILS)b=\underbrace {a(ILS)a(ILS)a(ILS)a(ILS)...(ILS)a} _{b}$

then

$a(ILS)(ILS)(ILS)b=\underbrace {a(ILS)(ILS)a(ILS)(ILS)a(ILS)(ILS)a(ILS)(ILS)...(ILS)(ILS)a} _{b}$

This pattern is very similar to uparrow notation but remember this is not about exponentiation or vaporpow anymore this is already in the realm of the number of arguments in p₼ notation, remember the NUMBER OF ARGUMENTS

$a(ILS)^{c}b=\underbrace {a(ILS)^{c-1}a(ILS)^{c-1}a(ILS)^{c-1}a(ILS)^{c-1}...a(ILS)^{c-1}a} _{b}$

look, try it carefully, here the pattern is very similar to the one in uparrow notation. Note that because uparrow notation is the ancestor of BEAF, therefore, can we put this into our notation again with a bigger notation, this may be a bit difficult to explain? already entered into the epsilon class or more, which is definitely already FAR, I say FAR beyond the grahm number, the graham number is just a speck of dust compared to the vastness of the universe, we don't talk about the graham number any more then we can enter it

Now $a(ILS)^{c}b$can be written as $PAZN(a,b,c(1)2)$

Note that this is an initial benchmark that starts actually after this we can also increase the number of arguments again and this will make the second, third and so on rray linearity difficult to explain, note that number (1) here I will discuss later but number 2 is this number is a linear array to how many there are, if 2 then this is the second linear array imagine if we start again from exponents with the shekel operator as the uparrow, how is this, if we have uparrow notation at the first level then we have the shekel operator at the second level

then if we increase the number to 3 then this is a linear array of the 3rd level compared to that if it is a linear array of the second level or I can say "shekel realm" this is the argument we add and we create a new operator to mark the 2nd level and we can increase the argument again continuously until whenever and we can and can go up to level 4, it doesn't feel very fast, then level 5, 6 and so on until finally

$PAZN(a,b,c(1)100)$

I can't explain anymore what this means because it's too extraordinary and I can't explain it now because it's very complicated, this is very similar to BEAF but the control is a bit different, after that we can even insert an array into an array like this, this starts to make My brain exploded and I'm having a hard time explaining it now

$PAZN(a,b(1)a,a,a)$

$PAZN(a,a,a(1)a,a,a(1)a,a,a(1)a,a,a(1)2)$

and so on, this is like inserting an array into an array and maybe it's a bit difficult to explain because the concept is too complicated, but because it doesn't take up space it's better to make it a 2-dimensional plane like this

$PAZN{\begin{pmatrix}a,a,...a&a,a,...a\\a,a,...a&a,a...,a\end{pmatrix}}$

and we can make the matrix for b this time it may be a bit difficult to see but this is what is called planar, for more details see below

$PAZN\underbrace {(a,a,...a(1)a,a,a(1)a,a,...a(1)a,a,...a(1)...(1)a,a,...a)} _{b}$

well then this can also be written as $PAZN(a,b(2)2)$

Then we set the number of entries in the brackets and add it to 3. If we set it to 3 there is a change, namely the entry which was previously 1 will be changed to the previous number being 2. This will create a cube when rendered but it seems like even a cube can't represent this because\ too complicated

$PAZN(a,b(3)2)=PAZN\underbrace {(a,a,...a(2)a,a,a(2)a,a,...a(2)a,a,...a(2)...(2)a,a,...a)} _{b}$

and finally, we can change the numbers in brackets to 4 5 and so on until finally we arrive at the definition, maybe I'm also a bit bad at determining definitions so I apologize for the inconvenience

$PAZN(a,b(c)2)=PAZN\underbrace {(a,a,...a(c-1)a,a,a(c-1)a,a,...a(c-1)a,a,...a(c-1)...(c-1)a,a,...a)} _{b}$

and that's it for today, because today is late for the continuation I will continue tomorrow, this is just the beginning and initial concept

Number list for this chapter

Gapik = $PAZN(16)$

Manat = $PAZN(16,16)$

Uzza = $PAZN(16,16,16)$

Agora = $PAZN(16,16,16,16)$

Arogot = $PAZN\underbrace {(16,16,16,16,16,...16)} _{1616}$

Bagora = $PAZN(16,1616,2(1)2)$

Barogot = $PAZN(16,1616,3(1)2)$

Shekel Hadash = $PAZN(16,1616(1)3)$

Shekel Jadid = $PAZN(16,1616(1)16,1616(1)2)$

(っ◔◡◔)っ ♥ T̶̡̛͚̻̬̮̼͇̳̝͕̦̲̪̜̩͔͎͚͚̭̙͍͇̪̘̘͙̻͆̐̑̔́͒͆̏͝ͅH̴̢̥̤̲͗E̴̡̡̧̩͉̳̰̩̠̞̦̜̹̲̫̟̭̟͗̉̀͗̇̍̇̂́́͘ͅͅ ̶̡̢̛̪͔̻̔̈͛̀̒̾̂́͋͋̇͒͒̇́̅̑̽̾̿̑̂͘͘͠͠I̴̡̧̛͕̠̠̜̥̥͕͎̻͔̠͓̖͈̗̺͔̝̰̖̤̖̞̞͚̒̌͊̏͋̉͒͋̔͊̇̔̏̌̈́͘͝ͅͅͅR̵̡̛̹̙͚̮̖͙̱̼̗̈́̄͛͂̈̿͗̂͌̾͆̎́̑Į̶̡̨̨̡͎̟̰̹̙̬͍̗̰͔̺̻̥͍͎̙̙̪̗̘̙̂͗́̅̓́̄́̔́͆̂͠͝S̷̡̨̧̢̢̲̹͇̼̦̻̰̮̻̹͓̝̤̤̥̞̦̞̃̉̂͂̀̀͂̓̍̽̽̌̇̾̂̉̋̎͆́͘͝͝͝͝ͅ ♥ = $PAZN(16,1616(2)2)$

𝔗̸̶̶̴̷̵̸̴̵̴̴̴̴̶̸̸̴̵̷̵̴̷̴̵̶̶̶̷̴̸̸̷̷̷̵̶̴̷̷̷̸̸̢̢̨̡̡̢̡̧̛̛̩͙̩̞͖̦̬͚̝̠̖̳̯̪͔̳͚̯̠̻̪̬͓̳̮͍̰̼̞͇̯̳̪̝͓͚͕̬̜̦̮̱̲̩̩̪̜̖̣̩̥͔͙͎͚̥͚͚͚̭͙̤̙̦͍͙͇̹̪̙̘̘̹̻͕͇͙̻̈́̊̅͆͊̀̐͑̑̾̔́̉͒̇͆̋̈̾́̂̏͂̆̅̑̍̉͐̄̒͛͛̊̓̂͗̽͂̈̅̉͐͆̀̌̐͑̈́̿̄̔͑̇́̅̃̀̀̓̄̚̕̕̕͜͜͠͝͝͠͝ͅͅͅͅℌ̷̴̶̴̴̴̴̴̢̳̼̗̗̥̮̤͔̪̲̗̂̈́͗͂͆̃̏̐̀͘͠𝔈̷̴̵̴̷̶̴̷̵̵̴̵̶̶̷̵̵̶̷̶̶̴̸̵̵̵̴̶̴̸̴̴̷̵̡̡̡̧̧̨̛̻̯̬͔͙̖͇͓̞͔̼͈͔̜͎͓̮̣͚͕͈̩͚͍̪͉̹̳̻̰̞̬̩͕͈̠̞͙͔̝̦̙̜͚̬̹̣̲̜̪̫͓͙̟͔̭̩̟̜̔̅͗̉͊̐̀͑̉͗̃̇́͒̍́̇̅̈́̉̂͆͑́̅́̄̉͋͛̓̍̌̽͂̌́͌̇̍̎̄͐̾́̂̒̆̌̉̂̑̎̓̈́͘͜͜͜͝͠ͅͅ ̸̶̶̸̸̷̶̵̸̸̶̸̴̵̸̷̷̴̷̴̷̶̵̷̷̸̵̸̴̶̷̴̷̷̶̢̡̡̢̢̛̛̛͎͔̟͎͚̦̦̙͚͈̰̻̹͖͙̭̤̤͚̥̙̬̫͍̦̤̪̥̥̠̪̼̠͎̥͖̯̰̱̬͖̯̯̪̗̗̻͔̻͕̲͌̔̔́̈͛́̑̂̀̒͌̒̃͗̾̅̂̀̂́͌̈͋̾̉̾͋̈́̇̓̉͒͗͒̇́̉̅̅̌̔̑̏̽͛̾̆̓̿̿͂̑̋̂͑̅̈́̄̑́̾̃̕͘͘͘̚͘͘̕͜͠͠͠͝𝔏̷͓̮̏͝ℑ̵̡̼̄𝔙̸̙́ℑ̶͎͍͑𝔑̸͔͈̏̄𝔊̵͑͜͝ ̵̡͚̑͗𝔓̵̟͉͑𝔏̷̡̌͠𝔄̸̼͖͋̓𝔑̵̣͝𝔈̴̨̈̄𝔗̴͇̟͘ = $PAZN(16,1616(3)2)$

Ÿ̸̜̘̱̟̹̬͇̙͚̤̭̭͕͚̣̟͎̠̣̤͈͔̟̜́̓͘͜ͅͅv̷̢̳̱̱̱̼̞̝͇̺̯̻͓̙̓͋̌̈ͅͅỷ̸̧͍̪̼̰̟̹̯̞͍͖̬̘͑́̊̍͋͆͛̽̅̀̊̈́̀͌͐͋̋̅̚͘͜͠ ̷̧̩͚̻̞͉̹͇͙̟̦̦̣̻͙̽͐͌͜͜͜ͅz̸̡̢̢̨̲͇͇̲̞͉̤̫̰̝̪̥͖͍͓̖̭̐͑̾̑͐͌̑̌̽̉̇́͌̆̌̂̉̈́̾̅̐̾͘͘̕͝ͅh̵̢̢̨͙̫͉͗̈̀͛͐͐͐̽̌̾͒͋͆͝͝ś̴̨̛̛̥̖̪͍̗̱͇̣̖͇̩͔͍̺̼͆̌͌̈͊͆́̓̍̓͒̽͌̆̄̅͆͘̕͝͠͠b̸̧̡̛̛̻̱̝̞̱͖̥̠͔̳̙̱͉̖͓̜̻̬̗̂̄͑̓̄̍͛́̾̀͛̀́͗̔͊̏̌́̃̚̚͜͝ ̴̨̡̢̢̝̩̲̮̰̤̭̬̜̦̞̲͔̟̻̫̒͋̉̄̒̃̏̈̃̿͛͛͌̈͂̄͘͘̕͜͝ͅz̴̧̧̢͓͙͍̰͈͕͔̪̙̰̠̑͐̓̆̓͆̄̎̄j̵̨͔̗̯̥̻̼͇̣̬͍̻̳̘̱̹̰͍̝̤͖̫̘̭̥͕́͛̂͒̎̑̾̐͒̌̅͂̾̔͋̚͜͝f̵̧̧̨̜̞̝͖̠͕͈̦͖̠͓̘̰̹̯̼̦̞̮̱̬̙̓̀͗̅̔̆̄̄̏̏̑́͐̒̊͌̉͋͆̕͜w̶̛̞̳̙̅́̿͗̒̂͑̇̐̈͌̎̿͛̎̈́̕͘͝͝v̵̢̧͓͓̙͈̗͕͑̀̾y̶̧̨̢̡̛̛̛̠̩̭͔̳̜̻̟͔͈̙͇̿̈́̈́̎̀̈́̄̃̅̈́̀͂͘̚͠ų̶̡̢̜̫̖̖̪̫̪̤͈͗̈́́̂͗̈́́͑̉t̸̛̯͎̺͕͔̦̦͔̙̘̏̈̆̅̍͋ ̷̘͇͎̬̖̮̬̳̞͙̽͒̓̈́̌̍̈́̉̿̾̏̃̀̈́̈͐̍͛͗̎̕g̴̨̘͙͚̃̾̽́̎͗͛͂̓̄̈́͋́͑͝m̷̗̖̀͆̒w̸̡͉͕͍͍͇̮̫͙̏̐̍̍̾̄̈́̆͑̀̔͊̓́̎̈́͆̕̚̚ͅḩ̵̙͉̝̼̣̻͔̩͓͍̈́̓̈́̈́͊̒̀͛̉̕͘ţ̴̛͔͚͈͖̥̞̙̩̰̥͓̅̒̃͗̈́̾̔̀͆̂̃̊̔͋͐̎̽̔̃̃̀̚͝͠ͅ ̶̢̧̞̞̪̪̘̜̲̣͇̲̫̭͓̙͎͌̈́̾̓͆́́̓̄̿͂̑̀̑͗̀̎̋͘b̷͖̟̾͂́̂́̒́͌̀̀͌͌́͆̿̈́̐͝n̵̡̢̥̠̩̖̺͇̳̝̱͉͉̫̜͎͇̮̞̼̞̥̰̲̖̤͖͕̽̈͒̓̾̓̂̇̊̊̓̔͋̀̑͜ ̴̠̟̄̾̏̋̎̀̆̿̿̿̽͛ḇ̵̛͖̈́̏͗̑́͊̇͛͋̓́̊̍͆̃͒̈́͛̃̀́̈́̾̿́̂̅̚͝ͅṷ̵͈̞̥̺̹̣̼͈̠̲͍̝͂ͅj̴̧̡̡̛͖̞̻̫̦̦͉̹̰͈̪͖̣͉̎̔͂͆̽̊̓̇̍̀̓̋̓̔̓̈́̒̈́̔̌͜͜ ̸͕̯̬̥̤̆̓̓̐̀̽̅͌͊̆̈́̅̀̈́̄k̸̞͉͙̱̰͍͔̦͓͖̠̳̺̳͔͎̈́̓̎̐ĭ̴̧̧̛͙͔̘͔̬͕̺̩̙͖͓̜̜͖̓̋͑̎̇̍͑̆̄͊͌̂͊̿͘͘̕͘̚͜͠͝ę̵̼͓̰̖̖͙͔̫̗̰̮͔͗̅͒̈̌̍̅͆̾̉̈́͐͆̐̆̓͌͊̆͜͠͝ͅẹ̶̢̧͉̣̞͓͍͇͈̙̭͉̠̯̦̫̜̮̹͔͔̠̖̭̲͚̲͇͛͐̄̈́̅͗͋̈́͐͒́͘͜͝͠d̵̨̧̛̮͓̘̩͍̟̗͂̋̒̇̿͋͒̒̈́̀̃̓͐̑̐̈́̀͂͆̈́͘̚ͅ,̶̨̡̢̝̜̭̱̩̫̱̹͕̰̣̰̜̠̯̱̺̪̲͉̠̻͆̍̿͑̀́̇̌̒͆͑̕͜͝ͅ ̶͎̩̟͙̖̌̋̾̈́͑͊̓̐̂͑̓̊̐̎̓̽̈́͗̅̅̑͋̈́̑͒̈́́̀̚̕Q̸̨̨̛̦͙̣̳͓͚͖̹͕̞̠̟̲̰̒̀͑̐̈́̐ ̷͈̼͎̩̳̃̀̑́̕g̷͚͙̻̯͈̯͔̠̦̪̃̇͐̋͋̓̑̀͑̀̂̂̆̎̚̚͠m̴̢̨̧̛̗̠̙̠̙̼͙͙̳͈̼̯̙̮̬͒͌̂̾̑͋̾̇͌̃̈́͊̓̀͘̕͜w̸̡̡̢̢̻̝͔̰͎̪̦̲̣͕͇̥̪̬̘̰̼̱̻̪̲̗̪̲͕̳͐͛̇̄̉̾̽̉̓͌̅̔̊̓͛̒̅͛͑̈́̒̓̑̐̆͘͠h̵̨̧̢̢̫͇͎̗̦̭̲͎̣͍̣̞̮̗̲̙̣͓̲̫̥̯̠̯̟͊x̵̡̧͇̖̹̠̼͕̹̰̲͍͉̱̦̪̹͇͖͇͎̲̜͈̎̃̒͋̊̓̂̋̆̂͂̏͑͊͐͘̚͝͝,̷̧̜̫͓̞̺͈̃͛͆̈́́͊̽̚ͅ ̴̧̨̨̟̳͓̤̫͓͇͙͍̠̱͉̠͓̪̺̫̳̗̰̺̰̙̭͗͂͝ͅb̶̛̟͙͇͍͕̠̤͓̤̄͗̈́̔̾͗͊̋̌̄͝s̸̢͍̳̦͖͇̩̹͚͉͍̣̝͙̬͖̥̹̤̰̯͇̥̻͙̄̕͜͜͜͝ͅ ̵̬̳͂̍͆̿b̶̨̧̨̡̡̪̲̪̠̪̟͔̰̖̭̱̩͇̲͕̠̙̙̰̰͙͛͂́͆̿̑͝ṳ̷̢̨͍̣̘̪̫͚̠͓̬͚͎̘̫͙̞̭͉̤͐͗̇̓̋͋̍͝j̸̨̥̱̣̳̜͓͖̬͖̟̈́̓̐̾̋̑͒͑̈́́̊̾̾̅̈̆̓̀̏̈̚̕̕̕͝͠ ̴̢̢̛̼̩̭̞̺̖̯͉̼͓̬̲̬̹͎͔̪͔̠̗̖͔͇̦̮̓̋̌͋̽̿͂̓̈́͋̄̓̏͊͒̒̀̚͜ͅw̸̡̛̛̟̠̮̬̓̉͒́̒̋̒̓̂͑͆̈́̔͒͑̈́͆̾̀̊̕͠͠͠͠ͅẖ̴̨̢̝̞̭̺͍̥̬̣̞̩͎̘̗͍̦̩̲̘̳̣͇̩͎̫̤̀̓̈́̂̒̅͜n̷̞̜͕̙̲͖͕̦̩̘̥̰̫̪̘͐̓͆͐͊̓͛͂̑̍̇̋͌̎̐̊́̚̚̚͘̚̕͝͠͠u̴̱͓͎̮̞͖͔̎͋̓̇̎̉̄̋̉̃͋̃͛̌̍̚̕͜͠í̸̧̡͕͕̠̻͍̗͉̯̹̺͕̞̻̱̦̭̒͒̿͗͒̆͒̀͑̉̿̈́̅̀̇̉̐̓̌̏̀͆̓͌̚͜͠͝͠t̶̨̼̗͓͚̥͉̥̱̩͔͖͕̣̙͉̜͔͓͇̥̖̩̗̰̬̟͉̘͙̄͊̌̇̂̌̅͋̎̇̊̅́̿̀̃͆͊̽̉͝v̶̨̲̪̤̜̝̞̝̻̯̹͉̖̳̅̀̎͑̇͐̋̌͌̽̎̆̒̀̀̾͒̓̓̂̊̓̓̀͗̚͠͝ỷ̷̨̟͕̱̺̟͓̤̞̭̫͉͖̞͈͛̾̐́̿̚͠m̶̢̡̛̛̤̖̻̜͇̹̫̣̭͇̤͔̝̫̩͖̟̘͈̳̭͖̜̜̈̈́̈́́͊̄̃̂͘͘̕͝͠ ̸̼̻͙̩̓͌̏͗͊̍̏̀̀̓́̐͗̌̄̇̕̕̕͜͝͝͠ị̵̖̺̗͎̱̱̟̙̦̼̫̖͓̖̖͓͔͇͙̂͐s̶͕̺̳̘̪̰̳͓͇̭̞̫̺̼̣̆̽̎̎̐̽̌̓͊́́̃̽̋̾̀̚͘͜͝ͅ ̶͓͇͚͒̒͊̄̓͐̀́̑̈̀̔̔̒̋̑̈̓̒̌̒͌͌͝m̴̨̳̞̳̟̱̳͓̜̪̙̺̠̈́̔͋̏̐̓̈͗͂́̑̽́̎̚͝͠͠ḩ̵̢̡̥̗̬̪̭̘̥͙̭̼̹̮͖̹͎͕̖̞͎̮̔̑̌͊̇́̆̓̌̅̃͜͠ͅm̷̟͙͍̟̭͇̺̠͖̬̻̯͚̪̂̑̓̈̾͘̕ͅ ̴̮̤͍͚̣̠̳̙̂̈́̈͒͐͛́̓͋͂͘͠ứ̶̰̘̯̼͇̊͛̾̎̌̈́̏̃̈̆̇͜ͅz̶̲͌̎͆̀͛̈́̃͆̎͒̽̈́̋̄̓́̈́̐̿̎ä̸̧̮̪̟̥̫́̏͋͗̊͊͋͆̍̚ủ̷̢͈̈̈̇̕ȃ̸̤̜͇͈̬̩͚̜̯̥͙̼̎̈͘ͅͅ ̵̡̧̛̝͈̣̦͓̼̖͚̥͔͔̟̣̏͐̄̆̅̇̅̕̚͝f̷̨̻͙͚̤̗̭̹̦̼͍̖͕́́́̏̓į̵͎̜̙͍̱̣̘͉̱͇̼͈̙̹̙͎̱̰̬̯͎̗͙͕̙̼̃̀̔̓̓̎̈̈́̐͠͝͝ͅṿ̵̘́̓̊̃̎͗͗̍̈́́̈́̕͝q̸̨̢̡̧̨̡͓̲͎̣̥̗͓̱͖͉̬͖̜͉̤͕̳͇̲͑͋̓ͅͅ ̸̭̺̮̖̰̟͑̒͑̈́̔̈́́̔͊̊́̈̐͘̚͝y̵̨̛̞̩̝͌͐͂͜ĉ̷̜̜̜̭̘̦́͋͋̏̓̂̾͝ͅ ̸̹̺̀̅͋̈́́̅̕ẇ̶̨̢̡̥̮͔̠̲̬͇̮̖͙̱̥̻͓̦̺̭̝̞̥̔́̂̓̈́̌̎̆͊̈̈́̈́͋͐̑̚̚͜b̷̢͉͎̞̠̯̜̺͖̣̲̳̟̫͉̻̟̱͖̠͕̤̓̋̀́k̴̟͉̜̻͓̥͐̏̈́͐̄̆̎̒̀̐͆̑̍͂̓̉̍̕͘r̵̨͚͉̬̦̣̼̘͔̲̰̜̤̝̜̞͖̝͇̬̻̩͗̆͑̿͘̚͜ͅm̵̢̨̭̫̱̺͎̟͉͕̲̯̞̣͍̮̮̙̖͕̣̤͐̅͂́͒̓̔̀͊̐͘͘͘͜͜͝͝͝y̴̧̛̳̳͓̼͔̟̭̜̖͌̌̆͆͒͌̀̀́̏̃̓̀͒̍̿́̓͌̌̊̿̉͋͂̀͘͘͜͠ͅf̶̠̀̓͐́̌̏̓̆̓͛͛͑́͑͋̓̋͘h̸̨̨̼̫̜͉̺̜͍̮̝̝̞̝̺͍̳̯̭͂̀̿̊́̐̓ͅỷ̸̧̧̳̞̥̮͚̫̫͔̼̗͖͉̺̜̟̫͎͔̤̱̆͛͘͜ ̶̢̡͉̹͇͖͉̻͉͎̙̳̱̰̻͍͓̺͖̰͈̱̳̺̹̩͇͕̥̃͛̌̅͛̿̂̑ͅn̷̡̖͉̯͔͈͔̼̝̜̣̣̰͈̼̼͖̠̮͚̮̯͔̰̺̹͛͆͑͑͊̈́̅͆̀̐̈́̕̚͝͠͝ȇ̵̛̛̛͚̗̳̪̫̠̃̒̐̃̎̃̄̑͊̈́͒̿͊̾̾̈́̀̈̿̔̄͆͠͝͠ĺ̷̨̙̮͔̘̟̪̳̦̱̘̤͍͓̠̞̠̞͓͔̰̈́̄̊̓͗͜ ̶̡̛̗̣̭̭̘͉͇͍̳̞͋̂̉͗͑̐̒͌̀́̓̐̈͆́͒͒͒͠͝q̵͓͖̤̱͖̥̠̤͙̣͇̫͕͎̳͚̞̗̻̘͔͉̂̈̓̐͘̕ğ̸̡͕̼̼͂̔̂̂̄́͊̈́̃̚̕͝x̷̨̦̻̫̭̞͚̗̭͚̰̼̻̤̲͎̟̞͓͍̍ͅͅ ̷̜̳̱͉̭́͊̾̋͗͐̔͋̈́͊͐͂̀͛͐̔̇͆̕͝͝q̴̢̨̧̨̢̱̣͖̬̹̣̯͙̩͚͖̭̮̥̖̦̯̪͕̜̗̝̱̎͛͗͋̉̐̇̆̕̕ͅͅǐ̵̢̧̡̹͕̫̹̘̗̪̭̭̟̯̣͍̓̾͑̄͗̇̓͋̽͆̌̋̿͛͐͗́͆̒̀̀̍̓͝å̷̰͖̒͊̈́̾̽̊̑̈́͐̿̃́͆̀̏̓̊͊́͂̚͠͝͝͝m̴̼̮̙͉͚̲͎͉͙͙̫̣͔̰̱̹̻͇̔̓́͋̎͛͆͂͐̾̎͗̿̎͂̋̎̕̚͝͝ͅͅͅë̴͎͙́͂́̿͐̒̍̽̑̊̆̅̌̿̇̏̂v̶̡̢͔̳̤͔̳͍̪̻̩̮̬̙͓͉̤͖̩̤̗̪̅̌̆͗͂̌͋͌̓̎̎̈́̾́̌̀̄̓͐̏̈́̈́̓̓̚͘͠͝ͅg̷̢̡̛̺͖̹̞͕͇̗͔̮̹̬̟̰͓͉̦̺̼͇͚̟̯̪̹̫͍̜̥͂̔̇̏̽͆̑́͛̓̎̿͑͋́̂̅̉̍̽͆͑̂̚̚x̶̨̛͓̦̙̻̹̭̲͎̻͛͊̇͋̀̽́͂̔͂́̏̽̏͛̾̎̕͘̚͝͝͠͝ͅ.̸̛̠̤̯͊̈́̏͐́̑̉̕

= $PAZN(16,1616(16,1616(1)2)2)$