Experimente mit Cantormengen

Dieses HTML-Dokument ist ein Arbeitsblatt zur Cantormenge und ihren Varianten. Sie können es als HTML-Dokument lesen. Tatsächlich können Sie es aber auch mit Ihrem Computer bearbeiten. Das Arbeitsblatt ist keine Einführung in Programmierung. Stattdessen werden Programme bereitgestellt, mit denen Sie Cantormengen erzeugen können. Sie können diese Programme nach Belieben abändern und so auf dem Computer mit Cantormengen experimentieren.

Wir arbeiten mit dem frei erhältlichen Statistik-Programm RStudio und der Programmiersprache R.

Sie können dieses HTML-Dokument im RMD-Format abspeichern, siehe die Schaltfläche Code rechts oben. Sie können das RMD-Dokument dann in RStudio öffnen, und Sie können die bereitgestellten Programme auf Ihrem Computer ausführen.

Die Cantormenge

Man erhält die Cantormenge \(C\subset [0,1]\) als Schnitt \(C=\bigcap_{n\in\mathbb N_0}C_n\) absteigender Mengen \([0,1]=C_0\supset C_1 \supset C_2 \supset \ldots\) Bei der Konstruktion von \(C_{n+1}\) entfernt man aus jedem Intervall in \(C_n\) jeweils ein offenes Intervall, das mittlere Drittel.

Auf dem Computer kann man die Konstruktion von \(C_n\) wie folgt codieren. Sie können den folgenden Code einlesen, indem Sie auf das Pfeilsymbol klicken.

U=c(1,0,1)
erzeuge = function(n) if (n==0) return(1) else return( U %x% erzeuge(n-1))

Der Aufruf erzeuge(n) liefert eine 01-Punktmenge, welche \(C_n\) entspricht. Der Ausdruck U beschreibt die Unterteilung des Einheitsintervalls.

erzeuge(2)

[1] 1 0 1 0 0 0 1 0 1

Mit dem R-Befehl plot können Sie diese Punktmenge graphisch darstellen. Das Argument type=“h” ergibt eine Darstellung als Histogramm mit Balken der Höhe \(0\) oder \(1\). Die Menge \(C_n\) entspricht einem horizontalen Schnitt im folgenden Bild.

n=5; plot(erzeuge(n), type="h")

Der Cantor-Staub

Die obige Konstruktion kann man auf zweidimensionale Punktmengen erweitern. Man startet mit dem Einheitsquadrat und unterteilt es in 9 kleinere Quadrate. Dann entfernt man die 5 mittleren Quadrate. Mit dieser Konstruktion fährt man fort und erhält so den Cantor-Staub.

U = array(c(1,0,1, 0,0,0, 1,0,1), dim=c(3,3))
n=1; erzeuge(n)

     [,1] [,2] [,3]
[1,]    1    0    1
[2,]    0    0    0
[3,]    1    0    1

Die Unterteilung wird durch eine \(01\)-Matrix dargestellt. Man kann solche Matrizen mit dem Befehl image visualisieren.

for (n in 1:4) image(erzeuge(n))

Der Sierpinski-Teppich

Eine Variante der obigen Konstruktion besteht darin, dass man von den 9 kleinen Quadraten lediglich das mittlere Quadrat entfernt. Die zugehörige Punktmenge nennt man den Sierpinski-Teppich.

U= array(c(1,1,1, 1,0,1, 1,1,1), dim=c(3,3))
for (n in 1:4) image(erzeuge(n))

zufällige Sierpinksi-Teppiche

Man kann die obigen Konstruktionen randomisieren. Zum Beispiel kann man per Münzwurf entscheiden, ob man für ein Quadrat die Sierpinski-Konstruktion durchführt, oder ob man stattdessen alle 9 Teilquadrate entfernt.

Auf dem Computer kann man hierzu folgendes Programm schreiben.

# ersetze "x" durch "0" mit Wkeit p
x0 = function(x) sample(c(0,x),1,prob=c(p,1-p))
# loesche Eintraege des Arrays A mit Wkeit p
loesche = function(A) array(sapply(A,x0), dim=dim(A))
# erzeuge eine zufaellige Cantor-Menge
erzeuge_zu = function(n) if (n==0) return(1) else return( loesche(U %x% erzeuge_zu(n-1)))

Die Funktion zu implementiert den Münzwurf auf dem Computer. Für eine Matrix aus Nullen und Einsen werden alle Einträge mit Zufallszahlen \(0\) oder \(1\) aus einem Münzwurf multipliziert. Hierbei tritt \(0\) mit Wahrscheinlichkeit \(p\) auf, und \(1\) tritt mit Wahrscheinlichkeit \(1-p\) auf.

Die Funktion rp setzt einen Wert \(x\) mit Wahrscheinlichkeit \(p\) auf \(0\).

Hier ist ein zufälliger Sierpinski-Teppich.

p=0.1
# U= array(c(1,0,1 ,0,0,0, 1,0,1), dim=c(3,3)) # Cantor-Staub
U= array(c(1,1,1, 1,0,1, 1,1,1), dim=c(3,3)) # Sierpinski-Teppich
image(erzeuge_zu(2))

