Calculating the fractional iterates of \(f(z) = e^z-1\) to reasonable accuracy
#1
I apologize for being away for awhile. I have been pretty busy post covid. There's a lot of work I have to get back to. So I haven't had time to do the hard tetration work I'd like to. I've been working on a new paper, and part of this paper justifies the code I talk about in this post. This code relies extraordinarily on Bo's and Gottfried's observations, though you won't see that.

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: 12)
Reply
#2
Hi James -

 nice to see you're back!   

 I'm giving your procedure a try and to understand the elements of that procedure.  

 I've got 2 points at the moment:

 - the 'init_vartheta' routine, although it is called only once and thus its time-consumption is of marginal importance, can much be improved.
Using the construction of the coefficients in the BETA by Stirling numbers 2.nd kind, the time for the initialization is about
Code:
Limit      matrix  BETA (msecs)
  100         47    812
  200         62   3136
  300         78   7160
  400        109  12840
  500        124  20078
Moreover, they are integer/rational values now and thus exact to arbitrary precision.

- I'm not sure to have understood the procedure in the integral in the 'intnum()' in function 'F()'; there is also a double-substituion. Does the X substitute work as height-argument for the (interpolation of the) height of iteration of \( exp(z)-1 \) ? In the first view it looks for me similar to my ansatz for interpolation of the coefficients in the list of powerseries of increasing (integer) heights, as considered for instance here ? But it seems also different ... so I'm not sure about this.         
For instance, simply using \( X=-1 \) and evaluate I get the following paowerseries in \( z \) :
Code:
Ser(subst(BASE,'x,-1),'z)

%304 = 2.718281828*z + 2.718281828*z^2 + 2.944805314*z^3 + 3.794268386*z^4 + 5.689514883*z^5 + 9.688440945*z^6 + 18.41853923*z^7 + 38.56758979*z^8 + 88.00303333*z^9 + 216.9453279*z^10 + 573.7534217*z^11 + 1618.357771*z^12 + 4844.436029*z^13 + 15324.50278*z^14 + 51039.55211*z^15 + 178405.6437*z^16 + 652621.0682*z^17 + 2492135.375*z^18 + 9912046.967*z^19 + 40978660.41*z^20 + O(z^21)

or

exp(1)*( z + z^2 + 13/12*z^3 + 67/48*z^4 + 1507/720*z^5 + 61589/17280*z^6 + ...)

       and I've no idea what this is exactly.             

I'm confident that - using the replacement of the generating-procedure for the BASE by the S2-matrix-expressions - analoguously one can improve the time-consumption as well as in the above item.
Gottfried Helms, Kassel
Reply
#3
(11/15/2022, 12:53 PM)Gottfried Wrote: Hi James -

 nice to see you're back!   

 I'm giving your procedure a try and to understand the elements of that procedure.  

 I've got 2 points at the moment:

 - the 'init_vartheta' routine, although it is called only once and thus its time-consumption is of marginal importance, can much be improved.
Using the construction of the coefficients in the BETA by Stirling numbers 2.nd kind, the time for the initialization is about
Code:
Limit      matrix  BETA (msecs)
  100         47    812
  200         62   3136
  300         78   7160
  400        109  12840
  500        124  20078
    Moreover, they are integer/rational values now and thus exact to arbitrary precision.         

- I'm not sure to have understood the procedure in the integral in the 'intnum()' in function 'F()'; there is also a double-substituion. Does the X substitute work as height-argument for the (interpolation of the) height of iteration of \( exp(z)-1 \) ? In the first view it looks for me similar to my ansatz for interpolation of the coefficients in the list of powerseries of increasing (integer) heights, as considered for instance here ? But it seems also different ... so I'm not sure about this.         
For instance, simply using \( X=-1 \) and evaluate I get the following paowerseries in \( z \) :
Code:
Ser(subst(BASE,'x,-1),'z)

%304 = 2.718281828*z + 2.718281828*z^2 + 2.944805314*z^3 + 3.794268386*z^4 + 5.689514883*z^5 + 9.688440945*z^6 + 18.41853923*z^7 + 38.56758979*z^8 + 88.00303333*z^9 + 216.9453279*z^10 + 573.7534217*z^11 + 1618.357771*z^12 + 4844.436029*z^13 + 15324.50278*z^14 + 51039.55211*z^15 + 178405.6437*z^16 + 652621.0682*z^17 + 2492135.375*z^18 + 9912046.967*z^19 + 40978660.41*z^20 + O(z^21)

or

exp(1)*( z + z^2 + 13/12*z^3 + 67/48*z^4 + 1507/720*z^5 + 61589/17280*z^6 + ...)

       and I've no idea what this is exactly.             

I'm confident that - using the replacement of the generating-procedure for the BASE by the S2-matrix-expressions -  analoguously one can improve the time-consumption as well as in the above item.


Hey, Gottfried!!



I apologize, I can explain the math in this much better. The function:



$$

\vartheta(x,z) = \sum_{n=0}^\infty f^{\circ n+1}(z) \frac{(-x)^n}{n!}\\

$$



This function is holomorphic for \(z \in\mathbb{C}/[0,\infty)\) and \(x \in \mathbb{C}\). It's been a long theory of mine, that:



$$

f^{\circ 0.5}(z) = \frac{1}{\sqrt{\pi}} \int_0^\infty \frac{\vartheta(x,z)}{\sqrt{x}}\,dx\\

$$



Or more generally, for \(0 < \Re(s) < 1\):



$$

f^{\circ s}(z) = \frac{1}{\Gamma(1-s)}\int_0^\infty \vartheta(x,z)x^{-s}\,dx\\

$$



I've recently, due to the deep dive we've all done Tongue , been able to concretely prove this.



So init_vartheta(), is essentially creating a polynomial approaching the asymptotic series of \(\vartheta\) about \(z\sim 0\):



$$

\text{BASE} = \sum_{k=0}^{300} \sum_{n=0}^{20} a_{kn}x^kz^n\\

$$



Which accurately expresses \(\vartheta\) to about 13 digits, though only near the value zero--(near meaning upto \(|x| < 100\) and \(|z| < 0.5\)).



The command intnum, is quite literally Pari-GP's command for the integral. The fact you are noticing it doing something similar to your work is EXACTLY MY POINT. Instead of matrices, I use integrals (I apologize, but I loathe matrices for a totally irrational reason, lol).








Now things get a little complicated here. The integral expression:



$$

f^{\circ s}(z) = \frac{1}{\Gamma(1-s)}\int_0^\infty \vartheta(x,z)x^{-s}\,dx\\

$$



Can be analytically continued from \(0 < \Re(s) < 1\) to \(\Re(s) > 0\) by this technique dating all the way back to Euler:



$$

\Gamma(1-s) f^{\circ s}(z) = \sum_{n=0}^\infty f^{\circ n+1}(z) \frac{(-1)^n}{n!(n+1-s)} + \int_1^\infty \vartheta(x,z)x^{-s}\,dx\\

$$



My code, in essence runs the following command:



Code:
F(s,y) = {

If(s==1, just return f)

If(abs(y) < 0.05,

   run the above integral sum expression, but only do: the sum for 300 terms, the integral from 1 to 90, because that's the area of accuracy

else(
   Rerun the function with f(y) instead of y, but shift the index backwards, i.e: log(F(s,f(y))+1)
)

}




Quote: I've got 2 points at the moment:

 - the 'init_vartheta' routine, although it is called only once and thus its time-consumption is of marginal importance, can much be improved.
Using the construction of the coefficients in the BETA by Stirling numbers 2.nd kind, the time for the initialization is about
Code:
Limit      matrix  BETA (msecs)
  100         47    812
  200         62   3136
  300         78   7160
  400        109  12840
  500        124  20078
    Moreover, they are integer/rational values now and thus exact to arbitrary precision.         


Okay, that's fascinating. So you can calculate:

$$
\vartheta(x,z) = \sum_{n=0}^\infty f^{\circ n+1}(z)\frac{(-x)^n}{n!}\\
$$

MUCH MUCH MUCH faster. That's good to hear. I'm not the best programmer. Unless we're dealing with a recursion problem, I'm a terrible programmer. Especially when it comes to run time Tongue  This wasn't so much intended to be a post about how good this program is, more so, just a short program that gives unreasonable accuracy on the lines of code per digit of accuracy of fractional iterates scale, lol.




Quote:For instance, simply using \( X=-1 \) and evaluate I get the following paowerseries in \( z \) :
Code:
Ser(subst(BASE,'x,-1),'z)

%304 = 2.718281828*z + 2.718281828*z^2 + 2.944805314*z^3 + 3.794268386*z^4 + 5.689514883*z^5 + 9.688440945*z^6 + 18.41853923*z^7 + 38.56758979*z^8 + 88.00303333*z^9 + 216.9453279*z^10 + 573.7534217*z^11 + 1618.357771*z^12 + 4844.436029*z^13 + 15324.50278*z^14 + 51039.55211*z^15 + 178405.6437*z^16 + 652621.0682*z^17 + 2492135.375*z^18 + 9912046.967*z^19 + 40978660.41*z^20 + O(z^21)

or

exp(1)*( z + z^2 + 13/12*z^3 + 67/48*z^4 + 1507/720*z^5 + 61589/17280*z^6 + ...)

       and I've no idea what this is exactly.             

AHH! I see your confusion. This is precisely:

$$
\vartheta(-1,z) = \sum_{n=0}^\infty f^{\circ n+1}(z) \frac{1}{n!}\\
$$

We do not evaluate \(x\) really, we integrate across \(x\). So you've evaluated a small, unimportant asymptotic series; which would be:

$$
\vartheta(-1,z) = \sum_{n=0}^\infty c_n z^n\\
$$

This is not a convergent taylor series (\(\vartheta\) is not holomorphic at \(z=0\)), but it diverges so damn slow that it's super useful.




I plan on posting an article I've almost finished written explaining everything. I've really gone down the rabbit hole on this one, lol Tongue  But I've also been really busy, end of covid and all. But I promise to fill you in!

Regards, James

EDIT!

Also know that this has NOTHING to do with the beta method. There is no beta function, no infinite compositions. Nothing but mellin transforms. Which have nothing to do with beta, lol.
Reply
#4
Hi James -

 thanks for your answer. Well, not all of the matrix stuff is faster than the `subst(poly,x,y)` method I had to learn... My first implementation using the matrix-based BASE interpretation in the integral needed about 100 times as much of your implementation. One can do big errors, since timing philosophy is little documented for Pari/GP ... Ok, changing order of evaluation and using real numbers instead of rational numbers I arrived at half of the speed of that `subst(subst())` construction.                

I've done a little test on the evaluation of the BASE-polynomial. I observed, that if we apply $x$ values at the coefficients of the BASE at a certain power of $z$, then that evaluation is equivalent to only a polynomial of small order with factor \( \exp(-x) \) , so for instance, of we use the coefficients \( c_{r,2} \) at \(z^2 \) we have something like \( f(x,2) = sum_{k=0}^\infty c_{k,2} x^k = (x^2-8x+2) \cdot \exp(-x) \) where the polynomial expression has higher orders when the coefficients \( c_{r,j} \) are taken from \( z^j \). But possibly you know this - its just my exploration of this somehow unfamiliar construction of the BASE.

Here is a list of the first few polynomials:
Code:
j    polynomial at z^j
- - - -- - - - - - - - - - - - - -
2  exp(-x)/(j-1)!/6* (6  )
3  exp(-x)/(j-1)!/6* (6 -   6x)
4  exp(-x)/(j-1)!/6* (6 -  24x +   9x^2)
5  exp(-x)/(j-1)!/6* (6 -  84x +  93x^2 -  18x^3 )
6  exp(-x)/(j-1)!/6* (6 - 306x + 765x^2 - 385x^3 +  45x^4)
7  exp(-x)/(j-1)!/6* (6 -1212x +6198x^2 -6110x^3 +6945x^4 - 135x^5 )
...

Unfortunately I've no idea at the moment how to find a significant pattern, but of course that polynomials could -for 21 coefficients at z-powers only- be manually determined and coded in the program. Even don't know whether this is efficient at all; I'll see.                  

As side effect: I'm happy to finally see the theta-function "in action": how it is and for what it is used, at least in one instance...

(work in progress...)
Gottfried Helms, Kassel
Reply
#5
HEY! GOTTFRIED!


This \(\exp(-x)\) you are seeing, is slightly inaccurate while at the same time very accurate. Let's look at:

$$
\vartheta(x,-1)\\
$$

And let's plot it over \(x \in [0,70]\)--using my program, so slightly inaccurate.

   


You can notice it goes all the way to the millions at about \(x \approx10,20,30\). RIGHT AFTER THOUGH, it decays to zero just like \(\exp(-x)\)...

Now the exact decay is more wonky, and the best I can prove is \(O(1/x)\), but if I choose \(z = -1+i\delta\) then this decay goes even faster. And the exponential decay term you have sussed out appears over and over again. But there's a lot of error, remember that, and these errors can add growth we don't like.

The main argument I make, which is purely a mathematical statement: Is that:

$$
\int_0^\infty|\vartheta(x,-1)|x^{-\sigma}\,dx < \infty\\
$$

In true honest form though, I expect \(\vartheta\) to have decay like \(\exp(-x)\). I just have no real idea how to prove this. So I settled with the above, Tongue



EDIT: Also \(\vartheta\) has nothing to do with the \(\theta\) that Kneser or Sheldon use; what Trappman calls the crescent iteration. \(\vartheta\) is a function I have used to describe fractional calculus (fancy mellin transforms) and its relation to iteration theory. \(\vartheta\)/fractional calculus/mellin transforms has worked perfectly for geometric fixed points. Geometric fixed points are pretty easy in the long run. The real trouble is: The same formulas work for neutral fixed points, but I could never prove this. I could never solidify why the above code even worked. Now I can...

Thanks to you and Trappman.... And all the stuff we clarified, talked about, looked at, ran through. Fucking everything.
Reply
#6
(11/17/2022, 06:45 AM)JmsNxn Wrote: HEY! GOTTFRIED!
Smile 
Well I'm chewing on your comment; but even more I'm still chewing to further understand
the inherent problems of that theta-construct and its evaluation.

The occuring of the increase of the coefficients which forces to evaluate the series only
as asmptotic is not really new for me, but it deconstructed ;-) my enthusiastic approach to
simply increase the number of coefficients for the polynomials in 'z' to 128...
Another problem with this is then the cpu-runtime consumption of many rational
coefficients with many many decimal digits ... if you are in the Pari/GP-user mailing
list you see one of my problems: how to convert my polynomials with rational
coefficients to such with real coefficients and limited precision to improve
runtime-characteristic (and first: to come into the near of your runtime speed). 

All this is primarily still for improving the intuition of your construction in detail & effect.

So at the moment: nothing new from my side, solving technical problems and
improving my test-environment to make visible what happens really.
I'll see whether I can do some reproduction of your plot, that shall be a cornerstone...

Kind regards -

Gottfried
Gottfried Helms, Kassel
Reply
#7
Oh yes, absolutely Gottfried.

This program has quite a few faults, runtime being the most obvious, lol. It is descriptive of much of my programming. I was primarily a C programmer, and I specialized in recursion. I have written some unbelievably complicated recursion programs for C. The thing is, Pari-GP does not have the run time benefits that C has when you write things recursively. I think a large part of that is that I try to preserve Taylor data.

For example, the fact I have built in F(1+s,z) as a valid command, which will produce the taylor series in s and the asymptotic taylor series in z--is super helpful if we think of this as an object. It is not helpful pointwise, when you run F(1.5,-0.5). This will run so slow, because much of the code for F(1+s,z) takes priority. I am aware of this, but I still like simple code above all, especially as I am using it on my computer. I am definitely not winning any efficiency awards though, lol Smile

I absolutely know your code, or Sheldon's code, is far superior in runtime. But again, they are not recursion based. Everything I do is recursion based (my brain kinda just works like that, lol).

Sincere Regards, James





Here are some iterates \(f^{\circ s}(z)\):

   

These take an exceptionally long time to compile. And I know this. I am again, just trying to stress that my mathematical construction which is slow to program produces the same results as all of Helms' Trappman's work. We can do all of this with integrals. Obviously, codewise, this is not as good--but mathematically my work works, lol.

This goes really far into the metaphor I always use. We can do Schrodinger mechanics, or we can do Heisenberg mechanics. We can talk about integral transforms, and actions on hilbert spaces--or we can talk about infinite matrices and eigen values. We are doing the same thing in either language, but we must choose a language. I'm just trying to add some integrals, and Schrodinger mechanics to the problem. And I'm doing so using the Mellin transform (which is just a modified fourier transform when you break it down). I'm trying to be Schrodinger to your Heisenberg... I hope this metaphor makes sense. Everyone here is so fixated on infinite matrix equations, and reducing matrix equations, and approximations through \(N\times N\) scenarios--and this is exactly Heisenberg's approach of quantum physics. Schrodinger's approach was to look at the solution functions globally and create differential/integral equations between the functions globally. Then Von Neumann, using Hilbert's work, proved that Heisenberg and Schrodinger were saying the same thing. Heisenberg just used matrices, and Schrodinger used integrals (to be simplistic).

Again, I'm just trying to add integrals to the discussion, and show how they give the exact same thing you guys already have. Just like Schrodinger...

Just understand that, Gottfried. My code is not something groundbreaking. It's just proof that my math is working Smile The integrals are converging pretty good Tongue

Here's a, very slow to produce (took about 24 hrs of cpu time), graph of \(f^{\circ 0.5}(z)\) for \(1.25>\Im(z) > 0\) and \(-2 < \Re(z) < 0.5\)

   

The schrodinger/integral/mellin/fourier view works. It's not as fast or as good as the Heisenberg, matrix solution method, we see everywhere. But mathematically, it's pretty fucking clean. Cool
Reply


Possibly Related Threads…
Thread Author Replies Views Last Post
  fractional iteration/another progress Gottfried 2 8,019 07/26/2008, 02:13 PM
Last Post: Gottfried
  fractional iteration with complex bases/a bit of progress Gottfried 1 6,889 07/21/2008, 10:58 PM
Last Post: Gottfried
  numerical examples for approximation for half-iterates for exp(x)-1 Gottfried 0 4,563 08/14/2007, 11:57 AM
Last Post: Gottfried



Users browsing this thread: 1 Guest(s)