Mu´sica con Aut´omatas Celulares

Musica con Automatas Celulares

Fabian Ricardo Munoz Reyes

Universidad Nacional de Colombia

Facultad de Ciencias, Departamento de Matematicas

Bogota, Colombia

Ano 2013

Musica con Automatas Celulares

Fabian Ricardo Munoz Reyes

Tesis o trabajo de grado presentada(o) como requisito parcial para optar al tıtulo de:

Magister en Ciencias - Matematicas

Director:

Gustavo N. Rubiano O.

Lınea de Investigacion:

Topologıa Fractal y Automatas Celulares

Universidad Nacional de Colombia

Facultad de Ciencias, Departamento de Matematicas

Bogota, Colombia

Ano 2013

Dedicado a:

Mi familia que tanto me ha apoyado en mi

camino, que han estado siempre hasta en los

momentos mas complicados, a mi novia quien

ha sido la persona que le ha dado un nuevo

sentido a mi vida, por la cual dıa a dıa deseo ser

mejor persona y al profesor Gustavo Rubiano

quien me ha compartido una gran cantidad de

conocimiento y desperto mucho mas mi amor

hacia los conjuntos fractales.

“La felicidad humana generalmente no se

logra con grandes golpes de suerte, que pueden

ocurrir pocas veces, sino con pequenas cosas que

ocurren todos los dıas.”

Benjamin Franklin

VII

Resumen

Los automatas celulares fueron introducidos iniciando los anos 50 por el matematico John

Von Neumann quien pretendıa generar una maquina con la propiedad de auto manufacturar-

se, pero al no contar con elementos fısicos y economicos para llevar a cabo su objetivo, deci-

dio usar un modelo abstracto el cual consiste en ubicar sobre cada cuadro de una cuadrıcula

un elemento de un conjunto finito, y segun el y los elementos en los cuadrados adyacentes,

evolucionan o cambian de estado con el tiempo, y lo que se busca es determinar el tipo de

comportamiento de evolucion de todos los elementos de la cuadrıcula con el tiempo.

Por la simpleza de su descripcion y la posibilidad de generar comportamientos complejos,

estos se han usado para modelar sistemas fısicos, quımicos y biologicos, como el comporta-

miento de un grupo de microbios en una gota de agua. Sin embargo no solo a nivel cientıfico

se encuentra su aplicacion, en la composicion de musica mediante sistemas digitales y re-

masterizacion de sonidos es posible trabajar con ellos, mediante la identificacion de estados

en una grilla con notas musicales.

Palabras clave: evolucion, caos, frecuencia.

Abstract

Cellular Automata were introduced by the mathematician John Von Neumann in the 50´s ,

he wanted to create a machine which can manufactured itself, but he did not get the physical

and economic resources to make it, so he decided using an abstract model. The idea is to

assign at each square on a grid one of a finite state numbers. Each square evolves according

the state of neighbour squares through the time, and the studies are focused to understand

the behaviour of Cellular Automaton, it could stabilize in a finite time, or it could be possible

its behaviour become periodic or chaotic.

By the simplicity of theirs description and the possibility to generate complex behaviours,

they are having used to model physical, chemistry and biology systems as the behaviour of

microbes on a water drop. However it is not just for scientific topics, it can be used on the

composition digital system music or developing sounds made. An example is to assign at

each state on a grid a musical note.

Keywords: evolution, chaos, frequency

Indice general

Resumen VII

Lista de Figuras IX

Lista de Tablas X

1. Introduccion 1

2. Automatas Celulares 2

2.1. Historia de los Automatas Celulares . . . . . . . . . . . . . . . . . . . . . . . 2

2.2. Estructura de los Automatas Celulares . . . . . . . . . . . . . . . . . . . . . 4

2.2.1. Estado y vecindad . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.2.2. Evolucion en un automata . . . . . . . . . . . . . . . . . . . . . . . . 5

2.2.3. Automatas Celulares vistos como sistemas dinamicos . . . . . . . . . 8

2.2.4. Clasificacion de Wolfram . . . . . . . . . . . . . . . . . . . . . . . . . 9

3. Generalizacion de Automatas Celulares 11

3.1. Definiciones basicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3.2. Automatas celulares sobre Z . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.3. Automatas celulares bidimensionales . . . . . . . . . . . . . . . . . . . . . . 16

3.4. Reglas semitotalısticas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4. Automatas celulares y musica 22

4.1. Musica con automatas lineales . . . . . . . . . . . . . . . . . . . . . . . . . . 22

4.2. Musica con automatas 2−dimensionales . . . . . . . . . . . . . . . . . . . . . 27

4.3. Automatas celulares con reglas semitotalısticas . . . . . . . . . . . . . . . . . 33

5. Conclusiones y recomendaciones 39

5.1. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

5.2. Recomendaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

A. Codigos de programacion para automatas lineales 41

A.1. Sonido Automata Celular Lineal 1 . . . . . . . . . . . . . . . . . . . . . . . . 41


Indice general IX


B. Codigos para automatas 2−dimensionales 48

B.1. Ejemplo 1 vecindad de Moore . . . . . . . . . . . . . . . . . . . . . . . . . . 48

B.2. Ejemplo 2 vecindad de Moore . . . . . . . . . . . . . . . . . . . . . . . . . . 49

B.3. Ejemplo 1 Vecindad de Neumann . . . . . . . . . . . . . . . . . . . . . . . . 51

B.4. Ejemplo 2 Vecindad de Neumann . . . . . . . . . . . . . . . . . . . . . . . . 53

C. Reglas Semitotalısticas 56

C.1. Reglas Semitotalıstica Ejemplo 1 . . . . . . . . . . . . . . . . . . . . . . . . 57

C.2. Reglas Semitotalısticas Ejemplo 2 . . . . . . . . . . . . . . . . . . . . . . . . 59

C.3. Reglas Semitotalısticas ejemplo 3 . . . . . . . . . . . . . . . . . . . . . . . . 60

D. Palabras de Fibonacci 63

Indice de figuras

2-1. Vecindad de Neumann . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2-2. Ejemplo de Game of the Life propuesto por Jhon Conway . . . . . . . . . . 4

2-3. Ejemplo de una vecindad de tamano 2r + 1 para un ACL . . . . . . . . . . . 5

2-4. Cinta cerrada para definir las vecindades de los extremos. . . . . . . . . . . . 5

2-5. Ejemplo de la evolucion de un ACL(k,1) en dos tiempos . . . . . . . . . . . . 6

2-6. Evolucion de las i−esimas celulas de un ACL(k, r) para r = 0,5. . . . . . . . 6

2-7. Regla 8 para dos condiciones iniciales distintas . . . . . . . . . . . . . . . . . 9

2-8. Reglas 179 (Izquierda) y 244 (Derecha) . . . . . . . . . . . . . . . . . . . . . 9

2-9. Reglas 75 (Izquierda) y 105 (Derecha) . . . . . . . . . . . . . . . . . . . . . . 10

2-10.Reglas 57 (Izquierda) y 109 (Derecha) . . . . . . . . . . . . . . . . . . . . . . 10

3-1. Vecindades de Neumann (izquierda) y de Moore (derecha) de radio 1. . . . . 16

3-2. Vecindades de Neumann (izquierda) y Moore (derecha) de radio 2. . . . . . . 16

3-3. Ejemplo de configuraciones que desaparecen . . . . . . . . . . . . . . . . . . 18

3-4. Ejemplo de configuraciones estaticas . . . . . . . . . . . . . . . . . . . . . . 18

3-5. Ejemplo de configuraciones periodicas . . . . . . . . . . . . . . . . . . . . . . 19

3-6. Ejemplo de Configuracion Periodica con Desplazamiento . . . . . . . . . . . 20

3-7. Izquierda Configuracion Inicial HighLife, Derecha Evolucion Numero 100 de

la configuracion dada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

4-1. Regla 14764 del Automata Celular con 3 estados y vecindades de radio 2. . . 24

4-2. Asociacion de las notas del piano con el sistema MIDI y la notacion de Mat-

hematica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4-3. Ventana ejemplo 1 automatas celulares lineales. Regla:150, Numero de pasos:

20, Condicion inicial: (1, 0, 1, 0, 1) . . . . . . . . . . . . . . . . . . . . . . . . 26

4-4. Ventana ejemplo 2 automatas celulares lineales. Regla:18, Numero de pasos: 40 27

4-5. Ventana ejemplo 3 automatas celulares lineales. Tres reglas de evolucion dis-

tintas, con 30 evoluciones y condiciones iniciales diferentes . . . . . . . . . . 28

4-6. Ventana ejemplo 1 automatas celulares bidimensionales. . . . . . . . . . . . 29

4-7. Biyeccion entre la vecindad de Von Neumann y un automata celular lineal . 31

4-8. Ejemplo 1 de automatas bidimensionales con vecindades de Von Neumann . 31

4-9. Ejemplo 2 de automatas bidimensionales con vecindades de Moore . . . . . 32

4-10.Ejemplo 2 de automatas bidimensionales con vecindades de Von Neumann . 33

Indice de figuras XI

4-11.Ventana ejemplo 1 de Reglas Semitotalısticas . . . . . . . . . . . . . . . . . 35

4-12.Ventanas regla de evolucion personalizada . . . . . . . . . . . . . . . . . . . 36

4-13.Ventana ejemplo 2 de Reglas Semitotalısticas . . . . . . . . . . . . . . . . . . 37

4-14.Ventana ejemplo 2 de Reglas Semitotalısticas . . . . . . . . . . . . . . . . . . 37

4-15.Ventana ejemplo palabras de Fibonacci . . . . . . . . . . . . . . . . . . . . . 38

Indice de cuadros

2-1. Regla de evolucion de un ACL (2, 1). . . . . . . . . . . . . . . . . . . . . . . 7

2-2. Regla de evolucion 105 de un ACL(2, 1). . . . . . . . . . . . . . . . . . . . . 8

2-3. Regla de evolucion 7A0DB878 de un ACL (4,h). . . . . . . . . . . . . . . . . 8

4-1. Instrucciones comandos Mathematica . . . . . . . . . . . . . . . . . . . . . . 22

4-2. Convencion colores del automata . . . . . . . . . . . . . . . . . . . . . . . . 23

4-3. Ventanas interactivas para el ejemplo 1 de automatas celulares bidimensionales. 30

4-4. Lista de asignaciones para el caso de 4 estados. . . . . . . . . . . . . . . . . 32

4-5. Cuadro comparativo de evoluciones entre Game of Life y Highlife . . . . . . 34

4-6. Ubicacion de instrumentos por bloques en matriz 21× 21 . . . . . . . . . . . 35

4-7. Evolucion de las notas segun el movimiento que realizan . . . . . . . . . . . 37

1. Introduccion

Los automatas celulares hicieron su aparicion en los anos 50 a manos del matematico

hungaro-estadounidense John Von Neumann quien propuso un modelo bidimensional de

celulas las cuales se encuentran puestas sobre una malla de dimension finita y que segun

un estado inicial y las celulas que forman parte de su vecindad, van cambiando de estados

mientras pasa el tiempo. La idea original por la cual fue construida esta idea tenıa como

objetivo la invencion de una maquina con la propiedad que fuera capaz de auto reprodu-

cirse, debido a que Von Neumann no contaba con los recursos economicos para empezar su

proyecto decidio seguir el consejo de Stainslow M. Ulam, amigo suyo, el cual le propuso esta

idea abstracta relacionando con la maquina de Turin. Este modelo matematico ha permitido

simular distintos comportamientos fısicos, economicos, biologicos y sociales con gran preci-

sion, algo que hasta el momento no se habıa logrado con buenos resultados, y se debe a que

aun cuando el planteamiento de un automata celular es sencillo, al analizar su evolucion en

el tiempo se pueden observar comportamientos estables, periodicos, caoticos y/o aleatorios.

La computacion es en la actualidad una de las herramientas mas poderosas que tiene el

hombre para el analisis de datos, y simulacion de fenomenos a partir de condiciones iniciales.

Con estas herramientas computacionales se ha podido avanzar en diferentes modelos para la

produccion de sonidos digitales, una de las formas como que ha producido buenos resultados

de manera sencilla ha sido el uso de automatas celulares, diferentes modelos en casos unidi-

mensionales y bidimensionales pueden ser planteadas con el fin de generar musica indicando

unicamente condiciones iniciales. Cada modelo requiere ciertas capacidades computaciona-

les, el software de Mathematica que es la herramienta usada en el presente trabajo tanto

para la generacion de sonidos como de las graficas de evolucion de automatas requieren una

gran capacidad computacional, por lo cual los comandos usados en otros dispositivos pueden

no tener resultados optimos.

2. Automatas Celulares

En este capıtulo definiremos el concepto de los automatas celulares, las formas de representa-

cion mas comunes de las reglas de evolucion asociadas a cada uno; empezaremos abordando

el caso lineal, y despues veremos su extension a varias dimensiones.

2.1. Historia de los Automatas Celulares

La primera persona en trabajar el concepto de automatas celulares, fue el matematico John

Von Neumann quien se encontraba interesado en la creacion de una maquina que fuera capaz

de manufacturarse a si misma, porque en esa epoca la manufacturacion de automoviles y

objetos electricos empezaba a automatizarse. [14]

Lo complicado de empezar este proyecto fue los bajos recursos que poseıa Von Neumann, y

fue gracias a su amigo Stainslaw M. Ulam quien le sugirio empezar con un modelo de un

sistema dinamico completamente teorico, el cual consiste basicamente de un malla, la cual

posee varios cuadros en su interior los cuales pueden tener un estado de una cantidad finita de

ellos y pueden ir cambiando segun una regla establecida la cual depende del tipo de vecindad

que se desee trabajar. Para su objetivo Von Neumann utilizo un automata con 29 estados

posibles y cuyas vecindades eran unicamente los cuadrados superior, inferior, y laterales de

la cuadrıcula. La figura 2-1 muestra un ejemplo del tipo de vecindad usada por Neumann. El

Figura 2-1.: Vecindad de Neumann

cuadrado de la mitad ira cambiando de estado a medida que pasa el tiempo (caso discreto)

2.1 Historia de los Automatas Celulares 3

segun el color que posean las celulas alrededor suyo. De esta manera logro crear un automata

que pudiera auto reproducirse. Von Neumann muere en el ano 1957, y solo hasta el ano de

1966, el matematico Arthur W. Burks publica los trabajos de John Von Neumann sobre

estos sistemas dinamicos.[2]

Despues de los trabajos de Von Neumann, otras personas siguieron investigando en este

campo buscando automatas mas sencillos que hicieran lo deseado por Von Neumann, uno de

los pocos que lo lograron fue el cientıfico ingles Edgar Frank Codd quien probo la existencia de

automatas celulares con la propiedad de construccion universal (idea de Neumann) con ocho

estados y tomando el mismo tipo de vecindades que Neumann [6], tiempo despues el cientıfico

Christopher Langton simplifico las reglas para la creacion de este tipo de automatas, esto fue

posible dando una propiedad universal computacional [11], la cual consiste basicamente en

tener una secuencia de instrucciones distribuidas espacialmente (parecido a las estructuras

del ADN) la cual es ejecutada para crear una nueva estructura y generar a partir de esta

una copia exacta de la condicion inicial.

Otro de los trabajos destacables en la teorıa de los automatas celulares fue el realizado por el

matematico John Horton Conway quien publico en 1970 un juego matematico llamado Life

[7] cuya idea era trabajar en dos dimensiones (tal y como lo hizo Neumann) pero tomando

los 8 cuadrados que lo rodean y solo dos estados posibles: vivo o muerto, e intenta simular

el nacimiento y muerte de organismos segun la cantidad de ellos que se encuentren a su

alrededor siguiendo estas reglas:

Sobreviviente: La celula sobrevive si existen dos o tres celulas vivas a su alrededor.

Muerte: La celula muere si a su alrededor hay cuatro o mas celulas vivas (sobrepobla-

cion), o si alrededor de la celula hay a lo mas una celula viva (desolacion).

Nacimiento: Cada espacio donde no haya una celula viva puede nacer una nueva celula

si hay exactamente tres celulas vivas a su alrededor.

