<![CDATA[Tetration Forum - Computation]]> https://tetrationforum.org/ Tue, 12 May 2026 11:43:09 +0000 MyBB <![CDATA[Python codes to test my recent results about tetration]]> https://tetrationforum.org/showthread.php?tid=1797 Thu, 26 Dec 2024 15:29:31 +0000 marcokrt]]> https://tetrationforum.org/showthread.php?tid=1797 Twelve Python Programs to Help Readers Test Peculiar Properties of Integer Tetration (DOI: 10.13140/RG.2.2.13553.80489).]]> Twelve Python Programs to Help Readers Test Peculiar Properties of Integer Tetration (DOI: 10.13140/RG.2.2.13553.80489).]]> <![CDATA[FractionalIteration now in Wolfram Function Repository]]> https://tetrationforum.org/showthread.php?tid=1766 Mon, 10 Jul 2023 06:16:36 +0000 Daniel]]> https://tetrationforum.org/showthread.php?tid=1766 FractionalIteration.]]> FractionalIteration.]]> <![CDATA[Code to calculate tetration using my method]]> https://tetrationforum.org/showthread.php?tid=1760 Fri, 02 Jun 2023 07:33:07 +0000 Shanghai46]]> https://tetrationforum.org/showthread.php?tid=1760 To calculate, it's tetra(x,a,b) for x^^(a+bi)


from math import*

def mod(a,b):
    A=(a**2+b**2)**0.5
    return A
def Arg(a,b):
    Z=atan2(b,a)
    return Z
def fn(a,n):
    X=0
    while n+1>0:
        n=n-1
        X=a**X
    return X
def logan(X,Y,a,n):
    while n>0:
        M=mod(X,Y)
        A=Arg(X,Y)
        X=log(M,a)
        Y=(A)/log(a,e)
        n=n-1
    return X,Y
def TAU(X):
    n=0
    a=1
    while n<400:
        a=X**a
        n=n+1
    return a
def LAMBDA(X):
    a=log(X,e)*TAU(X)
    return a
def lpr(x,p,b):
    X=LAMBDA(x) 
    if X>=0:
        A=(X**p)*cos(log(X,e)*b)
    else:
        A=e**(log(-X,e)*p-pi*b)*cos(log(-X,e)*b+p*pi)
    return A
def lpi(x,p,b):
    X=LAMBDA(x) 
    if X>=0:
        A=(X**p)*sin(log(X,e)*b)
    else:
        A=e**(log(-X,e)*p-pi*b)*sin(log(-X,e)*b+p*pi)
    return A
def entier(X):
    X=floor(X)
    return X
def decimal(X):
    a=entier(X)
    b=X-a
    return b
def Nu(X):
    n=0 
    a=fn(X,n)
    b=TAU(X)
    while ((a-b)**2)**0.5>0.0001:
        n=n+1
        a=fn(X,n)
    return n
def tetraa(X,a,b):
    E=entier(a)
    D=decimal(a)
    N=Nu(X)
    A=fn(X, N+E)-TAU(X)
    B=(A*(lpr(X, D,b)))+TAU(X)
    C=(A*(lpi(X, D,b))) 
    O=logan(B,C,X,N)
    return O
def BIGn(X):
    n=X
    a=1
    if 3.9<X<5:
      X=X**X
      a=2
    else:
      while X-3000<0:
          X=n**X
          a=a+1
    return a
def BIGx(X):
    n=X
    if 3.9<X<5:
      X=X**X
    else:
      while X-3000<0:
          X=n**X
    return X
def logwan(X,a,n): 
    while n>0:
        X=log(X+1,a)
        n=n-1
    return X
def PUr(X,a,b,n):
    while n>0:
        A=(X**a)*cos(log(X,e)*b)
        B=(X**a)*sin(log(X,e)*b)
        a=A
        b=B
        n=n-1
    return a
def PUi(X,a,b,n):
    while n>0:
        A=(X**a)*cos(log(X,e)*b)
        B=(X**a)*sin(log(X,e)*b)
        a=A
        b=B
        n=n-1
    return b
def Gn(a,b,X,n):
    while n>0:
        A=(X**a)*cos(log(X,e)*b)-1
        B=(X**a)*sin(log(X,e)*b)
        a=A
        b=B
        n=n-1
    return a,b
def lim(X):
    A=BIGx(X)
    if X<e:
        b=logwan(A,X,400)
    else:
        b=0
    return b
def gamma(X):
    A=(lim(X)+1)*log(X,e)
    return A
def NA(X):
    A=BIGx(X)
    B=lim(X)
    n=0
    while ((A-B)**2)**0.5>10**(-6):
        n=n+1
        A=logwan(A,X,1)
    return n
def fin(X,p,b):
    E=decimal(1-decimal(p))
    Z=entier(p)
    A=BIGx(X)
    B=logwan(A,X,NA(X))
    C=B-lim(X)
    D=(C/(gamma(X)**E)*cos(log(gamma(X),e)*b))+lim(X)
    W=(C/(gamma(X)**E)*sin(log(gamma(X),e)*b))
    F,U=Gn(D,W,X,NA(X))
    Y=BIGn(X)-E-p
    if Y>=0:
        O=logan(F,U,X,Y)
    else:
        O=PUr(F,U,X,-Y),PUi(F,U,X,-Y)
    return O
def tetra(X,n,b):
    if X==1:
      Z=(1,0)
    elif n<=-2 and n==int(n) and b==0:
      Z="ERROR" 
    elif n>=-1 and decimal(n)<=0 and b==0:
      Z=fn(X,n) 
    else:
      if e**(-e)<=X<=e**(1/e):
        Z=tetraa(X,n,b)
      elif X>e**(1/e):
        Z=fin(X,n,b)
      else:
        Z="ERROR"
    return Z]]> To calculate, it's tetra(x,a,b) for x^^(a+bi)


from math import*

def mod(a,b):
    A=(a**2+b**2)**0.5
    return A
def Arg(a,b):
    Z=atan2(b,a)
    return Z
def fn(a,n):
    X=0
    while n+1>0:
        n=n-1
        X=a**X
    return X
def logan(X,Y,a,n):
    while n>0:
        M=mod(X,Y)
        A=Arg(X,Y)
        X=log(M,a)
        Y=(A)/log(a,e)
        n=n-1
    return X,Y
def TAU(X):
    n=0
    a=1
    while n<400:
        a=X**a
        n=n+1
    return a
def LAMBDA(X):
    a=log(X,e)*TAU(X)
    return a
def lpr(x,p,b):
    X=LAMBDA(x) 
    if X>=0:
        A=(X**p)*cos(log(X,e)*b)
    else:
        A=e**(log(-X,e)*p-pi*b)*cos(log(-X,e)*b+p*pi)
    return A
def lpi(x,p,b):
    X=LAMBDA(x) 
    if X>=0:
        A=(X**p)*sin(log(X,e)*b)
    else:
        A=e**(log(-X,e)*p-pi*b)*sin(log(-X,e)*b+p*pi)
    return A
def entier(X):
    X=floor(X)
    return X
def decimal(X):
    a=entier(X)
    b=X-a
    return b
def Nu(X):
    n=0 
    a=fn(X,n)
    b=TAU(X)
    while ((a-b)**2)**0.5>0.0001:
        n=n+1
        a=fn(X,n)
    return n
def tetraa(X,a,b):
    E=entier(a)
    D=decimal(a)
    N=Nu(X)
    A=fn(X, N+E)-TAU(X)
    B=(A*(lpr(X, D,b)))+TAU(X)
    C=(A*(lpi(X, D,b))) 
    O=logan(B,C,X,N)
    return O
def BIGn(X):
    n=X
    a=1
    if 3.9<X<5:
      X=X**X
      a=2
    else:
      while X-3000<0:
          X=n**X
          a=a+1
    return a
def BIGx(X):
    n=X
    if 3.9<X<5:
      X=X**X
    else:
      while X-3000<0:
          X=n**X
    return X
def logwan(X,a,n): 
    while n>0:
        X=log(X+1,a)
        n=n-1
    return X
def PUr(X,a,b,n):
    while n>0:
        A=(X**a)*cos(log(X,e)*b)
        B=(X**a)*sin(log(X,e)*b)
        a=A
        b=B
        n=n-1
    return a
def PUi(X,a,b,n):
    while n>0:
        A=(X**a)*cos(log(X,e)*b)
        B=(X**a)*sin(log(X,e)*b)
        a=A
        b=B
        n=n-1
    return b
def Gn(a,b,X,n):
    while n>0:
        A=(X**a)*cos(log(X,e)*b)-1
        B=(X**a)*sin(log(X,e)*b)
        a=A
        b=B
        n=n-1
    return a,b
def lim(X):
    A=BIGx(X)
    if X<e:
        b=logwan(A,X,400)
    else:
        b=0
    return b
def gamma(X):
    A=(lim(X)+1)*log(X,e)
    return A
def NA(X):
    A=BIGx(X)
    B=lim(X)
    n=0
    while ((A-B)**2)**0.5>10**(-6):
        n=n+1
        A=logwan(A,X,1)
    return n
