In order to teach a machine to zoom, any step in an algorithm involving "looking at a render" as humans do all the time, is a step that is best to be eliminated.

Although I don't understand what Claude is doing exactly, this article caught my attention and may be of interest:

https://mathr.co.uk/blog/2016-02-25_automated_julia_morphing.htmlClaude is using those things called "external rays" to automate

choosing a location to zoom in on, so this is something closer to AI than Newton-Raphson zooming.

Ignoring what external rays are (I say something about it in the last paragraph), let me focus on the logic of the implications of this technique. Given is the following:

1. Every minibrot has its own external ray, uniquely characterized by its "angle".

2. There exists an algorithm (known to Claude) to find out where the external ray of a given angle "lands", leading to the location associated minibrot.

As a consequence, if you know the angle of the external ray that lands at a minibrot, there is no visual reference required to find its location. This also means that if there is a relation between those angles such as "add them together for the next morphing", zooming can be done automatically. A zoom path can then be determined by a calculation involving the angles of external rays. Claude has discovered such relationship that works for building a tree.

Borrowing this image from Claude's post as an example of some rays

...what we need to know is a way to find the angle of

any minibrot in this julia set, and a well-defined language to express where in the julia set we want to go, so that it's clear for the computer where we want to go. If Claude's algorithm to repeat a julia morphing works in general, zooming could theoretically be fully automated.

When it comes to such language, something as simple as this could work:

If we start in the center of the julia set (let's say the angle of the external ray is known there), we can go further

in or further

out of the nearby spiral with two arms. Out also means moving towards the spiral with one arm. By "skip" I mean something like jumping over the whole spiral. It's not possible to traverse through the spiral otherwise because it's infinite. With these 3 types of moves, every location in the julia set can be reached.... except those locations that are at one of those super thin lines, but they are inherited from the minibrot by shapestacking, so they're not as imporant. Let's ignore them for a while.

Inspired by regular expressions:

in = further into the large spiral

out = further out of the large spiral

skip = jump over the nearby large spiral

(action1, action2) = either action1 or action2

(action)^n = action n times

(action)* = action as many times as you like (possible 0 times)

The initial move, if in or out, is arbitrary which we will denote INIT:

INIT = (in, out) = either in or out

in this language, the single steps of some of my zoom techniques (often they are repeated) can be written as follows:

`evolution:`

skip

tree:

INIT skip

tree (longer arms):

INIT skip^(armLength)

bent tree:

INIT in skip

x-form (like stardust4ever):

(skip)*

5-armed dragon:

skip in^(5-1) skip

for the following julia morphings we define directionCount as the number of directions in the spiral that the julia set is connected to:

the first type of tiling I discovered:

skip in^(directionCount)

triangle tiling:

(in out^(directionCount - 1))*

spider web tiling:

(in^(2*directionCount+1) skip)*

spider WEB (no straight lines) tiling:

INIT (out in^(directionCount+1) skip)*

Something like this may also give rise to a study of zooming techniques through expressions in the language. I'm not sure anything super fancy can be done because the number of subsequent julia morphings that can be performed is limited to something like 16 by depth and iteration count (or simply put: render time). That's a small number. Even with perturbation, the complexity of current algorithms to render, expressed in the number of julia morphings performed, is double exponential, the

worst common complexity listed at wikipedia.

All that is needed to automate at least a single julia morphing defined by an expression in this language (= a location in the julia set = a minibrot) is a way to figure out the corresponding angles (of the external rays landing at those minibrots). If impossible -> time is wasted, lol. I have read some about external rays so I think I have an idea what they are, though it remains a mystery how they are computed. It involves some serious mathematics. If I could compute them easily I would try some things and see if I can find a pattern.

Here's what I get so far:

There is a map called an homeomorphism from C\M to C\D, where C is the complex plane, M is the Mandelbrot set and D is the unit disk without its border (an open set). In a sense the homeomorphism undoes the intricate shape of the Mandelbrot set and reduces it to just a disk.

The

ray in C\D with angle w is the set of all complex numbers that have angle (or argument) w. A ray in C\D can be thought of as a straight line that is perpendicular to D and extends to infinity in one direction. By definition it is the image of what we call an external ray in M, under the homeomorphism. Therefore, by definition, the external ray in M associated with the angle w is the inverse image of {all complex numbers with angle w} under this homeomorphism.

An external ray in M is (I guess) a continuous/connected curve. For every rational angle, the external ray in M extends to infinity in one direction and "lands at" (approaches) a point in the other direction which is always where two bulbs (or a bulb and a cardoid) touch each other, or in the cusp of a cardoid. In the latter case I say the external ray belongs to the minibrot whose cardoid it lands at.

So that's a summary of my recent thoughts about how zooming could be made even more computer assisted. I hope it's of any use.