Es importante entender que todos los nacimientos y las muertes ocurren simultaneamente

(Ver figura 2-2). A cada etapa de la evolucion del automata se le llama generacion y a

la evolucion de las generaciones se les denomina la evolucion del ACL de la configuracion

inicial.

Aunque las reglas de Life son muy sencillas se pueden desarrollar comportamiento complejos

y simulan muy bien el comportamiento de microorganismos en una gota de agua, es por este

modelo que los automatas celulares generaron gran interes en la comunidad cientıfica. Hay

que recordar que en la fısica son muchos los sistemas que se trabajan con elementos discretos y

por esa razon se ha logrado facilmente implementarlos en ella, como por ejemplo, en el modelo

dinamico de Ising [19] donde incluyendo la interaccion de la energıa cinematica y la generada

por la atraccion entre las partıculas subatomicas generan un automata celular sencillo pero no

4 2 Automatas Celulares

Figura 2-2.: Ejemplo de Game of the Life propuesto por Jhon Conway

determinıstico; en la quımica se han podido modelar redes de trabajo de reacciones acopladas

con difusion espacial [8]; otro campo donde se ha logrado aplicar los automatas celulares es

en la biologıa donde el desarrollo de estructuras y reglas en el crecimiento de los organismos

son, en ocasiones, dirigidas por reglas locales muy sencillas y por esto son muy bien descritas

por modelos con automatas celulares. [18]

Gracias al desarrollo y accesibilidad que han venido ganando los equipos de computacion, el

estudio de temas como la complejidad o el caos ha tambien incrementado. Stephen Wolfram

en los anos 80’s, cuyo interes es el estudio de la complejidad, senalo que los sistemas com-

plejos tienden a regirse por reglas sencillas y componentes muy simples, y es cuando ambas

interactuan que se generan patrones complejos, es por esta razon que usa para su trabajo los

automatas. Hay que resaltar, y que es muy importante, es que tanto Von Neumann, Conway

y Codd, entre tantos otros, se concentraron en conseguir automatas que cumplieran sus re-

querimientos, mientras que el estudio de Wolfram se enfoco en analizar los comportamientos

de diferentes reglas de evolucion, casi siempre sobre automatas celulares lineales.

2.2. Estructura de los Automatas Celulares

2.2.1. Estado y vecindad

Iniciaremos tratando el caso lineal y despues miraremos como se puede extender a otras

dimensiones, tomemos una cinta de longitud finita y dividamosla en partes iguales, a cada

uno de estos rectangulos que hemos generado lo llamaremos una celula.

A cada celula le podemos asignar un elemento de un conjunto finito A cualesquiera no vacıo,

puede ser un color, un numero, una letra, etc., a cada uno de los elementos del conjunto A

lo llamaremos un estado de la celula, se debe tener en cuenta que todas las celulas deben

tener el mismo numero de posibles estados, tal vez con diferente probabilidad de eleccion.

Como todas las celulas se encuentran sobre la misma cinta, podemos elegir segun la cantidad

de celulas que posea el automata r celulas en cada direccion, el conjunto de las r celulas que

2.2 Estructura de los Automatas Celulares 5

se encuentran a la izquierda de una celula fija, las r celulas que se encuentran a su derecha, y

la celula misma forman lo que llamaremos una 2r+1−vecindad. Para visualizarlo de manera

mas clara, la figura 2-3 muestra como son elegidas las vecindades.

b b bb b b

2r + 1

Célula

Figura 2-3.: Ejemplo de una vecindad de tamano 2r + 1 para un ACL

Para no tener complicaciones con los extremos de la cinta debido a la definicion de vecindades

se toma usualmente la cinta cerrada, en otras palabras, se juntan los dos extremos de la cinta

como se muestra en la figura 2-4.

Célula Inicial Célula final

Figura 2-4.: Cinta cerrada para definir las vecindades de los extremos.

Para los automatas lineales celulares Wolfram propuso una notacion, la cual es una pareja

ordenada (k, r), donde k indica el numero maximo de estados y r indica el numero de celulas

a cada lado que se toman para crear la vecindad. Es importante tener en cuenta que no

se indica cual es el numero total de las celulas que pertenecen a la cadena, aunque si se

indica implicitamente cual es el numero mınimo de celulas que deben haber 2r+1, daremos

un ejemplo de la notacion de Wolfram, un ACL(4, 2) (ACL es la abreviatura de Automata

Celular Lineal) es un automata lineal con una cantidad mınima de 5 celulas, y cada celula

tiene 4 estados posibles, por lo cual tendrıamos 45 = 1024 combinaciones de vecindades

diferentes.

2.2.2. Evolucion en un automata

Lo mas importante del trabajo con automatas es como evolucionan, es decir como van cam-

biando los estados de las celulas que se encuentran en la vecindad definida por el automata,

es decir de los estados de las r celulas que se encuentran a su derecha, los estados de las r


celulas que se encuentran a su izquierda y la celula misma, el arreglo inicial del automata

diremos que ocurre en el tiempo t0, y una vez evolucionan todas las celulas del arreglo a

su nuevo estado diremos que se encuentra en el tiempo t1 y asi sucesivamente, algo muy

importante es que al pasar de un tiempo al siguiente, todas las celulas del arreglo cambian

automaticamente. (Ver Figura 2-5)

t

t

t

0

1

2

Figura 2-5.: Ejemplo de la evolucion de un ACL(k,1) en dos tiempos

Otra cosa que puede ocurrir es que la longitud de la vecindad sea par, en este caso se puede

elegir una de las celulas para que albergue el nuevo estado y a partir de esta determinar las

otras. (Ver figura 2-6)

t

t

t

0

1

2

Figura 2-6.: Evolucion de las i−esimas celulas de un ACL(k, r) para r = 0,5.


Todos las celulas en el estado que se encuentre en un tiempo dado genera un patron que

se llamara un estado global [21], al cambiar de estados todas las celulas en el arreglo en

cada tiempo de evolucion, cambia el estado global del arreglo. Se debe tener en cuenta que

cualquiera de los posibles estados globales que posee el automata puede ser el estado inicial

desde el cual empezara la evolucion del automata, a esta condicion se nombra configuracion

inicial, y al estado global en el tiempo i se le denomina la generacion i−esima, por ultimo se

llamara regla de evolucion a la funcion de transicion que se aplica a cada celula del automata

y que segun los elementos que conforman su vecindad determinan el siguiente estado de la

misma. Esta funcion se puede expresar de diferentes maneras, una de ellas es de forma

tabular. (Ver ejemplo tabla 2-1)

Vecindad Evolucion Estado

000 → 1

001 → 0

010 → 0

011 → 1

100 → 0

101 → 1

110 → 1

111 → 0

Cuadro 2-1.: Regla de evolucion de un ACL (2, 1).

Al tener cada celula k posibles estados, el numero posible de reglas de evolucion de un

ACL(k, r) es igual a kk2r+1

; adaptado a el ejemplo dado por la tabla 2-1, esa regla de

evolucion es una de las 222r+1

= 256 reglas de evolucion posibles que posee un ACL(2, 1).

Para distinguir los ACL, Wolfram propuso utilizar sus reglas de evolucion asociadas, sin

embargo como el numero de estados posibles aumenta segun el numero de estados y/o

vecinos, se utiliza el equivalente en sistema decimal o en otras bases segun convenga, a esta

representacion se le conoce como el numero de Wolfram. Para la regla de evolucion descrita

en la Tabla 2-1, como el numero de estados posibles es dos usaremos primero la notacion

binaria y luego realizaremos la conversion a sistema decimal. (Ver tabla 2-2)

En otras ocasiones el numero de Wolfram en base decimal no es practico por la cantidad de

dıgitos que dicho numero pueda tener, es ahı cuando se vuelve imperativo usar otras bases

numericas para su escritura. Para el ejemplo de un ACL(4, h) con h = 0,5 descrito por la

tabla 2-3 sera mas conveniente el uso de la notacion hexadecimal.


0 0 0 0 1 1 1 1

Vecindades 0 0 1 1 0 0 1 1

0 1 0 1 0 1 0 1

Evolucion 1 0 0 1 0 1 1 0

Base Binaria 20 21 22 23 24 25 26 27

Base Decimal 1 0 0 8 0 32 64 0

Numero de Wolfram Base Binaria 1001011

Numero de Wolfram Base Decimal 1 + 8 + 32 + 64 = 105

Cuadro 2-2.: Regla de evolucion 105 de un ACL(2, 1).

0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3

0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3

1 3 2 2 0 0 3 1 2 3 2 0 1 3 2 0

41 40 41 40 41 40 41 40 41 40 41 40 41 40 41 40

7 10 0 13 11 8 7 8

7 A 0 D B 8 7 8

Cuadro 2-3.: Regla de evolucion 7A0DB878 de un ACL (4,h).

2.2.3. Automatas Celulares vistos como sistemas dinamicos

Por las descripciones que hemos dado sobre lo que es un automata celular tenemos que

cada celula del arreglo posee un finito numero de posibles estados, tenemos una regla de

evolucion que indica cual sera el proximo estado de una celula segun la vecindad en la que

se encuentre y este cambio de estado se produce en todas las celulas de manera simultanea

lo cual llamamos estado global y este cambia de manera discreta, por esta caracterısticas

podemos mirar un automata como un sistema dinamico discreto.

Aquellos sistemas o fenomenos cuyos comportamientos sean difıciles o imposibles de predecir

solo con los datos iniciales son llamados sistemas o fenomenos no determinısticos. Cuando

estos fenomenos ocurren se puede observar que el sistema presenta una aperiodicidad y que

esta no desaparece con el transcurrir del tiempo, a esta aperiodicidad se denomina caos.

Una cosa muy importante de los sistemas no determinısticos es que se pueden generar por

estructuras muy simples, en el caso de los automatas el comportamiento depende solo de la

regla de evolucion la cual es fija, no contiene probabilidades necesariamente o elementos que

cambien constantemente, sin embargo su evolucion puede ser impredecible [10].


2.2.4. Clasificacion de Wolfram

Segun el comportamiento que un automata celular muestre en su evolucion, Wolfram clasi-

fico los ACL en cuatro clases. Se muestran algunos ejemplos de cada clase usando diferentes

ACL(2, 1). El estado 1 se representa por medio del color negro y 0 se representa por el color

blanco, y la evolucion se puede observar por medio de las filas desde arriba hacia abajo.

CLASE 1: El Automata en su evolucion alcanza un estado global donde todas las

celulas tienen el mismo estado.(Figura 2-7)

Figura 2-7.: Regla 8 para dos condiciones iniciales distintas

CLASE 2: El Automata muestra una evolucion con un patron simple.(Figura 2-8)

Figura 2-8.: Reglas 179 (Izquierda) y 244 (Derecha)


CLASE 3: El Automata muestra una evolucion aperiodica y caotica.(Figura 2-9)


CLASE 4: El Automata muestra una evolucion compleja, es decir, aperiodica pero de

una u otra manera ordenada.(Figura 2-10)


3. Generalizacion de Automatas

Celulares

Los automatas celulares lineales son un caso especial de las funciones conocidas con el mismo

nombre, pero sobre grupos finitamente generados. Aquı, se generalizan los conceptos de

vecindad, estado global y generaciones.

3.1. Definiciones basicas

Sean M un grupo finitamente generado y A un conjunto finito de sımbolos (llamado un

alfabeto), notaremos por AM el conjunto de todas las funciones f : M → A, es decir M

indexa los elementos de A. Escribiremos x= [xm]m∈M, donde cada xm ∈ A para todo m ∈ M.

En la mayoria de los casos M = N := {0, 1, 2, · · · }, M = Z := {· · · ,−2,−1, 0, 1, 2, · · · },

M = Nn,M = Zm, o M = Nn × Zm con n,m ∈ N.

Visto A como un espacio topologico discreto, A es un espacio compacto por ser finito, luego

AM es compacto con la topologıa producto de Tychonoff, aun mas A

M es un espacio de

Cantor. Sea n ∈ M, definimos la funcion fn : AM → AM como el mapeo de cambio definido

por [fn(x)]m = xm+n para todo x ∈ AM y m ∈ M. El conjunto {fn}n∈M es una M-accion

continua sobre AM, la cual denotaremos por f .

Sea H un subconjunto finito de M , y sea φ : AH → A una funcion. El automata celular (CA)

determinado por la funcion φ es una funcion Φ : AM → AM definida por Φ(x)m := φ(xm+H)

donde xm+H := [xm+h]h∈H para todo x ∈ AM ym ∈ M. Se puede demostrar que los automatas

celulares son exactamente todas las transformaciones de AM las cuales conmutan con todos

los mapeos de cambio. [9]

Al conjunto H lo llamaremos la vecindad de Φ. Por ejemplo, si M = Z, entonces usualmente

se elige H = [−l, r] para algunos l, r ∈ N. Al numero l lo llamaremos radio izquierdo y al

numero r lo llamaremos radio derecho. En los casos mas generales en los que M = Zn, es

usual que H ⊂ [−l, r]n. Algunas clases de automatas celulares importantes son:

Automata celular lineal: Sea (A,+) un grupo abeliano finito, se dice que Φ un

automata celular es lineal si la regla local φ tiene la forma

12 3 Generalizacion de Automatas Celulares

φ(xH) :=∑

h∈H

gh(xh) (3-1)

para todo xH ∈ AH, donde gh : A → A es un endomorfismo para cada h ∈ H.

Automata celular afın: Sea (A,+) un grupo abeliano finito, se dice que Φ es un

automata celular afın si la regla local φ tiene la forma

φ(xH) := c+∑

h∈H

gh(xh) (3-2)

para todo xH ∈ AH, donde gh : A → A es un endomorfismo para cada h ∈ H y c es

una constante.

Automatas celulares de permutacion: Supongamos que M = Z, si notamos por

x = [x−n+1, · · · , xm] ∈ A[−n+1,m] para n,m ∈ N , se entendera por [ax] para un

elemento a ∈ A al elemento [ax] := [a, x−n+1, · · · , xm] ∈ A[−n,m]. Si Φ : AM → A

M

tiene como regla local a φ : A[−n,m] → A y tomamos x ∈ A[−n+1,m] definimos la funcion

φx : A → A por φx (a) := φ([ax]). Diremos que Φ es permutacion a izquierda si

φx : A → A es una biyeccion para todo x ∈ A[−n+1,m].

De manera analoga definimos x = [x−n, · · · , xm−1] ∈ A[−n,m−1] , [xa] := [x−n+1, · · · , xm, a] ∈

A[−n,m], y para la regla local φ definimos xφ : A → A como xφ(a) := φ([x]a), y si esta

ultima es biyectiva para todo x ∈ A[−n,m−1] diremos que Φ es permutativo a derecha, y

en el caso que Φ sea permutativo por derecha y por izquierda solamente diremos que

es de permutacion. Este concepto se puede extender a M un grupo arbitrario.

Una herramienta que es muy util en el estudio de automatas celulares y une estos conceptos

mas con el analisis matematico es la posibilidad de crear una medida. Sea S ⊂ M, y b ∈ AS.

Denotaremos por 〈b〉 := {a ∈ AM; aS := b} el conjunto cilindro determinado por b. Sea L

la σ−algebra sobre AM generada por todos los conjuntos cilindros. Una medida µ en A

M es

una funcion contable aditiva µ : L → R tal que µ[

AM]

= 1. Un ejemplo de los tipos de

medidas que se trabajan en este ambito es la Medida de Bernoulli . Sea β0 una medida

de probabilidad en A, esta induce la medida β en AM la cual para algun S ⊂ M finito y

un a ∈ AS, si S := |S| entonces β|〈a〉| =

∏

s∈S β0(as). Cuando trabajamos solamente con

medidas de probabilidad (aunque podemos extenderlo para algun numero real) definimos el

soporte de la medida µ como el subconjunto cerrado mas pequeno X ⊂ AM tal que µ|X| = 1;

este conjunto lo denotaremos por sup(µ), en el caso que X = AM diremos que µ tiene soporte

completo. Ahora miremos algunas propiedades que pueden tener estas medidas con respecto

al automata celular:

