A Different View of the Mandelbrot Set

[rhutson]

In the mid 1990s, I used undergraduate level calculus and the Fractint program to study Benoit Mandelbrot's simple recurrence  z_(n+1) = z_(n) + C.  I questioned if Newton's root solving method was being applied to some "interesting" functions.  So I setup the differential equation z^2 + C = z - f(z) / f'(z) or, alternatively,
y'(z)(-z^2 +z - C) - y(z) = 0  I solved that equation "by hand" and found this interesting family of functions:



18 years later, I used Wolframalpha Pro to verify my work.  Mathematica's solution is:



which is just a different form of what I arrived at by hand.  [I can describe the algebra necessary to prove that the two forms are identical or one can feed:  exp(-(1/sqrt(C-1/4) tan^(-1)((z-1/2)/sqrt(C-1/4)))) into Wolframalpha.]  That is, if Newton's method is applied to the function above with respect to z, the results simplify to z^2 + C !

See it for yourself with Mathematica where C + z^2 is listed as an alternative form when the "inverse Newton" differential equation is solved http://www.wolframalpha.com/input/?i=z+-+%C2%A0exp%28-%281%2Fsqrt%28C-1%2F4%29+atan%28%28z-1%2F2%29+%2F+sqrt%28C-1%2F4%29%29%29%29+%2F+%28d%2Fdz%28exp%28-%281%2Fsqrt%28C-1%2F4%29+atan%28%28z-1%2F2%29%2F+sqrt%28C-1%2F4%29%29%29%29%29%29

It is well known that the Mandelbrot Set can be used as a "catalog" of fractals (i.e., each point in the Mandelbrot Set has a specific Julia Set).   I haven't kept up with the literature for some time, but it still seems undescribed which functions the Mandelbrot recurrence maps, so I thought that I would share them.  Here is the way that I view what occurs with Mandelbrot's iteration: one selects a C, C selects a function, and then Newton's method is applied to that function with the critical point 0 as an initial guess.  If Newton's method cycles or becomes fixated for a particular C, then that C is in the Mandelbrot Set.  If Newton's method ends up chasing infinity, then that C is not in the Mandelbrot Set.

In trying to explain this interpretation of Mandelbrot's method to a friend, there was confusion about how Newton's method was being applied to z and C.  The selection of C selects a particular f(z), and then Newton's method is iterated on that f(z).  So C is both a variable and a constant -  but that's the way that Mandelbrot set it up.  

Note: so far this post is essentially a duplicate of a post which I recently made on the Wolfram Community http://community.wolfram.com/groups/-/m/t/99356?p_p_auth=USB6oyPV  Obviously, I am interested in discussing the matter.   While my work has apparently not been duplicated, there is a lot that I do not understand.  As it has been 18 years since I have done any calculus, well, I can be expected to make mistakes.  I think that I have remembered enough to have a discussion about the matter.

I'm trying not to get ahead of myself, but following is a somewhat vague, unproven finding, but it yields a useful algorithm.  Notice the C - 1/4 in the first form of the function.  A division by zero occurs when C == 1/4.  It is not a coincidence that 0.25 happens to be the V shaped focal point of the Seahorse Valley which is also the boundary of the positive X-axis of the Mandelbrot fractal.  By purposely introducing new roots into the divisor, "V shaped focal points" can be produced at any desired points.  Specifically, when iterating

z^2 + f(C) + 1/4

"the V shaped focal points" will occur precisely at the roots of f(C).  In the case of Mandelbrot's recurrence, f(C) = C - 1/4 which has a root at 1/4.  Try iterating

z^2 + sin(C) + 1/4

and this occurs



Zooming out on the sin(C) iteration reveals infinite identical fractals



Note that for exploratory or graphic design purposes, there is no need to add the (0.25, 0i)
to the recurrence - the fractal will just be shifted on the X-axis by 1/4.  Here is an example
of a "designed" (rather than discovered) fractal which was generated by the following
Fractint code:

Code:

6PointCircle { 
        stuff = (Pixel - (1, 0)) * (Pixel - (0.5, 0.866025403)) * (Pixel - (-0.5, 0.866025403)) * (Pixel - (-1, 0)) * (Pixel - (-0.5, -0.866025403)) * (Pixel - (0.5, -0.866025403)),
        z = stuff,
        z2 = Sqr(z) :

        z = z2 + stuff
        z2 = Sqr(z)

        LastSqr <= 4
}