Für kleine Wahrscheinlichkeiten ergeben sich Punktmengen, die dem Sierpinski-Teppich sehr ähnlich sind. Für große Wahrscheinlichkeiten zerfällt der Sierpinski-Teppich. Man kann sich nun die Frage stellen, ab welcher Wahrscheinlicheit der Sierpinski-Teppich zerfällt. Diese Frage kann man experimentell untersuchen. Man kann sie auch mathematisch präzisieren und mit Methoden der Stochastik untersuchen. Der zufällige Sierpinski-Teppich ist ein einfaches Modell für sogenannte Perkolation.

Der Menger-Schwamm

Man kann die Konstruktion der Cantor-Menge und des Sierpinski-Teppichs auf drei Dimensionen verallgemeinern. Dies führt auf den sogenannten Menger-Schwamm.

U=array(c(1,1,1,1,0,1,1,1,1, 1,0,1,0,0,0,1,0,1, 1,1,1,1,0,1,1,1,1), dim=c(3,3,3))

Menger=erzeuge(2)

Die graphische Darstellung in drei Dimensionen erfolgt in einem eigenen Fenster. Dieses Fenster kann nicht im HTML-Dokument dargestellt werden, sondern setzt das Programm RStudio voraus.

Die graphische Darstellung kann mit dem R-Paket rgl wie folgt programmiert werden. Das Paket befindet sich nicht im Grundumfang von R, sondern muss zunächst mit install.packages(“rgl”) installiert werden.

# Paket rgl installieren (Befehl auskommentiert)
# install.packages("rgl")
# Paket rgl einlesen
library(rgl)
# Funktion fuer graphische Ausgabe definieren
zeige3d=function(A){
  # get the coordinates of the "1" entries
  co3d = which(A == 1, arr.ind = TRUE, useNames=FALSE)
  # determine number of "1" entries
  n=dim(co3d)[1]
  # convert to points in 3d by adding "0" in missing dimensions
  # get dimension of array
  d=length(dim(A))
  # add one 0-column if not three-dimensional:
  if (d<3) co3d=cbind(co3d, rep(0,n))
  # add another 0-column if one-dimensional:
  if (d==1) co3d=cbind(co3d, rep(0,n))
  # open new plot window
  open3d()
  # draw cubes at every "1" position
  for (i in 1:n) {
    # get coordinates
    pt=2*co3d[i,]
    # plot cube at position pt
    shade3d( translate3d( cube3d(col = "green"), pt[1], pt[2], pt[3]) )
  }
}

Mit der Funktion zeige3d lässt sich nun der Menger-Schwamm leicht darstellen.

# U=array(c(1,0,1), dim=3) # Cantormenge
# U= array(c(1,0,1,0,0,0,1,0,1), dim=c(3,3)) # Cantor-Staub 2d
# U= array(c(1,1,1,1,0,1,1,1,1), dim=c(3,3)) # Sierpinski-Teppich
# U=array(c(1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,1), dim=c(3,3,3)) # Cantor-Staub 3d
U=array(c(1,1,1,1,0,1,1,1,1,1,0,1,0,0,0,1,0,1,1,1,1,1,0,1,1,1,1), dim=c(3,3,3)) # Menger-Schwamm
M=erzeuge(2)
zeige3d(M)

Sie können mit der Funktion zeige3d auch die Cantormenge und den Sierpinski-Teppich darstellen. Verwenden Sie hierfür im obigen Programmcode einfach die entsprechende Unterteilung U.

zufällige Fraktale in 3d

Sie können für alle obigen Unterteilungen U zufällige Punktmengen dreidimensional darstellen. Wählen Sie wie oben einfach eine Wahrscheinlichkeit \(p\) und verwenden Sie die Funktion erzeuge_zu.

# U = array(c(1,0,1), dim=3) # Cantormenge
# U = array(c(1,0,1,0,0,0,1,0,1), dim=c(3,3)) # Cantor-Staub
U = array(c(1,1,1,1,0,1,1,1,1), dim=c(3,3)) # Sierpinski-Teppich
# U=array(c(1,1,1,1,0,1,1,1,1,1,0,1,0,0,0,1,0,1,1,1,1,1,0,1,1,1,1), dim=c(3,3,3)) # Menger-Schwamm
p=0.1; zeige3d(erzeuge_zu(2))

Sierpinski-Dreieck und Tetraeder

Ähnlich zum Sierpinski-Teppich kann man ein gleichseitiges Dreieck in 4 gleichseitige Dreiecke unterteilen und dann das mittlere Dreieck entfernen. Wiederholt man diese Konstruktion, ergibt sich das Sierpinski-Dreieck. Dies ist etwas aufwendiger zu programmieren als der Sierpinski-Teppich. Eine Alternative besteht darin, eine ähnliche Konstruktion mit einer Unterteilung eines Quadrats in 16 Teilquadrate durchzuführen.

U= array(c(1,0,0,0,1,1,0,0,1,0,1,0,1,1,1,1), dim=c(4,4)) # Sierpinski-Dreieck
zeige3d(erzeuge(1))

Auch dieses Verfahren kann man auf drei Dimensionen übertragen. Es ergibt sich der Sierpinski-Tetraeder.

U1=c(1,0,0,0,1,1,0,0,1,0,1,0,1,1,1,1)
U2=c(0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0)
U3=c(0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0)
U4=c(0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0)
U= array(c(U1, U2, U3, U4), dim=c(4,4,4)) # Sierpinski-Tetraeder
zeige3d(erzeuge(1))