3.1 Definiciones basicas 13

Medida invariante: Sean µ una medida en AM y Φ : AM → A

M un automata celular.

Definimos la medida Φµ como Φµ(B) = µ(Φ−1(B)), para todo B ∈ B. Diremos que µ

es Φ−invariante si Φµ = µ.

Medida uniforme: Sea A := |A|. Una medida uniforme σ en AM es una medida de

Bernoulli tal que, para cualquier subconjunto finito S ⊂ M, y cualquier x ∈ AS, si

S = |S|, entonces σ|〈x〉| = 1/AU .

Ahora, sea Φ : AM → AM y x ∈ A

M diremos que y ∈ AM es el ancestro de x si se cumple

Φ(y) = x, al conjunto {x ∈ AM/x no tiene ancestros} se llama el Jardın del Eden. Es claro

que si Φ es un epimorfismo sobreyectivo el Jardın del Eden es vacıo , sin embargo cuando

el epimorfismo es inyectivo no es facil determinar su Jardın del Eden, es aquı donde cobra

importancia las medidas anteriormente definidas, el ejemplo de ello mas importante es el que

se conoce con el nombre del Teorema del Jardın del Eden [13].Cuando un automata Φ

cumple que su Jardın del Eden es vacıo, diremos que Φ es un automata celular reversible.

Para el caso de los automatas celulares que se definıan en el capıtulo 2, tenemos un numero

finito de estados k el cual podemos asociar con en conjunto finito Zp y vecindades H =

{−r, · · · , r} es decir A = Zp y H ⊂ M = Z. Ademas si gh : Zp → Zp es un endomorfismo

tenemos gh(n) = ch · n por lo cual las reglas locales son de la forma:

φ(xH) =∑

h∈H

ch · xh (3-3)

Por definicion el numero de elementos de AH es |A||H| y en nuestro ejemplo k2r+1. Debido a

que los elementos de Zn son {0, 1, · · · , n− 1}. Podemos organizar los elementos de AH usando

el orden lexicografico, luego si ρ : AH → N envıa un elemento B ∈ AH a su correspondiente

numero natural segun el orden lexicograficos, se puede definir:

W(φ) :=∑

B∈AH

φ(B) · ρ(B) (3-4)

Esta funcion le asigna a cada regla local un numero, este valor lo conoceremos como el

numero de Wolfram del automata celular Φ, este va a ser un numero entero en el rango

[0, kk2r+1

− 1].Si k = 2 y r = 1 se tendrıa que el numero de reglas locales diferentes serıa

256, pero en el caso de dos dimensiones tomando vecindades de 9 celulas tendrıamos 2256

reglas diferentes por lo cual se vuelve muy complicado representar las reglas mediante una

asignacion numerica dada explıcitamente por la evolucion de cada uno de los estados segun

sus vecindades, es por eso que se introducira otra manera de expresar las reglas de evolucion

en dos o mas dimensiones.


3.2. Automatas celulares sobre Z

Teniendo los conceptos generales sobre automatas celulares se enfocara el trabajo al caso que

M sea el conjunto de los numeros enteros. Sea d un entero positivo, llamaremos al conjunto

Zd el espacio celular d−dimensional. A los elementos de Zd los llamaremos las celulas y a los

elementos de A los conoceremos como los estados.

Las vecindades de una celula en el caso de Zd, son de la forma H =∏d

i=1[−li, ri] ⊂ Zd.

Entonces para x ∈ Zd denotamos por:

xH :=

d∏

i=1

[−li + xi, ri + xi] (3-5)

Esta vecindad tendra un total de |H| =∏d

i=1(li + ri + 1) celulas que la conforman, ası que

al tener cada celula posibles A = |A| estados, existen A|H| posibles configuraciones, y como

a cada una de ellas, de acuerdo a la regla local φ puede ser asignada a A diferentes estados,

entonces el numero total de reglas locales diferentes es:

AA|H|

(3-6)

De todos los tipos de vecindades que se tienen en dos o mas dimensiones existen dos tipos

muy conocidos en la literatura relacionada con los automatas celulares debido a las personas

que trabajaron con ellas y se conocen como vecindad de Moore y vecindad de Neumann.

VECINDAD DE MOORE, dado un numero r entero positivo diremos que H es

una vecindad de Moore de radio r si H = [−r, r]d, y se denota por V dr .

VECINDAD DE NEUMANN, dado un numero r entero positivo diremos que H

es una vecindad de Neumman de radio r si para cada x ∈ H se tiene

d∑

i=1

|xi| 6 r (3-7)

en este caso de denota por Mdr .

Veamos la importancia que juega la topologıa en la teorıa de los automatas celulares. Sean

f1, f2, · · · de configuraciones donde fi ∈ AZd

para cada i, diremos que f ∈ AZd

es el lımite

de la sucesion si para todo x ∈ Zd tenemos que fi(x) = f(x) para todo i > k. Claramente si

el lımite existe es unico, a este lo denotaremos por:

f = lımx→∞

fi (3-8)

Veamos una primera proposicion relacionada con los lımites de las configuraciones.

3.2 Automatas celulares sobre Z 15

Proposicion 3.1. Toda sucesion de configuraciones tiene una subsucesion convergente

Demostracion. Sean f1, f2, · · · una sucesion arbitraria con fi ∈ AZd

, y x1,x2, · · · una lista de

elementos de elementos de Zd. Vamos a generar la lista de subındices i0 < i1 < i2 < · · · que

nos van a indicar la subsucesion convergente y lo haremos de manera recursiva: sea i0 ∈ Z+,

supongamos que ik−1 ha sido elegido y vamos a elegir ik para k > 1. ik sera el menor entero

que satisface las siguientes condiciones:

(1k) ik > ik−1

(2k) fik(xj) = fik−1(xj) para todo j = 1, 2, · · · , k − 1.

(3k) Existen infinitos indices i tales que fi(xj) = fik(xj) para todo j = 1, 2, · · · , k.

Veamos por que razon los numeros ik siempre existen. Al haberse elegido ik−1 estamos

asegurando que se cumple la propiedad (3k−1) para el ındice i−1, por lo cual podemos elegir

uno de estos i tal que i > ik−1, y por la misma propiedad (3k−1), se cumple la propiedad

(2k). Con lo cual se garantiza la existencia de estos ik.

Veamos una proposicion que nos muestra la continuidad que posee el automata celular.

Proposicion 3.2. Sea Φ un automata celular y sean f1, f2, · · · una sucesion convergente de

configuraciones. Entonces tenemos que Φ(f1),Φ(f2), · · · converge y

lımt→∞

Φ(ft) = Φ(f) (3-9)

donde

(3-10)

lımt→∞

ft = f (3-11)

Demostracion. Sea Φ un automata celular y sea x ∈ Zd. Por definicion de lımite, dado

K ∈ Z+, si i > K entonces

fi(x) = f(x) (3-12)

Luego:

Φ(fi)(x) = φ(fi(x)) (3-13)

= φ(f(x)) (3-14)

= Φ(f)(x) (3-15)

Como se eligio x arbitrariamente, tenemos que Φ(f1),Φ(f2), · · · es una sucesion que converge

a Φ(f).


3.3. Automatas celulares bidimensionales

Para esta parte analizaremos solamente el caso bidimensional de los automatas sobre Z2.

Sea Θn = {0, 1, · · · , n− 1} el conjunto de los posibles estados del automata , es importante

notar que en los casos de automatas lineales podemos tomar un arreglo de longitud finita

y podıamos conectar el inicio del arreglo con el final y generar un arreglo circular, pero en

mas dimensiones la configuracion inicial C se toma sobre todo el ”plano cartesiano” de Z2 ,

para estos casos H = [−a1, b1]× [−a2, b2] , y llamaremos regla local ψ : (Θn)H → Θn.

Como se habıa mencionado anteriormente, las vecindades de Moore y Neumann son las mas

usadas. Las figuras 3-1 y 3-2 dan una mejor idea de las definiciones dadas en el capıtulo 3.2

en el caso que M = Z2.

x(i,j) x(i+1,j)

x(i,j+1)

x(i−1,j)

x(i,j−1)

x(i+1,j+1)

x(i,j)

x(i,j+1)

x(i+1,j)

x(i+1,j−1)x(i,j−1)x(i−1,j−1)

x(i−1,j)

x(i−1,j+1)

Figura 3-1.: Vecindades de Neumann (izquierda) y de Moore (derecha) de radio 1.

x(i+1,j)

x(i,j+1)

x(i,j+2)

x(i+1,j+1)

x(i+1,j) x(i+2,j)x(i,j)

x(i,j−1) x(i+1,j−1)

x(i,j−2)

x(i−1,j)

x(i−1,j+1)

x(i−1,j−1)

x(i−2,j) x(i+1,j)

x(i,j+1)

x(i,j+2)

x(i+1,j+1)

x(i+1,j) x(i+2,j)x(i,j)

x(i,j−1) x(i+1,j−1)

x(i,j−2)

x(i−1,j)

x(i−1,j+1)

x(i−1,j−1) x(i+2,j−1)

x(i+2,j+1)

x(i+1,j+2) x(i+2,j+2)

x(i+1,j−2) x(i+2,j−2)x(i−1,j−2)

x(i−1,j+2)

x(i−2,j)

x(i−2,j−1)

x(i−2,j+1)

x(i−2,j+2)

x(i−2,j−2)

Figura 3-2.: Vecindades de Neumann (izquierda) y Moore (derecha) de radio 2.

En general para una celula la vecindad de Neumann de radio r la conforman 2r2 + 2r + 1

celulas, y al existir k estados tendrıamos kk2r2+2r+1

reglas locales, mientras que para vecin-

3.4 Reglas semitotalısticas 17

dades de Moore de radio r tienen (2r + 1)2 celulas y kk(2r+1)2

reglas locales. Estos numeros

pueden ser muy grandes, solo para dar un ejemplo si tomamos n = 2 y H = [−1, 1]2 tenemos

que el numero de reglas en total serıa 229= 2512 > 1070 por lo cual es muy complicado

trabajar indicando el numero de Wolfram, por esta razon vamos a introducir una funcion

llamada regla semitotalistica.

3.4. Reglas semitotalısticas

Las reglas semitotalısticas fueron introducidas en la literatura por primera vez, por el ma-

tematico Jhons Conway en el trabajo realizado por el conocido como Life, por esta razon

sera el primer ejemplo a tratar y luego se extendera a dimensiones mayores a 2.

Sea A = {0, 1} un conjunto de estados, y tomemos el espacio M = Z2. Para cada celula en

M vamos a tomar la vecindad de Moore de radio 1. Definimos la funcion Φ : AM → AM el

automata celular generado por la regla φ : A[−1,1]2 → A tal que:

φ(x[−1,1]2) :=

1 si

x(i,j) = 1 y 2 6∑

[k,l]∈[−1,1]2x(i+k,j+l) 6 3

x(i,j) = 0 y∑

[k,l]∈[−1,1]2x(i+k,j+l) = 3

0 en otro caso

(3-16)

A este automata se conoce como el Life, y es exactamente la misma definicion nombrada

en la introduccion, es decir, una celula nace si cerca de ella hay exactamente 3 celulas vivas

y una celula viva continua en ese estado si en su vecindad posee 2 o 3 celulas vivas. Esta

forma de definir el estado de una celula segun el numero de celulas que comparten el estado

1 en una vecindad es lo que se conoce como regla semitotalıstica. Ahora extendamos este

concepto a cualquier vecindad sobre H ⊂ Z2 con la condicion que (0, 0) ∈ H. Vamos a tomar

cuatro numeros enteros positivos Smin, Smax, Nmin, Nmax con las condiciones que Smin 6 Smax

y Nmin 6 Nmax. Los dos primeros enteros Smin, Smax nos definiran bajo que condiciones

una celula viva (estado 1) sobrevive para la siguiente generacion y los otros dos numeros

Nmin, Nmax nos indica cuando ocurre un nacimiento donde haya una celula muerta.

Definimos la regla semitotalıstica φ[Smin, Smax, Nmin, Nmax] como la regla local para una ve-

cindad H que evoluciona de la siguiente manera:

φ[Smin, Smax, Nmin, Nmax](xH) :=

1 si

x(i,j) = 0 y Nmin 6∑

[k,l]∈[−1,1]2x(i+k,j+l) 6 Nmax

x(i,j) = 1 y Smin 6∑

[k,l]∈[−1,1]2x(i+k,j+l) 6 Smax

0 en otro caso

(3-17)


Lo mas importante de este tipo de reglas semitotalısticas es que nos permite estudiar la

evolucion del automata y determinar algunas caracterısticas del mismo mediante una tecnica

conocida como Teorıa del Campo Promedio [16].Usando la notacion anterior el juego de

la vida es la regla semitotalıstica φ(2, 3, 3, 3). Veamos algunas caracterısticas de diferentes

configuraciones que durante su evolucion muestran cuatro comportamientos distintos, los

cuales son:

Configuraciones que desaparecen: Estas son aquellas que despues de un numero finito

de pasos se convierten en el estado global donde todas las celulas son 0.(Figura 3-3)

Figura 3-3.: Ejemplo de configuraciones que desaparecen

Configuraciones estaticas: Una configuracion es estatica si despues de un determinado

numero de pasos alcanza un estado global que no cambia durante las generaciones

posteriores.(Figura 3-4)

Figura 3-4.: Ejemplo de configuraciones estaticas


Configuraciones periodicas: Son configuraciones que luego de un numero finito de ge-

neraciones vuelve a un estado global anterior.(Figura 3-5)

Figura 3-5.: Ejemplo de configuraciones periodicas

Configuraciones periodicas con desplazamiento: Estas son configuraciones que median-

te un determinado numero de pasos vuelven a la misma configuracion pero se han

desplazado en el plano o el espacio.(Figura 3-6)


Figura 3-6.: Ejemplo de Configuracion Periodica con Desplazamiento

De los cuatro ejemplos de configuraciones, los ultimos son las mas interesantes debido

a la complejidad que estas pueden generar en la interaccion con otras configuraciones.

En este grupo se incluyen los patrones conocidos como Gliders, simulan armas que

disparan celulas vivas o dejan rastro de su recorrido mientras se desplazan. Conway

conjeturo en 1970 que ningun patron podrıa crecer indefinidamente en el numero de

celulas vivas, gracias a la aparicion de los gliders, un equipo de investigacion del Ins-

tituto de Tecnologıa de Massachusetts liderado por Bill Gosper generaron el primer

patron conocido como Gosper Glider Gun el cual es capaz de generar un glider en su

decimo quinta generacion y despues cada treinta generaciones aparece otro glider.

De las otras reglas semitotalısticas diferentes al juego de la vida, una muy conocida en la

literatura de reglas semitotalısticas es Highlife, la cual se diferencia de Life en el cambio del

parametro Nmax que pasa de 2 a 6, con solo ese pequeno cambio se obtiene que en su mayorıa

cualquier configuracion inicial crece en su poblacion de manera rapida cubriendo casi todo

el espacio. (Figura 3-7)

Figura 3-7.: Izquierda Configuracion Inicial HighLife, Derecha Evolucion Numero 100 de la

configuracion dada.

La extension de las reglas semitotalısticas a mas estados se puede realizar de diferentes


maneras, por ejemplo se puede asignar un numero a cada uno de los estados, y segun el

promedio de las celulas que pertenezcan a la vecindad y tomando la parte entera se obtiene

el estado de la celula en la siguiente configuracion. Otra manera, usada en la modelacion de

circuitos y dispositivos electronicos para observar el movimiento de electrones en un circuito

con los siguientes cuatro estados y reglas:

Celulas vacıas Sin importar sus vecinas, se mantienen igual.

Cabeza del electron Ocupa el espacio de la celula conductor en el siguiente paso.

Cola del electron Ocupa el espacio de la cabeza del electron en el siguiente paso.

Conductores Se convierte en cabeza del electron si una o dos celulas de la vecindad

son cabezas de electron, caso contrario se mantiene como conductor.

Conociendo un poco mas sobre las reglas semitotalısticas, iniciaremos con la generacion de

