Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
I thought I'd take a crack at base = 1/2
#1
Seeing Ember Edison, and Leo talk about cases which cannot be solved using a theta mapping--I thought I'd see if the infinite composition manner is feasible with these anomalous values. I'm only going to sketch an approach here, and try to construct a real valued tetration where:



To begin, we find a function that approximates this tetration. Let's call this function which is holomorphic on and has a period of . This function will satisfy the functional equation:



These can be expressed as,



Where if ; then this expression equals:



Which converges compactly uniformly on the above domain because the sum,



converges compactly uniformly for and s in a compact set of the above domain.

Now, what we want to do is insert an error term such that,



for some normalization constant . To define the error term we use a sequence of functions:



Now, I'm not going to show this converges, but adapting the case from --this shouldn't be hard to show converges. Instead, I'll just post some graphs showing the structure. These are only accurate to about 9 digits, so far. I just wrote together a quick script.

Here's --so this has a 2 pi I period; and is real valued. This is over

   

Here's our function over :

   

And here's our function over

   

Again, both of these graphs satisfy to about 9 digits.



So all in all, I'm very confident that the infinite composition method will work for . I'm wondering if a similar result will hold for complex bases; but I'm not there yet. I'll try to write a script for that in a bit; for the moment I thought I'd just post the function .




As I'm studying this more, we do not get as I thought we do. Branch cuts appear flippantly in ; which I wasn't expecting, but still isn't very unexpected. I'm currently compiling a graph of in the complex plane. And it's pretty wonky so far. But is definitely locally holomorphic almost everywhere. My proof that no branch cuts occur in do not carry over to so it's reasonable to see branch cuts. The negative logs throw a good wrench in the gears.

We also can run an indefinite amount of iterations; which is really nice. We can't do this with without hitting overflow errors. I'll post this graph tomorrow when it finishes compiling.
Reply
#2
Here's the code I've used for these functions. I've made it to about 10 digit precision. I've set the iterations to 100 by default. So we're looking for . It works nearly flawlessly, still a little sketchy though.


.zip   Abel_half_T.zip (Size: 979 KB / Downloads: 46)
Reply
#3
Here's a graph of (so it's not normalized yet) over and . You can see a singularity forming and a very regular look to it.

   




This wouldn't be the extension I'd choose, as it has a wall of singularities along and is periodic. We'd want to apply the beta-method approach of growing the period to infinity. Not sure how that would work for at the moment.

Regards, James
Reply
#4
I'm going to adjoin another topic here, per Ember Edison's questions. We're going to look at which is a very anomalous point. We're going to start by constructing the infinite composition,



Which satisfies the functional equation,



And satisfies the similar family structure that and did. This function is holomorphic every where for .


We're going to focus on ; which is -periodic and real valued. We want to insert the same sequence which guesses how close we are to tetration. These will be,