If not for the 1/4 offset to the right, the arrows in the following image would be pointing at {(1, 0), (0.5, 0.866025403), (-0.5, 0.866025403), (-1, 0), (-0.5, -0.866025403), (0.5, -0.866025403)} :



A interesting discovery is the fractal produced by iterating z^2 + atan(C).  This one requires some zooming out:



So have fun experimenting with iterations of z^2 + f(C).  One word of warning is that I discovered that the further apart the roots of f(c) are, the smaller the size of the Mandelbrot like set will be.  

That seems to be nearly enough words for thought for now.  If you were able to follow what I was trying to communicate, then use Mathematica or http://www.wolframalpha.com and start "playing" around with quadratic mappings.  Just enter something like
 
z^2 + z + C = z - f(z) / f'(z)

into the program and then discover.  Remember, the the "V shaped focal points which I need help naming" will occur at the roots of the divisor.

Also, you can study Julia sets more easily now too.  As a child, I was fascinated with simply hitting the x^2 button on a handheld calculator and wondering why some initial values cycled or fixated.  That is easily explained.  Iterating z^2 is actually also applying Newton's method to f(z) = z/(1-z).  Just enter z^2 = z - f(z) / f'(z) into Wolframalpha and see for yourself.   Then try

plot z/(1-z)

and see if you can envisage what happens when Newton's method is applied to that function.

I await questions, suggestions, corrections, and comment.

[Roquen]

I was thinking about starting a thread along these lines but from a different perspective.  Any formulation which can be reduced to

z' = z² + T(s)

is simply an input domain deformation by transform T.  It would be interesting to consider your formulation above in terms of exponential/log mapping of the domain since, with the noted exception of addition, all the common operators on C are naturally describable by their effect on the magnitude & angle of the inputs.

EDIT: 's' here is the sampling point in the visualization domain.

[Roquen]

Follow-up: I should note that my previous statement sounds like I'm stating fact, when in reality it's simply an informal observation which "seems" to hold for transforms 'T' that I've played with.

[rhutson]

Follow-up: I should note that my previous statement sounds like I'm stating fact, when in reality it's simply an informal observation which "seems" to hold for transforms 'T' that I've played with.

I just generated some new images on my old DOS box, which might be interesting.
I can sort of show you an idea of what is happening, even though I don't understand it.
My idea is to come up with interesting functions of C rather than of z.

First up, I wondered what the Fractint code

Code:

C1C {
        limit = 4,
        stuff = pixel/(1-pixel) + p1,
        z = stuff,
        z2 = Sqr(z) :
        
        z = z2 + stuff,
        z2 = Sqr(z)

        LastSqr <= limit
}

would generate with the parameter 1/4

Plugging     z^2 + C/(1-C) + 1/4 = z - f(z) / f'(z)  into Mathematica yields the "inverse Newton" functions

   

As expected by the + 1/4 idea, a division by zero occurs at the root of f(C) in z^2 + f(C) + 1/4
(The root of C/(1-C) being 0 of course.)

What Fractint generated was unusual, but there was a "<" pointing at the root of C/(1-C) just as I expected:




Next, I decided to throw in some transcendentals and to iterate

z^2 + C/(1-C) * Sin(C) * Atan(C) + 1/4

Plugging      z^2 + C/(1-C)*Sin(C)*Tan^(-1)(C) + 1/4 = z - f(z) / f'(z)   into Mathematica yields:



Mathematica is sorting hiding (simplifying) how the "+1/4" trick works, but you'll notice that there are three divisions by 0
when C = 0 -  one by C, one by sin(C), and one by tan^(-1)(C).

Now that has an infinite number of roots: 0 and all integral multiples of Pi.

If you want to test my conjecture, then center that iteration at 0 or integral multiples of π, and you should find a seahorse tentacle pointing at the roots.  Here is an image generated by that recurrence zoomed in 2E-15 centered on 0:



Those tentacles won't ever touch graphically since that would require zooming in infinitely with an infinite maximum iterations.

One interesting discovery that made is omitting the + 1/4 on the iteration, that is, iterating

z^2 + C/(1-C)*Sin(C)*Tan^(-1)(C)

yields a slightly different and more interesting fractal. (Try zooming in around (7.85, 0i).)
I thought that it would be the same fractal just shifted on the X-axis.  I'll have to investigate that further.