musica mediante automatas celulares; tendremos en cuenta reglas semitotalısticas y automa-

tas celulares sobre Z.

4. Automatas celulares y musica

El objetivo de esta seccion es relacionar la idea de automata celular con la generacion de

musica, para esto haremos uso de el software Mathematica 8, por ende debemos conocer los

comandos usados por el programa para la generacion de sonidos y probaremos con diferentes

configuraciones iniciales y programaciones distintas para mejorar las piezas musicales.

4.1. Musica con automatas lineales

Empezaremos con el caso mas sencillo de generacion de piezas musicales que es con automa-

tas celulares lineales. Para cumplir el objetivo se debe conocer primero los cuerpos de los

comandos que se usaran en el software Mathematica para la evolucion de los automatas

celulares y para la produccion del sonido. Mathematica tiene un programa predeterminado

llamado CellularAutomaton, este comando permite ver la evolucion de la condicion ini-

cial, a partir de matrices, dado el numero de pasos que se desea conocer la evolucion del

mismo. El cuerpo de este programa es:

CellularAutomaton[Regla,Condicion Inicial,Numero de generaciones]

Cada uno de estos datos se debe indicar de la siguiente manera.

Regla: En esta parte debemos indicar el numero de Wolfram que representa la regla

en notacion decimal. La informacion aquı suministrada se puede escribir de diferentes

maneras segun el numero de estados y la longitud de las vecindades. La tabla 4-1

contiene la informacion mas detallada de las posibles opciones que el software admite

en el caso de automatas lineales.

INSTRUCCIONES INFORMACION # Reglas

n Regla n−esima con vecindades de radio 1 y 2 estados. 256

{n, k} Regla n−esima con vecindades de radio 1 y k estados. kk3

{n, k, r} Regla n−esima con vecindades de radio r y k estados. kk2r+1

Cuadro 4-1.: Instrucciones comandos Mathematica

4.1 Musica con automatas lineales 23

Condicion inicial: En esta parte se debe colocar el vector (caso lineal) al cual le

sera aplicada la regla de evolucion elegida. Se debe tener en cuenta que los elementos

que van a estar en la matriz deben pertenecer al conjunto {0, 1, · · · , k − 1} si se va a

analizar la evolucion con k estados, en el caso de elegirse uno o mas estados el software

mostrara un error de evolucion.

Evolucion: El numero que se indique en esta seccion determina el numero de veces

que se aplicara recursivamente la funcion de evolucion asociado al numero de Wolfram

sobre el vector descrito en la casilla de condicion inicial.

Una vez los tres datos son incluidos dentro del cuerpo del comando CellularAutomaton,

el software genera una matriz con tantas columnas como posee el vector original y tantas

filas como el sucesor del numero escrito en la casilla de evolucion. Por ejemplo, si se escri-

be CellularAutomaton[{14764, 3, 2}, {0, 2, 2, 1, 2, 0, 0, 0}, 10}] , va a generar una lista de 11

vectores que muestran las siguientes diez generaciones del vector {0, 2, 2, 1, 2, 0, 0, 0} segun

la regla 14764 de 3243 reglas en total. Una manera sencilla de apreciar la evolucion es grafica-

mente y para ello, Mathematica tiene el comando ArrayPlot el cual genera una cuadrıcula

a partir de una matriz, y asigna a cada estado un color, de manera predeterminado cuando

hay mas de dos estados se asigna en una escala de grises pero si se desea se puede asignar

el color a cada estado segun se desee, para el siguiente ejemplo se van a usar los colores que

aparecen a continuacion:

ESTADO → COLOR

0 → BLANCO

1 → AZUL

2 → NEGRO

Cuadro 4-2.: Convencion colores del automata

Para lograr que el programa asuma estos colores se debe usar dentro del cuerpo del comando

ArrayPlot, la opcion ColorRules. Para el ejemplo que se desea visualizar la programacion

es la siguiente:

ArrayPlot[CellularAutomaton[{14764, 3, 2}, {0, 2, 2, 1, 2, 0, 0, 0}, 10], ColorRules

→ {0 → white, 1 → blue, 2 → black }].

Y el resultado es:

24 4 Automatas celulares y musica

Figura 4-1.: Regla 14764 del Automata Celular con 3 estados y vecindades de radio 2.

Mathematica permite crear sonidos digitales con diferentes comandos, el que sera usa durante

el trabajo es SoundNote, la razon para haberlo elegido es que este sistema trabaja dentro de su

cuerpo con las escalas en el sistema MIDI (que por sus siglas en ingles traduce Interfaz Digital

de Instrumentos Multimedia), y junto con esta notacion para escalas musicales tambien tiene

su propio sistema con numeros enteros como se muestra en la imagen 4-2.

Los programas que se van a desarrollar durante el trabajo van a ser un su mayorıa inter-

activos, de esta manera sin realizarle modificaciones a la codificacion del mismo se puede

experimentar y obtener diferentes resultados. El ejemplo 1 para automatas celulares que

tiene la codificacion que aparece en el anexo A.1, el programa va a realizar la siguiente ope-

racion genera una matriz donde cada fila va a corresponder a cada etapa de evolucion del

automata iniciando desde la condicion inicial hasta el numero de pasos seleccionado. Acto

seguido empieza a elegir las columnas de izquierda a derecha, como en dicha columna existen

tantas componentes como pasos elegidos mas uno que equivale a la condicion inicial, esta solo

tiene 1 y 0 en cada componente usando esto se multiplica de manera invertida cada columna

con un vector que arranca en 1 y va hasta el numero consecutivo al total de pasos elegido; y

a cada uno de estos numeros se triplicara con el fin de separar las notas y lograr distinguir

los sonidos de notas adyacentes, sin embargo el software maximo admite entre su sistema de

notas para el comando SoundNote numeros entre −37 y 40 pero como el triple del numero

de columnas puede ser facilmente superar a 40 se va convertir cada numero a su equivalente

modulo 71 para que al restarle 34 se tenga en la lista de numeros en el rango aceptado por el

cuerpo del programa. Cuando ya se tiene la lista con los numeros en el rango aceptado solo se

van a tomar aquellas notas no nulas, para ello existe el comando DeleteCases que permite

borrar en una lista todos los datos que cumplan una caracterıstica comun, en este caso los

valores nulos seran removidos de la lista y el resto generaran el sonido en cada decima de

segundo; por ultimo va la condicion inicial el cual es un vector de 5 componentes con 0 o 1

en cada uno de ellos. Al ejecutar el programa la ventana que aparecera se puede observar en

la imagen 4-3

4.1 Musica con automatas lineales 25

Figura 4-2.: Asociacion de las notas del piano con el sistema MIDI y la notacion de

Mathematica.


Figura 4-3.: Ventana ejemplo 1 automatas celulares lineales. Regla:150, Numero de pasos:

20, Condicion inicial: (1, 0, 1, 0, 1)

En la parte superior se puede elegir entre una de las seis reglas propuestas, se eligieron estas

seis por su comportamiento caotico ,y entre 20, 30 y 40 pasos segun la longitud del sonido

que se desee escuchar, para finalizar aparece una grilla con cinco cajas donde se puede dar

click para intercambiar entre el estado 0 o 1 a cada una y de esa manera elegir la condicion

inicial por la cual el celular va a evolucionar. El programa ejecuta simultaneamente el sonido

y la imagen que muestra la evolucion del automata de la manera indicada anteriormente,

cada vez que se realice una modificacion a alguno de los datos el programa vuelve a correr.

El proximo programa realizara el mismo proceso pero con tres automatas lineales que tendran

una condicion inicial independiente y con la posibilidad de desplazar la condicion inicial una

de la otra. Sin embargo todos van a tener la misma regla, el mismo numero de pasos para

su evolucion y a diferencia del anterior se puede seleccionar entre tres instrumentos para

escuchar diferentes melodıas. La programacion se encuentra en el anexo A.2. La ventana que

el programa muestra cuando es ejecutado se muestra en la imagen 4-4 Este ejemplo permite

mayor interaccion con el usuario, en el se pueden modificar las reglas y el numero de pasos

al igual que en el ejemplo 1, pero ademas se puede seleccionar cual de los tres instrumentos

predeterminados Tuba, Guitarra o Piano, ademas se puede seleccionar con cuantas matrices

se desea trabajar simultaneamente, de manera predeterminada se encuentra el valor 1. Los

siguientes recuadros van a desplegar tantas filas como se elija el valor de numero de matrices,

para el ejemplo de la imagen 4-4 se selecciono tres matrices y por ende aparecen tres filas en

4.2 Musica con automatas 2−dimensionales 27

Figura 4-4.: Ventana ejemplo 2 automatas celulares lineales. Regla:18, Numero de pasos: 40

la seccion de ubicacion de los automatas y condiciones iniciales. Al igual que en el ejemplo 1,

la matriz de condiciones iniciales se puede modificar dando click en cada recuadro, lo nuevo

son las barras de ubicacion que permiten separar las condiciones iniciales tantos cuadros

como se desee.

El ultimo ejemplo de casos lineales se basa en el anterior, la diferencia es que en este ejemplo

van a sonar tres instrumentos de manera simultanea con reglas de evolucion independientes

y con la opcion de separar cada condicion inicial del anterior. Cada automata tendra un

color propio y seran los siguientes: Tuba con color amarillo, Guitarra con color azul y Piano

con color rojo. Pero no son los unicos colores que aparecen en el sistema, basandose en

las combinaciones de la escala cromatica si suenan en la misma nota al mismo instante

los instrumentos Guitarra y Tuba el cuadrado aparecera de color verde, Guitarra y Piano

morado, Piano y Tuba naranja, y si suenan los tres el color sera negro, ası es posible visualizar

en que ocasiones estan sonando cada uno de los instrumentos. El codigo de este programa

se encuentra en el anexo A.3.

4.2. Musica con automatas 2−dimensionales

Al trabajar en 2 dimensiones, la cantidad de reglas que se pueden elegir es muchısimo mas

alta y la interaccion entre notas agudas y graves es mucho mayor, por ende la produccion

en este caso es muchısimo mas enriquecedora. Una herramienta que vamos a usar en la gran

mayorıa de los ejemplos en dos dimensiones, es la matriz 4-1. La llamaremos, la matriz de

sonido y simplemente es una matriz de tamano 7× 7, para un solo instrumento donde cada


Figura 4-5.: Ventana ejemplo 3 automatas celulares lineales. Tres reglas de evolucion distin-

tas, con 30 evoluciones y condiciones iniciales diferentes

columna indicara la letra de la nota que va a sonar {C,D,E, F,G,A} y cada fila tendra un

numero del 0 al 6, para que cada espacio del arreglo simbolice una unica nota.

C0 D0 E0 F0 G0 A0 B0

C1 D1 E1 F1 G1 A1 B1

C2 D2 E2 F2 G2 A2 B2

C3 D3 E3 F3 G3 A3 B3

C4 D4 E4 F4 G4 A4 B4

C5 D5 E5 F5 G5 A5 B5

C6 D6 E6 F6 G6 A6 B6

(4-1)

La idea es correr sobre esta matriz un automata bidimensional con multiples estados y se

elegiran una cierta cantidad de notas segun se elija en la ventana del programa, con el fin

que el sonido emitido en cada instante este controlado. A diferencia del caso lineal, en este

caso se va a tomar diferentes tipos de vecindades, esto va a ocasionar que algunos programas

sean muy extensos ya que Mathematica no trabaja con vecindades de Von Neumann. En los

dos primeros ejemplos se va a tomar dos posibles estados, de tal manera que aquellos lugares

donde la casilla sea 1 van a ser elegidos y de ellos una cantidad va a sonar, estos valores

seran tomados aleatoriamente por el programa. Aquı ya no es posible visualizar durante la

evolucion los estados anteriores debido a que el software cuando trabaja con evolucion en 3D

se torna muy lento, lo que se va a observar es cada estado en cada decima de segundo que

dure la evolucion. La imagen 4-6 muestra la ventana que se despliega cuando el programa

es ejecutado.


Figura 4-6.: Ventana ejemplo 1 automatas celulares bidimensionales.

El codigo de este ejemplo se encuentra en el anexo B.1. Esta ventana despliega diferentes

pestanas interactivas que se explican a continuacion:

Numero de pasos: indica cuantas veces evoluciona el automata segun la regla indicada.

Numero de notas a tomar: selecciona del total de notas con estado 1 el numero de

notas que se deseen escuchar. Se pueden elegir desde 5 hasta 10. (Ver imagen superior

izquierda tabla 4-3)

Eleccion de regla: se encuentran tres opciones para la eleccion de la regla:

• Predeterminados: son seis opciones de reglas que el computador elije aleatoria-

mente. (Ver imagen superior derecha tabla 4-3)

• Escribir regla: permite digitar el numero decimal de la regla de evolucion. (Ver

imagen inferior izquierda tabla 4-3)

• Aleatoria: si se desea elegir otra regla diferente a las del casos Predeterminados,

el software elije otra regla.(Ver imagen inferior derecha tabla 4-3)

Regla primer automata: en cada caso de los anteriores se despliega una forma diferente

para la eleccion de la regla de evolucion.

Condicion inicial: es una matriz de tamano 7 × 7 a la cual se le puede cambiar cada

componente entre el valor 1 y 0 dando click en cada recuadro.


Cuadro 4-3.: Ventanas interactivas para el ejemplo 1 de automatas celulares bidimensionales.

El siguiente ejemplo solamente cambiara en la forma como se estan tomando las vecindades,

en el caso anterior las vecindades son de Moore de radio 1 y ahora seran de Von Neumann.

El problema radica en que Mathematica no trabaja con vecindades de Von Neumann, lo que

realiza el programa es ver esta vecindad bidimensional como una vecindad de un automata

lineal de radio 2, ambos casos van a tener el mismo numero de reglas de evolucion por lo

cual la programacion para el caso de Von Neumann consiste en tomar en cada estado cada

vecindad de Von Neumann, convertirla en una lineal, y simplemente devolver el valor al cual

evoluciono la celula central, y repetir este proceso para cada celula teniendo en cuenta que

sobre la frontera las celulas adyacentes faltantes seran tomadas con estado 0. La imagen 4-7

muestra mas claramente como se realizara la eleccion de la misma.

La programacion para las vecindades de Von Neumann se encuentra en el anexo B.3. Y

despliega la ventana que se muestra en la imagen 4-8. Otro ejemplo para el caso bidimensional

consiste en aumentar el numero de estados de 2 a 4, los no nulos representaran diferentes

instrumentos y la idea es que trabajando sobre una matriz de tamano 7 × 7 con entradas

en Z4 va a sonar la nota de la posicion (i, j) con el instrumento indicado por la componente

ai,j. La tabla 4-5 muestra la asignacion de estados, colores e instrumentos que se usara para

los siguientes ejemplos. La ventana es la misma de los ejemplos anteriores salvo la seccion

donde se selecciona la condicion inicial, para estos casos el estado 1 siempre sera un check,


Figura 4-7.: Biyeccion entre la vecindad de Von Neumann y un automata celular lineal

si se desea cambiar a otro estado se debe seguir dando click sobre el cuadro aun cuando este

siempre aparezca relleno, para seleccionar la condicion inicial que se desea se puede observar

en la matriz grafica como ira cambiando el color en ella. La ventana que se despliega en este

ejemplo se puede visualizar en la imagen 4-9.

Figura 4-8.: Ejemplo 1 de automatas bidimensionales con vecindades de Von Neumann

Otro ejemplo para el caso bidimensional consiste en aumentar el numero de estados de 2 a

4, los no nulos representaran diferentes instrumentos y la idea es que trabajando sobre una

matriz de tamano 7 × 7 con entradas en Z4 va a sonar la nota de la posicion (i, j) con el

instrumento indicado por la componente ai,j . La tabla 4-4 muestra la asignacion de estados,

colores e instrumentos que se usara para los siguientes ejemplos. La ventana es la misma de

los ejemplos anteriores salvo la seccion donde se selecciona la condicion inicial, para estos

casos el estado 1 siempre sera un check, si se desea cambiar a otro estado se debe seguir

dando click sobre el cuadro aun cuando este siempre aparezca relleno, para seleccionar la

