El conjunto de Cantor con GeoGebra

Muchos fractales se forman realizando una acción simple una y otra vez, en una secuencia de pasos recursivos. En cada paso, el objeto inicial (input) puede ser una figura simple (una curva poligonal, por ejemplo) y el resultado (output) es una modificación de esa forma.

A continuación presentamos un método para construir fractales con GeoGebra. Para esto necesitaremos los siguientes comandos:

Punto()
Segmento()
Secuencia()
Elemento()
Encadena()
Longitud()

Por supuesto, supondremos que tienes un conocimiento básico del programa. Si no lo conoces aún, en el siguiente enlace Tutorial GeoGebra puedes encontrar un tutorial para familiarizarte con él. Tampoco es necesario explicar aquí cada uno de los comandos mencionados, pero si deseas profundizar en el tema puedes visitar este sitio: Comandos GeoGebra.

El conjunto de Cantor

Comencemos con el ejemplo más conocido: el conjunto de Cantor. Iniciamos nuestra construcción con un segmento de línea, eliminamos el tercio medio, lo que resulta en dos segmentos. Repetimos esta misma acción en cada uno de estos segmentos, cuyo resultado nos da cuatro segmentos. En el siguiente paso tenemos ocho, y luego dieciséis. Esto continúa hasta el infinito (o mientras las limitaciones de nuestra computadora lo permitan).



Vamos a construir esto en GeoGebra clásico (puede ser versión 5 o 6). Comencemos con un segmento de línea arbitrario a. Para esto necesitamos usar el comando Segmento el cual se encuentra en el menú principal.


Con este comando obtenemos el segmento cuyos extremos son los puntos A y B.

Nota: En lo que sigue, los comandos que usaremos los escribiremos en la casilla de entrada de GeoGebra que se encuentra en la parte inferior como se muestra en la imagen siguiente:

<-Aquí

El comando Punto() nos permite seleccionar cualquier punto a lo largo de la longitud de a; Punto(a, 0) es el punto final inicial, y Punto(a, 1) es el punto final del terminal. Para eliminar el tercio medio de a, lo reemplazamos con los dos segmentos

Segmento(Punto(a, 0), Punto(a, 1/3))

Segmento(Punto(a, 2/3), Punto(a, 1))

Debemos tener en cuenta que esto equivale a escribir dos comandos. Si seguimos nuestro proceso de esta manera, en cada paso la cantidad de comandos tendrá que duplicarse, y la cantidad de trabajo que estamos haciendo aumentará a una tasa exponencial. ¡Este proceso resulta ser un poco tedioso! Necesitamos una forma de realizar cada paso con un solo comando. Pero eso es fácil, usemos una lista. Nuestro comando entonces será

{Segmento(Punto(a, 0), Punto(a, 1/3)), Segmento(Punto(a, 2/3), Punto(a, 1))}

lo que resulta en el par de segmentos de línea: {*, *}. Ahora, en cada etapa queremos que el resultado tenga la misma forma que la entrada, por lo que deberíamos comenzar, no con un solo segmento de línea, sino con una lista que contenga un solo segmento de línea: {*}. Luego, en cada etapa, el input y el output serán listas de segmentos.

Así que vamos a empezar de nuevo: L_1 será la lista {a}, y L_2 será

{
     Segmento(
          Punto(a, 0),
          Punto(a, 1/3)
     )
     Segmento(
          Punto(a, 2/3),
          Punto(a, 1)
     )
}

Después creamos la lista 3 realizando la misma acción en cada uno de estos segmentos. No tienen nombre, pero podemos acceder a ellos a través del comando Elemento(). 

El Elemento(L_2, 1) es el primer segmento, y el Elemento(L_2, 2) es el segundo segmento. Así que L_3 se define como:

{
     Segmento(
          Punto(Elemento (lista2,1), 0),
          Punto(Elemento (lista2,1), 1/3)
     )
     Segmento(
          Punto(Elemento(lista2,1), 2/3),
          Punto(Elemento(lista2,1), 1)
     )
     Segmento(
          Punto(Elemento(lista2,2), 0),
          Punto(Elemento(lista2,2), 1/3)
     )
     Segmento(
          Punto(Elemento(lista2,2), 2/3),
          Punto(Elemento(lista2,2), 1)
     )
}

Con esto hemos logrado lo que necesitamos, pero sigue siendo un poco insatisfactorio. La cantidad de líneas escritas aún se duplicará en cada etapa si tenemos que ingresar los segmentos manualmente. Necesitamos una forma de hacer que la computadora los lea por su cuenta. Esto se puede hacer con el comando Secuencia(). La expresión

Secuencia(F(k), k, 1, n)

devuelve la lista

{F(1), F(2),…, F(n)}

donde F es una función que acepta un entero como argumento. En nuestro caso, la n debe ser el número de elementos en la L_2, o Longitud(L_2). La función debe devolver el par de segmentos resultante de eliminar el tercio medio del Elemento(L_2, k) para cada k, o

{
   Segmento(
      Punto (Elemento (L_2, k), 0),
      Punto (Elemento (L_2, k), 1/3)
   )
   Segmento(
      Punto (Elemento (L_2, k), 2/3),
      Punto (Elemento (L_2, k), 1)
   )
}