Finally, I iterated z^2 + C^50 + 1/4 .  Plugging z^2 + C^50 + 1/4 = z - f(z) / f'(z) into Mathematica yields



Centered at 0, the resulting fractal was as I expected:



Fifty seahorse tentacles all pointing at 0!

[Dinkydau]

Nice find!

[rhutson]

Nice find!

Thanks!  I'm not sure if anyone understands how I am generating these, and that's what I am trying to explain.  (I understand how I am, but not exactly sure why it works.)

The 50 seahorse cusp can be generalized by just iterating  z^2 + C^n + 1/4.  Or in Fractint code:

Code:

Cpower{  ; p1 is an input parameter to Fractint
        limit = 4, 
        stuff = (pixel^p1) + 1/4,
        z = stuff,
        z2 = Sqr(z):
        
        z = z2 + stuff,
        z2 = Sqr(z)

        LastSqr <= limit
}

For positive integral values of p1, that works as expected with p1 = 1 being the classic Mandelbrot fractal with the seahorse cusp centered at 0.  It "works" with positive real numbers too in a very interesting way that would make a great animation or animated image.  Just increment the power from say 3, 3.25, 3.5, 3.75, 4, and you can see how a new cusp is "born".  And it also works with negative powers!  Instead of the seahorse cusps / spirals pointing "inwards", they spread outwards!  Technical difficulties are currently preventing me from sharing images, but the code is above.

---

I edited my previous post because I had previously thought that the add "+ 1/4" idea wouldn't alter the fractal, just its position on the X-axis.  This is true of the Mandelbrot fractal.  My algorithm once again is that in the iteration z^2 + f(C) + 1/4, seahorse cusp(s) will appear at the roots of f(C).  So to position the Mandelbrot fractal with the cusp at 100 instead of 0.25, just iterate

z^2 + (C-100) + 1/4 = z^2 +C - 99.75

which yields the "inverse Newton functions"



But what I learned is that it is not generally true that adding 1/4 will simply shift the fractal.  Indeed, when I first iterated

z^2 + C/(1-C)

I first took a look at the "inverse Newton functions"  (plug z^2 + C/(1-C) = z - f(z) / f'(z) in Wolframalpha / Mathematica)



and noted that the seahorse valley cusp would be at 1/5.  And that's where the arrow is pointing in the following image:



which I found to be a much more interesting image than when +1/4 is added to the iteration.

[Roquen]

I'm sure that I'm not being clear, so WRT this statement:

(c = T(s)) is simply an input domain deformation by transform T. 

First off this statement is in terms of the standard iteration method and not the solve & perform newton's method discussed here.  I haven't thought about it but it appears that they are related (by looking at the images).  I backed off from the statement because it works for standard transforms, but may not generalize.  As an example a potential logical extension is that the Julia set should be identical to an infinite (in the limit) zoom of the m-set at the julia point...but this would involve splitting the "domain" into two parts: one for the function and one for the visualization.  I'm too lazy to think stuff like this through.

Sticking with the standard iteration method, then you need to solve T for 's' to see how parts behave globally.  So T(s) = 2s is a uniform scaling of (1/2).  T(s) = s - 1, translates by +1 in X.  So generally T(s) = f(s) + t, the 't' may or may not end up being a global (final) translation.

[element90]

Interesting thread. I've read the stuff regarding the use of the Newton method for finding the position of the "cusps" but my point of view I don't really care that much. The one thing that did catch my eye was:

z = z^2 + T(s)

My software allow the complex plane to transforms by adding a set of transforms. The transforms are applied one after the other so effectively are applied "onion" like e,g. f4(f3(f2(f1(z)))). I don't know what you're doing with the 6PointCircle fractal I get a fractal of the same shape using these transforms:





Changing the addition transform to -1.6 the fractal becomes:



And just because I can, I played with more transforms:



results in this:



and



results in this:

[Roquen]

My fractal knowledge base is very small, but I have a reasonable amount of experience with procedural graphics, so my opinion is biased.  Performing a domain deformation is a purely procedural graphics technique and it is IMHO much easier than attempting to come up with a new fractal definition/modification.  In effect you're not modifying a given fractal..it simply becomes a fixed primitive and you use your knowledge of domain modifications to move toward some desired visual.  Performing domain deformations will work for any fractal that works solely based on the sample points, or more specifically that doesn't depend on the sampling domain being an affine transform, such as a uniform sampling of some Euclidean space.  So for the m-set you perform a one-time transformation of 's' to compute 'c', for a Julia set a one-time transform of 's' to compute 'p₀'.  So you can use this technique for say a Mandelbulb, assuming that the implementation is brute force.  A DE version assumes you haven't arbitrary mucked with sampling space.  That's not to say don't try using this with DE fractals because the goal is a nice picture not some abstract notion of mathematical correctness....it will end up either be useful or not.

Also my mentioning "solving" for T above might be misleading.  The only time you would need to do something like that is to figure out what some part of a transform does in the visualization space...which isn't something many people would need to do.  IMHO a potentially very useful tool is "domain coloring".  I shove a number of them into a photobucket album:  <HERE>.  I screwed up the image quality and the ordering is goofy...like the identity transform is last.

[rhutson]

Interesting thread. I've read the stuff regarding the use of the Newton method for finding the position of the "cusps" but my point of view I don't really care that much.

Now I'm sure that the purpose of my topic has been misunderstood, so I will try again.  Please ignore the distraction which I created by mentioning my seahorse cusp generation algorithm (which currently relies upon conjecture, not Newton's method). I got ahead of myself in excitement in an attempt to explain a "more simple", alternate, and completely valid view of what the Mandelbrot Set represents.

