(04/26/2021, 02:11 AM)sheldonison Wrote: Thanks James,

Your latest paper looks really impressive; I will comment more later; I've been too busy to spend any time on tetration over the last month and a half.

- Sheldon

Thank you, Sheldon, for doing that variable change,

And thinking of it as a weird Schroder equation. That was definitely the click I needed. Using obviously doesn't work because it solves,

Which is definitely not tetration at . Whereas, the function,

IS definitely tetration at because . Which isn't really obvious when you write it using the variable . They both go to infinity, and they both display chaotic behaviour; but one looks like and the other just looks like .

If you ever get the time to do Tetration again, I'm happy to answer any questions. A lot of this is very complicated, and especially when pasting the tetration functions together to get the tetration we actually want; I imagine it'll be very confusing. The key though, is that once you can do this uniformly in and ; you can talk about moving while iterating; and everything still works.

At this point, I can't think of anything to add to the paper. And as a disclaimer; I am a horrible programmer. I only ever did a bunch of C programming back in the glory days of XBOX mods; where I dealt with hex code as a primary. My piece de resistance was a hack for Capcom games that broke the encryption of picture files... to make girls naked on a certain Capcom game. So I do not know how to even approach generating a Taylor Series. I imagine you, who has definitely dealt with constructing Taylor Series before; especially in exotic situations; may have some light to shed. The trouble I'm having is approaching the function, without it blowing up at other points -_-. And these blow ups (which I just call short circuits) are quite clearly artifacts of my code -_-. I'm trying to even think of a way of generating Taylor Series, and I have no F*n clue, lol.

You can see what I mean here; where it converges much better in some areas (the singularity is more obviously a singularity; the dip to zero is more prominent; and the imaginary arguments seem more dramatic), but then some singularities in the code appear (these spikes pop out of the wood work, which are definitely artifacts). Which is no doubt, because my iteration requires larger samples of to produce a more accurate result. But larger values of is producing overflow errors, because it looks like tetration... -_- A computer knows no difference between and --at least in MatLab. Couple that with some round-off errors, and some poorly coded exponentials; and we get blow ups which follow a dynamic pattern. (A lot of the code errors look like Leau Petals, so at least that's kind of cool, lol.)

Honestly, this would be the easiest code on planet earth if we had a processor that could handle arbitrary large strings of binary digits. If it weren't for overflow errors, this problem would be elementary -_-. Sucks to live in a world of finite resources, lol.

Regards, James

BTW

I've added my primitive code on GitHub, so if anyone's interested in seeing how I ran the numbers, it's there.

https://github.com/JmsNxn92/Recursive_Tetration/

And this is the link to the arXiv publication.

https://arxiv.org/abs/2104.01990