My favorite self-replicating function is the sine, and I spent some time finding it using just its very strong self-replication properties here:<p><a href="https://myownfortune.wordpress.com/2017/09/21/why-sine-wave/" rel="nofollow">https://myownfortune.wordpress.com/2017/09/21/why-sine-wave/</a>
This is a fun exploration! It's interesting that the summed functions have a feature topology that mirrors each sub-function, but some of the local features retain their original scaling, while features in the overlap region adopt a new scaling. This reminds me a little of using absolute scaling in SVG or CSS on something that is parented or embedded (not at the root of the hierarchy). Sometimes you use that kind of thing for character rigs in movies & games - break out of the local coordinate system and use world space.<p>Since the scaling isn't uniform, this is what causes t1 & t2 to have to be piece-wise linear. I'd love to see what happens if the transform functions, i.e. t1 & t2, were restricted to affine transforms. Like, how much harder is it if you further require the summed function to be a uniformly scaled & translated version of the sub-function? What if you added to the formal definition something like:
f_S = a * f_L ( b * x + c ), where a,b,c are constants<p>This also reminds me of a mutation I added to my artificial evolution digital art project where I was trying to generalize on the idea of a fractal. I called it the 'harmonic mutation', and it takes any function f(x) and produces a new function with two or more scaled copies, like c0 * f(c1 * x + c2) + c3 * f(c4 * x + c5). Repeat several times with the same constants, and you can make a fractal out of any function at all. Very similar concept to Perlin turbulence too, where you have summed & scaled octaves of noise.
Refinable functions, used for constructing wavelets and subdivision schemes, seem similar: <a href="https://en.wikipedia.org/wiki/Refinable_function" rel="nofollow">https://en.wikipedia.org/wiki/Refinable_function</a> and <a href="https://arxiv.org/abs/1012.2453" rel="nofollow">https://arxiv.org/abs/1012.2453</a>
The definition of an exactly self replicating function seems to be any function 'f' such that there are continuous bijections a,b,c such that f∘a + f∘b = c∘f, and a does not equal b.<p>Edit: I think this includes all strictly quasi-concave functions, but I'm not entirely sure.
Just if anyone interested: There are also sequences that are labelled 'fractal', those are fun too:<p><a href="https://oeis.org/A000120" rel="nofollow">https://oeis.org/A000120</a><p><i>'An example of a fractal sequence. That is, if you omit every other number in the sequence, you get the original sequence. And of course this can be repeated. So if you form the sequence a(0 </i> 2^n), a(1 * 2^n), a(2 * 2^n), a(3 * 2^n), ... (for any integer n > 0), you get the original sequence.'<i>
When I saw Figure 3 I was reminded of the New Zealand kidney fern, where the veining is a very close approximation to that type of L-system, at least for the first seven or so divisions. <a href="http://www.terrain.net.nz/friends-of-te-henui-group/nz-ferns/kidney-fern.html" rel="nofollow">http://www.terrain.net.nz/friends-of-te-henui-group/nz-ferns...</a>
Based on the title, I imagined this would be about AWS Lambda functions.<p>I wonder if anyone tried simulating evolution using these. I suppose you could even make the fitness be about earning money, e.g. solving captchas? Such that if a function can't pay for its own upkeep it'd die off, while if it does well it could spawn offspring.
This reminds me of the concept of a "ring of functions" (albeit slightly more constrained). Since you seem to be familiar with measure theory already, that idea is probably already well known to you (the author), but I figured I'd mention it anyway.
A while ago I thought about the fact that if you repeatedly apply f(x)=2+x/2 to a number, you approach 4. What happens if you repeatedly apply, with a 50/50 chance, either x/2 or x+2 to a distribution? What distribution do you get?<p>I could find a lot of analysis using matrices in discrete math, but I couldn't find much for continuous distributions. I haven't gotten all the way through reading this, but it seems like it could be helpful.
Nice post!<p>If you're interested in future directions, or working off of research that others might have generated while looking into similar questions, for the sake of taking this idea (self-replicat'n functions) to that next level.. it would be p interesting if you could use just a hint of the much-fabled <i>ｃａｔｅｇｏｒｙ ｔｈｅｏｒｙ</i> for the sake of generalization!
hm, now I wonder what happens if you take 'any old function', add it to a reversed and shifted version of itself, and normalize. do you eventually get one of these self-replicating functions, or are there functions that 'diverge' under this treatment?<p>Taking a random array and giving it this treatment, I seem to get a gaussian distribution after just a few (say, 100) iterations on a 100-element sequence, shifted by 1/3 and then downsampled to be a 100-element sequence again). but of course this is a global and downsampled view, the function might be very craggy locally.
Articles like this make me so sad, because it seems absolutely fascinating, but I know nothing about math. I became a programmer later in life and never got a solid education in it.<p>Beautiful visuals though, lol.