In the strictest definition, Benoit Mandelbrot's mapping method is a surjective mapping from the entire complex domain onto the Boolean set {false, true} which is then graphed into two dimensions.  The recurrence

z_new = z^2 + C

where C is varied on the complex domain is Newton's method being applied to a family of functions.  Recall that Newton's method for numerically finding root(s) of f(z) is to iterate

z_new = z - f(z) / f'(z)

I setup the "obvious to me" differential equation

z^2 + C = z - f(z) / f'(z)

which in standard form becomes

y'(z)(-z^2 +z - C) - y(z) = 0

where C is an independent variable.

The solution to that equation is



Lacking a better name, I shall refer to that function as MP(z, C).  ("MP" = Mandelbrot Parent; I welcome suggestions for a better name.)  Note that MP(z,C) has no roots.  It is well known that Newton's method of root finding "behaves poorly"   in some situations.

In the classic Mandelbrot graphing method,  C (element of the complex domain) selects a unique function; Newton's method is then applied to that function with an initial guess of zero as the root.  If the iteration of Newton's method for C escapes to infinity, then C is not in the Mandelbrot Set; otherwise, C is in the Mandelbrot Set.  If C is not in the Mandelbrot Set, then color[false] is indicated for that C.  If C is in the Mandelbrot Set, then color[true] is indicated for that C.  Assuming that color[false] = white and that color[true] = black, this would result in a black Mandelbrot fractal on a white background.  Refer to the first generated image of the Mandelbrot Set



Colors weren't used.  Instead a '*' was displayed if C was in the Mandelbrot Set, and presumably the background was implicitly white.

What this means is that each C element of the Mandelbrot Set represents a specific function(z); if Newton's method is applied to that function, the iteration will not escape to infinity.  Thus, in my valid view, the Mandelbrot Set represents a set of functions.