condicion inicial que se desea se puede observar en la matriz grafica como ira cambiando el


color en ella. La ventana que se despliega en este ejemplo se puede visualizar en la imagen

4-9. El codigo de este ejemplo se encuentra en el anexo B.2.

Estado Instrumento Color

1 Piano Amarillo

2 Guitarra Azul

3 Violin Rojo

Cuadro 4-4.: Lista de asignaciones para el caso de 4 estados.

Figura 4-9.: Ejemplo 2 de automatas bidimensionales con vecindades de Moore

Notese que en la imagen 4-9 se puede visualizar la condicion inicial y compararla con la

matriz donde se da click en cada cuadrado para cambiar de estado, de allı que tanto los

elementos en las posiciones (2, 1) y (2, 2) tengan el cuadro relleno en la matriz pero en la

parte grafica cada una representa estados diferentes (3 y 2 respectivamente). Para el caso

con vecindades de Von Neumann la programacion se encuentra en el anexo B.4. Un ejemplo

de la ventana que este despliega es 4-10:

4.3 Automatas celulares con reglas semitotalısticas 33

Figura 4-10.: Ejemplo 2 de automatas bidimensionales con vecindades de Von Neumann

4.3. Automatas celulares con reglas semitotalısticas

Cuando se habla de automatas multidimensionales no se puede pasar por alto el trabajo

realizado por John Conway sobre reglas semitotalısticas y en especial con el juego de la vida.

Los siguientes ejemplos van a trabajar con vecindades de Von Neumann, en cada caso se

puede elegir las condiciones de evolucion para la regla semitotalıstica. Es importante observar

que influye muchısimo la eleccion de los intervalos de nacimiento y supervivencia sobre la

condicion inicial. En la tabla 4-5 se puede ver la evolucion de la misma condicion inicial

usando Game of Life y HighLife.

El siguiente ejemplo se fundamenta en lo hecho anteriormente para automatas bidimensio-

nales, se va a elegir como condicion inicial una matriz de tamano 7× 7 con solo dos posibles

estados y evolucionara segun la regla semitotalıstica, de manera predeterminada el programa

iniciara con el juego de la vida, pero se puede seleccionar tambien HighLife o personalizarlo

con los valores que se deseen trabajar para la evolucion. La programacion que despliega el

codigo de este programa que se encuentra en el anexo C.1 muestra la ventana de la imagen

4-11. En la parte superior se puede elegir el numero de veces que se desea aplicar la regla se-

mitotalıstica a la condicion inicial, cuantas notas se desean elegir que suenen en cada instante

y la regla de evolucion, cuando se eligen las pestanas de Game of Life y HighLife muestran

las condiciones de evolucion con las que trabaja en cada caso siguiendo el orden dado en

el capıtulo 3 (Mınimo de sobrevivencia, Maximo de Sobrevivencia, Menor de nacimiento y

Mayor de nacimiento). El codigo de este programa fue creado completamente y no se basa

en un comando existente. Cuando se elije la opcion de Personalizada, se despliega una lista

de ventanas donde se puede modificar cada uno de los valores de sobrevivencia y nacimiento


Comparacion reglas semitotalısticas

Juego de la Vida R(2,3,3,3) HighLife R(2,3,3,6)

Estado Inicial Estado Inicial

Quinta Evolucion Quinta Evolucion

Decima Evolucion Decima Evolucion

Decima Quinta Evolucion Decima Quinta Evolucion

Vigesima Evolucion Vigesima Evolucion

Cuadro 4-5.: Cuadro comparativo de evoluciones entre Game of Life y Highlife


Figura 4-11.: Ventana ejemplo 1 de Reglas Semitotalısticas

como se muestra en la figura 4-12

El proximo ejemplo consiste en realizar el mismo proceso que el anterior con la diferencia

que al elegir las notas, se va a elegir uno de tres instrumentos: Tuba, Guitarra y Piano para

sonar con las notas que son elegidas aleatoriamente, se puede visualizar en la imagen 4-13.

La diferencia entre los dos ejemplos se puede ver en el codigo del programa que esta en el

anexo C.2.

Por ultimo, el siguiente ejemplo para lograr ver como los ejemplos anteriores se debe contar

con una computadora con alto rendimiento de no ser ası simplemente se escuchara el audio

y luego se podra visualizar la evolucion grafica del mismo. Este ejemplo consiste en tomar

una condicion inicial de tamano 21 × 21, donde cada submatriz cuadrada de tamano 7 × 7

representara las notas para cada instrumento de nueve posible. La tabla 4-6 muestra como

seran las posiciones de los instrumentos en cada submatriz.

Guitarra Piano Saxo Alto

Arpa Bajo Saxo Tenor

Tuba Flauta Sitar

Cuadro 4-6.: Ubicacion de instrumentos por bloques en matriz 21× 21

La ventana que va a aparecer cuando se ejecute el programa cuyo codigo aparece en el

anexo C.3, es el de la imagen 4-14. En esta ocasion no aparecen las casillas de HighLife y


Figura 4-12.: Ventanas regla de evolucion personalizada

Game of Life por cuestiones de rendimiento ya que cada uno de estos elementos disminuye

el rendimiento de la computadora. Al igual que en los dos primeros ejemplos solo se van a

elegir un numero determinado de notas sobre el total, esto con el fin de no generar un sonido

muy grave.

Sistemas L-lineales

Como unidad adicional, se va a realizar un ejemplo de sonidos pero en otro contexto como lo

son los sistemas L-lineales. La idea de estos es iniciar con una figura bidimensional y aplicar

recurrentemente la regla del L-sistema tal y como lo realiza un automata celular, la unica

diferencia es que el primero no trabaja sobre un conjunto discreto. Un ejemplo de estas reglas

es conocida como las palabras de Fibonacci. Cada palabra de Fibonacci es una sucesion de

movimientos en alguno de las direcciones del plano: arriba, abajo, derecha o izquierda. La

idea para generar este tipo de sonidos usando este metodo consiste en la escritura del sistema

MIDI para cada nota, se toma como nota inicial C0 que es posible expresar como (C, 0). El

vector de movimiento indica cual sera la siguiente nota. La tabla 4-7 muestra cual sera el

cambio que cada nota va a sufrir segun su movimiento.

Se debe tener en cuenta que esta forma es cıclica es decir despues del 6 vendrıa el 0, y

despues de la G vendrıa la A. Siguiendo estas reglas se creara una sucesion de sonidos que se

escucharan con una duracion de 1 decima de segundo. La programacion que permite lograr

este sonido se encuentra en el anexo D, la imagen 4-15 muestra la ventana que se crea

al correr el programa. Este ejemplo es muy sencillo y el unico valor con el cual se puede

interactuar es con el numero de la Palabra que se desee escuchar.



Sentido Cambio de Nota Ejemplo

Derecha Aumenta el numero de la nota C0 → C1

Arriba Avanzo a la siguiente letra en la nota D2 → E2

Izquierda Disminuye el numero de la nota E5 → E4

Abajo Retrocedo a la anterior letra en la nota B6 → A6

Cuadro 4-7.: Evolucion de las notas segun el movimiento que realizan



Figura 4-15.: Ventana ejemplo palabras de Fibonacci

5. Conclusiones y recomendaciones

5.1. Conclusiones

La aplicacion de los automatas celulares en diferentes campos del conocimiento ha ido in-

crementando por su simplicidad, que conlleva en ocasiones a comportamientos difıciles de

simular con otro tipo de funciones, en el caso de la produccion musical genera piezas intere-

santes que en ocasiones se destacan por sonidos periodicos pero extranos. Ademas:

Los automatas lineales generan piezas caoticas con mayor facilidad pero su sonido no

es muy agradable cuando solo se usa un instrumento y todas las notas. Lo mejor es

tomar notas separadas en la escala musical ya que es mas evidente el comportamiento

del mismo.

Los automatas dos dimensionales tienden a generar sonidos mas fuertes debido a la

gran cantidad de notas que pueden sonar simultaneamente. En estos casos es mejor

introducir una funcion que seleccione algunas notas aleatoriamente para que se puedan

distinguir diferentes tonos.

Las reglas semitotalısticas son la mejor opcion para la generacion de sonidos armoni-

cos, debido a que controla la sobrepoblacion de celulas vivas en cada generacion, el

inconveniente es el tamano que se necesita para producir patrones como gliders que

mantengan la dinamica del automata.

5.2. Recomendaciones

El estudio de los automatas celulares ha ido generando gran importancia a nivel de investi-

gacion en matematica tanto teorica como aplicada, sin embargo es muchısima la cantidad de

preguntas que se encuentran abiertas en estas areas, y se muestran como inquietud en este

trabajo. A partir de este punto se pueden desarrollar otras investigaciones relacionadas con:

Identificacion de reglas con comportamientos caoticos en automatas bidimensionales.

Implicacion de la caracterıstica del automata celular (reversible, lineal, afın, etc.) en el

comportamiento caotico de los sistemas.

40 5 Conclusiones y recomendaciones

Generacion de sonidos mediante automatas que se retroalimenten de informacion de

otros automatas, y como esto puede encadenar mejores resultados de producciones de

sonidos digitales.

A. Codigos de programacion para

automatas lineales

A continuacion se muestran los codigos usados en la generacion de los programas y se realiza

una breve explicacion de su funcionamiento, se debe tener en cuenta que dicho codigo solo

es funcional en el software Mathematica:

A.1. Sonido Automata Celular Lineal 1

Ejemplo que permite cambiar los valores de un vector de cinco componentes que servira como

dato inicial para diferentes reglas.

Manipulate [

Animate [ ArrayPlot [

Transpose [

Table [ I f [ i < t + 1 ,

Cel lularAutomaton [ Regla ,{ data [ [ 1 ] ] , 0 } , Pasos ] [ [ Al l , i ] ] ,

Table [ 0 ,{ j , Pasos +1} ] ] ,

{ i , Dimensions [ Cel lularAutomaton [ Regla ,{ data [ [ 1 ] ] , 0 } , Pasos ] ] [ [ 2 ] ] } ] ] ] ,

{t , Dimensions [ Cel lularAutomaton [ Regla ,{ data [ [ 1 ] ] , 0 } , Pasos ] ] [ [ 2 ] ] , 1 } ,

DefaultDurat ion −>

Dimensions [ Cel lularAutomaton [ Regla ,{ data [ [ 1 ] ] , 0 } , Pasos ] ] [ [ 2 ] ] ∗ . 1 ,

Animat ionRepet i t ions −> 1 , AnimationRunning −> True ] ,

{Regla , {18 , 30 , 50 , 60 , 90 , 150} , ControlType −> Se t t e r } ,

{Pasos , {20 , 30 , 40}} ,

De l imi ter ,

Item [ ” Condici on I n i c i a l ” , Alignment −> Center ] ,

{{data , RandomInteger [{0 , 1} , {3 , 5} ]} , ControlType −> None} ,

Dynamic [

Panel [

Grid [

Outer [

Checkbox [ Dynamic [ data [ [#1 , #2 ] ] ] , {0 , 1} ] &, Range [ 1 ] , Range [ 5 ] ]

]

42 A Codigos de programacion para automatas lineales

]

] ,

Dynamic [

EmitSound [

Sound [

SoundNote [

Mod[

DeleteCases [

3 Range [ Pasos + 1 ] Reverse [#] , 0 ] , 7 1 ] − 34 , . 1 ] & /@

Transpose [ Cel lularAutomaton [ Regla , {data [ [ 1 ] ] , 0} , Pasos ]

]

]

]

] ,

FrameLabel −> {”” , ”” , ”EJEMPLO 1”} ]


Version modificada del ejemplo 1 incluyendo eleccion de instrumentos, numero de condiciones

iniciales y separacion entre las mismas.

Sonido [ x ] := Switch [ x , ”Guitar ” , Red , ”Piano ” , Blue , ”Tuba” , Green ] ;

Manipulate [


Transpose [

Table [ I f [ i < t − Str ingLength [ Instrumento ] ,

Cel lularAutomaton [

Regla , {Take [{{ data [ [ 1 ] ] , {a }} , {data [ [ 2 ] ] , {b}} , {data [ [

3 ] ] , {c }}} , h ] , 0} , Pasos ] [ [ Al l , i ] ] ,

Table [ 0 , { j , Pasos + 1 } ] ] , { i ,

Dimensions [


Regla , {Take [{{ data [ [ 1 ] ] , {a}} , {data [ [ 2 ] ] , {b}} , {data [ [

3 ] ] , {c }}} , h ] , 0} , Pasos ] ] [ [ 2 ] ] } ] ] ,

ColorRules −> {1 −> Sonido [ Instrumento ] , 0 −> White } ] , {t ,

1 + Str ingLength [ Instrumento ] ,

Dimensions [



3 ] ] , {c }}} , h ] , 0} , Pasos ] ] [ [ 2 ] ] +

A.3 Sonido Automata Celular Lineal 3 43

Str ingLength [ Instrumento ] , 1} ,


Dimensions [



3 ] ] , {c }}} , h ] , 0} , Pasos ] ] [ [ 2 ] ] ∗ . 1 ,

Animat ionRepet i t ions −> 1 ,

AnimationRunning −> True ] , {Regla , {18 , 30 , 50 , 60 , 90 , 150} ,

ControlType −> Se t t e r } , {Pasos , {20 , 30 ,

40}} , { Instrumento , {”Tuba” , ”Piano ” , ”Guitar ”}} , {{data ,

RandomInteger [{0 , 1} , {3 , 5} ]} ,

ControlType −> None} , {{h , 1 , ”Numero de Matr ices ”} , 1 , 3 , 1 ,

ControlType −> Se t t e r } , De l imi ter ,

Item [ ” Ubicaci on de l o s automatas ” , Alignment −> Center ] ,

Dynamic [ Panel [

Grid [ Take [{{” Lo ca l i z a c i o n cond i c i o n 1” ,

S l i d e r [ Dynamic [ a ] , {−12, 12 , 1} ] ,

Dynamic [ a ]} , {” Lo ca l i z a c i o n cond i c i o n 2” ,

S l i d e r [ Dynamic [ b ] , {−12, 12 , 1} ] ,

Dynamic [ b ]} , {” Lo ca l i z a c i o n cond i c i o n 3” ,

S l i d e r [ Dynamic [ c ] , {−12, 12 , 1} ] , Dynamic [ c ]}} , h ] ] ] ] ,

De l imi ter , Item [ ” Condic iones i n i c i a l e s ” , Alignment −> Center ] ,

Dynamic [ Panel [

Grid [ Outer [ Checkbox [ Dynamic [ data [ [#1 , #2 ] ] ] , {0 , 1} ] &, Range [ h ] ,

Range [ 5 ] ] ] ] ] ,

Dynamic [ EmitSound [

Sound [ SoundNote [

Mod[ DeleteCases [ 3 Range [ Pasos + 1 ] Reverse [#] , 0 ] , 7 1 ] −

34 , . 1 , ToString [ Instrumento ] ] & /@

Transpose [



3 ] ] , {c }}} , h ] , 0} , Pasos ] ] ] ] ] ,



Modificacion ejemplo 2 con la opcion de escuchar diferente numero de instrumentos, cada

uno con su condicion inicial independiente, regla de evolucion y separacion de los mismos.


Completar [ x , i I n t e g e r , j I n t e g e r ] :=

Module [{ z = Dimensions [ x ] [ [ 2 ] ] } ,

Transpose [

Table [ I f [ k <= i | | k > z + i , Table [ 0 , { l , Dimensions [ x ] [ [ 1 ] ] } ] ,

x [ [ Al l , k − i ] ] ] , {k , Dimensions [ x ] [ [ 2 ] ] + i + j } ] ] ]

Suma [ x , y , i I n t e g e r ] :=

Module [{ x0 = Dimensions [ x ] [ [ 2 ] ] , y0 = Dimensions [ y ] [ [ 2 ] ] } ,

I f [ x0 >= y0 , Completar [ x , 0 , i ] + Completar [ y , x0 + i − y0 , 0 ] ,

Completar [ x , y0 + i − x0 , 0 ] + Completar [ y , 0 , i ] ] ]