Si usamos esto como nuestra función F(k), el resultado será de la forma {{*, *}, {*, *}}. Sin embargo, queremos una lista de segmentos, no una lista de pares de segmentos. Entonces, después de ejecutar la secuencia, aplicaremos el comando Encadena(), lo que resultará en
{*, *, *, *}

De esta manera, tenemos:

Encadena(
   Secuencia(
      {
         Segmento(
            Punto(Elemento(L_2, k), 0),
            Punto(Elemento(L_2, k), 1/3)
          )
          Segmento(
            Punto(Elemento(L_2, k), 2/3),
            Punto(Elemento(L_2, k), 1)
          )
       }
      k
      1,
      Longitud(L_2)
   )
)

Así que nuestra entrada debe ser

L_3 = Encadena(Secuencia({Segmento(Punto(Elemento(L_2, k), 0), Punto(Elemento(L_2, k), 1/3)), Segmento(Punto(Elemento(L_2, k), 2/3), Punto(Elemento(L_2, k), 1))}, k, 1, Longitud(L_2)))

Para ser consistentes, podríamos comenzar por definir L_2 de esta manera:

L_2 = Encadena(Secuencia({Segmento(Punto(Elemento(L_1, k), 0), Punto(Elemento(L_1, k), 1/3)), Segmento(Punto(Elemento(L_1, k), 2/3), Punto(Elemento(L_1, k), 1))}, k, 1, Longitud(L_1)))

Entonces L_3 se definiría como arriba, y luego tendríamos

L_4 = Encadena(Secuencia({Segmento(Punto(Elemento(L_3, k), 0), Punto(Elemento(L_3, k), 1/3)), Segmento(Punto(Elemento(L_3, k), 2/3), Punto(Elemento(L_3, k), 1))}, k, 1, Longitud(L_3)))

y así sucesivamente, creando L_5,  L_6, etc. Finalmente ocultamos todos menos la última etapa para ver una buena imagen del conjunto de Cantor. Lo curioso es que no hay mucho que ver. Aunque el conjunto de Cantor es incontable, tiene una medida de cero.


Construcción del conjunto de Cantor usando el Programa de guión (scripting)

Otra manera de realizar la construcción anterior es por medio del Programa de guión (scripting). Para ello abrimos GeoGebra clásico (puede ser version 5 o 6) y creamos un botón que se encuentra en el menú principal


Aparecerá la siguiente ventana

El Rótulo es el título opcional, yo le he puesto Setup 

En la casilla de Guión (script) de GeoGebra escribiremos las siguientes líneas:

A = (0, 0)

B = (1, 0)

L_1 = {Segmento(A, B)}

L_2 = Encadena(Secuencia({Segmento(Punto(Elemento(L_1, k), 0), Punto(Elemento(L_1, k), 1/3)), Segmento(Punto(Elemento(L_1, k), 2/3), Punto(Elemento(L_1, k), 1))}, k, 1, Longitud(L_1)))

L_3 = Encadena(Secuencia({Segmento(Punto(Elemento(L_2, k), 0), Punto(Elemento(L_2, k), 1/3)), Segmento(Punto(Elemento(L_2, k), 2/3), Punto(Elemento(L_2, k), 1))}, k, 1, Longitud(L_2)))

L_4 = Encadena(Secuencia({Segmento(Punto(Elemento(L_3, k), 0), Punto(Elemento(L_3, k), 1/3)), Segmento(Punto(Elemento(L_3, k), 2/3), Punto(Elemento(L_3, k), 1))}, k, 1, Longitud(L_3)))

Si copias y pegas el Guión anterior, tendrá el siguiente aspecto:


Damos clic en OK y finalmente damos clic sobre el botón para obtener el mismo resultado.

Comentarios finales

Ahora que ya sabes como construir el conjunto de Cantor en GeoGebra, puedes hacer variaciones de esta construcción. Puedes buscar la manera de poner cada paso en un nivel diferente como en la imagen mostrada al inicio de la construcción o si prefieres puedes cambiar el color. Las posibilidades son casi infinitas.

En el siguiente applet puedes apreciar el resultado final de la construcción con dos elementos extra: un deslizador para mostrar cada lista y una casilla para animar. Puedes mover los puntos A y B.


Por último, cabe mencionar que el Guión anterior, el cual contiene 6 líneas, se puede reducir a una sola línea, pero requiere del uso del comando Ejecuta(), el cual sirve para crear sucesiones recursivas. 

Entonces el Guión final es:

Ejecuta(Encadena({"L1={Segment((0,0), (1,0))}"}, Secuencia("L"+(i+1)+"=Join(Sequence({Segment(Point(Element(L"+i+",k),0), Point(Element(L"+i+",k),1/3)),Segment(Point(Element(L"+i+",k),2/3), Point(Element(L"+i+",k),1))},k,1,Length(L"+i+")))", i, 1, 3)))

Si deseas conocer más al respecto de este comando consulta el enlace Comando Ejecuta


Comentarios

Entradas populares

Galileo Galilei y su ley de caída libre

El triángulo y la Recta de Euler

Una historia de la Teoría de Conjuntos