Self-Replicating Functions
tylerneylon.com
tylerneylon.com
https://github.com/tylerneylon/math/blob/master/self_repl_fn...
The underline doesn't touch the g of github, and furthermore, has a chamfer on it!
Incredible.
https://myownfortune.wordpress.com/2017/09/21/why-sine-wave/
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
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.
You can find a bunch of his videos on YouTube too.
https://youtu.be/AgeuRukfZLE https://youtu.be/vIVjEkWTEXI https://youtu.be/SLAa-CnUEW4 https://youtu.be/JBgG_VSP7f8
Edit: I think this includes all strictly quasi-concave functions, but I'm not entirely sure.
'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 2^n), a(1 * 2^n), a(2 * 2^n), a(3 * 2^n), ... (for any integer n > 0), you get the original sequence.'
It is indeed interesting.
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.
Edit: example: https://github.com/tylerneylon/math/blob/master/self_repl_fn...
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.
The original idea behind this was to figure out how to study the stability of certain probabilistic transformations. The hope was to be able to make transformations that are good at detecting non-random inputs, particularly in time-series data. Could potentially be used in a similar way to neural-nets.
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 ｃａｔｅｇｏｒｙ ｔｈｅｏｒｙ for the sake of generalization!
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.
again, lovely article, got inspired by ti
Other ideas: * Higher dimensions (eg f1 + f2 + f3 = g with domain R^2) * Shifted fns f1, f2 whose sum has surprisingly small diff from their sum: ie small |C(f1+f2)-shift(f1)|; the normal fn appears to fall into this category
Note, not f but “both strongly resembling the original function f.”
This work is inspired by the self-similarity of fractals, which is in some cases primarily an intuitive or informal idea: for example, the Mandelbrot set is considered self-similar, but I'm not aware (despite searching) of any simple automorphisms of the Mandelbrot.
Beautiful visuals though, lol.