Manipulate [

Animate [ Module [{ x = {CellularAutomaton [ a [ [ 1 ] ] , {data [ [ 1 ] ] , 0} , n ] ,

Suma [ Cel lularAutomaton [ a [ [ 1 ] ] , {data [ [ 1 ] ] , 0} , n ] ,

3∗CellularAutomaton [ a [ [ 2 ] ] , {data [ [ 2 ] ] , 0} , n ] , b [ [ 1 ] ] ] ,

Suma [5∗ CellularAutomaton [ a [ [ 3 ] ] , {data [ [ 3 ] ] , 0} , n ] ,



b [ [ 2 ] ] ] } } ,

ArrayPlot [

Transpose [

Table [ I f [ i < t + 1 , x [ [ k ] ] [ [ Al l , i ] ] , Table [ 0 , { j , n + 1 } ] ] , { i ,

Dimensions [ x [ [ k ] ] ] [ [ 2 ] ] } ] ] ,

ColorRules −> {1 −> Yellow , 3 −> Blue , 4 −> Green , 5 −> Red ,

6 −> Orange , 8 −> Purple , 9 −> Black } ] ] , {t , 1 ,

Which [ k == 1 ,

Dimensions [ Cel lularAutomaton [ a [ [ 1 ] ] , {data [ [ 1 ] ] , 0} , n ] ] [ [ 2 ] ] ,

k == 2 , Dimensions [


3∗CellularAutomaton [ a [ [ 2 ] ] , {data [ [ 2 ] ] , 0} , n ] , b [ [ 1 ] ] ] ] [ [ 2 ] ] ,


Suma [5∗ CellularAutomaton [ a [ [ 3 ] ] , {data [ [ 3 ] ] , 0} , n ] ,



b [ [ 2 ] ] ] ] [ [ 2 ] ] ] , 1} ,


Which [ k == 1 ,

Dimensions [ Cel lularAutomaton [ a [ [ 1 ] ] , {data [ [ 1 ] ] , 0} , n ] ] [ [ 2 ] ] ,




3∗CellularAutomaton [ a [ [ 2 ] ] , {data [ [ 2 ] ] , 0} , n ] , b [ [ 1 ] ] ] ] [ [ 2 ] ] ,

k == 3 ,

Dimensions [

Suma[5∗ CellularAutomaton [ a [ [ 3 ] ] , {data [ [ 3 ] ] , 0} , n ] ,



b [ [ 2 ] ] ] ] [ [ 2 ] ] ] ∗ . 1 , Animat ionRepet i t ions −> 1 ,

AnimationRunning −> True ] , {{n , 20 , ”Numero de Pasos ”} , {20 , 30 ,

40}} , {{k , 2 , ”Numero de Instrumentos ”} , {1 , 2 , 3}} , De l imi ter ,

Item [ ” Reglas de cada automata ” ,

Alignment −> Center ] , {{a , {30 , 30 , 30}} ,

ControlType −> None} , {{b , {10 , 10}} ,

ControlType −> None} , {{data , RandomInteger [{0 , 1} , {3 , 5} ]} ,

ControlType −> None} ,

Dynamic [ Panel [

Grid [ Take [{{” Regla primer automata ” ,

PopupMenu [

Dynamic [ a [ [ 1 ] ] ] , {18 , 30 , 50 , 60 , 90 ,

150} ]} , {”Regla segundo automata ” ,

PopupMenu [

Dynamic [ a [ [ 2 ] ] ] , {18 , 30 , 50 , 60 , 90 ,

150} ]} , {”Regla t e r c e r o automata ” ,

PopupMenu [ Dynamic [ a [ [ 3 ] ] ] , {18 , 30 , 50 , 60 , 90 , 150} ]}} ,

k ] ] ] ] , De l imi ter ,

Item [ ” Movimiento ent r e l o s automatas ” , Alignment −> Center ] ,

Dynamic [ Panel [

Grid [ Take [{{” D i s tanc i a ent r e automatas 1 y 2” ,

S l i d e r [ Dynamic [ b [ [ 1 ] ] ] , {0 , 30 , 5} ] ,

Dynamic [ b [ [ 1 ] ] ] } , {”D i s tanc i a ent r e automatas 2 y 3” ,

S l i d e r [ Dynamic [ b [ [ 2 ] ] ] , {0 , 30 , 5} ] , Dynamic [ b [ [ 2 ] ] ] } } ,

k − 1 ] ] ] ] ,

Dynamic [ Panel [

Grid [ Outer [ Checkbox [ Dynamic [ data [ [#1 , #2 ] ] ] , {0 , 1} ] &, Range [ k ] ,

Range [ 5 ] ] ] ] ] ,


Sound [ Take [{ Sound [

SoundNote [

Mod[ DeleteCases [ 3 Range [ n + 1 ] Reverse [#] , 0 ] , 7 1 ] − 34 , . 1 ,

ToString [ ”Tuba ” ] ] & /@

Transpose [


Cel lularAutomaton [ a [ [ 1 ] ] , {data [ [ 1 ] ] , 0} ,

n ] ] , {Max[{ Dimensions [

Cel lularAutomaton [ a [ [ 1 ] ] , {data [ [ 1 ] ] , 0} , n ] ] [ [ 2 ] ] ,

Dimensions [ Cel lularAutomaton [ a [ [ 2 ] ] , {data [ [ 2 ] ] , 0} , n ] ] [ [

2 ] ] ,


2 ] ] } ] ∗ . 1 −


2 ] ] ∗ . 1 ,

Max[{ Dimensions [



2 ] ] , Dimensions [

Cel lularAutomaton [ a [ [ 2 ] ] , {data [ [ 2 ] ] , 0} , n ] ] [ [

2 ] ] } ] ∗ . 1 } ] ,

Sound [ SoundNote [


ToString [ ” Guitar ” ] ] & /@

Transpose [







2 ] ] } ] ∗ . 1 −


2 ] ] ∗ . 1 + b [ [ 1 ] ] ∗ . 1 ,

Max[{ Dimensions [



2 ] ] ,


2 ] ] } ] ∗ . 1 + b [ [ 1 ] ] ∗ . 1 } ] ,

Sound [ SoundNote [


ToString [ ” Piano ” ] ] & /@

Transpose [








2 ] ] } ] ∗ . 1 −


2 ] ] ∗ . 1 + b [ [ 1 ] ] ∗ . 1 + b [ [ 2 ] ] ∗ . 1 ,

Max[{ Dimensions [





2 ] ] } ] ∗ . 1 + b [ [ 1 ] ] ∗ . 1 + b [ [ 2 ] ] ∗ . 1 } ] } , k ] ] ] ] ,


B. Codigos para automatas

2−dimensionales

En estos casos se debe tener en cuenta para las vecindades de tipo Von Neumann una

programacion para realizar la biyeccion con los automatas lineales de radio 2. Para todos

los ejemplos es necesario incluir la matriz de sonido cuyas componentes poseen las notas

mostradas en la imagen. Su codigo es: Ahora se define la matriz de SONIDO1 como aquella

que guarda en sus componentes las combinaciones de notas por fila y columna como se

observa en la tabla.

SONIDO1 = {{”C0” , ”D0” , ”E0” , ”F0” , ”G0” , ”A0” , ”B0”} ,

{”C1” , ”D1” , ”E1” , ”F1” , ”G1” , ”A1” , ”B1”} ,

{”C2” , ”D2” , ”E2” , ”F2” , ”G2” , ”A2” , ”B2”} ,

{”C3” , ”D3” , ”E3” , ”F3” , ”G3” , ”A3” , ”B3”} ,

{”C4” , ”D4” , ”E4” , ”F4” , ”G3” , ”A4” , ”B4”} ,

{”C5” , ”D5” , ”E5” , ”F5” , ”G5” , ”A5” , ”B5”} ,

{”C6” , ”D6” , ”E6” , ”F6” , ”G6” , ”A6” , ”B6”}} ;

B.1. Ejemplo 1 vecindad de Moore

Para el ejemplo 1 con vecindades de Moore, la regla debe ser un numero menor a 229= 2512,

y la matriz debe tener tamano 7 × 7. Se va a definir la variable MOORE1 como 2512 y el

vector de Ejemplo1 como una lista de seis numeros que se encuentran entre 0 y MOORE1-1.

Los comandos son los siguientes:

MOORE1 = 2ˆ2ˆ(4∗1ˆ2 + 4∗1 + 1 ) ;

Ejemplo1 = Table [ RandomInteger [MOORE1] − 1 , { i , 6 } ] ;

Estas dos variables junto con la variable SONIDO1, se puede correr el siguiente programa:

Manipulate [


Cel lularAutomaton [{Regla , 2 , {1 , 1}} , data , p ] [ [ i ] ] ] , { i , 1 ,

p + data [ [ 1 , 1 ] ] ∗ 0 + Ins ∗0 + Regla ∗0 , 1} ,

DefaultDurat ion −> (p + 1 )∗ . 1 , Animat ionRepet i t ions −> 1 ,

AnimationRunning −> True ] , {{data , RandomInteger [{0 , 1} , {7 , 7} ]} ,

B.2 Ejemplo 2 vecindad de Moore 49

ControlType −> None} , De l imi ter , {{p , 50 , ”Numero de pasos ”} , {50 ,

60 , 70}} , {{ Ins , 5 , ”Numero de notas a tomar ”} , {5 , 6 , 7 , 8 , 9 ,

10}} , De l imi ter , Item [ ” Regla de evo luc i o n ” , Alignment −> Center ] ,

Item [ ” ” , Alignment −> Center ] , {{Conf , 1 ,

” E l ecc i o n de r eg l a ”} , {1 −> ”Predeterminados ” ,

2 −> ” E s c r i b i r r e g l a ” , 3 −> ” Alea to r i a ”}} ,

{{Regla , Ejemplo1 [ [ 1 ] ] } , ControlType −> None} ,

Dynamic [

Panel [

Which [ Conf == 1 ,

Grid [{{” Regla primer automata ” ,

PopupMenu [

Dynamic [ Regla ] , {Ejemplo1 [ [ 1 ] ] −> ”Ejemplo1 ” ,

Ejemplo1 [ [ 2 ] ] −> ”Ejemplo2 ” , Ejemplo1 [ [ 3 ] ] −> ”Ejemplo3 ” ,


Ejemplo1 [ [ 6 ] ] −> ”Ejemplo6 ”} ]}} ] , Conf == 2 ,

Grid [{{” Regla de l automata ” , InputF ie ld [ Dynamic [ Regla ] ] } } ] ,

Conf == 3 ,


Dynamic [ Regla =

RandomInteger [2ˆ2ˆ(4∗1ˆ2 + 4∗1 + 1) − 1 ] ] } } ] ] ] ] , De l imi ter ,


Dynamic [ Panel [

Grid [ Outer [ Checkbox [ Dynamic [ data [ [#1 , #2 ] ] ] , {0 , 1} ] &, Range [ 7 ] ,

Range [ 7 ] ] ] ] ] ,


Sound [ Table [

Sound [ RandomSample [

F la t ten [ Table [

SoundNote [SONIDO1 [ [ i , j ] ] , {(m − 1 )∗0 . 1 , m∗0 .1} ,

SoundVolume −>

CellularAutomaton [{ Regla , 2 , {1 , 1}} , data , p ] [ [m ] ] [ [ i ,

j ] ] ] , { i , 7} , { j , 7 } ] ] , Ins ] , {(m − 1 )∗ . 1 , m∗ . 1 } ] , {m, 1 ,

p , 1 } ] ] ] ] , FrameLabel −> {”” , ”” , ”EJEMPLO 1”} ]

B.2. Ejemplo 2 vecindad de Moore

Para el ejemplo 2 con vecindades de Moore, la regla debe ser un numero menor a 449, y

la matriz debe tener tamano 7 × 7. Para esto se definen como el ejemplo 1 las variables

50 B Codigos para automatas 2−dimensionales

MOORE2 como 449y Ejemplo 3 como una lista de numeros entre 0 y MOORE2-1.

MOORE2 = 4ˆ4ˆ(4∗1ˆ2 + 4∗1 + 1 ) ;

Ejemplo3 =Table [ RandomInteger [MOORE2] − 1 , { i , 6 } ] ;

Al igual que en el ejemplo 1, se debe incluir la matriz SONIDO1 para que el siguiente

programa funcione.

Manipulate [


Cel lularAutomaton [{Regla , 4 , {1 , 1}} , data , p ] [ [ i ] ] ,

ColorRules −> {0 −> White , 1 −> Yellow , 2 −> Blue , 3 −> Red} ] , { i ,

1 , p + data [ [ 1 , 1 ] ] ∗ 0 + Ins ∗0 + Regla ∗0 , 1} ,

DefaultDurat ion −> (p + 1 )∗ . 1 , Animat ionRepet i t ions −> 1 ,

AnimationRunning −> True ] , {{data , RandomInteger [{0 , 3} , {7 , 7} ]} ,


60 , 70}} , {{ Ins , 5 , ”Numero de notas a tomar ”} , {5 , 6 , 7 , 8 , 9 ,

10}} , De l imi ter , Item [ ” Regla de evo luc i o n ” , Alignment −> Center ] ,

Item [ ” ” , Alignment −> Center ] , De l imi ter , {{Conf , 1 ,

” E l ecc i o n de r eg l a ”} , {1 −> ”Predeterminados ” ,

2 −> ” E s c r i b i r r e g l a ” , 3 −> ” Alea to r i a ”}} ,

{{Regla , Ejemplo3 [ [ 1 ] ] } , ControlType −> None} ,

Dynamic [

Panel [

Which [ Conf == 1 ,


PopupMenu [




Ejemplo3 [ [ 6 ] ] −> ”Ejemplo6 ”} ]}} ] , Conf = 2 ,

Grid [{{” Regla primer automata ” , InputF ie ld [ Dynamic [ Regla ] ] } } ]

, Conf == 3 ,


Dynamic [ Regla = RandomInteger [MOORE2 − 1 ] ] } } ] ] ] ] , De l imi ter ,


Dynamic [ Panel [


Range [ 7 ] ] ] ] ] ,


Sound [ Table [


B.3 Ejemplo 1 Vecindad de Neumann 51

Flat ten [ Table [


SoundVolume −>

CellularAutomaton [{ Regla , 4 , {1 , 1}} , data , p ] [ [m ] ] [ [ i ,

j ] ] ] , { i , 7} , { j , 7 } ] ] , Ins ] , {(m − 1 )∗ . 1 , m∗ . 1 } ] , {m, 1 ,

p , 1 } ] ] ] ] , FrameLabel −> {”” , ”” , ”EJEMPLO 3”} ]

B.3. Ejemplo 1 Vecindad de Neumann

El programa principal necesita de las siguientes funciones que realizan la biyeccion de las

vecindades de Von Neumann con los automatas lineales con radio 2

REGLA1N1[Q , i I n t e g e r , j I n t e g e r , Regla ] :=