def fin(X,p,b):
    E=decimal(1-decimal(p))
    Z=entier(p)
    A=BIGx(X)
    B=logwan(A,X,NA(X))
    C=B-lim(X)
    D=(C/(gamma(X)**E)*cos(log(gamma(X),e)*b))+lim(X)
    W=(C/(gamma(X)**E)*sin(log(gamma(X),e)*b))
    F,U=Gn(D,W,X,NA(X))
    Y=BIGn(X)-E-p
    if Y>=0:
        O=logan(F,U,X,Y)
    else:
        O=PUr(F,U,X,-Y),PUi(F,U,X,-Y)
    return O
def tetra(X,n,b):
    if X==1:
      Z=(1,0)
    elif n<=-2 and n==int(n) and b==0:
      Z="ERROR" 
    elif n>=-1 and decimal(n)<=0 and b==0:
      Z=fn(X,n) 
    else:
      if e**(-e)<=X<=e**(1/e):
        Z=tetraa(X,n,b)
      elif X>e**(1/e):
        Z=fin(X,n,b)
      else:
        Z="ERROR"
    return Z]]> <![CDATA[Writing Kneser's super logarithm using values of Kneser at a single point]]> https://tetrationforum.org/showthread.php?tid=1738 Mon, 10 Apr 2023 07:48:40 +0000 JmsNxn]]> https://tetrationforum.org/showthread.php?tid=1738
\[
\text{tet}_K'(\tau(0)) = 1\\
\]

The value \(\tau(0) = 0.806...\). Then we bank a Taylor series:

\[
\text{tet}_K(\tau(0) + z) = \text{tet}_K(\tau(0)) + z + \sum_{k=2}^\infty a_k z^k\\
\]

I developed this Taylor series using Sheldon's fatou.gp. And this is all that I've used from sheldon. Once you have this Taylor series, you can create the super logarithm, and by proxy, the Kneser tetration. My code is on par with speed with Sheldon, but it can take some time. I think a big graph should show what I mean. Here is \(|\Re(z)| <4\) and \(|\Im(z)| < 1\) and we graph \(\text{slog}(z)\):


.png   TRYING_SLOG_A_BIT_MORE_SOPHISTICATED.png (Size: 57.22 KB / Downloads: 540)

It's still not perfect; but this is Kneser's super logarithm from a single taylor series of Kneser's super exponential centered at a point \(\text{tet}_K'(\tau(0)) = 1\). To get perfection we will need to sample along \(\tau\), and getting Taylor series about here; which can speed up the current slog code I have. Additionally this would fix some issues with large graphs I have.

So, to refresh; we can take a single 50kb file, which stores \(a_k\); and we can use this to run Kneser's slog with little to no interruptions. My code is not faster than Sheldon's. But it is more malleable. When we write slog(A+z) this expression writes the taylor series of slog about A in the variable z. My expression of slog uses much more of the built in functions of pari. And you can treat it like \(\sin\) or how built in pari code works.

AGAIN! I've done nothing mathematically here. I've simply stored the taylor series:

\[
\text{tet}_K(z+\tau(0)) = \text{TAYLOR}\\
\]

I used sheldon's program to get the Kneser numbers. But now, all we need is TAYLOR to construct the slog function. From here we can write Kneser's tetration everywhere. If we use a single Taylor series from Kneser--generated by Sheldon; we can bypass all of Sheldon's code and write simpler code which does a "good enough job".

This code is very rough, and slightly inaccurate. But we're good for about 15-20 digits of accuracy. Which is the cap from the import of 50kb Taylor data. This technique does not work generally. The code I use specifies that \(z \mapsto \exp(z)\) is nowhere normal, and each point \(z_0 \mapsto \exp(z_0)\) eventually gets close to \(0 \mapsto \exp(0) \mapsto \exp(1) \mapsto \exp(\exp(1))\mapsto...\). This is a proven property of the exponential function. Thereby, my code works. If you want to take arbitrary tetrations, this code will not work. And in no way will it even look like it works.

This algorithm produces \(\text{slog}_K(z)\) for vertical branching points at \(\pm L\).  This works solely off the 50kb that \(a_k\) generate. The \(\text{slog}\) we create is the unique one about the real-line, but there are branches in the complex plane.


.png   TRY_DIRTY_SHELDON_RIEMANN.png (Size: 46 KB / Downloads: 455)

Inverting this super logarithm creates Kneser's tetration. This is all Sheldon's heavy lifting. But It tricks the story. We only need 50kb of data, and we can process it as fast but in more manageable language. The taylor series of \(|text{tet}_K'(\tau)| = 1\) gives the raw solution/]]>
\[
\text{tet}_K'(\tau(0)) = 1\\
\]

The value \(\tau(0) = 0.806...\). Then we bank a Taylor series:

\[
\text{tet}_K(\tau(0) + z) = \text{tet}_K(\tau(0)) + z + \sum_{k=2}^\infty a_k z^k\\
\]

I developed this Taylor series using Sheldon's fatou.gp. And this is all that I've used from sheldon. Once you have this Taylor series, you can create the super logarithm, and by proxy, the Kneser tetration. My code is on par with speed with Sheldon, but it can take some time. I think a big graph should show what I mean. Here is \(|\Re(z)| <4\) and \(|\Im(z)| < 1\) and we graph \(\text{slog}(z)\):


.png   TRYING_SLOG_A_BIT_MORE_SOPHISTICATED.png (Size: 57.22 KB / Downloads: 540)

It's still not perfect; but this is Kneser's super logarithm from a single taylor series of Kneser's super exponential centered at a point \(\text{tet}_K'(\tau(0)) = 1\). To get perfection we will need to sample along \(\tau\), and getting Taylor series about here; which can speed up the current slog code I have. Additionally this would fix some issues with large graphs I have.

So, to refresh; we can take a single 50kb file, which stores \(a_k\); and we can use this to run Kneser's slog with little to no interruptions. My code is not faster than Sheldon's. But it is more malleable. When we write slog(A+z) this expression writes the taylor series of slog about A in the variable z. My expression of slog uses much more of the built in functions of pari. And you can treat it like \(\sin\) or how built in pari code works.

AGAIN! I've done nothing mathematically here. I've simply stored the taylor series:

\[
\text{tet}_K(z+\tau(0)) = \text{TAYLOR}\\
\]

I used sheldon's program to get the Kneser numbers. But now, all we need is TAYLOR to construct the slog function. From here we can write Kneser's tetration everywhere. If we use a single Taylor series from Kneser--generated by Sheldon; we can bypass all of Sheldon's code and write simpler code which does a "good enough job".

This code is very rough, and slightly inaccurate. But we're good for about 15-20 digits of accuracy. Which is the cap from the import of 50kb Taylor data. This technique does not work generally. The code I use specifies that \(z \mapsto \exp(z)\) is nowhere normal, and each point \(z_0 \mapsto \exp(z_0)\) eventually gets close to \(0 \mapsto \exp(0) \mapsto \exp(1) \mapsto \exp(\exp(1))\mapsto...\). This is a proven property of the exponential function. Thereby, my code works. If you want to take arbitrary tetrations, this code will not work. And in no way will it even look like it works.

This algorithm produces \(\text{slog}_K(z)\) for vertical branching points at \(\pm L\).  This works solely off the 50kb that \(a_k\) generate. The \(\text{slog}\) we create is the unique one about the real-line, but there are branches in the complex plane.


.png   TRY_DIRTY_SHELDON_RIEMANN.png (Size: 46 KB / Downloads: 455)

Inverting this super logarithm creates Kneser's tetration. This is all Sheldon's heavy lifting. But It tricks the story. We only need 50kb of data, and we can process it as fast but in more manageable language. The taylor series of \(|text{tet}_K'(\tau)| = 1\) gives the raw solution/]]> <![CDATA[I'm going to write a modified version of MakeGraph by mike3]]> https://tetrationforum.org/showthread.php?tid=1706 Thu, 16 Feb 2023 09:26:42 +0000 JmsNxn]]> https://tetrationforum.org/showthread.php?tid=1706
It's been pissing me off how slow Mike3's MakeGraph program runs. And I've decided to employ a speed up of this program.

Now, traditionally; Mike3's program goes pixel by pixel and assigns a colour point. I am going to add in a subroutine which splines together n by k pixels into a linear solution of the pixel values at the origin of this block. This is much more in tune with standard graphing programs. I'd just like to have these algorithms attached to pari-gp; rather than run pari in a graphing program.

I'm still beta testing this; but my idea works on paper. The general idea is we write a modified version of mike3's program. Where instead of re-evaluating the function at each pixel; we set 5 by 5 or 10 by 5 pixels are assigned this value. Which greatly speeds up convergence.

If we assume func(z) = O(h(n)); then Mike3's program runs like O(n^2h(n)). I believe I can reduce this to O(n log(n) h(n)) without sacrificing too much quality.

I'm going to publish it soon. But it is proving pretty tricky to get everything right--plus I suck with graphics. But theoretically this will diversify mike3's program greatly.

