Sierpinski triangle

From Free net encyclopedia

Image:Sierpinski triangle.png The Sierpinski triangle, also called the Sierpinski gasket, is a fractal, named after Wacław Sierpiński. Sierpiński demonstrated that this fractal is a universal curve, in that any possible one-dimensional graph, projected onto the two-dimensional plane, is homeomorphic to a subset of the Sierpinski gasket. For curves that cannot be drawn on a 2D surface without self-intersections, the corresponding universal curve is the Menger sponge.

1 Construction
2 Properties
3 Analogs in higher dimension
4 Self-assembly with DNA
5 Computer program
6 See also
7 References
8 External links

[edit]

Construction

An algorithm for obtaining arbitrarily close approximations to the Sierpinski triangle is as follows:

Image:Sierpinsky triangle (evolution).gif

Start with any triangle in a plane. The canonical Sierpinski triangle uses an equilateral triangle with a base parallel to the horizontal axis (first image).
Shrink the triangle by 1/2, make two copies, and position the three shrunken triangles so that each triangle touches the two other triangles at a corner (image 2).
Repeat step 2 with each of the smaller triangles (image 3 and so on).

Note that this infinite process is not dependent upon the starting shape being a triangle - it is just clearer that way. The first few steps starting, for example, from a square also tend towards a Sierpinski gasket. Michael Barnsley used an image of a fish to illustrate this in his paper V-variable fractals and superfractals (PDF).

Image:Sierp.png

The actual fractal is what would be obtained after an infinite number of iterations. More formally, one describes it in terms of functions on closed sets of points. If we let <math>d_a</math> note the dilation by a factor of 1/2 about a point a, then the Sierpinski triangle with corners a, b, and c is the fixed set of the transformation <math>d_a</math> U <math>d_b</math> U <math>d_c</math>.

This is an attractive fixed set, so that when the operation is applied to any other set repeatedly, the images converge on the Sierpinski triangle. This is what is happening with the triangle above, but any other set would suffice.

If one takes a point and applies each of the transformations <math>d_a</math>, <math>d_b</math>, and <math>d_c</math> to it randomly, the resulting points will be dense in the Sierpinski triangle, so the following algorithm will again generate arbitrarily close approximations to it:

Start by labelling p₁, p₂ and p₃ as the corners of the Sierpinski triangle, and a random point v₁. Set v_n+1 = ½ ( v_n + pr_n ), where r_n is a random number 1, 2 or 3. Draw the points v₁ to v_∞. If the first point v₁ was a point on the Sierpinski triangle, then all the points v_n lie on the Sierpinski triangle. If the first point v₁ to lie within the perimeter of the triangle is not a point on the Sierpinski triangle, none of the points v_n will lie on the Sierpinski triangle, however they will converge on the triangle. If v₁ is outside the triangle, the only way v_n will land on the actual triangle, is if v_n is on what would be part of the triangle, if the triangle was infinitely large.

Or simpler:

Take 3 points in a plane, start at one of the points.
Randomly select any of the other three points and move half the distance from the first point to that point. Plot the current position.
Repeat from step 2.

Or using an Iterated function system

An alternative way of computing the Sierpinski triangle uses an Iterated function system and starts by a point in the origin (x₀=0, y₀=0) and then the new points are iteratively computed by randomly applying (with equal probability) one of the following 3 coordinate transformations (using the so called chaos game):

Image:Serpinski1.jpg x_n+1=0.5 x_n
y_n+1=0,5 y_n ; a half-size copy
when this coordinate transformation is used, the point is drawn in yellow in the figure

x_n+1=0.5 x_n+0,5
y_n+1=0,5 y_n+0,5 ; a half-size copy shifted right and up
when this coordinate transformation is used, the point is drawn in red

x_n+1=0.5 x_n+1
y_n+1=0,5 y_n ; a half-size copy doubled shifted to the right
when this coordinate transformation is used, the point is drawn in blue

Or using an L-system — The Sierpinski triangle drawn using an L-system.

[edit]

Properties

The Sierpinski triangle has Hausdorff dimension log(3)/log(2) ≈ 1.585, which follows from the fact that it is a union of three copies of itself, each scaled by a factor of 1/2.

If one takes Pascal's triangle with 2ⁿ rows and colors the even numbers white, and the odd numbers black, the result is an approximation to the Sierpinski triangle.

The area of a Sierpinski triangle is zero (in Lebesgue measure). This can been seen from the infinite iteration, where we remove 25% of the area left at the previous iteration.

[edit]

Analogs in higher dimension

The tetrix is the three-dimensional analog of the Sierpinski triangle, formed by repeatedly shrinking a regular tetrahedron to one half its original height, putting together four copies of this tetrahedron with corners touching, and then repeating the process.

Image:Sierpinski pyramid.png

[edit]

Self-assembly with DNA

Researchers in Erik Winfree's lab at the California Institute of Technology have also constructed self-assembling Sierpinski triangles using DNA tiles (Rothemund et al. 2004).

[edit]

Computer program

Computer programs to draw Sierpinski triangles are usually done recursively in programming languages that permit explicit recursion such as Java.

import java.awt.*;
import java.applet.*;

public class SierpinskiTriangle extends Applet {
    private Graphics g;
    private int dMin=4;    // limit to recursion in pixels

    public void paint(Graphics g) {
        this.g = g;
        int d  = 1024;    // basis (width of the triangle)
        int x0 =   50;    // distance from the left
        int y0 =   50;    // distance from the top
        int h  = (int)(d*Math.sqrt(3)/2);    // height
        // so: suitable for an equilateral triangle
        int xA=x0,      yA=y0+h;    // (bottom-left)
        int xB=x0+d,    yB=y0+h;    // (bottom-right)
    //  int xB=x0,      yB=y0;      // (top-left)
    //  int xB=x0+d,    yB=y0;      // (top-right)
        int xC=x0+d/2,  yC=y0;    // equilateral triangle (top-center)
    //  int xC=x0,      yC=y0;    // right triangle, right angle at A
                                  // (top-left)
    //  int xC=x0+d,    yC=y0;    // right triangle, right angle at B
                                  // (top-right)
        int[] x = { xA, xB, xC };
        int[] y = { yA, yB, yC };

        drawSierpinskiTriangle( x, y, d/2 );     // start recursion
    }

    private void drawSierpinskiTriangle ( int[] x, int[] y, int d ) {
        if (d<=dMin) g.fillPolygon ( x, y, 3 );  // bottom of the recursion
        else {
            // centers of the sides:
            int xMc = (x[0]+x[1])/2,    yMc = (y[0]+y[1])/2;
            int xMb = (x[0]+x[2])/2,    yMb = (y[0]+y[2])/2;
            int xMa = (x[1]+x[2])/2,    yMa = (y[1]+y[2])/2;

            int[] xNew1 = { x[0], xMc, xMb };
            int[] yNew1 = { y[0], yMc, yMb };
            drawSierpinskiTriangle ( xNew1, yNew1, d/2 );    // recursion

            int[] xNew2 = { x[1], xMc, xMa };
            int[] yNew2 = { y[1], yMc, yMa };
            drawSierpinskiTriangle ( xNew2, yNew2, d/2 );    // recursion

            int[] xNew3 = { x[2], xMb, xMa };
            int[] yNew3 = { y[2], yMb, yMa };
            drawSierpinskiTriangle ( xNew3, yNew3, d/2 );    // recursion
        }
    }
}

[edit]