CellularAutomaton [{Regla , 2 , 2} , {Q[ [ i , j − 1 ] ] , Q [ [ i − 1 , j ] ] ,

Q [ [ i , j ] ] , Q [ [ i + 1 , j ] ] , Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ;

REGLA2N1[Q , i I n t e g e r , j I n t e g e r , p Integer , q In t ege r , Regla ] :=

Which [ i == 1 && j == 1 ,

Cel lularAutomaton [{Regla , 2 , 2} , {0 , 0 , Q[ [ i , j ] ] , Q [ [ i + 1 , j ] ] ,

Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

i == 1 && 1 < j < q ,

Cel lularAutomaton [{Regla , 2 , 2} , {Q[ [ i , j − 1 ] ] , 0 , Q[ [ i , j ] ] ,

Q [ [ i + 1 , j ] ] , Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

i == 1 && j == q ,

Cel lularAutomaton [{Regla , 2 , 2} , {Q[ [ i , j − 1 ] ] , 0 , Q[ [ i , j ] ] ,

Q [ [ i + 1 , j ] ] , 0} , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

1 < i < p && j == 1 ,

Cel lularAutomaton [{Regla , 2 , 2} , {0 , Q[ [ i − 1 , j ] ] , Q [ [ i , j ] ] ,

Q [ [ i + 1 , j ] ] , Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

1 < i < p && j == q ,

Cel lularAutomaton [{Regla , 2 , 2} , {Q[ [ i , j − 1 ] ] , Q [ [ i − 1 , j ] ] ,

Q [ [ i , j ] ] , Q [ [ i + 1 , j ] ] , 0} , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

i == p && j == 1 ,

Cel lularAutomaton [{Regla , 2 , 2} , {0 , Q[ [ i − 1 , j ] ] , Q [ [ i , j ] ] , 0 ,

Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

i == p && 1 < j < q ,


Q [ [ i , j ] ] , 0 , Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

i == p && j == q ,



Q[ [ i , j ] ] , 0 , 0} , 1 ] [ [ 2 ] ] [ [ 3 ] ] ] ;

EVON1[ Q , i I n t e g e r , j I n t e g e r , p Integer , q In t ege r , Regla ] :=

I f [ 1 < i < p && 1 < j < q , REGLA1N1[Q, i , j , Regla ] ,

REGLA2N1[Q, i , j , p , q , Regla ] ] ;

Regla3N1 [ x , Regla ] :=

Module [{n = 1 , m = 1 , P = x , z = Dimensions [ x ]} ,

While [ n <= z [ [ 1 ] ] ,

While [m <= z [ [ 2 ] ] ,

P [ [ n , m] ] = EVON1[ x , n , m, z [ [ 1 ] ] , z [ [ 2 ] ] , Regla ] ; m++] ; m = 1 ;

n++ ] ; P ] ;

AUTOMATADENEUMANNN1[ Regla , Matriz , Pasos ] :=

Module [{A = CellularAutomaton [ {Regla , 2 , {1 , 1}} , Matriz , Pasos ]} ,

For [ f = 1 , f < Pasos + 1 , f++;

A[ [ f ] ] = Regla3N1 [A [ [ f − 1 ] ] , Regla ] ] ; A ] ;

La siguiente funcion va a juntar la informacion de la evolucion del automata con las notas

correspondientes segun su estado.

Sonido [ x , y , z , t ] :=

Module [{A = AUTOMATADENEUMANNN1[ x , y , z ]} ,

EmitSound [

Sound [ Table [




SoundVolume −> A[ [m ] ] [ [ i , j ] ] ] , { i , 7} , { j , 7 } ] ] ,

t ] , {(m − 1 )∗ . 1 , m∗ . 1 } ] , {m, z + 1 } ] ] ] ] ;

Con los anteriores programas y definiendo NEUMANN1 como 232, y la lista ejemplos2 como

un vector con numeros entre 0 y NEUMANN1-1. Se puede ejectuar el codigo:

NEUMANN1 = 2ˆ2ˆ(2∗1ˆ2 + 2∗1 + 1 ) ;

Ejemplo2 = Table [ RandomInteger [NEUMANN1] − 1 , { i , 6 } ] ;

Manipulate [{ Sonido [ Regla , data , k , i n s ] ,

Animate [ ArrayPlot [AUTOMATADENEUMANNN1[ Regla , data , k ] [ [ l ] ] ] , { l , 1 ,

Det [ data ]∗0 + k + 1 , 1} , DefaultDurat ion −> (k + 1 )∗ . 1 ,


AnimationRunning −> True ]} , De l imi ter , {{k , 30 ,

”Numero de pasos : ”} , {30 , 40 , 50}} , {{ ins , 5 ,

”Numero de notas : ”} , {5 , 6 , 7 , 8 , 9 , 10}} ,

De l imi ter , Item [ ” Regla de evo luc i o n ” , Alignment −> Center ] ,


Item [ ” ” , Alignment −> Center ] , {{data ,

RandomInteger [{0 , 1} , {7 , 7} ]} , ControlType −> None} ,

{{Conf , 1 , ” E l ecc i o n de r eg l a ”} , {1 −> ”Predeterminados ” ,

2 −> ” Exc r i b i r r e g l a ” , 3 −> ” Alea to r i a ”}} , {{Regla , Ejemplo2 [ [ 1 ] ] } ,


Dynamic [

Panel [

Which [ Conf == 1 ,


PopupMenu [




Ejemplo2 [ [ 6 ] ] −> ”Ejemplo6 ”} ]}} ] , Conf == 2 ,

Grid [{{” Regla de l automata ” , InputF ie ld [ Dynamic [ Regla ] ] } } ] ,

Conf == 3 ,

Grid [{{” Regla de l automata ” ,

Dynamic [ Regla = RandomInteger [NEUMANN1 − 1 ] ] } } ] ] ] ] , De l imi ter ,


Dynamic [ Panel [


Range [ 7 ] ] ] ] ] , FrameLabel −> {”” , ”” , ”Ejemplo 2”} ]

B.4. Ejemplo 2 Vecindad de Neumann

Al igual que en el ejemplo 1 se necesita una serie de programas que difiere del anterior en el

numero de estados, el resto de valores son iguales. Asi que se define NEUMANN2 como 445

y Ejemplos4 como una lista de valores entre 0 y NEUMANN2-1.

NEUMANN2 = 4ˆ4ˆ(2∗2 + 1 ) ;

Ejemplo4 = Table [ RandomInteger [NEUMANN2] − 1 , { i , 6 } ] ;

REGLA1N2[Q , i I n t e g e r , j I n t e g e r , Regla ] :=

CellularAutomaton [{Regla , 4 , 2} , {Q[ [ i , j − 1 ] ] , Q [ [ i − 1 , j ] ] ,

Q [ [ i , j ] ] , Q [ [ i + 1 , j ] ] , Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ;

REGLA2N2[Q , i I n t e g e r , j I n t e g e r , p Integer , q In t ege r , Regla ] :=

Which [ i == 1 && j == 1 ,

Cel lularAutomaton [{Regla , 4 , 2} , {0 , 0 , Q[ [ i , j ] ] , Q [ [ i + 1 , j ] ] ,

Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,


i == 1 && 1 < j < q ,

Cel lularAutomaton [{Regla , 4 , 2} , {Q[ [ i , j − 1 ] ] , 0 , Q [ [ i , j ] ] ,

Q [ [ i + 1 , j ] ] , Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

i == 1 && j == q ,

Cel lularAutomaton [{Regla , 4 , 2} , {Q[ [ i , j − 1 ] ] , 0 , Q [ [ i , j ] ] ,

Q [ [ i + 1 , j ] ] , 0} , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

1 < i < p && j == 1 ,

Cel lularAutomaton [{Regla , 4 , 2} , {0 , Q [ [ i − 1 , j ] ] , Q [ [ i , j ] ] ,

Q [ [ i + 1 , j ] ] , Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

1 < i < p && j == q ,


Q [ [ i , j ] ] , Q [ [ i + 1 , j ] ] , 0} , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

i == p && j == 1 ,

Cel lularAutomaton [{Regla , 4 , 2} , {0 , Q [ [ i − 1 , j ] ] , Q [ [ i , j ] ] , 0 ,

Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

i == p && 1 < j < q ,


Q [ [ i , j ] ] , 0 , Q [ [ i , j + 1 ] ] } , 1 ] [ [ 2 ] ] [ [ 3 ] ] ,

i == p && j == q ,


Q [ [ i , j ] ] , 0 , 0} , 1 ] [ [ 2 ] ] [ [ 3 ] ] ] ;

EVON2[ Q , i I n t e g e r , j I n t e g e r , p Integer , q In t ege r , Regla ] :=

I f [ 1 < i < p && 1 < j < q , REGLA1N2[Q, i , j , Regla ] ,

REGLA2N2[Q, i , j , p , q , Regla ] ] ;

Regla3N2 [ x , Regla ] :=

Module [{n = 1 , m = 1 , P = x , z = Dimensions [ x ]} ,

While [ n <= z [ [ 1 ] ] ,

While [m <= z [ [ 2 ] ] ,

P [ [ n , m] ] = EVON2[ x , n , m, z [ [ 1 ] ] , z [ [ 2 ] ] , Regla ] ; m++] ; m = 1 ;

n++ ] ; P ] ;

AUTOMATADENEUMANNN2[ Regla , Matriz , Pasos ] :=

Module [{A = CellularAutomaton [ {1 , 4 , {1 , 1}} , Matriz , Pasos ]} ,

For [ f = 1 , f < Pasos + 1 , f++;

A[ [ f ] ] = Regla3N2 [A [ [ f − 1 ] ] , Regla ] ] ; A ] ;

Sonido2 [ x , y , z , t ] :=

Module [{A = AUTOMATADENEUMANNN2[ x , y , z ]} ,

EmitSound [

Sound [ Table [





SoundVolume −> A[ [m ] ] [ [ i , j ] ] ] , { i , 7} , { j , 7 } ] ] ,

t ] , {(m − 1 )∗ . 1 , m∗ . 1 } ] , {m, z + 1 } ] ] ] ] ;

C. Reglas Semitotalısticas

Para las reglas semitotalısticas a trabajar se deben siempre incluir en el encabezado los

siguientes codigos que son los encargados de tomar para cada elemento de ella, los perte-

necientes a la vecindad de Moore y realizar la suma de estados para corroborar si mueren,

nacen o sobreviven cada una de las celulas.

REGLATIPO1[Q , i I n t e g e r , j I n t e g e r ] :=

Sum[Q[ [ i + n , j + k ] ] , {n , −1, 1} , {k , −1, 1} ] − Q[ [ i , j ] ] ;

REGLATIPO2[Q , i I n t e g e r , j I n t e g e r , p Integer , q In t eg e r ] :=

Which [ i == 1 && j == 1 ,

Sum[Q[ [ i + n , j + k ] ] , {n , 0 , 1} , {k , 0 , 1} ] − Q[ [ i , j ] ] ,

i == 1 && 1 < j < q ,

Sum[Q[ [ i + n , j + k ] ] , {n , 0 , 1} , {k , −1, 1} ] − Q[ [ i , j ] ] ,

i == 1 && j == q ,

Sum[Q[ [ i + n , j + k ] ] , {n , 0 , 1} , {k , −1, 0} ] − Q[ [ i , j ] ] ,

1 < i < p && j == 1 ,

Sum[Q[ [ i + n , j + k ] ] , {n , −1, 1} , {k , 0 , 1} ] − Q[ [ i , j ] ] ,

1 < i < p && j == q ,

Sum[Q[ [ i + n , j + k ] ] , {n , −1, 1} , {k , −1, 0} ] − Q[ [ i , j ] ] ,

i == p && j == 1 ,

Sum[Q[ [ i + n , j + k ] ] , {n , −1, 0} , {k , 0 , 1} ] − Q[ [ i , j ] ] ,

i == p && 1 < j < q ,

Sum[Q[ [ i + n , j + k ] ] , {n , −1, 0} , {k , −1, 1} ] − Q[ [ i , j ] ] ,

i == p && j == q ,

Sum[Q[ [ i + n , j + k ] ] , {n , −1, 0} , {k , −1, 0} ] − Q[ [ i , j ] ] ] ;

Evol [ Q , i I n t e g e r , j I n t e g e r , p Integer , q In t eg e r ] :=

I f [ 1 < i < p && 1 < j < q , REGLATIPO1[Q, i , j ] ,

REGLATIPO2[Q, i , j , p , q ] ] ;

Las siguientes funciones van a tomar la sucesion de matrices correspondientes a la evolucion

del automata y generaran el sonido para cada decima de segundo.

R1 [ x , p Integer , q In t eg e r ] :=

Module [{n = 1 , m = 1 , P = x} ,

While [ n <= p , While [m <= q , P [ [ n , m] ] = Evol [ x , n , m, p , q ] ; m++] ;

C.1 Reglas Semitotalıstica Ejemplo 1 57

m = 1 ; n++ ] ; P ] ;

R2 [ x , y , p Integer , q In t ege r , smin , smax , nmin , nmax ] :=

Module [{n = 1 , m = 1 , L = x} ,

While [ n <= p ,

While [m <= q ,

I f [ smin <= x [ [ n , m] ] <= smax && y [ [ n , m] ] == 1 , L [ [ n , m] ] = 1 ,

I f [ nmin <= x [ [ n , m] ] <= nmax && y [ [ n , m] ] == 0 , L [ [ n , m] ] = 1 ,

L [ [ n , m] ] = 0 ] ] ; m++] ; m = 1 ; n++ ] ; L ] ;

Steps [ k , Q ] := Table [Q, {k } ] ;

NOTA2[ x ] :=

Switch [ x , 1 , ”C” , 2 , ”D” , 3 , ”E” , 4 , ”F” , 5 , ”G” , 6 , ”A” , 7 , ”B” ] ;

KL = Transpose [

Table [ S t r ingJo in [NOTA2[ i ] , ToString [ j − 1 ] ] , { i , 1 , 7} , { j , 1 , 7 } ] ] ;

ReglaSemi2 [ x , { smin , smax , nmin , nmax } ] :=

Module [{ x0 = 1 , z = Dimensions [ x ] , L = x , S = x} ,

L = R1 [ x , z [ [ 1 ] ] , z [ [ 2 ] ] ] ;

S = R2 [L , x , z [ [ 1 ] ] , z [ [ 2 ] ] , smin , smax , nmin , nmax ] ; S ] ;

XI [ x , m ] :=

I f [ Dimensions [ x ] [ [ 1 ] ] > m, RandomSample [ x , m] ,

RandomSample [ x , Dimensions [ x ] [ [ 1 ] ] ] ] ;

C.1. Reglas Semitotalıstica Ejemplo 1

El siguiente codigo trabajara correctamente incluyendo los anteriores programas que juntan

la matriz con la nota correspondiente.

GAMEOFLIFE1[Q , smin , smax , nmin , nmax , k ,

i n s ] := {Animate [

ArrayPlot [

Jo in [{Q} ,

Fo ldL i st [ ReglaSemi2 , Q, Steps [ k , {smin , smax , nmin , nmax } ] ] ] [ [

i ] ] ] , { i , 1 , k + 1 , 1} , DefaultDurat ion −> ( k + 1 )∗ . 1 ,


Module [{N =

Join [{Q} ,

Fo ldL i st [ ReglaSemi2 , Q, Steps [ k , {smin , smax , nmin , nmax } ] ] ] ,

58 C Reglas Semitotalısticas

L = Range [ k ]} ,

L = Table [

Table [{N[ [ l ] ] [ [ i , j ] ] , KL [ [ i , j ] ] } , { i , 1 , 7} , { j , 1 , 7} ] , { l , 1 ,

k } ] ; EmitSound [

Sound [ Table [

SoundNote [

XI [ F la t ten [

Table [ DeleteCases [ F la t ten [ Cases [L [ [ l , i ] ] , {1 , } ] ] , 1 ] , { i ,

1 , 7 } ] ] , i n s ] , . 1 ] , { l , 1 , k } ] ] ] ] }

Manipulate [

GAMEOFLIFE1[ data , Regla [ [ 1 ] ] , Regla [ [ 2 ] ] , Regla [ [ 3 ] ] , Regla [ [ 4 ] ] , p ,

Ins ] , {{data , RandomInteger [{0 , 1} , {7 , 7} ]} ,


60 , 70}} , {{ Ins , 3 , ”Numero de notas a tomar ”} , {3 , 4 , 5 , 6 , 7 , 8 ,

9 , 10}} , De l imi ter ,

Item [ ” Regla de evo luc i o n ” , Alignment −> Center ] ,

Item [ ” ” , Alignment −> Center ] , {{Conf , 1 ,

” E l ecc i o n r e g l a s em i t o t a l ı s t i c a ”} , {1 −> ”Game o f L i f e ” ,

2 −> ”HighLi f e ” , 3 −> ” Persona l i zada ”}} , {{Regla , {2 , 2 , 2 , 3}} ,


Dynamic [

Panel [

Which [ Conf == 1 , Regla = {2 , 3 , 3 , 3} ,

Conf == 2 , Regla = {2 , 3 , 3 , 6} ,

Conf == 3 ,

Grid [{{” Sobrev iv i en t e Mınimo ” ,

PopupMenu [

Regla [ [ 1 ] ] , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ,

9} ]} , {” Sobrev iv i en t e Maximo” ,

PopupMenu [ Regla [ [ 2 ] ] , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9} ]} ,

{”Nacimiento Mınimo ” ,

PopupMenu [ Regla [ [ 3 ] ] , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9} ]} ,

{”Nacimiento Maximo” ,

PopupMenu [ Regla [ [ 4 ] ] , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9} ]}} ]

]

]

] ,