.......................


Wish me luck Tongue]]>
It's been pissing me off how slow Mike3's MakeGraph program runs. And I've decided to employ a speed up of this program.

Now, traditionally; Mike3's program goes pixel by pixel and assigns a colour point. I am going to add in a subroutine which splines together n by k pixels into a linear solution of the pixel values at the origin of this block. This is much more in tune with standard graphing programs. I'd just like to have these algorithms attached to pari-gp; rather than run pari in a graphing program.

I'm still beta testing this; but my idea works on paper. The general idea is we write a modified version of mike3's program. Where instead of re-evaluating the function at each pixel; we set 5 by 5 or 10 by 5 pixels are assigned this value. Which greatly speeds up convergence.

If we assume func(z) = O(h(n)); then Mike3's program runs like O(n^2h(n)). I believe I can reduce this to O(n log(n) h(n)) without sacrificing too much quality.

I'm going to publish it soon. But it is proving pretty tricky to get everything right--plus I suck with graphics. But theoretically this will diversify mike3's program greatly.

.......................


Wish me luck Tongue]]> <![CDATA[Calculating the fractional iterates of \(f(z) = e^z-1\) to reasonable accuracy]]> https://tetrationforum.org/showthread.php?tid=1669 Tue, 15 Nov 2022 02:18:43 +0000 JmsNxn]]> https://tetrationforum.org/showthread.php?tid=1669
To begin, this program is designed to calculate one thing and one thing only.

Let's let:

\[
f(z) = e^z -1\\
\]

And let's let:

\[
f^{\circ s}(z) : \mathbb{C}_{\Re(s) > 0} \times \mathbb{C}/[0,\infty) \to \mathbb{C}/[0,\infty)\\
\]

I have written, not a perfect algorithm, but a very efficient algorithm--to evaluate this function. Now my code algorithms are different from most of what is written about here, but are incredibly convenient if you know how to use them. I promise I will release a nice article which relates all my work in a month or so.

To begin, before diving into the entire construct; this code is accurate to 13 decimal points, and to get more decimal points, requires an overhaul of this code. It is possible to tweak my code to get 100 decimal points, but it requires a lot of fucking ram. And it requires treating much larger taylor series than I already treat. I capped everything at 13 digits, as this is a theoretical discovery more than anything. Please play with me here.


Here is the code:

Code:
\p 50
\ps 20

