Welcome to Fractal Forums

Hi there. LOOONG time no see. :)

Now that I started studying, I've learned a thing or two about multidimensional derivatives.
The case where you take a generic differentiable nested function's derivative is quite easy and was found by one of you guys quite a time ago.
Back then I unnecessarily started a thread of that topic, deriving the result myself.

It basically was, as the chain rule quickly shows, f'(x) f'(f(x)) f'(f(f(x))) f'(...

Now I wonder what happens if you take the complex numbers as vector.
E.g what's Nabla*(f(...,...)+i g(...,...))

By quickly trying it out I noticed that in case of quaternions, the real part of such an operation ends up looking a lot like divergence and the imaginary part appears to be the curl.
This I was able to verify. Wikipedia actually has that listed in the article about Quaternions.
However, in that case, the original quaternions where "pure", so they didn't have any real part.
(0,1/dx,1/dy,1/dz)(0,f(x,y,z),g(x,y,z),h(x,y,z))=div(f,g,h)+I curl(f,g,h)

So the complex case, not being useful when getting rid of the real part, should behave a little differently.
Same goes for a full quaternion equation set.

Now the problem is, and I checked on it with Mathematica which I now have, what's the pattern of a nested two argument function (alternatively four arguments for quaternions) ?
There obviously is one and Mathematica doesn't have a problem with finding that but I failed to derive a simple running derivative type way of calculating  that.

I'd be interested in
1) how does the shape directly change?
2) could this be used for any kind of interesting colouring?

I did do a search but nothing like this popped up accordingly so I hope this isn't as pointless as the scalar running derivative turned out to be.

In case nothing interesting shows up by doing so, maybe doing a transpose multiplication returns something more interesting...

That would be an example for a derivative with respect to x, of two two-argument functions, nested four times.
Any obvious patterns for the Eagle-eyed programmer wizzes of you? :)




Edit: Does the Latex work right now? Seems to be only an unknown image on my end... Writing it all by hand is pretty... long and error prone, so I'd like to avoid that <.<

Edit: Here is the actual final result to be viewed. It's the Nabla operator on a complex function, viewed as vector after four iterations:

ehrm, kram, you need to put [latex] around your latex ...

there seems to be a problem, my test: [latex]x^2[/latex]

damn, dunno what going wrong, i just updated the late plugin, but somehow it doesnt work, neither i got any error messages ... shit!

try using "jstex" as tag, it is behaving very weird right now, i installed a js latex parser plugin....

Well, as you can see, that worked in the sense that it now shows anything at all. Though it does NOT format the text :-/
Any obvious flaw? I directly used the Mathematica Output, saved as a .tex file.

Btw, if we're at it, the symbol in the editor is broken too.

Edit: Oh, ok... eqn too long... interesting... <.<
Great. I gotta write it by hand when I have time...

Here is the derivative for a single iteration. It should be some kind of simple pattern that most likely has a nice loop-like algorithmic form for additional iterations. But it quickly becomes so cluttered that it's hard to tell.
I guess this kind of stuff is at the edge of the usefulness of this kind of notation. Maybe we could develop some kind of nice IFS notation that makes it easy to grasp these kinds of patterns and possibly other things in the theory of fractals in general...

df(f,g)/dx=f^(1,0)(x,y) f^(1,0)(f(x,y),g(x,y))+f^(0,1)(f(x,y),g(x,y)) g^(1,0)(x,y)
 df(f,g)/dy=f^(0,1)(f(x,y),g(x,y)) g^(0,1)(x,y)+f^(0,1)(x,y) f^(1,0)(f(x,y),g(x,y))
 dg(f,g)/dx=g^(0,1)(f(x,y),g(x,y)) g^(1,0)(x,y)+f^(1,0)(x,y) g^(1,0)(f(x,y),g(x,y))
 dg(f,g)/dy=g^(0,1)(x,y) g^(0,1)(f(x,y),g(x,y))+f^(0,1)(x,y) g^(1,0)(f(x,y),g(x,y))

Let's see...
The first line roughly says:
d/dx f(0,x,y) * d/dx f(1,x,y) + d/dx g(0,x,y) d/dy f(1,x,y)

The first half of that looks a lot like the expansion we already have for the scalar running derivative. So I guess, this extends to:
f'(x) f'(f(x)) f'(f(f(x))) ...

The second half looks similar, except that at first you have the derivative of the second function, followed by the derivative of the first one by the other variable. A single iteration is too little to find a pattern in that... So let's look at a deeper nesting level...

An additional iteration gives:

d/dx f(0,x,y) d/dx f(1,x,y) d/dx f(2,x,y) +
d/dx g(0,x,y) d/dy g(1,x,y) d/dy f(2,x,y) +
d/dx g(0,x,y) d/dy f(1,x,y) d/dx f(2,x,y) +
d/dx f(0,x,y) d/dx g(1,x,y) d/dy f(2,x,y)

The first number represents the iteration.
d/dx here isn't used in the usual sense. It's just to see, which variable is derived.

d/dx f(0,x,y) here would mean
f^(1,0)(x,y)
or alternatively
f^(x)(x,y)

I'm detecting some kind of binomial/pascal-triangle expansion/permutation thing.

fdx->fdx->fdx is what we already found for scalar derivatives.
Here we have three more terms in case of the second iteration... and I have the feeling that they'll EXPlode for higher iterations, as permutations tend to do.
fdx -> fdx -> fdx
gdx -> gdy -> fdy
gdx -> fdy -> fdx
fdx -> gdx -> fdy

aaa
cdb
cba
acb

Still not a clear pattern...
The last two lines are anti-cyclic.
If the second one was bac, it would fit better into the picture of this.