De l imi ter , Item [ ” Condici on I n i c i a l ” , Alignment −> Center ] ,

Dynamic [ Panel [

C.2 Reglas Semitotalısticas Ejemplo 2 59


Range [ 7 ] ] ] ] ] , FrameLabel −> {”” , ”” , ”EJEMPLO 1”} ]

C.2. Reglas Semitotalısticas Ejemplo 2

El siguiente ejemplo conserva la misma idea que el ejemplo 1 con la salvedad que se van

eligiendo simultaneamente instrumentos al azar para generar cada nota. El codigo se muestra

a continuacion.

GAMEOFLIFE2[Q , smin , smax , nmin , nmax , k ,

i n s ] := {Animate [

ArrayPlot [

Jo in [{Q} ,


i ] ] ] , { i , 1 , k + 1 , 1} , DefaultDurat ion −> ( k + 1 )∗ . 1 ,


Module [{N =

Join [{Q} ,

Fo ldL i st [ ReglaSemi2 , Q, Steps [ k , {smin , smax , nmin , nmax } ] ] ] ,

L = Range [ k ]} ,

L = Table [

Table [{N[ [ l ] ] [ [ i , j ] ] , KL [ [ i , j ] ] } , { i , 1 , 7} , { j , 1 , 7} ] , { l , 1 ,

k } ] ; EmitSound [

Sound [ Table [

SoundNote [

XI [ F la t ten [

Table [ DeleteCases [ F la t ten [ Cases [ L [ [ l , i ] ] , {1 , } ] ] , 1 ] , { i ,

1 , 7 } ] ] , i n s ] , . 1 ,

ToString [ RandomChoice [{” Bass ” , ”Harp” , ”Guitar ” } ] ] ] , { l , 1 ,

k } ] ] ] ] }

Manipulate [

GAMEOFLIFE2[ data , Regla [ [ 1 ] ] , Regla [ [ 2 ] ] , Regla [ [ 3 ] ] , Regla [ [ 4 ] ] , p ,

Ins ] , {{data , RandomInteger [{0 , 1} , {7 , 7} ]} ,


60 , 70}} , {{ Ins , 3 , ”Numero de notas a tomar ”} , {3 , 4 , 5 , 6 , 7 , 8 ,

9 , 10}} , De l imi ter ,


Item [ ” ” , Alignment −> Center ] ,

{{Conf , 1 , ” E l ecc i o n r e g l a s em i t o t a l ı s t i c a ”} , {1 −> ”Game o f L i f e ” ,


2 −> ”HighLi f e ” , 3 −> ” Persona l i zada ”}} , {{Regla , {2 , 2 , 2 , 3}} ,


Dynamic [

Panel [

Which [ Conf == 1 , Regla = {2 , 3 , 3 , 3} ,

Conf == 2 , Regla = {2 , 3 , 3 , 6} ,

Conf == 3 ,

Grid [{{” Sobrev iv i en t e Mınimo ” ,

PopupMenu [

Regla [ [ 1 ] ] , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ,

9} ]} , {” Sobrev iv i en t e Maximo” ,

PopupMenu [ Regla [ [ 2 ] ] , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9} ]} ,

{”Nacimiento Mınimo ” ,

PopupMenu [ Regla [ [ 3 ] ] , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9} ]} ,

{”Nacimiento Maximo” ,

PopupMenu [ Regla [ [ 4 ] ] , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9} ]}} ]

]

]

] ,


Dynamic [ Panel [



C.3. Reglas Semitotalısticas ejemplo 3

El siguiente codigo fracciona la matriz de 21× 21 en 9 matrices de 7× 7 donde cada una de

ellas representa un instrumento musical especıfico.

NOTA3[ x ] :=

Switch [ x , 1 , ”Guitar ” , 2 , ”Piano ” , 3 , ”AltoSax ” , 4 , ”Harp” , 5 ,

”Guitar ” , 6 , ”TenorSax” , 7 , ”Tuba” , 8 , ” Flute ” , 9 , ” S i t a r ” ] ;

GAMEOFLIFE3[ Q , smin , smax , nmin , nmax ,

k ] := {Animate [

ArrayPlot [

Jo in [{Q} ,


u ] ] ] , {u , 1 , k , 1} , DefaultDurat ion −> ( k + 1 )∗ . 1 ,

C.3 Reglas Semitotalısticas ejemplo 3 61


AnimationRunning −> True ] Module [{B = Q,

L = RandomChoice [{0 , 1} , {k + 1 , 9} ] , S = Range [ k ]} ,

B = Join [{Q} ,

Fo ldL i st [ ReglaSemi2 , Q, Steps [ k , {smin , smax , nmin , nmax } ] ] ] ;

For [m = 0 , m < k + 1 , m++;

L [ [m, 1 ] ] = Table [ Table [B [ [m ] ] [ [ i , j ] ] , { j , 1 , 7} ] , { i , 8 , 1 4 } ] ;

L [ [m, 2 ] ] = Table [ Table [B [ [m ] ] [ [ i , j ] ] , { j , 8 , 14} ] , { i , 1 , 7 } ] ;

L [ [m, 3 ] ] = Table [ Table [B [ [m ] ] [ [ i , j ] ] , { j , 15 , 21} ] , { i , 1 , 7 } ] ;


L [ [m, 5 ] ] =

Table [ Table [B [ [m ] ] [ [ i , j ] ] , { j , 8 , 14} ] , { i , 8 , 1 4 } ] ;

L [ [m, 6 ] ] =



L [ [m, 8 ] ] =


L [ [m, 9 ] ] =

Table [ Table [B [ [m ] ] [ [ i , j ] ] , { j , 15 , 21} ] , { i , 15 , 2 1 } ] ] ;

For [m = 0 , m < k , m++;

S [ [m] ] =

XI [ F la t ten [

Table [ DeleteCases [


SoundNote [

S t r ingJo in [NOTA2[ i ] ,

ToString [ j ] ] , {(m − 1 )∗0 . 1 , (m − 1 )∗0 . 1 +

0 .1∗L [ [m, l ] ] [ [ i , j ] ] } , NOTA3[ l ] ] , { j , 1 , 7} , { i , 1 ,

7 } ] ] , SoundNote [ , {(m − 1 )∗0 . 1 , (m − 1 )∗0 . 1} , ] ] , { l ,

1 , 9 } ] ] , 5 ] ] ; EmitSound [ Sound [ F lat ten [ S ] ] ] ] }

Manipulate [

GAMEOFLIFE3[ data , smin , smax , nmin , nmax ,

p ] , {{data , RandomInteger [{0 , 1} , {21 , 21} ]} ,


60 , 70}} , De l imi ter ,


Item [ ” ” , Alignment −> Center ] ,

{{smin , 3 , ” Sobrev iv i en t e mınimo ”} , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ,

9}} , {{smax , 3 , ” Sobrev iv i en t e maximo”} , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ,


9}} , {{nmin , 2 , ”Nacimiento mınimo ”} , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ,

9}} , {{nmax , 3 , ”Nacimiento maximo”} , {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9}} ,


Dynamic [ Panel [



D. Palabras de Fibonacci

Este es un ejemplo extra, un poco alejado de los automatas celulares pero que si como sistema

dinamico. Los siguientes codigos generan la lista dado por el L−sistema:

LMove [ z S t r ing , \ [ Delta ] , p o s L i s t ] := Block [{ x , y , \ [ Theta ] , moves } ,

{x , y} = pos [ [ 1 ] ] ;

\ [ Theta ] = pos [ [ 2 ] ] ;

moves = {{x , y }} ;

Map[

( Switch [# ,

”+”, \ [ Theta ] += \ [ Delta ] ; ,

”−”, \ [ Theta ] −= \ [ Delta ] ; ,

”F” , {x , y} += {Cos [ \ [ Theta ] ] , Sin [ \ [ Theta ] ] } ] ;

AppendTo [ moves , {x , y } ] ; )

&, Characters [ z ] ] ;

Return [ moves ] ;

] ;

morfismo [ \ [ CapitalSigma ] , \ [Mu] , n ] :=

Block [ { \ [ Cap i ta lDe l ta ] = \ [ CapitalSigma ]} ,

Do [ \ [ Cap i ta lDe l ta ] = Flat ten [ \ [ Cap i ta lDe l ta ] / . \ [Mu] ] , {n } ] ;

Return [ \ [ Cap i ta lDe l ta ] ] ;

] ;

\ ]

PF[ n ] :=

Module [{A = morfismo [{0} , {1 −> 0 , 0 −> {0 , 1}} , n ] , B = 1} ,

B = Pa r t i t i o n [A,

2 ] / . {{1 , 0} −> ”FF+”, {0 , 1} −> ”F−F” , {0 , 0} −> ”F−F+”} //

St r ingJo in ;

LMove [B, 90 Degree , {{0 , 0} , 90 Degree } ] ] ;

Las siguientes funciones van a ir generando una tabla con cada uno de los puntos, y generan

un grafo que va uniendo con lıneas estos puntos siguiendo ese orden.

PF2 [ n ] :=

Module [{A = PF[ n ] , B = 1} ,

64 D Palabras de Fibonacci

B = Table [ Table [A [ [ i ] ] , { i , 1 , j } ] , { j , 1 , Dimensions [A ] [ [ 1 ] ] } ] ] ;

GrafiPF [ n ] :=

Module [{A = PF[ n ] , x = {1 , 1}} ,

x = {Max [ Table [A [ [ j , 1 ] ] , { j , Dimensions [A ] [ [ 1 ] ] } ] ] ,

Max [ Table [A [ [ j , 2 ] ] , { j , Dimensions [A ] [ [ 1 ] ] } ] ] } ;

Animate [ Graphics [ Line [PF2 [ n ] [ [ i ] ] ] ,

PlotRange −> {{0 , x [ [ 1 ] ] } , {0 , x [ [ 2 ] ] } } ] , { i , 1 ,

Dimensions [A ] [ [ 1 ] ] , 1} ,

DefaultDurat ion −> ( Dimensions [A ] [ [ 1 ] ] + 1)∗ . 0 8 ,

Animat ionRepet i t ions −> 1 , AnimationRunning −> True ] ]

Mor [ n ] := Pa r t i t i o n [ morfismo [{0} , {1 −> 0 , 0 −> {0 , 1}} , n ] , 2 ] ;

Por ultimo el siguiente codigo va determinado la siguiente nota indicando la regla del cambio

de la letra o el numero de la nota en la codificacion MIDI acorde al siguiente movimiento

del mismo.

Sonido [ x ] :=

Switch [ x , 0 , ”A” , 1 , ”B” , 2 , ”C” , 3 , ”D” , 4 , ”E” , 5 , ”F” , 6 , ”G” ] ;

PalFiboSonido1 [ n ] :=

Module [{ z =

Mor [ n ] / . {{1 , 0} −> ”FF+”, {0 , 1} −> ”F−F” , {0 , 0} −> ”F−F+”} //

Str ingJo in , k = Dimensions [Mor [ n ] ] [ [ 1 ] ] ,

m = Dimensions [Mor [ n ] ] [ [ 1 ] ] } ,

k = LMove [ z , 90 Degree , {{0 , 0} , 90 Degree } ] ;

m = Dimensions [ k ] [ [ 1 ] ] ;

Sound [ Table [

SoundNote [

S t r ingJo in [ Sonido [Mod[ k [ [ i , 1 ] ] , 7 ] ] ,

ToString [Mod[ k [ [ i , 2 ] ] , 7 ] ] ] , . 0 8 ] , { i , m} ] ] ] ;

GrafiPF2 [ n ] :=

Module [{A = PF[ n ] , x = {1 , 1}} ,

Animate [ Graphics [ Line [PF2 [ n ] [ [ i ] ] ] ] , { i , 1 , Dimensions [A ] [ [ 1 ] ] , 1} ,

DefaultDurat ion −> ( Dimensions [A ] [ [ 1 ] ] + 1)∗ . 0 8 ,

Animat ionRepet i t ions −> 1 , AnimationRunning −> True ] ]

Manipulate [{GrafiPF2 [m] ,

65

EmitSound [ PalFiboSonido1 [m] ] } , {{m, 8 ,

”N−esima palabra de F ibonacc i ”} , 1 , 11 , 1} ,

FrameLabel −> {”” , ”” , ”PALABRAS DE FIBONACCI”} ]

Bibliografıa

[1] Bilotta Eleonora, Pantano Pietro , Artificial Life Music Tells of Complexity, Centro

Interdipartimentale della Comunicaziones, Universita della Calabria, 2000.

[2] Burks Arthur W. (Editor) .Essays on Cellular Automata. University of Illinois

Press,1970.

[3] Burraston Dave , One Dimensional Cellular Automata Musical Experiments with Max,

University of Technology Sydney.

[4] Burraston Dave, Edmonds Ernest , Dan Livingstone y Eduard Reck Miranda, Cellular

Automata in MIDI based Computer Music, Faculty of Information Thecnology, Uni-

versity of Technology, Sydney and School of Computing, University of Plymouth, UK,

2004.

[5] Chopard Bastien, Droz Michel, Cellular Automata Modeling of Physical Systems, Cam-

bridge University Press, 1998.

[6] Codd Edgar F., Cellular Automata, Academic Press,Pag 27,1968.

[7] Gardner Martin, Mathematical Games - The fantastic combinations of John Conway´s

new solitaire game Life. Scientific American, October 1970, pag 120 - 123.

[8] Greenberg James M., Hassard B. D., Hastings and S. P., Pattern Formation and Periodic

Structures in Systems Modeled by Reaction-Difussion Equations, Boletin de la sociedad

americana de matematicas, Volumen 84, Numero 6, Noviembre 1978.

[9] Hedlund, G.A., Endormorphisms and automorphisms of the shifts dynamical sys-

tem,Theory of Computing Systems Volume 3, Number 4 pag 320-375, Springer 1969.

[10] Heinz-Otto-Peitgen, Hartman Jurgens, Dietmar Soupe, Chaos and Fractals, New Fron-

tiers of Science,Springer-Verlog,1992.

[11] Langton Christopher G. , Self-reproduction in cellular automata.Physica D, 10:135-

144,1984.

[12] Miranda Eduardo Reck , Evolving Cellular Automata Music: From Sound Synthesis to

Composition, Sony Computer Science Laboratory Paris.

Bibliografıa 67

[13] Pivato Marcus , The Ergodic Theory of Cellular Automata,Department of Mathema-

tics,Trent University,pag 7-8.

[14] Poundston William, The Recursive Universe, William Morrow and Company Inc.

[15] Romero Costas Matıas , Causa Emiliano y Pirotta Tarsicio Lucas (Grupo Biopus),

Automatas Musicales Interactivos, Centro de Experimentacion e Investigacion en Artes

Electronicas de la Universidad Nacional de Tres de Febrero,Junio 2009.

[16] Seck Tuoh Mora Juan Carlos, Automatas Celulares Lineales Reversible, Agosto 1997.

[17] Genaro Juarez Martınez, Teorıa del campo promedio en automatas celulares similares a

”The game of life”, Centro de investigaciones y estudios avanzados del I.P.N.,Octubre

2000.

[18] Thompson D’Arcy Wentworth ,On growht and form,editado por J.T. Bonner, Cambrid-

ge University.

[19] Toffoli Tommaso; Margolus Norman (1987), Cellular Automata Machines: A New En-

viroment for Modeling, MIT Press, Chapter 17.2, Ising systems” pp 186-190.

[20] Wolfram Stephen , Statistical mechanics of cellular automata, Institute for Advanced

Study, Princeton.

[21] Wuensche Andrew, Lesser Mike. The Global Dynamics of Cellular Automata. Santa Fe

Institute. 1992

Documents

Mu´sica con Aut´omatas Celulares