As I found specific examples helpful in math classes, I shall choose C = -0.75  (primarily because David Joyce discusses that iteration here http://aleph0.clarku.edu/~djoyce/julia/julia.html)

To "plug" C = -3/4 into MP(z, C), I shall feed http://www.wolframalpha.com/ this:

exp(-(2 tan^(-1)((-1+2 z)/sqrt(-1+4 C)))/sqrt(-1+4 C)) for C = -.75

Before simplification, MP(z, -3/4) looks like this:



I hope that you see how each different C selects a specific f(z), as that is key to understanding what I am trying to communicate.

Back to the example, Mathematica simplifies MP(z, -3/4) into

f(z) = e^(-tanh^(-1)(0.5-z))

If one performs Newton's method on that function, the results will simplify to the iteration z_new = z^2 - 3/4
Feel free to confirm that theory/fact with Mathematica or whatever means.  Or just enter

z  - e^(-tanh^(-1)(0.5-z)) / (d/dz(e^(-tanh^(-1)(0.5-z))))

into

http://www.wolframalpha.com/

z^2 - .75

just as I expected.  (There would be a bug in Mathematica otherwise.)

While I do seem distracting with my interesting side notes, another way of seeing which function Newton's method is being applied to with Mandelbrot's method is to just enter the differential equation into wolframalpha:

z^2 - 3/4 = z - f(z) / f'(z)

Now this is interesting since Mathematica expresses the solution in algebraic form rather than exponential form:



So if Newton's method is applied to

f(z) = sqrt(2 z+1)/sqrt(3-2 z)

the resulting iteration will be

z^2 - 3/4

which is listed as an alternate form for

z - (sqrt(2 z+1)/sqrt(3-2 z)) / (d/dz((sqrt(2 z+1)/sqrt(3-2 z))))

Note that f(z) = sqrt(2 z+1)/sqrt(3-2 z) has a root at -1/2, and then read the already posted URL http://aleph0.clarku.edu/~djoyce/julia/julia.html and ponder.

There is much more to share and discuss, but we cannot proceed until the basic concept of what I am trying to convey is understood.  If you can understand undergraduate calculus, then you can understand my different view of Mandelbrot's method.
(This is an "old new theory" which I never published.)

Any questions?  Does anyone understand?

[Alef]

Very interesting algebraic find. So it iterates to a solution.

If I understand correcty, it means that complex solution of any function(n)=0 are points on which points a v holes of a fractal z=z^2+ function(c) +1/4?

Small correction, its an elephant valley. Seahorse valley is were cardoid meats circle and there are something like seahorses. But in mandelbrot he he side there are something like elephants with noses.

[rhutson]

Very interesting algebraic find. So it iterates to a solution.

One would think that the Newton's method iteration for those MP(z, C) functions would setup an iteration with more mathematical operations, but the iteration simplifies to z^2 + C.  The mystery of "How could such a simple iteration yield such complex behavior?" has been partially answered.  I likened it to a magic trick, and now you know the secret to Mandelbrot's magic trick.

For fun, I setup the iteration for Newton's method on MP(z,C) with the partial derivative done with respect to C instead of z.  As one would expect, the iteration became more complicated:



 

If I understand correcty, it means that complex solution of any function(n)=0 are points on which points a v holes of a fractal z=z^2+ function(c) +1/4?

That is my mathematical conjecture.  I discovered that by noticing that a division by 0 occurs in MP(z, 1/4).  I figured that it couldn't be a coincidence that 1/4 is the positive boundary on the real, X-axis.  By exploring with Fractint, I discovered that a v cusp always pointed to the roots of f(C) in the divisor.  That is of course nothing similar to a mathematical proof,  but the algorithm is useful enough to find new fractals.  Since the cusps can be programmed to appear at any desired points, I had imagined a fractal animation, but I never got around to programming that.  What I mean by an animation is that a square of Mandelbrots could appear.  The square could then be rotated and shaped into a diamond, lines could be drawn connecting the points of the square or diamond, etc.  The limits of the animation would be commensurate to that of a graphical designer.  I always thought that it would be neat to see the name "Mandelbrot" graphed out with Mandelbrot fractals.  Here's a tip: if you're going to try something like that, the farther apart the cusps are, the more zooming in will be needed to visualize the fractal.  For example, the iteration

z^2 + (C-1e9)*(C+1e9) + 1/4

will produce two Mandelbrot fractals with cusps at -1e9 and 1e9, but they're going to be very, very small.  Iterating

z^2 + (C-4)*(C+4) + 1/4

will yield two fractals with the same symmetry, but they'll be easier to find (i.e., larger).

Small correction, its an elephant valley. Seahorse valley is were cardoid meats circle and there are something like seahorses. But in mandelbrot he he side there are something like elephants with noses.

Oops, thank you very much for the correction.  The dates on my Fractint formula files stop in January 1996, so in a way I'm new at this again.

Oh, if it seemed like I had a CAPS LOCK attitude in my previous post, well, I've been frustrated trying to explain my findings.  Besides being fascinated with fractals, my motivation to explain the z^2 + C iteration came from reading "Fractal Creations" by Tim Wegner and Mark Peterson.  The book asked "How can such a wondrous and complex shape come from the absurdly simple formula z_n+1 = z_n² + c?"  I set out to answer that question, and I essentially did around 1995.  I wanted a complete, detailed explanation, but I just didn't have the mathematical education to proceed farther.  Time passed, and my interests moved to other areas of study, and I essentially forgot about the Mandelbrot Set.  According to an email that I sent to a couple of friends on August 21, 2011, my PBS station broadcast "Hunting the Hidden Dimension", a production about the Mandelbrot Set and fractals.  I was quite surprised that no one had yet noticed the direct connection between the Mandelbrot iteration and Newton's method.  Neither of my two friends (one a MS in Computer Science and the other a PhD in Physics) was very interested in my findings.  And then I emailed Tim Wegner and informed him of my findings.  Tim's response was essentially, "Even if you math is correct, I don't see any deep meaning to this."  Tim's response really baffled me.  I don't see any deep meaning either and never expected to find one,  but I thought that he would be a bit more excited.   (My email did contain some errors which may have been a factor.)  Two years later, Wolfram Research began selling "Pro" subscriptions to Wolfram|Alpha with the obvious desire of selling more Mathematicas.  As soon as the Wolfram Community went out of beta testing, I posted partial information there, but there is still no response to my post.  I'm certainly pleased that I found FractalForums.com!

Now here is something to ponder.  With the recurrence

z_n+1 = z_n² + 1/4

Newton's method is being applied to an MP function with a hidden division by 0 :



I remember being taught that division by zero is undefined, yet the algorithm seems to work in a defined manner.  Hmm.

Oh, next is an alternate definition of a Julia Set (if you haven't figured it out).

[Roquen]

I grok things fast assuming the other person explains long enough.  Effectively you're defining a domain transform T which translates the point of interest (in this case the cusp) to the origin then converting the equation an equivalent form which allows to inspect where the root (the point of interest) will end up.  So if the point if interest were instead the tip of the needle we'd replace the "+1/4" with "-2".  Without thinking this through I don't see any advantage over simply solving T which doesn't require translation the point of interest.  Or I'm still missing something (perhaps I should read more carefully).

[rhutson]

I grok things fast assuming the other person explains long enough.  ... So if the point if interest were instead the tip of the needle we'd replace the "+1/4" with "-2".

The concept which I have introduced isn't likely to be quickly understood by anyone.  I just don't think that anyone has researched the math behind a graph of functions with no roots colored by how many iterations of Newton's method it takes to determine if the algorithm escapes to infinity since I can think of no practical purpose of such research.

Regarding, the iteration which you mentioned of

z_n+1 = z_n² + C - 2

my conjecture predicts that will result in a fractal with the cusp centered at -2.25

Remember, the cusps will appear at the roots of ƒ(C) in

z_n+1 = z_n² + ƒ(C) + 1/4

With your suggested iteration, ƒ(C) = C - 2.25, so the cusp will appear at -2.25

The fractal can be programmed to appear at any desired points.  For example, the iteration

z^2 +  (C - (1, 1i)) * (C - (1,-1i)) * (C - (-1, 1i)) * ((C - (-1, -1i)) + 1/4

will make a square of Mandelbrot fractals.  In general for

z^2 + ƒ(C) + 1/4,    ƒ(C) = (C - point1) * (C - point2) * ... (C - point_N) will generate fractals at those points.

I will reiterate that the 1/4 "trick" has nothing to do with Newton's method.  The Mandelbrot fractal itself is directly related to Newton's method.  I discovered the conjectural ƒ(C)+1/4 algorithm as a consequence of discovering the fact that the Mandelbrot fractal graphically depicts how a family of functions behaves when Newton's method is applied to them.  I cannot explain why the ƒ(C)+1/4 algorithm works.  I should not have introduced the ƒ(C)+1/4 algorithm on this topic as it is only tangentially related to my topic.  As I noted previously, I got ahead of myself.

[hobold]

I just don't think that anyone has researched the math behind a graph of functions with no roots colored by how many iterations of Newton's method it takes to determine if the algorithm escapes to infinity since I can think of no practical purpose of such research.

The complex plane can be extended to the projective plane. Loosely speaking, by adding a single infinitely distant point to the set of all complex numbers (google for "Riemann sphere" for a nice geometric interpretation). From that perspective, Mandelbrot iterations don't ever diverge, but converge on the infinitely distant point instead.

This is just a wild guess, not even a conjecture, but it could be that projective geometry turns divergence into just another root that Newton's method then finds. In that sense, your findings could eventually turn out to reduce to existing knowledge. But even then, your out-of-the-box view enabled you to add significant new tools to the fractalists' kit. So it is certainly not boring or uninteresting!