The name Julia set comes from the French mathematician Gaston Julia (1893-1978), who along with Pierre Fatou (1878-1929), developed much of the theory of nonlinear iteration method in the complex plane. Much of their work on the theory of complex iteration was motivated by an article by the British mathematician Sir Arthur Cayley on computing the roots of z³ - 1 = 0 using Newton's method.

FRACTAL BASIN BOUNDARIES

To explain what a Julia set is, we start with the simplest nonlinear transformation of the complex plane, viz., z ® z². It follows that depending upon the magnitude of z, repeated application of the transform on the points of the complex plane lead to three cases.

Based on the above observation, we conclude that the transformation f(z) = z² of the complex plane partitions the plane into three sets. The set of points that diverge to infinity and we call it the escape set (E), the set of points that lead to orbits that are trapped within a well-defined boundary on the plane, called trapping set (T) and finally the set of points on the unit circle. The set of points which are at the boundary of the diverging set (E) and the trapping set (T) is called the Julia set of the map f(z) = z².

The unit circle as the Julia set of the complex map f(z) = z² is a special case of the more general (and fascinating!) map of the quadratic family given by f_c(z) = z² + c, when c = 0. The parameter c is in the complex plane.

Thus, for c = 0, the origin and the point at infinity are two attracting points. There is a subset of the plane that gets attracted to the point at infinity and the complement of this subset that gets attracted to the origin. These subsets are called the basin of attractions for two attracting points and the boundary that separates them is called the Julia set.

More formally, the Julia set for the quadratic family of map, given by Eqn. 1, in the complex plane is defined in the following way:

The escape set (E) for the parameter c is E_c = z₀ : |z_n| ® ¥ as n ® ¥. The complement of E_c is T_c = z₀ | z₀ E_c. Then the Julia set J_c is the set of points that is the boundary of set E_c.

To make the point clear, we show a Julia set of the quadratic map given by

zn+1 = zn2 + c

(1)

where z is a complex number and the parameter c is also complex. The above map is equivalent to the two-dimensional map, given by

æ ç ç ç è xn+1 yn+1 ö ÷ ÷ ÷ ø = æ ç ç ç è xn2 - yn2 + a 2xnyn + b ö ÷ ÷ ÷ ø ,

(2)

where z = x + iy = (x, y) is a point to be iterated and c = a + ib = (a, b) acts as the parameter.

COMPUTER GENERATED JULIA SET

For a given value of the parameter c, we iterate the above quadratic map starting at an arbitrary chosen initial value, z₀. If the iterative process generates a sequence of numbers that get closer and closer to a particular value and eventually come to rest there (fixed point) or if the sequence arrive at a cycle of values, repeated over and over again (periodic orbit) or if the sequence is erratic and unpredictable (chaotic), then from the above definition, such an initial value is a member of the trapping set T_c and the initial point z₀ is plotted in black. If the initial value, z₀, flies off to infinity, then it is a member of the set E_c and such initial conditions are left white. The above procedure is repeated for a large number of initial points in the complex plane.

The figure below shows the result of the above algorithm for c = -0.5 + 0.5i. The trapping set is shown in black. It is important to realize that it is the boundary between the white and the black region that is the Julia set, J_c, and not the whole region of space colored black or white!!

Here is a simple C code that implements the above algorithm of Julia set as a basin of attraction plot. It is kept simple so that one can follow the algorithm without getting lost in fancy coloring schemes, command line options and all the paraphrenalia that comes with it! The program outputs a ppm file. The code also shows how simple it is to generate a ppm file. The code can easily produce a color image by making the call to the function color(arg1, arg2, arg3) such that the arguments are some function of the number of iterations it takes to decide whether the iterates are blowing up or not.

#include <stdio.h> #include <math.h> #define XSIZE 400 #define YSIZE 400 #define MAXITER 250 void color(int red, int green, int blue, FILE *ofp){ fputc((char)red, ofp); fputc((char)green, ofp); fputc((char)blue, ofp); } int main(int argc, char *argv[]) { double xmin = -1.5, xmax = 1.5, ymin = -1.2, ymax = 1.2; double deltax, deltay, x, y, x0, y0; double p = -0.5, q = 0.5, radius, zr, zi; int color_index, xpix, ypix; FILE *ofp; ofp = fopen("julia.ppm", "w"); fprintf(ofp,"P6\n# Y2K Compliant / Julia Set\n"); fprintf(ofp,"%d %d\n255\n",XSIZE,YSIZE); deltax = (xmax - xmin)/(XSIZE-1); deltay = (ymax - ymin)/(YSIZE-1); for (xpix = 0; xpix < XSIZE; xpix++){ x0 = xmin + (double)xpix*deltax; for (ypix = 0; ypix < YSIZE; ypix++){ y0 = ymin + (double)ypix*deltay; x = x0; y = y0; color_index = 0; do{ zr = x*x-y*y + p; zi = 2.0*x*y + q; radius = zr*zr + zi*zi; color_index++; if (radius >= MAXITER) color(255, 255, 255, ofp); /* white */ if (color_index == MAXITER) color(0, 0, 0, ofp); /* black */ x = zr; y = zi; } while (radius <= MAXITER && color_index <= MAXITER); } } fclose(ofp); }

An important thing to realize about the above code is that the algorithm it uses catches the escape set E_c. How does one know if the orbit is going to escape to infinity. The key to the computation of the diverging set is the observation that once |z_k| is large enough (based on precise mathematical criteria), it will escape to infinity. It turns out there is a way to find the optimal value which is a function of the constant parameter c. If |z_k| > r(c) = max(|c|, 2), then it is guaranteed that the subsequent iterates of the complex quadratic function will eventually go to infinity. Using this criteria alone is not practical because for certain choice of initial conditions, the orbit may take a very large number of iterations before it escapes a disk of radius r(c). To make sure that the algorithm terminates, the test for escape set is done for a preset maximum number of iterations. Thus, the above algorithm decides a point belongs to the trapping set if within the preset number of maximum iterates the condition, |z| < r(c), for all iterates.

It turns out there are only two types of Julia sets, no matter what c is. Either the area is a connected structure or it's broken into an infinite number of separate pieces to form a cloud of points. Of the images showed in the galleries the Julia set with c = (0.11, 0.6557) is an example of disconnected Julia set. Disconnected sets are completely disconnected into a countably infinite assembly of isolated points. In addition, these points are arranged in dense groups such that any finite disk surrounding a point contains at least one other point in the set. Such sets are said to be dustlike. As they can be shown to be similar to the Cantor middle thirds set, they are often called Cantor dusts. In contrast, the connected sets are completely connected. Topologically, they are either equivalent to a severely deformed circle or to a line with an infinite series of branches and sub-branches called a dendrite (at c = i for example).