We're going to stick to , which should give a decent amount of accuracy (it's giving about 50 digits on the real line, and 20 or so for complex arguments). Keeping that in mind, here is over (remember we aren't normalized yet):

   

And this satisfies to at least 20 digits.

And here's over

   

And this satisfies to at least 20 digits. But remember, this tetration will have a period 2 pi i and singularities along , so it's not the one we want. We want to grow the period to infinity, which again, I'm not certain how to do with this case like I was with .

I'll attach here the patch together code. It's similar to ; it runs much slower, and it requires a new initialization file INIT_NEUTRAL.dat which I've included. I'm going to make a complex plane graph and see how this looks.


.zip   Abel_neutral.zip (Size: 979.41 KB / Downloads: 32)


Again, I'm very confident infinite compositions will not run into trouble on the real positive line mathematically. Coding it may produce odd anomalies though.




Here's a graph of the taylor series of about for ; this is accurate to about 30 digits ( to about 30 digits) where it's converging:

   

This function equals to about two decimal places everywhere (why it's such a monotone colour); and just sort of wobbles around. I've attached, to show the functional equation is being satisfied, a graph of over and :

   

It's mostly just black because that's how well the taylor series satisfies the functional equation.


I'm still wary of how you'd normalize this, so that ; but as a super function, this is perfectly viable. It looks like an almost periodic mess at the moment. But the point I'm trying to make is that it still produces an analytic function. Everything I've been saying still holds--but there are many more questions to be asked about the infinite composition method for other bases. I am trying to flush out perfectly, before I move onto other bases. But so far so good!
Reply
#5
Quote:*** read: Warning: INIT_NEUTRAL.DAT not written for a 64 bit architecture.



Oh, Shit, Why don't you use a txt-based gp file to store beta_taylor, it's 2021! Who will install x86-32 applications on the system


Code:
beta_init(n) = {
local(fileobject_beta_taylor);
  beta_taylor = Phi_Inv(w,l,n);
    write1("E:/Temp/beta_taylor_(E^-E).gp",""); 
    fileobject_beta_taylor = fileopen("E:/Temp/beta_taylor_(E^-E).gp","a"); 
    filewrite(fileobject_beta_taylor, "beta_taylor = " beta_taylor ";"); 
    fileclose(fileobject_beta_taylor);
  print("Done initializing beta.");
}

For large files (>512kb?), use "filewrite" "fileclose" as the write command. Then just use 7zip to pack it up, even a 700MB text file is no match for 7zip.
The user may have to be reminded to execute

Quote:default(parisize, 1048576000)


Do not think that Pari-GP is very intelligent, it idiotic design as many, only txt-based is your real god

===========================================================================

Quote:gp > beta(2,1)

*** Pol: incorrect priority in gtopoly: variable t11 < l

What's up with this?
Reply
#6
(09/29/2021, 04:44 PM)Ember Edison Wrote:
Quote:*** read: Warning: INIT_NEUTRAL.DAT not written for a 64 bit architecture.



Oh, Shit, Why don't you use a txt-based gp file to store beta_taylor, it's 2021! Who will install x86-32 applications on the system


Code:
beta_init(n) = {
local(fileobject_beta_taylor);
 beta_taylor = Phi_Inv(w,l,n);
   write1("E:/Temp/beta_taylor_(E^-E).gp",""); 
   fileobject_beta_taylor = fileopen("E:/Temp/beta_taylor_(E^-E).gp","a"); 
   filewrite(fileobject_beta_taylor, "beta_taylor = " beta_taylor ";"); 
   fileclose(fileobject_beta_taylor);
 print("Done initializing beta.");
}

For large files (>512kb?), use "filewrite" "fileclose" as the write command. Then just use 7zip to pack it up, even a 700MB text file is no match for 7zip.
The user may have to be reminded to execute

Quote:default(parisize, 1048576000)


Do not think that Pari-GP is very intelligent, it idiotic design as many, only txt-based is your real god

===========================================================================

Quote:gp > beta(2,1)

*** Pol: incorrect priority in gtopoly: variable t11 < l

What's up with this?

Not too sure, but t11 is the storage of the variable l

I realized, after talking to sheldon today, I initialized beta with 32 bit architecture rather than 64 bit. You just have to run beta_init(100) and everything should work the same.

I apologize again, I'm a horrible programmer lol.
Reply
#7
So I've switched over to 64-bit pari-gp in hopes this may solve some of my problems. And I decided to take a whack at . We're going to do the exact same procedure. So I thought I'd add some new notation. We're going to switch from to here; so let's take the logarithm of the normal idea of a base.



So that I don't have to keep defining new function names. And this function satisfies the functional equation,



It is periodic in , and is real valued for all variables real. And decays to zero at . Additionally it is holomorphic for .

We're going to focus on and for simplicity keep --so it's 2 pi i periodic. And here's a graph of for .

   

We define the iteration similarly,




Now, this method works fine, but it's really really reallly weird. It almost just looks like a sinusoid times 1E-10. The functional equation is defined upto 20 digits or so atm. I am very confused by all this. But the equation is being satisfied. I think it's because the normalization constant is about or something; not sure tbh. But the superfunction equations being satisfied.

It is definitely not working perfectly; it worked really well with , but is very very very weird. It basically just oscillates about the fixed point.

I thought I'd just post the code (it's 64 bit this time, so there shouldn't be as much of a problem)--rather than dealing with all the nuances. I won't make as many graphs as before. But I do believe this still works. Again, the math says this should still work, but coding it is crazy weird. I'll leave it to you to make your own judgements.


Remember to run beta_init(100) before doing anything. This takes about 30 mins on my pc to compile--the files too big to attach the initialization file. After that you'll get Init_tiny.dat which you can include in any future compilations. This just initializes for .

You can also reinitialize for arbitrary b by changing the base variable at the beginning of the file. So you can run all the tests you want on weird values, ember. Just change the base value, reinitialize the beta function; and have at it. I have stuck to 100 iterations as the default, but recall, for b = e, about 10 iterations is a max (plus you need a limiter). But for values , 100 iterations should work fine. Complex plane, not sure, but prolly won't work.


.gp   abel_tiny_t.gp (Size: 7.52 KB / Downloads: 36)


Here's a graph of over which shows the points where it hits 1 and 0. 


   


It's boxy as hell, and further out it just looks constant with a small wobble of 1E-10. I'm not too sure about all of this in the complex plane. it gets really wonky; I think that singularities are popping up surreptitiously so the complex plane is a little off. You can still grab taylor series to about \ps 100 though. And the functional equation is capping at about E-27 precision; when you use the taylor series, that is.

Regards, James




Well this is even wackier than I expected. This function is bananas! The above graph doesn't do it justice at all; this jumps up and down between 0 and 1, and eventually settles to a line. But other than that, it looks a lot like a square wave for a large portion of its domain. The above graph has sampling errors, so it looks like lines, but this is really a square wave looking thing. But taylor series converge fairly damn well; I'm not sure what to make of all this o.o

over :

   
Reply


Possibly Related Threads...
Thread Author Replies Views Last Post
  I thought I'd compile some of the things I know... JmsNxn 15 5,124 02/01/2021, 11:20 PM
Last Post: tommy1729
  New Quantum Algorithms (Carleman linearization) Finally Crack Nonlinear Equations Daniel 2 1,435 01/10/2021, 12:33 AM
Last Post: marraco
  Complex fixed points of base-e tetration/tetralogarithm -> base-e pentation Base-Acid Tetration 19 47,435 10/24/2009, 04:12 AM
Last Post: andydude
  A tiny base-dependent formula for tetration (change-of-base?) Gottfried 8 18,986 03/18/2009, 07:26 PM
Last Post: Gottfried



Users browsing this thread: 1 Guest(s)