[

Classical Euclidean geometry works with objects which exist in integer
dimensions: zero-dimensional points, one-dimensional lines and curves,
two-dimensional surfaces like planes, and three-dimensional solid objects
such as balls and blocks (think spheres and cubes). However, many things
in nature are better described as having a dimension which is not a whole
number, because of a property called *self-similarity*: if you magnify
some part of the object, you will find that part is identical to the whole
object, on a smaller scale. A common example is a fern branch, where each
leaf resembles the entire branch in miniature (**figure 0a**).

The fern leaf, when pressed flat, is part of a two-dimensional plane, and
appears to take up two-dimensional space, even though any individual point
on the fern appears to be simply part of a one-dimensional curve that helps
make up the leaf. One may argue that the fern's dimension is then somewhere
between one and two: it doesn't really take up two-dimensional space in the
same way the interior of a square does, but it does take up more than just
the one dimension of a simple curve. Such an object is said to have
*fractal dimension*, by virtue of its self-similarity, and such
objects are said to be *fractal*. Benoit Mandelbrot coined this term
in 1975 from the Latin adjective *fractus*, meaning fragmented and
irregular, to describe objects with the two properties of self-similarity
and fractal dimension. (We may unconsciously associate "fractal" with
"fractional", but we will see below that fractal dimensions are
rarely what we normally think of as fractions, i.e., rational numbers.)
While a straight line has a dimension of exactly one, a fractal curve will
have a dimension between one and two, depending on how much space it takes up
as it curves and twists. The more a fractal curve fills up a plane,
the closer it approaches two dimensions. In the same manner of thinking,
a fractal surface (like, say, the surface of a cloud) will cover a dimension
somewhere between two and three. Hence, a fractal landscape which consists
of a hill covered with tiny bumps would be closer to two dimensions, while
a landscape composed of a rough surface with many average sized hills
would be much closer to the third dimension.

Self-similarity, in its strictest interpretation (also called *scale
invariance*), implies that a fractal object has an infinite level of
detail, as no matter how much you magnify the fractal, you will see the
same amount of detail. **Figure 0b** shows an animation of one well-known
example, the *Koch curve* (which we will revisit below), showing exactly
this magnification of detail.

Where Euclidean geometry describes lines, ellipses, circles, etc.
with equations, fractal geometry describes objects in terms of algorithms
--- sets of instructions on how to create a fractal. One way (arguably the
most elementary) to describe fractals is through what are called
*iterated function systems*, or IFS. This is the only type of fractal
that we shall discuss in detail in this article. IFS follow the general
approach of altering a geometric object in a particular way, leaving multiple
smaller objects each of which is similar to the original, and then repeating
the process on each of those smaller objects to create even smaller parts,
and so on. The fractal is the result of carrying this process out infinitely
many times. (Of course, in practice, we cannot repeat the process infinitely
many times, but in practice at some point we run up against the resolution
of our ability to draw the results --- that is, past some point the changes
we make are no longer visible, unless we magnify the original figure.)

One of the earliest, and simplest, fractals is the *Cantor set*, or
*Cantor dust*, defined by mathematician Georg Cantor (1845-1918).
To create it, begin with a line segment (say, the segment from 0 to 1
on a number line), and remove the middle third. Then remove the middle
third of each of the resulting pieces. After the first step, there are
two segments of length 1/3, after the second, there are four segments of
length 1/9, and so on (**figure 0c**). After many steps there appears to be
simply a very large collection of tiny points --- so many that they appear
to "take up space" on the one-dimensional line.

We will return to the Cantor set and other fractals shortly, but now we will investigate the question of how exactly one can calculate fractal dimensions. The dimension of the Cantor set should be more than zero but less than one; the fern leaf should have dimension between one and two. How can we determine what those dimensions are?

Now you understand what fractals are and where they come from, how are their dimensions calculated? For certain objects with which you have dealt all of your life, such as squares, lines, and cubes, it is easy to assign a dimension. You intuitively feel that a line has one dimension, a square (including its interior) has two dimensions, and a cube (with its interior) has three dimensions. You might feel this way because there is one direction in which you can move on a line (that is, the direction parallel to the line), two directions on a square, one direction on a line, and three directions in a cube, but what about fractals? Sometimes you can move in a certain number of directions and sometimes you can move in a different number of directions. This is what causes fractal dimensions to be non-integers.

To derive a formula which will work with all figures, let's first look
at how dimensions manifest when we use self-similarity to magnify the
Euclidean figures whose dimensions we already know. (We focus our
investigation on self-similarity because it is the defining characteristic
of fractals.) If we magnify a line segment [dimension 1] by a scale factor
of *n*, then we get *n = n ^{1}*

We can solve this equation for *D* using logarithms. (Here we will
use "log" to mean the natural logarithm or logarithm base *e*, although
the properties of logarithms can be used to show that it actually does not
matter what base is used to calculate the logarithms.)
By the properties of logarithms, *log(n ^{D})=log(k)*

where *n* is the magnification scale factor (or, equivalently, the number
of equal pieces into which objects are broken at each step) and *k* is
the number of copies of the original object obtained (or created) at each step.

We can verify that this approach is consistent with the Euclidean notion of dimension for the three simple objects mentioned above:

- For a line:
*D = log(n*^{1})/log(n) = 1 log(n)/log(n) = 1 - For a square:
*D = log(n*^{2})/log(n) = 2 log(n)/log(n) = 2 - For a cube:
*D = log(n*^{3})/log(n) = 3 log(n)/log(n) = 3

Now let us consider some examples based on a line segment. (Since a line
segment has dimension 1, we should expect any IFS which removes parts from
it to create a fractal with dimension less than 1, and any IFS which adds
parts to it to create a fractal with dimension greater than 1.) In the
simplest case, suppose we partition the line segment into 2 pieces at each
step. If we keep only one of the pieces each time, then after one step we
have a line segment of length 1/2, after two steps we have a line segment
of length 1/4, and so on (**figure 1a**). Eventually every point except
the left endpoint will be thrown away, leaving just a single point. If we
apply the formula above, we have that this point should have dimension

since at each step we scale down by a factor of *n=2* but keep only
*k=1* of the pieces. This is consistent with our notion that a single
point has dimension zero.

If we keep the scale factor *n=2* and instead keep both pieces
(*k=2*), then of course we are never losing or adding any points,
and will end up with the same line segment (**figure 1b**). The dimension
is calculated as

as it should be. Therefore, in order to generate a true fractal, we
will need a scale factor *n* greater than 2.

The next simplest example is to choose *n=3* and *k=1*;
however, we soon see that keeping only one part (*k=1*) will
always reduce the line segment in the end to a single point.
Therefore, let us choose *n=3* and *k=2*, at each step
splitting each line segment into thirds and keeping 2 of those thirds.
If we keep the first and last third, then we have discovered the
"remove the middle third" Cantor set mentioned above (**figure 1c**).
This "Cantor dust" has dimension

which is indeed between 0 and 1. We can make many different "Cantor dust"
fractals; **Figure 1d** illustrates what happens if we choose *n=5*
and *k=3*, in which case we get a fractal set with dimension

The four examples in Figure 1 all involve removing parts of a line segment. It is also possible to create a fractal by adding parts to a line segment, or through some combination of adding and removing parts. The Koch curve and Koch snowflake described in the next section are examples of fractals created by adding and removing parts of a line segment; in the case of the Koch curve, the adding turns out to outweigh the removing, as the resulting curve begins to take up 2-dimensional space and will be seen to have a dimension greater than 1. Examples of fractals created by only adding parts to a line segment (or curve) include fractal "trees" like the fern leaf in figure 0a.

Fractals can also be created beginning from a two-dimensional object.
Each of the following examples divides a unit square with a (linear)
scale factor of *n=3*, resulting in 9 smaller squares at each step,
of which we keep varying numbers *k*. To demonstrate the Euclidean
point (**figure 2a**), we keep only one square with each iteration,
making *k=1*. In the next example (**figure 2b**), we create
a Euclidean line segment by keeping only the top three squares with each
iteration, making *k=3*. The last Euclidean figure which can be derived
from this example is the plane (**figure 2c**). To accomplish this,
we keep all the squares with each iteration (*k=9*). The reader can
verify that the fractal dimension formula calculates dimensions of 0, 1, and 2,
respectively, for these objects.

Here we will give two examples of figures with fractal dimension, both
inspired by the classic Cantor set. In **figure 2d**, we keep only the
two pieces in the upper left and lower right corner with each iteration.
In this case, *k=2* and *n=3*, reproducing exactly the dimension
*log 2/log 3 ≈ 0.6309*^{o}.
In **figure 2e**, we remove only the middle piece, this time leaving
*k=8* of the nine pieces at each step. This process leaves the fractal
known as the *Sierpinski carpet*, whose dimension is *log 8/log 3
≈ 1.8928*

Below are several sections, each dealing with an individual fractal. Of course, not all of the fractals in the world are listed below, but only ones which are well known or illustrate an important point which everyone should know. With each fractal, there is a picture, followed by some information about it. For many of the fractals, there is also a link to a C/C++ or BASIC program which will generate a picture of the fractal. For more working source code, visit the Appendix Of Source Code at ThinkQuest. Even if you are not interested in these specific fractals, it is strongly enouraged that you read through each one because many topics other than the specific fractal are reviewed. For example, strange attractors and several applications of fractals to real-life situations are discussed.

The Lorenz Model, named after E. N. Lorenz in 1963, is a model for the convection of thermal energy. This model was the very first example of another important point in chaos and fractals, dissipative dynamical systems, otherwise known as strange attractors. Strange attractors are covered more in depth here.

Return to the Chaos Theory, Dynamic Systems, And Fractal Geometry main page at ThinkQuest.