Const(poly) = {
    my(vars = variables(poly));
    substvec(poly, vars, vector(#vars));
};

f(z) = exp(z) - 1;

iter_f(n,z) = {
    if(n==0, z,
    Pol(f(iter_f(n-1,z)),z);
    );
};

init_vartheta({LIMIT=300}) = {
    BASE = sum(n=0,LIMIT,Pol(iter_f(n+1,z),z)*(-x)^n/factorial(n));
};


F(s,y) = {
    if(s==1, return(f(y)));

    if(Const(s)>1, F(s-1,f(y)),
        if(abs(Const(y))<0.05,
            (1/gamma(1-s))*(sum(n=0,300, subst(iter_f(n+1,z),z,y)*(-1)^n/(factorial(n)*(1+n-s))) + intnum(X=1,90,subst(subst(BASE,x,X),z,y)*X^(-s))),
            log(F(s,f(y)) + 1)
        )
    );
};

We run this code in Pari-gp, where it acts as a calculator. I'll give a rough run down of the code:


We start this by writing:

Code:
\r neutral_int
init_vartheta()
                  GP/PARI CALCULATOR Version 2.13.2 (released)
          amd64 running mingw (x86-64/GMP-6.1.2 kernel) 64-bit version
          compiled: Jun 10 2021, gcc version 8.3-posix 20190406 (GCC)
                            threading engine: single
                (readline v8.0 disabled, extended help enabled)

                     Copyright (C) 2000-2020 The PARI Group

PARI/GP is free software, covered by the GNU General Public License, and comes
WITHOUT ANY WARRANTY WHATSOEVER.

Type ? for help, \q to quit.
Type ?17 for how to get moral (and possibly technical) support.

parisizemax = 3000000000, primelimit = 500000
   realprecision = 57 significant digits (50 digits displayed)
   seriesprecision = 20 significant terms
%6 = (7.3124522221141931945873965423489781850870963336375 E-574*z^20 + 4.8776641577580803165997457076259405952006870791110 E-576*z^19 + 3.2533729371585239861252793578076839333642436527966 E-578*z^18 + 2.1698381028845785190912405551606111538850924034236 E-580*z^17 + 1.4470734195083639760114636923270112313333833413846 E-582*z^16 + 9.6498718463090253371361871330158177146488344742966 E-585*z^15 + 6.4345469484715300226050838546265794266461049531099 E-587*z^14 + 4.2901966756256620121086824394762639526571841493871 E-589*z^13 + 2.8601982722689581947419466107731984641405981829792 E-591*z^12 + 1.9066506966376583109223165588593100135056802136581 E-593*z^11 + 1.2708602917968835452795860344260753111502911809426 E-595*z^10 + 8.4697542120625621748490806146107026700881852065906 E-598*z^9 + 5.6439536224722981518853895350062310010105217671656 E-600*z^8 + 3.7603398308175438781868992276092586249171876491427 E-602*z^7 + 2.5048995559479616592645703228743438043732892424379 E-604*z^6 + 1.6682343079708266464423028467933492903021662807954 E-606*z^5 + 1.1107165013033971231837564220368316028037815124859 E-608*z^4 + 7.3924559154968194554659329253699274729037039100560 E-611*z^3 + 4.9173764404635162674939686864988431083616655720994 E-613*z^2 + 3.2673597611053264235840323498331183444263558618600 E-615*z)*x^300 + (-2.0589547720821092060786223192151143959240060383760 E-571*z^20 - 1.3779914826472309568294107919635582483482636490661 E-573*z^19 - 9.2218758582917270562944692905636679807443162207638 E-576*z^18 - 6.1711121739999530177255076282387244935981321050957 E-578*z^17 - 4.1293078519937848457489908731271917325970331298606 E-580*z^16 - 2.7628589866638515934497565556810800983915286426183 E-582*z^15 - 1.8484406465819516637405603795846618804829672385618 E-584*z^14 - 1.2365593781076561456034845471595071306486740782974 E-586*z^13 - 8.2714950840113874438767279000894870655299064782632 E-589*z^12 - 5.5323413394245904725289968268135134676405323003597 E-591*z^11 - 3.699861227636877896616633708095127345018[+++]

These Taylor values are divergent, the same way Gottfried and Bo talked about. It's just way better in this form. This code, read the code above, and then ran the initialization of \(\vartheta\).

From here we have two functions; we have \(f(z) = e^z-1\) and \(f^{\circ s}(z)\). Where \(z\) is valid for \(z\not\in [0,\infty)\) and \(\Re(s) > 0\). Additionally all code is valid to 13 digits at least.

From here, we call \(F(s,z) = f^{\circ s}(z)\). I'll spend a bit describing how to use this function.

Code:
F(0.5,F(0.5,-5+I))
%7 = -0.99635947169836762192725358390433494253623663552745 + 0.0056697868968831960894314416400933210717550792617893*I
f(-5+I)
%8 = -0.99635947169957680983203733901585094813263971484423 + 0.0056697868969038589404768188791737542163949162730891*I

This evaluates \(f^{\circ 0.5}(f^{\circ 0.5}(-5+i)) = e^{-5 + i} -1\), which is accurate to 13 digits.

The function
Code:
F(s,z)

takes an argument \(\Re(s) > 0\) and \(z\not \in [0,\infty)\). We have at least 13 digit accuracy in the digit precision of this semi group. Additionally, we have 13 digit accuracy in the taylor series.

Let's try expanding:

\[
f^{\circ 0.5}(z-5+i) = h(z)\\
\]

We'd write this as:

Code:
F(0.5,z-5+I)
%9 = (-1.4656748902284050870504481862537795117671444246461 + 0.013883663470269166110664749712091909975949044350577*I) + (0.0090552475535492909792479328232154641781195015743980 + 0.013791788086198760462199343906524092446614863468969*I)*z + (0.0045670178028367387071314821117573918515789937225712 + 0.0068041753533976256135561527057713296047659865352235*I)*z^2 + (0.0015476865068734175206106841571398528403105012863369 + 0.0022070765928811747955236233464310513021430501476307*I)*z^3 + (0.00039891543892133659548658340989669165569996938228453 + 0.00052140830231873072442992810627522686362712867239751*I)*z^4 + (8.4178174236866631903867457930707359218420844461063 E-5 + 9.2220969676350184272646106150840043596397895758635 E-5*I)*z^5 + (1.5297155692229718205929575150684078516045300547506 E-5 + 1.1395397338723591211620539015417303944240961887947 E-5*I)*z^6 + (2.4648659933433487006503562525188591833685417639558 E-6 + 5.1377007877187693499137867370832521899136010774460 E-7*I)*z^7 + (3.4808960611572283953358417653324009343919347206223 E-7 - 2.0528161657762188628631661516172178141919335211807 E-7*I)*z^8 + (3.8065304843361262020434116594035191636557801219975 E-8 - 7.9278413908388873487851724824603493615481918735897 E-8*I)*z^9 + (1.0262817647647246718140355878199687007495381069315 E-9 - 1.8042710996946409674216037570469209013672633186364 E-8*I)*z^10 + (-1.0671844118504040416472747693791047833813058467303 E-9 - 3.1069505116746984305164580175645155123873173268737 E-9*I)*z^11 + (-4.2264043416520561526591337823459060486928937586240 E-10 - 3.9529446327467605097430462476720645209437537948999 E-10*I)*z^12 + (-1.0898912674485696287799509959338396278648791985816 E-10 - 2.2577638080132273808895439521968670601373004378094 E-11*I)*z^13 + (-2.2035809700737663175818097198090007249431422665734 E-11 + 6.5314195869655575147470127053405308248805299942984 E-12*I)*z^14 + (-3.4919297780828299609990518244588393208166940017650 E-12 + 3.0720461691049833172482387788303336124354214938314 E-12*I)*z^15 + (-3.6[+++]

This produces a perfect taylor series, which is at least accurate to 13 digits.


What if we want the taylor series in the opposite direction? What if I write:

\[
f^{\circ 1+s}(-5+i)\\
\]

And I want the taylor expansion in \(s\)?

Code:
F(1+s,-5+I)
%10 = (-0.99635947169957680983203733901585094813263971021027 + 0.0056697868969038589404768188791737542163949161932332*I) + (0.60609216070061100500241466679407467098619430745279 - 0.0077250176109846098808165311553651411366060097011257*I)*s + (-0.41285028279167336813051969083342279733530972881951 + 0.0085229886404815413973422399150977622926380796272986*I)*s^2 + (0.30361358186710751566577626629756404923298178075460 - 0.0088325861081141740647195757373726384677017469326918*I)*s^3 + (-0.23592873968303340883809953707678661516971746042177 + 0.0089393169567161129394010205581945137928297062420063*I)*s^4 + (0.19096956817462706430587704934303355783481085371569 - 0.0089579585981148333632972715609138607712393768297543*I)*s^5 + (-0.15941854364830271813160499945837995038600880161538 + 0.0089371693479168984622390162313503272080243708731951*I)*s^6 + (0.13627260246566502697860348729434647969007037592224 - 0.0088983577138788008294310695249194978698704662348583*I)*s^7 + (-0.11866604910316757419904248700380406228603171508754 + 0.0088511979829179419033345860406703144298817967817887*I)*s^8 + (0.10486744079874876669911988681960690660290618205919 - 0.0088001486751402172736197048996441755078019630054121*I)*s^9 + (-0.093782151116666434801974278707266098008872239799289 + 0.0087472952687562274893120367856051516580193915156286*I)*s^10 + (0.084690536770248759102663212872320243928606350730621 - 0.0086936246561684599598210394520297784162250142416144*I)*s^11 + (-0.077103048723103474748768233212747741749936145681226 + 0.0086396084404931198323320526587606607844820231484328*I)*s^12 + (0.070676531038672679007430968970104655489191639418639 - 0.0085854740979227678667229120529134109538809774911364*I)*s^13 + (-0.065164008098491834925836344345463460612349983669567 + 0.0085313325433693449367454469441149262933119729525905*I)*s^14 + (0.060383533528453698516558823626929372468072953883903 - 0.0084772386944008324064901157778848674038011565110348*I)*s^15 + (-0.056198273129911454863841818316929817054507395990904[+++]

These are again, accurate to about 13 digits. Even in the late coefficients.


We can even go even further and pull a multivariable taylor series:

\[
f^{\circ 1+s}(z-5+i)\\
\]

Code:
F(1+s,z-5+I)
Reading GPRC: C:\Program Files (x86)\Pari64-2-13-2\/gprc.txt
GPRC Done.

  *** _*_: Warning: increasing stack size to 16000000.
  ***   Warning: increasing stack size to 32000000.
  ***   Warning: increasing stack size to 64000000.
%11 = ((-0.99635947169957680983203733901585094813263971021027 + 0.0056697868969038589404768188791737542163949161932332*I) + (0.60609216070061100500241466679407467098619430745279 - 0.0077250176109846098808165311553651411366060097011257*I)*s + (-0.41285028279167336813051969083342279733530972881951 + 0.0085229886404815413973422399150977622926380796272986*I)*s^2 + (0.30361358186710751566577626629756404923298178075460 - 0.0088325861081141740647195757373726384677017469326918*I)*s^3 + (-0.23592873968303340883809953707678661516971746042177 + 0.0089393169567161129394010205581945137928297062420063*I)*s^4 + (0.19096956817462706430587704934303355783481085371569 - 0.0089579585981148333632972715609138607712393768297543*I)*s^5 + (-0.15941854364830271813160499945837995038600880161538 + 0.0089371693479168984622390162313503272080243708731951*I)*s^6 + (0.13627260246566502697860348729434647969007037592224 - 0.0088983577138788008294310695249194978698704662348583*I)*s^7 + (-0.11866604910316757419904248700380406228603171508754 + 0.0088511979829179419033345860406703144298817967817887*I)*s^8 + (0.10486744079874876669911988681960690660290618205919 - 0.0088001486751402172736197048996441755078019630054121*I)*s^9 + (-0.093782151116666434801974278707266098008872239799289 + 0.0087472952687562274893120367856051516580193915156286*I)*s^10 + (0.084690536770248759102663212872320243928606350730621 - 0.0086936246561684599598210394520297784162250142416144*I)*s^11 + (-0.077103048723103474748768233212747741749936145681226 + 0.0086396084404931198323320526587606607844820231484328*I)*s^12 + (0.070676531038672679007430968970104655489191639418639 - 0.0085854740979227678667229120529134109538809774911364*I)*s^13 + (-0.065164008098491834925836344345463460612349983669567 + 0.0085313325433693449367454469441149262933119729525905*I)*s^14 + (0.060383533528453698516558823626929372468072953883903 - 0.0084772386944008324064901157778848674038011565110348*I)*s^15 + (-0.05619827312991145486384181831692981705450739599090[+++]


All in all, this is a really good tool for \(f(z) = e^z-1\), and for all of its iterates. But it is a slightly lower precision construction. I have attached the pari gp tool.

Fuck em up boyz!


.gp   neutral_int.gp (Size: 585 bytes / Downloads: 541) ]]>
To begin, this program is designed to calculate one thing and one thing only.

Let's let:

\[
f(z) = e^z -1\\
\]

And let's let:

\[
f^{\circ s}(z) : \mathbb{C}_{\Re(s) > 0} \times \mathbb{C}/[0,\infty) \to \mathbb{C}/[0,\infty)\\
\]

I have written, not a perfect algorithm, but a very efficient algorithm--to evaluate this function. Now my code algorithms are different from most of what is written about here, but are incredibly convenient if you know how to use them. I promise I will release a nice article which relates all my work in a month or so.

To begin, before diving into the entire construct; this code is accurate to 13 decimal points, and to get more decimal points, requires an overhaul of this code. It is possible to tweak my code to get 100 decimal points, but it requires a lot of fucking ram. And it requires treating much larger taylor series than I already treat. I capped everything at 13 digits, as this is a theoretical discovery more than anything. Please play with me here.


Here is the code:

Code:
\p 50
\ps 20

Const(poly) = {
    my(vars = variables(poly));
    substvec(poly, vars, vector(#vars));
};

f(z) = exp(z) - 1;

iter_f(n,z) = {
    if(n==0, z,
    Pol(f(iter_f(n-1,z)),z);
    );
};

init_vartheta({LIMIT=300}) = {
    BASE = sum(n=0,LIMIT,Pol(iter_f(n+1,z),z)*(-x)^n/factorial(n));
};


F(s,y) = {
    if(s==1, return(f(y)));

    if(Const(s)>1, F(s-1,f(y)),
        if(abs(Const(y))<0.05,
            (1/gamma(1-s))*(sum(n=0,300, subst(iter_f(n+1,z),z,y)*(-1)^n/(factorial(n)*(1+n-s))) + intnum(X=1,90,subst(subst(BASE,x,X),z,y)*X^(-s))),
            log(F(s,f(y)) + 1)
        )
    );
};

We run this code in Pari-gp, where it acts as a calculator. I'll give a rough run down of the code:


We start this by writing:

Code:
\r neutral_int
init_vartheta()
                  GP/PARI CALCULATOR Version 2.13.2 (released)
          amd64 running mingw (x86-64/GMP-6.1.2 kernel) 64-bit version
          compiled: Jun 10 2021, gcc version 8.3-posix 20190406 (GCC)
                            threading engine: single
                (readline v8.0 disabled, extended help enabled)

                     Copyright (C) 2000-2020 The PARI Group

PARI/GP is free software, covered by the GNU General Public License, and comes
WITHOUT ANY WARRANTY WHATSOEVER.

Type ? for help, \q to quit.
Type ?17 for how to get moral (and possibly technical) support.

parisizemax = 3000000000, primelimit = 500000
   realprecision = 57 significant digits (50 digits displayed)
   seriesprecision = 20 significant terms
%6 = (7.3124522221141931945873965423489781850870963336375 E-574*z^20 + 4.8776641577580803165997457076259405952006870791110 E-576*z^19 + 3.2533729371585239861252793578076839333642436527966 E-578*z^18 + 2.1698381028845785190912405551606111538850924034236 E-580*z^17 + 1.4470734195083639760114636923270112313333833413846 E-582*z^16 + 9.6498718463090253371361871330158177146488344742966 E-585*z^15 + 6.4345469484715300226050838546265794266461049531099 E-587*z^14 + 4.2901966756256620121086824394762639526571841493871 E-589*z^13 + 2.8601982722689581947419466107731984641405981829792 E-591*z^12 + 1.9066506966376583109223165588593100135056802136581 E-593*z^11 + 1.2708602917968835452795860344260753111502911809426 E-595*z^10 + 8.4697542120625621748490806146107026700881852065906 E-598*z^9 + 5.6439536224722981518853895350062310010105217671656 E-600*z^8 + 3.7603398308175438781868992276092586249171876491427 E-602*z^7 + 2.5048995559479616592645703228743438043732892424379 E-604*z^6 + 1.6682343079708266464423028467933492903021662807954 E-606*z^5 + 1.1107165013033971231837564220368316028037815124859 E-608*z^4 + 7.3924559154968194554659329253699274729037039100560 E-611*z^3 + 4.9173764404635162674939686864988431083616655720994 E-613*z^2 + 3.2673597611053264235840323498331183444263558618600 E-615*z)*x^300 + (-2.0589547720821092060786223192151143959240060383760 E-571*z^20 - 1.3779914826472309568294107919635582483482636490661 E-573*z^19 - 9.2218758582917270562944692905636679807443162207638 E-576*z^18 - 6.1711121739999530177255076282387244935981321050957 E-578*z^17 - 4.1293078519937848457489908731271917325970331298606 E-580*z^16 - 2.7628589866638515934497565556810800983915286426183 E-582*z^15 - 1.8484406465819516637405603795846618804829672385618 E-584*z^14 - 1.2365593781076561456034845471595071306486740782974 E-586*z^13 - 8.2714950840113874438767279000894870655299064782632 E-589*z^12 - 5.5323413394245904725289968268135134676405323003597 E-591*z^11 - 3.699861227636877896616633708095127345018[+++]

These Taylor values are divergent, the same way Gottfried and Bo talked about. It's just way better in this form. This code, read the code above, and then ran the initialization of \(\vartheta\).

From here we have two functions; we have \(f(z) = e^z-1\) and \(f^{\circ s}(z)\). Where \(z\) is valid for \(z\not\in [0,\infty)\) and \(\Re(s) > 0\). Additionally all code is valid to 13 digits at least.

From here, we call \(F(s,z) = f^{\circ s}(z)\). I'll spend a bit describing how to use this function.

Code:
F(0.5,F(0.5,-5+I))
%7 = -0.99635947169836762192725358390433494253623663552745 + 0.0056697868968831960894314416400933210717550792617893*I
f(-5+I)
%8 = -0.99635947169957680983203733901585094813263971484423 + 0.0056697868969038589404768188791737542163949162730891*I

This evaluates \(f^{\circ 0.5}(f^{\circ 0.5}(-5+i)) = e^{-5 + i} -1\), which is accurate to 13 digits.

The function
Code:
F(s,z)

takes an argument \(\Re(s) > 0\) and \(z\not \in [0,\infty)\). We have at least 13 digit accuracy in the digit precision of this semi group. Additionally, we have 13 digit accuracy in the taylor series.

Let's try expanding:

\[
f^{\circ 0.5}(z-5+i) = h(z)\\
\]

We'd write this as:

Code:
F(0.5,z-5+I)
%9 = (-1.4656748902284050870504481862537795117671444246461 + 0.013883663470269166110664749712091909975949044350577*I) + (0.0090552475535492909792479328232154641781195015743980 + 0.013791788086198760462199343906524092446614863468969*I)*z + (0.0045670178028367387071314821117573918515789937225712 + 0.0068041753533976256135561527057713296047659865352235*I)*z^2 + (0.0015476865068734175206106841571398528403105012863369 + 0.0022070765928811747955236233464310513021430501476307*I)*z^3 + (0.00039891543892133659548658340989669165569996938228453 + 0.00052140830231873072442992810627522686362712867239751*I)*z^4 + (8.4178174236866631903867457930707359218420844461063 E-5 + 9.2220969676350184272646106150840043596397895758635 E-5*I)*z^5 + (1.5297155692229718205929575150684078516045300547506 E-5 + 1.1395397338723591211620539015417303944240961887947 E-5*I)*z^6 + (2.4648659933433487006503562525188591833685417639558 E-6 + 5.1377007877187693499137867370832521899136010774460 E-7*I)*z^7 + (3.4808960611572283953358417653324009343919347206223 E-7 - 2.0528161657762188628631661516172178141919335211807 E-7*I)*z^8 + (3.8065304843361262020434116594035191636557801219975 E-8 - 7.9278413908388873487851724824603493615481918735897 E-8*I)*z^9 + (1.0262817647647246718140355878199687007495381069315 E-9 - 1.8042710996946409674216037570469209013672633186364 E-8*I)*z^10 + (-1.0671844118504040416472747693791047833813058467303 E-9 - 3.1069505116746984305164580175645155123873173268737 E-9*I)*z^11 + (-4.2264043416520561526591337823459060486928937586240 E-10 - 3.9529446327467605097430462476720645209437537948999 E-10*I)*z^12 + (-1.0898912674485696287799509959338396278648791985816 E-10 - 2.2577638080132273808895439521968670601373004378094 E-11*I)*z^13 + (-2.2035809700737663175818097198090007249431422665734 E-11 + 6.5314195869655575147470127053405308248805299942984 E-12*I)*z^14 + (-3.4919297780828299609990518244588393208166940017650 E-12 + 3.0720461691049833172482387788303336124354214938314 E-12*I)*z^15 + (-3.6[+++]

This produces a perfect taylor series, which is at least accurate to 13 digits.


What if we want the taylor series in the opposite direction? What if I write:

\[
f^{\circ 1+s}(-5+i)\\
\]

And I want the taylor expansion in \(s\)?

Code:
F(1+s,-5+I)
%10 = (-0.99635947169957680983203733901585094813263971021027 + 0.0056697868969038589404768188791737542163949161932332*I) + (0.60609216070061100500241466679407467098619430745279 - 0.0077250176109846098808165311553651411366060097011257*I)*s + (-0.41285028279167336813051969083342279733530972881951 + 0.0085229886404815413973422399150977622926380796272986*I)*s^2 + (0.30361358186710751566577626629756404923298178075460 - 0.0088325861081141740647195757373726384677017469326918*I)*s^3 + (-0.23592873968303340883809953707678661516971746042177 + 0.0089393169567161129394010205581945137928297062420063*I)*s^4 + (0.19096956817462706430587704934303355783481085371569 - 0.0089579585981148333632972715609138607712393768297543*I)*s^5 + (-0.15941854364830271813160499945837995038600880161538 + 0.0089371693479168984622390162313503272080243708731951*I)*s^6 + (0.13627260246566502697860348729434647969007037592224 - 0.0088983577138788008294310695249194978698704662348583*I)*s^7 + (-0.11866604910316757419904248700380406228603171508754 + 0.0088511979829179419033345860406703144298817967817887*I)*s^8 + (0.10486744079874876669911988681960690660290618205919 - 0.0088001486751402172736197048996441755078019630054121*I)*s^9 + (-0.093782151116666434801974278707266098008872239799289 + 0.0087472952687562274893120367856051516580193915156286*I)*s^10 + (0.084690536770248759102663212872320243928606350730621 - 0.0086936246561684599598210394520297784162250142416144*I)*s^11 + (-0.077103048723103474748768233212747741749936145681226 + 0.0086396084404931198323320526587606607844820231484328*I)*s^12 + (0.070676531038672679007430968970104655489191639418639 - 0.0085854740979227678667229120529134109538809774911364*I)*s^13 + (-0.065164008098491834925836344345463460612349983669567 + 0.0085313325433693449367454469441149262933119729525905*I)*s^14 + (0.060383533528453698516558823626929372468072953883903 - 0.0084772386944008324064901157778848674038011565110348*I)*s^15 + (-0.056198273129911454863841818316929817054507395990904[+++]

These are again, accurate to about 13 digits. Even in the late coefficients.


We can even go even further and pull a multivariable taylor series:

\[
f^{\circ 1+s}(z-5+i)\\
\]

Code:
F(1+s,z-5+I)
Reading GPRC: C:\Program Files (x86)\Pari64-2-13-2\/gprc.txt
GPRC Done.

  *** _*_: Warning: increasing stack size to 16000000.
  ***   Warning: increasing stack size to 32000000.
  ***   Warning: increasing stack size to 64000000.
%11 = ((-0.99635947169957680983203733901585094813263971021027 + 0.0056697868969038589404768188791737542163949161932332*I) + (0.60609216070061100500241466679407467098619430745279 - 0.0077250176109846098808165311553651411366060097011257*I)*s + (-0.41285028279167336813051969083342279733530972881951 + 0.0085229886404815413973422399150977622926380796272986*I)*s^2 + (0.30361358186710751566577626629756404923298178075460 - 0.0088325861081141740647195757373726384677017469326918*I)*s^3 + (-0.23592873968303340883809953707678661516971746042177 + 0.0089393169567161129394010205581945137928297062420063*I)*s^4 + (0.19096956817462706430587704934303355783481085371569 - 0.0089579585981148333632972715609138607712393768297543*I)*s^5 + (-0.15941854364830271813160499945837995038600880161538 + 0.0089371693479168984622390162313503272080243708731951*I)*s^6 + (0.13627260246566502697860348729434647969007037592224 - 0.0088983577138788008294310695249194978698704662348583*I)*s^7 + (-0.11866604910316757419904248700380406228603171508754 + 0.0088511979829179419033345860406703144298817967817887*I)*s^8 + (0.10486744079874876669911988681960690660290618205919 - 0.0088001486751402172736197048996441755078019630054121*I)*s^9 + (-0.093782151116666434801974278707266098008872239799289 + 0.0087472952687562274893120367856051516580193915156286*I)*s^10 + (0.084690536770248759102663212872320243928606350730621 - 0.0086936246561684599598210394520297784162250142416144*I)*s^11 + (-0.077103048723103474748768233212747741749936145681226 + 0.0086396084404931198323320526587606607844820231484328*I)*s^12 + (0.070676531038672679007430968970104655489191639418639 - 0.0085854740979227678667229120529134109538809774911364*I)*s^13 + (-0.065164008098491834925836344345463460612349983669567 + 0.0085313325433693449367454469441149262933119729525905*I)*s^14 + (0.060383533528453698516558823626929372468072953883903 - 0.0084772386944008324064901157778848674038011565110348*I)*s^15 + (-0.05619827312991145486384181831692981705450739599090[+++]


All in all, this is a really good tool for \(f(z) = e^z-1\), and for all of its iterates. But it is a slightly lower precision construction. I have attached the pari gp tool.

Fuck em up boyz!


.gp   neutral_int.gp (Size: 585 bytes / Downloads: 541) ]]> <![CDATA[Terse Schroeder & Abel function code]]> https://tetrationforum.org/showthread.php?tid=1650 Sun, 02 Oct 2022 13:42:25 +0000 Daniel]]> https://tetrationforum.org/showthread.php?tid=1650
Code:
order=10;
H[0]=0;
H[1]=f'[0]^t ;
Do[H[max]=First[r[t]/.RSolve[{r[0]==0,r[t]==Sum[Derivative[k][f][0]BellY[max,k,Table[H[j]/.t->t-1,{j,max}]],{k,2,max}]+ f'[0] r[t-1]},r[t],t]],{max,2,order}];
Schroeder=f'[0]^t z+Sum[1/k! H[k]z^k,{k,2,order}]
Abel=Limit[Schroeder,{f'[0]->1}]
]]>
Code:
order=10;
H[0]=0;
H[1]=f'[0]^t ;
Do[H[max]=First[r[t]/.RSolve[{r[0]==0,r[t]==Sum[Derivative[k][f][0]BellY[max,k,Table[H[j]/.t->t-1,{j,max}]],{k,2,max}]+ f'[0] r[t-1]},r[t],t]],{max,2,order}];
Schroeder=f'[0]^t z+Sum[1/k! H[k]z^k,{k,2,order}]
Abel=Limit[Schroeder,{f'[0]->1}]
]]> <![CDATA[Language converter]]> https://tetrationforum.org/showthread.php?tid=1649 Fri, 30 Sep 2022 04:38:33 +0000 Daniel]]> https://tetrationforum.org/showthread.php?tid=1649 Language Converter Sadly it currently only works with small chunks of code.]]> Language Converter Sadly it currently only works with small chunks of code.]]> <![CDATA[Slick Mathematica "trick"]]> https://tetrationforum.org/showthread.php?tid=1648 Thu, 29 Sep 2022 09:07:26 +0000 Daniel]]> https://tetrationforum.org/showthread.php?tid=1648 <![CDATA[GitHub repo for Mathematica packlet FractionalIteration]]> https://tetrationforum.org/showthread.php?tid=1629 Fri, 26 Aug 2022 06:53:09 +0000 Daniel]]> https://tetrationforum.org/showthread.php?tid=1629 FractionalIteration. If you work with Mathematica feel free to review my work or add your own version! First I need to convert my old package to a paclet, a series of directories and files to automatically load the system, including documentation, into Mathematica.]]> FractionalIteration. If you work with Mathematica feel free to review my work or add your own version! First I need to convert my old package to a paclet, a series of directories and files to automatically load the system, including documentation, into Mathematica.]]> <![CDATA[Computing Kneser's Super Logarithm and its Analytic Continuation]]> https://tetrationforum.org/showthread.php?tid=1536 Fri, 17 Jun 2022 23:17:47 +0000 Catullus]]> https://tetrationforum.org/showthread.php?tid=1536 Galactic algorithm for computing it? (Even if we do not know what algorithm would have that big O.) If so, what is it?
What about computing the inverse Kneser's tetration, instead of his super logarithm?
What about computing the analytical continuation of the Kneser method?]]> Galactic algorithm for computing it? (Even if we do not know what algorithm would have that big O.) If so, what is it?
What about computing the inverse Kneser's tetration, instead of his super logarithm?
What about computing the analytical continuation of the Kneser method?]]> <![CDATA[Computing Integer Tetrations]]> https://tetrationforum.org/showthread.php?tid=1404 Thu, 09 Jun 2022 03:26:53 +0000 Catullus]]> https://tetrationforum.org/showthread.php?tid=1404 <![CDATA[Quickest way to compute the Abel function on the Shell-Thron boundary]]> https://tetrationforum.org/showthread.php?tid=1388 Thu, 21 Apr 2022 00:52:17 +0000 JmsNxn]]> https://tetrationforum.org/showthread.php?tid=1388
\[
\alpha <s>_{\varphi} y = \exp_{y^{1/y}}^{\circ s}\left(\log^{\circ s}_{y^{1/y}}(\alpha) + y + \varphi\right)\\
\]

For \(\varphi\) a complex number--I'm mostly just dealing with real positive values at the moment. The goal is to evaluate the function \(\varphi(\alpha,y,s)\), such that these operators will satisfy Goodstein's equation:

\[
\alpha <s> \left(\alpha <s+1> y\right) = \alpha <s+1> (y+1)\\
\]

But for the moment, I'm just concerning myself with calculating the first function. Everything works great so far, but I'm scratching my head for when \(y^{1/y} = \partial \mathfrak{S}\)-- when it's on the boundary of the Shell-Thron region (equivalently \(|\log(y)| = 1\)). Now I know we can construct a repelling and attracting Abel function about these points--and I know all the theory. But I just realized, I've never actually seen a program that constructs it. I know Sheldon has a program for handling it, but I really don't want to go digging through all the matrix theory. I just want a quick formula. I know if you make a variable change that it becomes pretty elementary.

So for the moment, I can construct \(\alpha <s>_{\varphi} y\), for pretty much the entire complex plane in \(y\) (excluding branch cuts), excluding where \(y^{1/y} \in \mathfrak{S}\). This is primarily because I don't know a fast way to get both abel functions... I could program in a way, but I think it's going to be way too slow. This program is already pretty slow as it is (we have to consistently reinitialize to account for varying bases of the exponential). I don't want to slow it down any more. I was wondering if there's anywhere on this forum that has an easy to read program I can adapt for this.

...I just hope I don't have to write too much just to handle the case \(|\log(y)| = 1\) -_-....

Edit: I thought I'd add that I know how to write in the neutral case but it just nukes the speed of my code. I know how to program in the \(\eta\) case, but I'm wondering what the current fastest way is. For the moment, I'm just returning \(0\) anywhere on the boundary, because it just nukes my code and makes everything so fucking slow for these values of \(y\).]]>
\[
\alpha <s>_{\varphi} y = \exp_{y^{1/y}}^{\circ s}\left(\log^{\circ s}_{y^{1/y}}(\alpha) + y + \varphi\right)\\
\]

For \(\varphi\) a complex number--I'm mostly just dealing with real positive values at the moment. The goal is to evaluate the function \(\varphi(\alpha,y,s)\), such that these operators will satisfy Goodstein's equation:

\[
\alpha <s> \left(\alpha <s+1> y\right) = \alpha <s+1> (y+1)\\
\]

But for the moment, I'm just concerning myself with calculating the first function. Everything works great so far, but I'm scratching my head for when \(y^{1/y} = \partial \mathfrak{S}\)-- when it's on the boundary of the Shell-Thron region (equivalently \(|\log(y)| = 1\)). Now I know we can construct a repelling and attracting Abel function about these points--and I know all the theory. But I just realized, I've never actually seen a program that constructs it. I know Sheldon has a program for handling it, but I really don't want to go digging through all the matrix theory. I just want a quick formula. I know if you make a variable change that it becomes pretty elementary.

So for the moment, I can construct \(\alpha <s>_{\varphi} y\), for pretty much the entire complex plane in \(y\) (excluding branch cuts), excluding where \(y^{1/y} \in \mathfrak{S}\). This is primarily because I don't know a fast way to get both abel functions... I could program in a way, but I think it's going to be way too slow. This program is already pretty slow as it is (we have to consistently reinitialize to account for varying bases of the exponential). I don't want to slow it down any more. I was wondering if there's anywhere on this forum that has an easy to read program I can adapt for this.

...I just hope I don't have to write too much just to handle the case \(|\log(y)| = 1\) -_-....

Edit: I thought I'd add that I know how to write in the neutral case but it just nukes the speed of my code. I know how to program in the \(\eta\) case, but I'm wondering what the current fastest way is. For the moment, I'm just returning \(0\) anywhere on the boundary, because it just nukes my code and makes everything so fucking slow for these values of \(y\).]]> <![CDATA[The beta method program]]> https://tetrationforum.org/showthread.php?tid=1379 Fri, 25 Feb 2022 02:05:18 +0000 JmsNxn]]> https://tetrationforum.org/showthread.php?tid=1379
I thought I'd post a link to my github repository for the beta.gp program. I will post the readme of the program and the file itself, along with the github. If only I feel the need to update or fix some errors in my code; I'll do it on github, and not necessarily on this post.

Here is the readme.txt which gives a run down of everything:

Code:
# The-Beta-Method-Thesis
The final program for the beta method of iterated exponentials

Coded by James David Nixon, with supplementary code by Sheldon Levenstein and Mike3 of the tetration forum.
Levenstein optimized some protocols I had written, and we use Mike3's graphing protocol.


To begin use of the program one must execute the file in a pari-gp shell.
We can now choose digit precision by taking "\p d" and series precision by "\ps count"; for d,count positive integers.


From here, one must call init(l,b); or init_OFF(l,b) if abs(b) > 1E6, abs(b)<1E-4. The variable l must have a real part greater than zero; and b cannot equal zero (this produces the trivial beta), and the trivial tetration Sexp = 1.

After initialization, the values l = mult and b = base are global variables. It is possible to initialize these objects as polynomials as well; meaning mult = 1+u or base = 1+v are perfectly valid. This protocol internally uses the variable x, so do not use this variable or reassign this variable else where in the program.

This produces 4 function protocols (and a few variations):

beta(z) = exp(base * beta(z-1))/(1+exp(-mult * (z-1)))

tau(z) = log(1+tau(z+1)/beta(z+1))/base - log(1+exp(-mult * z))/base

Sexp_N(z+1) = beta(z+1) + tau(z+1) = exp(base * (beta(z) + tau(z)))

Each of these functions has a period of 2 * Pi * I/mult. They will be accurate to the digit precision, usually; if not, re run the initialization protocol with a higher series precision. Or one can keep the series precision and run init(l,b,COUNT) (resp. init_OFF); where COUNT determines how many iterations to do. One should never have to exceed 1000. There is an optional parameter in tau and Sexp_N which can tell us how many times to do the iteration; the program by default chooses enough for most calculations; sometimes it may be beneficial to induce more iterations.

We can treat these three functions as polynomials as well; so that beta(1+z), tau(1+z), Sexp_N(1+z), are all viable prompts, which produce the polynomial about 1 in z to the desired series precision.

There is also a separate initialization protocol you can run after the first which gives the summative form of the error. This would be:

init_rho(c, {LIMIT = default(seriesprecision)}) which creates up to the series precision a sequence of functions rho, which act as sum(j=1,LIMIT,RHO[j]) = tau(q+CENTER,LIMIT-2). The variable CENTER=c; and this is declared as a global constant. This protocol internally uses the variable q; so it is best warned to not use the variable q elsewhere in the program.

This spawns the function:

rho(z,j)

which is an evaluation of a polynomial centered about CENTER upto the series precision. The variable j indexes up until how many rho terms were made using LIMIT in init_rho. Or, if there's an overflow it sets the protocol to zero; or if j is outside of the index list, sets the protocol to zero. This satisfies:

rho(z,0) = 0;
rho(z,1) = -log(1+exp(-mult * z))/base
sum(j=0,LIMIT-1, rho(z,j)) = tau(z, LIMIT-2)

rho(z,j) = tau(z,j-1) - tau(z,j-2);

And lastly, a protocol:

tau_rho(z) = tau(z,LIMIT-2);

Which is just short hand for the sum.


/*****************************************************************************************************/
The next functions are a Julia set protocol for beta.

We want to determine the points that are in the weak Julia set, and the points which are not.
These are points where the orbits escape. A point a belongs to the weak Julia set if, for any D> 0:

limsup n to infinity sup(|z-a|<D, 1/beta(z+n)) = infinity

Sadly, there is no efficient way to calculate this, other than the below expression; which tests if 1/beta(z+depth) grows eggregiously fast in a neighborhood.
This is allowed because where beta(z) is very small, nearby we are arbitrarily close to infinity; whether in further orbits or in the same orbit.


This is the Julia test, which requires a single for-loop; which is accurate enough.

The variable depth must come in the form of a nonzero natural number; it tells us how deep to run the recursion.

The variable rad can be chosen as small as possible; and decides the radius of the circle we sample from; 1E-100 gives a good enough result.

The variable sample must come in the form of a nonzero natural number. It determines how many samples we take from the circle of radius rad about a.


This function takes sample amount of sample points on a disk about a; and tests whether we diverge at depth or not.
The ideal form of this function would be at rad to 0, and sample to infinity; and depth to infinity.
But, nonetheless this is still fairly accurate; and as accurate as possible without unscrupuously shrinking rad and growing the sample; plus, making depth as deep as possible.

Is_Julia(a,{depth = 25},{rad = 1E-100},{sample = 24})


Attached to this function is the Is_Shell_Thron, and Is_Shell_Thron_EXP. This takes a point a and tests upto a depth and a series precision the fixed point (or lack there of) of the exponential exp(log(a) * z) (resp. exp(a * z)); and spits out the constant or a zero for lack of fixed point. This is solely for the purpose of graphing and testing for if a point is in Shell-Thron.

/*****************************************************************************************************/

The next functions are a tad more involved. We want to find the normalization constant, and this can be difficult.
Expect this normalization process to fail for values like b=0.0001 or b = -1000; or any extreme values.
At this point, it is much better to just run the super exponential that is not normalized.

We effectively run a Newtonian root finder algorithm, but we run it twice; in the neighborhood of z = 0
I have included these functions in the normalization initialization; but they may not initialize properly for b = 0.0001, or  b=-1000.

It can also encounter a good amount of problems with complex b, but it will work; the problem is typically wait times.


init_NORM(l,b)  where l and b must be mult and base or else we fail. Then we have access to:

x_NORM()

such that

Sexp(z) = Sexp_N(z+x_NORM())

in which Sexp(0) = 1; now. Again, this is superfluous and not as well coded as the rest of this program; expect wait times and imprecision.

/************************************************************************************************************************************

The following is Mike3's readme for his graphing protocol, used to make phase-plot graphs.


/* ============================================================================= 
** Color graphing system - mike3 - 20.11.10 04:07
** Hi.
** I thought I'd post the code I use to generate the color graphs from Pari/GP.
** Here it is.
**
** Note: the output is in .PPM format.
** You'll need something else to convert that to .PNG. (I use GIMP.)
**
** Also, I might warn you: it takes a LONG time to graph a complex function
** with a significantly complicated calculation procedure, as it must be
** evaluated at every pixel of the graph.
**
** (updated 12/16/2010 -- program was not all good:
**   * spurious "func" parameter in MakeGraph and "safetyarg" was missing.)
** ------------------------------------------------------------------------------------------
** 
** ============================================================================= */

/* =============================== Code: ==================================================== */
/* Complex function magnitude/phase plotter. */

/* To use:
*     1. Define function to graph as func(z).
*     2. Load this program.
*     3. Execute MakeGraph(width, height, x0, y0, x1, y1, filename) with the parameters given as follows:
*        width, height = width/height of image in pixels
*        x0, y0, x1, y1 = rectangle of complex plane to graph: x0 + y0i in upper-left corner to x1 + y1i in lower-right corner
*        filename = name of file to save as.
* Output is in .PPM format.
*/


And here's beta.gp


.gp   beta.gp (Size: 23.12 KB / Downloads: 691)


And for further updates; if I feel the need to add anything I will probably just change github, rather than editing this post.

https://github.com/JmsNxn92/The-Beta-Method-Thesis/



This post goes hand in hand with the beta method thesis; introduced in this forum post.

And here's a pretty picture I generated with this program, of what a tetration looks like for \(b=e^{-0.3-i} \approx 0.4002657... - i0.6233770...\) with a period of \(2 \pi i\); graphed over the region \(0 \le \Im(s),\Re(s) \le 2 \pi \). It isn't normalized but you can visually see how to shift the function into tetration--that lone zero in the bottom left corner needs to be positioned at \(\text{Sexp}(-1) = 0\).


.png   INV_ABEL_NEGATIVE_POINT_3_MINUS_I_MULT_1.png (Size: 109.62 KB / Downloads: 726)


Regards, James]]>
I thought I'd post a link to my github repository for the beta.gp program. I will post the readme of the program and the file itself, along with the github. If only I feel the need to update or fix some errors in my code; I'll do it on github, and not necessarily on this post.

Here is the readme.txt which gives a run down of everything:

Code:
# The-Beta-Method-Thesis
The final program for the beta method of iterated exponentials

Coded by James David Nixon, with supplementary code by Sheldon Levenstein and Mike3 of the tetration forum.
Levenstein optimized some protocols I had written, and we use Mike3's graphing protocol.


To begin use of the program one must execute the file in a pari-gp shell.
We can now choose digit precision by taking "\p d" and series precision by "\ps count"; for d,count positive integers.


From here, one must call init(l,b); or init_OFF(l,b) if abs(b) > 1E6, abs(b)<1E-4. The variable l must have a real part greater than zero; and b cannot equal zero (this produces the trivial beta), and the trivial tetration Sexp = 1.

After initialization, the values l = mult and b = base are global variables. It is possible to initialize these objects as polynomials as well; meaning mult = 1+u or base = 1+v are perfectly valid. This protocol internally uses the variable x, so do not use this variable or reassign this variable else where in the program.

This produces 4 function protocols (and a few variations):

beta(z) = exp(base * beta(z-1))/(1+exp(-mult * (z-1)))

tau(z) = log(1+tau(z+1)/beta(z+1))/base - log(1+exp(-mult * z))/base

Sexp_N(z+1) = beta(z+1) + tau(z+1) = exp(base * (beta(z) + tau(z)))

Each of these functions has a period of 2 * Pi * I/mult. They will be accurate to the digit precision, usually; if not, re run the initialization protocol with a higher series precision. Or one can keep the series precision and run init(l,b,COUNT) (resp. init_OFF); where COUNT determines how many iterations to do. One should never have to exceed 1000. There is an optional parameter in tau and Sexp_N which can tell us how many times to do the iteration; the program by default chooses enough for most calculations; sometimes it may be beneficial to induce more iterations.

We can treat these three functions as polynomials as well; so that beta(1+z), tau(1+z), Sexp_N(1+z), are all viable prompts, which produce the polynomial about 1 in z to the desired series precision.

There is also a separate initialization protocol you can run after the first which gives the summative form of the error. This would be:

init_rho(c, {LIMIT = default(seriesprecision)}) which creates up to the series precision a sequence of functions rho, which act as sum(j=1,LIMIT,RHO[j]) = tau(q+CENTER,LIMIT-2). The variable CENTER=c; and this is declared as a global constant. This protocol internally uses the variable q; so it is best warned to not use the variable q elsewhere in the program.

This spawns the function:

rho(z,j)

which is an evaluation of a polynomial centered about CENTER upto the series precision. The variable j indexes up until how many rho terms were made using LIMIT in init_rho. Or, if there's an overflow it sets the protocol to zero; or if j is outside of the index list, sets the protocol to zero. This satisfies:

rho(z,0) = 0;
rho(z,1) = -log(1+exp(-mult * z))/base
sum(j=0,LIMIT-1, rho(z,j)) = tau(z, LIMIT-2)

rho(z,j) = tau(z,j-1) - tau(z,j-2);

And lastly, a protocol:

tau_rho(z) = tau(z,LIMIT-2);

Which is just short hand for the sum.


/*****************************************************************************************************/
The next functions are a Julia set protocol for beta.

We want to determine the points that are in the weak Julia set, and the points which are not.
These are points where the orbits escape. A point a belongs to the weak Julia set if, for any D> 0:

limsup n to infinity sup(|z-a|<D, 1/beta(z+n)) = infinity

Sadly, there is no efficient way to calculate this, other than the below expression; which tests if 1/beta(z+depth) grows eggregiously fast in a neighborhood.
This is allowed because where beta(z) is very small, nearby we are arbitrarily close to infinity; whether in further orbits or in the same orbit.


This is the Julia test, which requires a single for-loop; which is accurate enough.

The variable depth must come in the form of a nonzero natural number; it tells us how deep to run the recursion.

The variable rad can be chosen as small as possible; and decides the radius of the circle we sample from; 1E-100 gives a good enough result.

The variable sample must come in the form of a nonzero natural number. It determines how many samples we take from the circle of radius rad about a.


This function takes sample amount of sample points on a disk about a; and tests whether we diverge at depth or not.
The ideal form of this function would be at rad to 0, and sample to infinity; and depth to infinity.
But, nonetheless this is still fairly accurate; and as accurate as possible without unscrupuously shrinking rad and growing the sample; plus, making depth as deep as possible.

Is_Julia(a,{depth = 25},{rad = 1E-100},{sample = 24})


Attached to this function is the Is_Shell_Thron, and Is_Shell_Thron_EXP. This takes a point a and tests upto a depth and a series precision the fixed point (or lack there of) of the exponential exp(log(a) * z) (resp. exp(a * z)); and spits out the constant or a zero for lack of fixed point. This is solely for the purpose of graphing and testing for if a point is in Shell-Thron.

/*****************************************************************************************************/

The next functions are a tad more involved. We want to find the normalization constant, and this can be difficult.
Expect this normalization process to fail for values like b=0.0001 or b = -1000; or any extreme values.
At this point, it is much better to just run the super exponential that is not normalized.

We effectively run a Newtonian root finder algorithm, but we run it twice; in the neighborhood of z = 0
I have included these functions in the normalization initialization; but they may not initialize properly for b = 0.0001, or  b=-1000.

It can also encounter a good amount of problems with complex b, but it will work; the problem is typically wait times.


init_NORM(l,b)  where l and b must be mult and base or else we fail. Then we have access to:

x_NORM()

such that

Sexp(z) = Sexp_N(z+x_NORM())

in which Sexp(0) = 1; now. Again, this is superfluous and not as well coded as the rest of this program; expect wait times and imprecision.

/************************************************************************************************************************************

The following is Mike3's readme for his graphing protocol, used to make phase-plot graphs.


/* ============================================================================= 
** Color graphing system - mike3 - 20.11.10 04:07
** Hi.
** I thought I'd post the code I use to generate the color graphs from Pari/GP.
** Here it is.
**
** Note: the output is in .PPM format.
** You'll need something else to convert that to .PNG. (I use GIMP.)
**
** Also, I might warn you: it takes a LONG time to graph a complex function
** with a significantly complicated calculation procedure, as it must be
** evaluated at every pixel of the graph.
**
** (updated 12/16/2010 -- program was not all good:
**   * spurious "func" parameter in MakeGraph and "safetyarg" was missing.)
** ------------------------------------------------------------------------------------------
** 
** ============================================================================= */

/* =============================== Code: ==================================================== */
/* Complex function magnitude/phase plotter. */

/* To use:
*     1. Define function to graph as func(z).
*     2. Load this program.
*     3. Execute MakeGraph(width, height, x0, y0, x1, y1, filename) with the parameters given as follows:
*        width, height = width/height of image in pixels
*        x0, y0, x1, y1 = rectangle of complex plane to graph: x0 + y0i in upper-left corner to x1 + y1i in lower-right corner
*        filename = name of file to save as.
* Output is in .PPM format.
*/


And here's beta.gp


.gp   beta.gp (Size: 23.12 KB / Downloads: 691)


And for further updates; if I feel the need to add anything I will probably just change github, rather than editing this post.

https://github.com/JmsNxn92/The-Beta-Method-Thesis/



This post goes hand in hand with the beta method thesis; introduced in this forum post.

And here's a pretty picture I generated with this program, of what a tetration looks like for \(b=e^{-0.3-i} \approx 0.4002657... - i0.6233770...\) with a period of \(2 \pi i\); graphed over the region \(0 \le \Im(s),\Re(s) \le 2 \pi \). It isn't normalized but you can visually see how to shift the function into tetration--that lone zero in the bottom left corner needs to be positioned at \(\text{Sexp}(-1) = 0\).


.png   INV_ABEL_NEGATIVE_POINT_3_MINUS_I_MULT_1.png (Size: 109.62 KB / Downloads: 726)


Regards, James]]> <![CDATA[Does anyone know any efficient Julia set graphing programs for exponentiation?]]> https://tetrationforum.org/showthread.php?tid=1371 Fri, 03 Dec 2021 04:47:32 +0000 JmsNxn]]> https://tetrationforum.org/showthread.php?tid=1371
I'm just hoping someone has any idea. I might ask this on stackoverflow, if no one knows any off hand.

Regards, James]]>
I'm just hoping someone has any idea. I might ask this on stackoverflow, if no one knows any off hand.

Regards, James]]>