Un modelo para el desarrollo de software

basado en Computación con ADN

Autor: Diego Leonardo Marrone

Matrícula: 1329-0018

Tutor: M. Ing. Lic. Jorge Ierache

Materia: Trabajo de Diploma

Universidad de Morón

Año 2004

A mi madre y hermanos, por todo el apoyo brindado durante estos años.

AGRADECIMIENTOS

Principalmente, quiero agradecer a mi tutor y guía el M. Ing. Lic. Jorge Ierache. Su experiencia y conocimientos fueron fundamentales en el desarrollo de esta tesis. Al Ing. Fernando Freytes, quien me guió en los comienzos de este trabajo. A todos los docentes de esta Universidad que a lo largo de mi carrera contribuyeron en mi formación profesional. Y a todas aquellas personas que de alguna forma me apoyaron en este trabajo. Para todos ellos, mi más sincero agradecimiento.

4

INDICE

1 Introducción.......................................................................................................................... 6 2 Conceptos fundamentales de biología molecular .............................................................. 8

2.1 Estructura del ADN ...................................................................................................................... 8 2.2 Estructura del ARN ...................................................................................................................... 9 2.3 Proteínas .................................................................................................................................... 10 2.4 Síntesis protéica ......................................................................................................................... 10 2.5 Replicación del ADN .................................................................................................................. 11 2.6 Técnicas de manipulación del ADN ........................................................................................... 11

2.6.1 Desnaturalización ............................................................................................................... 12 2.6.2 Renaturalización ................................................................................................................. 12 2.6.3 Electroféresis ...................................................................................................................... 12 2.6.4 Fragmentación .................................................................................................................... 12 2.6.5 Enlaces................................................................................................................................ 13 2.6.6 Reacción en cadena de polimerasa (RCP) ......................................................................... 13 2.6.7 Secuenciación ..................................................................................................................... 14

3 El estado del arte ................................................................................................................ 16 3.1 El Experimento de Adleman ....................................................................................................... 16

3.1.1 Conclusiones del experimento ............................................................................................ 19 3.2 La primer representación binaria .............................................................................................. 20 3.3 El Modelo de Stickers ................................................................................................................ 20

3.3.1 Representación de la información ...................................................................................... 21 3.3.2 Operaciones con cadenas de bits ....................................................................................... 21 3.3.3 La máquina de Stickers ....................................................................................................... 23

3.4 Operaciones aritméticas con ADN ............................................................................................ 25 3.5 El autómata de ADN .................................................................................................................. 28 3.6 ADN sobre superficies ............................................................................................................... 31

4 Análisis del nuevo paradigma de procesamiento ............................................................ 34 4.1 La necesidad de un nuevo paradigma ........................................................................................ 34 4.2 Computación tradicional vs. computación con ADN ................................................................. 35 4.3 Aplicaciones ............................................................................................................................... 37 4.4 Universalidad del nuevo paradigma .......................................................................................... 38

5 Modelo propuesto para el desarrollo basado en Computación con ADN ..................... 40 1. Análisis del problema .............................................................................................................. 41 2. Diseño de secuencias ............................................................................................................... 42 3. Selección de Operaciones ........................................................................................................ 43 4. Pruebas .................................................................................................................................... 44 5. Implementación ....................................................................................................................... 45

6 Aplicación del modelo propuesto ...................................................................................... 47 6.1 Selección del problema .............................................................................................................. 47 6.2 Solución actual ........................................................................................................................... 49 6.3 Solución aplicando el modelo propuesto ................................................................................... 50

7 Conclusiones ....................................................................................................................... 56 7.1 Futuras líneas de investigación ................................................................................................. 56

Anexo I: Computación con ADN aplicada a la Criptografía ........................................................ 58 Anexo II: Resultados experimentales del Autómata de ADN ........................................................ 62 Anexo III: Aplicación del modelo al problema de los Caminos Hamiltonianos ............................. 65

Bibliografía ............................................................................................................................. 69

Introducción

6

1 Introducción La tecnología de procesamiento actual se encuentra en una evolución constante. A pesar de ello, son conocidas las limitaciones que la misma posee y que le impedirán satisfacer las necesidades futuras de procesamiento. Por tal motivo, comienzan a buscarse nuevas alternativas al procesamiento basado en semiconductores, y una de ellas es la Computación con ADN. La Computación con ADN se basa en la utilización de moléculas de ADN como la unidad fundamental de procesamiento. Mediante estas moléculas se implementan diversas codificaciones, entre ellas la codificación binaria. La manipulación de las mismas se alcanza a través de la ejecución de procesos bioquímicos. El procesamiento basado en ADN presenta ciertas ventajas respecto al procesamiento actual, entre las que se destacan su procesamiento masivamente paralelo y su gran capacidad de memoria. En esta tesis, se presenta el estado del arte de este nuevo paradigma de procesamiento que tiene pocos años de vida y que aún es desconocido por muchos en el ambiente informático. El objetivo principal perseguido en esta tesis es la definición de un modelo para el desarrollo de software basado en ADN con un nivel de abstracción mayor al de la implementación biológica. La principal importancia de este modelo radica en que los desarrollos actuales basados en ADN se realizan a muy bajo nivel. Dicho de otro modo, es como si se estuviera desarrollando en Assembler, realizando una analogía con el paradigma de procesamiento actual. Por otro lado, el modelo debe especificar una notación común a utilizar, estandarizando y formalizando el desarrollo. Una vez presentado el modelo teórico, se demostrará su aplicación mediante la resolución de un problema puntual. Este trabajo se compone de siete capítulos o secciones, siendo la primera esta introducción. A continuación se detalla el objetivo de cada uno de los capítulos restantes. En el capítulo 2, se presentan aquellos conceptos de biología molecular que resultan de fundamental importancia para la comprensión de la Computación con ADN. Se incluyen en el mismo las técnicas de manipulación del ADN. El capítulo 3 describe el estado del arte de la Computación con ADN, desde su inicio hasta los últimos avances presentados. En este capítulo se comienzan a observar las posibilidades que la misma ofrece. En el capítulo 4, se realiza un análisis de la Computación con ADN como nuevo paradigma de procesamiento. En este análisis, se demuestra la necesidad de investigar nuevos paradigmas de procesamiento y se presenta una comparación del nuevo paradigma con el paradigma actual, resaltando ventajas y desventajas de cada uno. El capítulo 5 define el principal aporte de esta tesis, presentando el modelo teórico para el desarrollo basado en Computación con ADN. En el capítulo 6, se demuestra la aplicación del modelo presentado en el capítulo anterior, resolviendo un caso práctico. Para ello, se realiza la selección de un problema que resalte las ventajas del modelo. Por último, en el capítulo 7 se presentan las conclusiones y las futuras líneas de investigación que surgen de esta tesis.

Conceptos fundamentales de

biología molecular

8

2 Conceptos fundamentales de biología molecular En este capítulo se abordan temas de fundamental conocimiento para la posterior comprensión de la computación basada en ADN. Básicamente, el capítulo se inicia realizando una introducción a la biología molecular, para luego presentar las diversas técnicas existentes para la manipulación de moléculas de ADN.

2.1 Estructura del ADN La estructura actualmente aceptada del ADN fue presentada por primera vez en 1953, por los bioquímicos James Watson y Francis Crick [Wat], lo que les valió el Premio Nobel. Dicho modelo, produjo un cambio en la dirección de las ciencias biológicas. Según el mismo, la molécula de ADN está constituída por dos largas cadenas de ácidos nucleicos, llamados nucleótidos, unidos entre sí formando una doble hélice. Cada nucleótido se compone de tres unidades: un grupo fosfato, un azúcar de cinco carbonos (llamada desoxirribosa), y una base nitrogenada. Esta base nitrogenada, puede ser una purina de doble anillo (Adenina o Guanina), o una pirimidina de anillo simple (Timina o Citosina). De este modo, existen cuatro tipos de nucleótidos dependiendo de la base nitrogenada que lo componga. El grupo fosfato se encuentra unido a la molécula de azúcar, la cual se une también a alguna de las bases nitrogenadas.

Figura 2-1

El grupo fosfato de cada nucleótido se liga al grupo hidroxil del nucleótido adyacente. Este grupo hidroxil se halla unido al tercer carbono del anillo formado por el azúcar desoxirribosa. Por medio de este enlace covalente fuerte, también llamado fosfodiéster, se forma una cadena polinucleótida. Las bases nitrogenadas de una cadena son atraídas por las bases de otra cadena, produciéndose un enlace no covalente débil. Dicho enlace, se realiza mediante puentes de hidrógeno, conformándose así una doble hélice. El apareamiento entre las bases tiene las siguientes características: la Adenina se une a la Timina a través de dos puentes de hidrógeno, y la Guanina a la Citosina por medio de tres

9

puentes de hidrógeno. Esta disposición, por medio de la cual una purina se une con una pirimidina, resulta en una molécula de diámetro uniforme.

Figura 2-2

La estructura en doble hélice del ADN, con el apareamiento limitado de bases (Adenina-Timina, Guanina-Citosina), implica que el orden o secuencia de bases de una de las cadenas delimita automáticamente el orden de la otra, por eso se dice que las cadenas son complementarias. Una vez conocida la secuencia de las bases de una cadena, se deduce inmediatamente la secuencia de bases de la complementaria.

Figura 2-3

2.2 Estructura del ARN El ARN tiene una organización química similar a la del ADN, basada en nucleótidos. Cada nucleótido de ARN está compuesto también por tres unidades: un grupo fosfato, un azúcar de cinco carbonos llamada ribosa y una base nitrogenada. La base nitrogenada puede ser una purina (Adenina o Guanina), o una pirimidina (Uracilo o Citosina). El ARN difiere del ADN en tres aspectos principales de su organización química. En primer lugar, el azúcar del ARN es del tipo ribosa, lo que implica que la segunda molécula de carbono del anillo está ligada a un grupo hidroxil (OH). En el ADN, el segundo

10

carbono del anillo tiene sólo un átomo de higrógeno (H). De aquí proviene el prefijo desoxi (de la palabra desoxirribosa), que significa desprovisto de oxígeno. En segundo lugar, el Uracilo se encuentra presente sólo en el ARN. Del mismo, la Timina se encuentra únicamente en los nucleótidos de ADN. Por otro lado, el ARN se halla formado por una única cadena polinucleótida.

2.3 Proteínas Una proteína es un compuesto formado por moléculas llamadas aminoácidos, que determinan su estructura y su función [Rob]. La secuencia de aminoácidos está a su vez determinada por la secuencia de bases de los nucleótidos del ADN. Cada secuencia de tres bases, llamada triplete, constituye una palabra del código genético o codón, que especifica un aminoácido determinado, existiendo 20 aminoácidos distintos. Así, el triplete GAC (Guanina, Adenina, Citosina) es el codón correspondiente al aminoácido leucina, mientras que el CAG (Citosina, Adenina, Guanina) corresponde al aminoácido valina. Por tanto, una proteína formada por 100 aminoácidos queda codificada por un segmento de 300 nucleótidos de ADN. Los aminoácidos se unen en largas hileras llamadas cadenas polipeptídicas. El número casi infinito de combinaciones en que se unen los aminoácidos y las formas helicoidales y globulares en que se arrollan las hileras o cadenas polipeptídicas, permiten explicar la gran diversidad de funciones que estos compuestos desempeñan en los seres vivos.

2.4 Síntesis protéica La síntesis protéica es el proceso mediante el cual las células producen sus propias proteínas. Dicho proceso comienza en el núcleo celular con la separación de la molécula de ADN en sus dos hebras, por ruptura de los puentes de hidrógeno, quedando expuestas las bases nitrogenadas. Los escasos ribonucleótidos libres en el núcleo, se acoplan sobre las bases expuestas, apareándose según corresponda. De este modo, se forma una cadena de ARN cuya secuencia de bases nitrogenadas es complementaria y opuesta a la del ADN sobre la cual se formó. Este proceso recibe el nombre de transcripción. La cadena de ARN formada, se desprende del ADN, sale del núcleo celular y se acopla a los ribosomas, unas estructuras especializadas que actúan como centro de síntesis de proteínas. Por este motivo, la cadena de ARN es llamada ARN mensajero (ARNm). Mientras esto sucede, se produce el ingreso a la célula de distintos nutrientes, entre ellos diferentes aminoácidos. A medida que los aminoácidos van ingresando, son seleccionados por otro tipo de ARN llamado de transferencia (ARNt), encargado de transportarlos hasta el ARNm. Las moléculas de ARNt están constituídas sólo por tres nucleótidos, por lo cual cada una de ellas tiene afinidad por un aminoácido en especial. Al llegar a los ribosomas, cada triplete o codón de ARNt busca en la cadena de ARNm el lugar correspondiente, apareando allí sus bases. Una vez que esto ocurre, los aminoácidos se separan del ARNt, uniéndose entre ellos y constituyendo una proteína. Este fenómeno recibe el nombre de traducción. Como puede verse, la estructura química de la proteína formada responde a la información dada por el ADN del núcleo, actuando como patrón o molde para la selección y el acomodamiento de los aminoácidos.

11

2.5 Replicación del ADN La replicación del ADN consiste en la copia exacta de las moléculas de ADN. En casi todos los organismos celulares, este proceso tiene lugar en el núcleo, justo antes de la división celular. En el cuerpo humano, cada célula contiene casi un metro de ADN, compuesto por tres mil millones de bases, que se tienen que copiar cada vez que la célula se divide. De este modo, cada célula hija tendrá una copia del ADN original. La célula logra esto en aproximadamente media hora [Gen]. La replicación comienza con la separación de las dos cadenas de polinucleótidos, cada una de las cuales actúa a continuación como plantilla para el montaje de una nueva cadena complementaria. A medida que la cadena original se abre, cada uno de los nucleótidos de las dos cadenas resultantes atrae otro nucleótido complementario previamente formado por la célula. Los nucléotidos se van uniendo entre sí mediante enlaces de hidrógeno, para formar las dos cadenas complementarias. A medida que los nucleótidos complementarios se van encajando en su lugar, una enzima llamada ADN polimerasa los une, enlazando el grupo fosfato de uno con la molécula de azúcar del siguiente, para así construir la hebra lateral de la nueva molécula de ADN. Este proceso continúa hasta que se forma una nueva cadena de polinucleótidos a lo largo de la antigua.

Figura 2-4

2.6 Técnicas de manipulación del ADN Existen diversas técnicas utilizadas para el estudio y manipulación del ADN. A continuación, se detallan las mismas.

12

2.6.1 Desnaturalización La desnaturalización consiste en la separación de las dos cadenas de ADN [Ent]. Esto se consigue rompiendo los puentes de hidrógeno que unen los nucleótidos complementarios. Dicha ruptura se logra por calentamiento de las cadenas, las cuales son expuestas a una temperatura, conocida como temperatura de fusión. Esta temperatura es aquella a la cual el 50% de las cadenas se disocia, y la misma depende del contenidos de pares GC, ya que los mismos se unen por tres puentes de hidrógeno, mientras que los pares AT sólo lo hacen por dos. Por lo tanto, cuanto mayor sea la cantidad de pares GC, mayor será la temperatura de fusión. Generalmente, esta temperatura se halla entre los 90 y 95°C. Existe un método alternativo para conseguir la ruptura de los puentes de hidrógenos en el que no interviene la temperatura. El mismo se basa en colocar a las cadenas en agua destilada, donde el bajo contenido de sodio desestabiliza los puentes de hidrógenos logrando la separación buscada.

2.6.2 Renaturalización En oposición a la desnaturalización se encuentra la renaturalización, que permite la fusión de dos hebras de ADN separadas [Ent]. Esto se logra bajando la temperatura a la cual se encuentran o aumentando el contenido de sodio de la mezcla. Ambos métodos reestablecen los puentes de hidrógenos y con ellos el ADN bicatenario. La renaturalización implica también la fusión de hebras de distinto origen. En este caso más estricto recibe el nombre de hibridación.

2.6.3 Electroféresis La electroféresis es un método que se basa en la separación de fragmentos de ADN por su tamaño al hacerlos pasar por un gel sometido a un campo eléctrico. El gel sirve como soporte de la separación y los más usados son la agarosa y la acrilamida [Gen]. Cuando se somete al gel a un campo eléctrico, el ADN, cargado negativamente debido a los grupos fosfatos, tiende a desplazarse hacia el polo positivo a través de la trama del gel. Las moléculas pequeñas se mueven más fácilmente que las grandes, lo que permite separar los fragmentos de ADN por su tamaño. Esta técnica permite distingir fragmentos de ADN que se diferencian en un solo nucleótido, y por lo tanto, conocer la longitud de una cadena.

2.6.4 Fragmentación Esta técnica consiste en reconocer una secuencia determinada de nucleótidos y extraerla del resto de la cadena [Ent]. Esto se logra mediante la utilización de unas enzimas llamadas de restricción, producidas por varias bacterias. Estas enzimas tienen la capacidad de cortar los enlaces fosfatos de la molécula de ADN en secuencias específicas. La secuencia extraída recibe el nombre de RLPM (Restriction Fragment Lenght Polymorphism) y su longitud se encuentra generalmente en el orden de los cuatro a los ocho nucleótidos.

13

2.6.5 Enlaces Un enlace consiste en la unión de dos cadenas de ADN. Esta unión se logra mediante una clase de enzima llamada ADN ligasa [Sem1]. La ADN ligasa se encarga de catalizar la formación de un enlace fosfodiéster entre dos nucleótidos.

2.6.6 Reacción en cadena de polimerasa (RCP) Esta técnica utiliza una enzima denominada ADN polimerasa que copia cadenas de ADN en un proceso que simula la forma en la que el ADN se replica de modo natural en la célula. La RCP fue ideada y desarrollada por el bioquímico estadounidense Kary Mullis en 1983. Aunque la utilidad de esta técnica no se reconoció inmediatamente, en 1991 su uso ya se había generalizado, y en 1993 Mullis obtuvo el Premio Nobel de química por este trabajo. La RCP opera en forma de ciclos. Cada ciclo duplica la cantidad de ADN, por lo que permite obtener hasta mil millones de copias de un solo fragmento en unas pocas horas. La RCP necesita para copiar ADN de una reserva de los cuatro nucleótidos de la molécula de ADN, de una fibra corta de ADN copiado formada por varios nucleótidos que inician la replicación y es llamada cebador oligonucleotídico, y de una enzima especializada llamada polimerasa. La reacción tiene lugar en tres fases. Durante la primera, llamada desnaturalización, la plantilla o fragmento original de ADN se calienta hasta una temperatura de 90 a 95 °C durante treinta segundos. Esto provoca la separación de las dos cadenas. En la segunda fase llamada templado, la temperatura de la mezcla se rebaja hasta 55 °C durante veinte segundos para que los cebadores oligonucleotídicos se enlacen con el ADN escindido. En la tercera fase, o de polimerización, la temperatura de la mezcla se eleva hasta 75 °C para que la polimerasa copie rápidamente la molécula de ADN. Estas tres fases tienen lugar en la misma ampolla y constituyen un ciclo completo de RCP, que se realiza en menos de dos minutos. Teóricamente, el ciclo de RCP se puede repetir sin límite, pero la polimerasa, los nucleótidos y los cebadores suelen renovarse al cabo de unos treinta ciclos. Estos treinta ciclos, que duran menos de tres horas, bastan para producir mil millones de copias de ADN. La polimerasa utilizada en los primeros experimentos de RCP resultaba fácilmente destruida por el calor, lo que obligaba a añadir más enzimas en cada ciclo. Este problema se solucionó mediante la utilización de una polimerasa termoestable llamada Taq, que al no ser destruida por las altas temperaturas, basta con añadirla una vez al principio de la reacción. Inicialmente se extraía Taq de una bacteria termófila que vive en los manantiales de agua caliente del Parque Nacional Yellowstone. Actualmente, se fabrica polimerasa Taq con bacterias modificadas genéticamente. La RCP es hoy en día la técnica más rápida y económica para copiar ADN, y su proceso se halla totalmente automatizado. La amplificación mediante RCP permite realizar diversos análisis genéticos, y estudios de fragmentos aislados de ADN que de otra forma no hubiesen sido posibles. Incluso, la mayoría de las técnicas utilizadas en el Proyecto Genoma Humano aplican RCP [Gen].

14

2.6.7 Secuenciación La secuenciación del ADN permite determinar el orden preciso de las bases nucleótidas de un fragmento de ADN. La mayoría de los tipos de secuenciación de ADN se basan en una técnica denominada terminación de cadena o didesoxi desarrollada por el biólogo molecular británico Frederick Sanger en 1977. Este proceso de secuenciación consiste en cuatro reacciones enzimáticas en cuatro tubos diferentes y se basa en la utilización de didesoxinucleótidos. Los didesoxinucleótidos son nucleótidos sin grupo hidroxil. Al carecer de grupo hidroxil, los didesoxinucleótidos no pueden unirse con otros nucleótidos, por lo cual la aparición de uno de ellos implica el fin de la cadena de ADN. Cada mezcla de reacción se halla compuesta por una de las cadenas de las moléculas de ADN a secuenciar, nucleótidos de las cuatro bases marcados radiactivamente, ADN polimerasa, un cebador para comenzar la replicación y didesoxinucleótidos de una base para cada una de las cuatro reacciones. En cada mezcla, cada uno de los didesoxinucleótidos compite con su nucleótido homólogo por incorporarse a la cadena de ADN. Cuando un didesoxinucleótido logra incorporarse, la polimerización finaliza. Como resultado, se obtiene en cada tubo un conjunto de cadenas dobles cuyas longitudes dependen del didesoxinucleótido incorporado. De este modo, conociendo la posición del didesoxinucleótido, puede saberse que su nucleótido complementario, ocupa dicha posición en la cadena original. Para lograr esto último, se realiza electroféresis con gel. Para realizar este proceso, se utiliza un gel con una división en cuatro carriles, uno por base. Cada una de las cuatros mezclas obtenidas, se vuelca en el gel, sobre el carril que corresponda según el didesoxinucleótido utilizado. Una vez terminada la electroféresis, el gel se pone en contacto con una película radiográfica. La aparición de una banda en uno de los cuatro carriles dada por los nucleótidos marcados radiactivamente, indica que un didesoxinucleótido se encuentra en un posición determinada. De este modo, obteniendo posición por posición, se completa toda la secuencia de nucleótidos de la cadena original. La secuenciación de ADN se encuentra actualmente automatizada [Tar]. La principal diferencia entre el método automático y el enunciado anteriormente, radica en primer lugar en el tipo de marcaje, realizándose el mismo mediante fluorescencia. Cada uno de los didesoxinucleótidos es marcado con un fluorocomo de distinto color. La otra diferencia importante se encuentra en la forma de detectar los distintos nucleótidos. La detección de las fluorescencias se lleva a cabo al mismo tiempo que la electroféresis, de manera que los fragmentos de menor tamaño que ya se han detectado se dejan escapar del gel. Esto permite aumentar la cantidad de nucleótidos que se pueden detectar en cada electroféresis. Esta metodología ha permitido al Proyecto Genoma Humano obtener el orden o secuencia de las bases nitrogenadas en el ADN humano [Gen].

El estado del arte

16

3 El estado del arte Cuando en noviembre de 1994, el Profesor Leonard Adleman de la Universidad del Sur de California, publicó su trabajo titulado “Molecular Computation Of Solutions To Combinatorial Problems” quedaron sentadas las bases de un nuevo campo para las ciencias computacionales, la Computación con ADN (DNA Computing). Dicho trabajo, demostraba la posibilidad de resolver problemas NP completos, aplicando diversas técnicas de manipulación de ADN. Estudios posteriores presentaron la posibilidad de representar cadenas de bits con moléculas de ADN y realizar operaciones con ellas. Asimismo, uno de los avances más importantes fue la construcción de una máquina elemental de procesamiento, un autómata finito basado en el procesamiento mediante ADN. Este capítulo tiene como objetivo describir el desarrollo de la Computación con ADN y las posibilidades que la misma ofrece.

3.1 El Experimento de Adleman El experimento de Adleman consistió en resolver el problema de los caminos Hamiltonianos manipulando moléculas de ADN [Adl1]. Este conocido problema se basa en, dada N ciudades y diversas rutas que las conectan, encontrar el camino más corto posible para llegar desde una ciudad origen a otra destino, pasando por todas las ciudades y sin pasar dos veces por la misma ciudad. La particularidad de este problema se encuentra en que a medida que aumenta el número de ciudades el tiempo de resolución del mismo se incrementa exponencialmente. Los problemas con más de mil ciudades, no pueden ser actualmente resueltos ni por las más potentes supercomputadoras. El problema de los caminos Hamiltonianos es clasificado como un problema NP completo. Se definen como problemas NP completos a aquellos que no poseen un algoritmo determinístico con orden polinomial capaz de resolverlos. Estos problemas son considerados computacionalmente intratables. Adleman restringió su experimento a siete ciudades, tomando la ciudad 0 como origen y la ciudad 6 como destino. La solución al mismo está dada por el siguiente recorrido de ciudades: 0-1-2-3-4-5-6.

Figura 3-1

17

Un algoritmo para resolver este problema, independientemente del tipo de computadora utilizada sería:

1. Generar caminos aleatorios a través del grafo. 2. Quedarse sólo con los caminos que empiezan en la ciudad inicio (0) y terminan en la

ciudad fin (6). 3. Quedarse sólo con los caminos que tengan siete ciudades. 4. Quedarse con todos los caminos que pasan por todas las ciudades. 5. Cualquier camino que pase los puntos anteriores, es solución al problema.

Estos cinco pasos son los mismos que utilizó Adleman para encontrar una solución a través de computación con ADN, y a continuación se detalla la ejecución de cada uno de ellos:

1. Este paso consistió en crear siete secuencias de 20 nucleótidos, cada una de las cuales representaba una ciudad. A su vez, cada camino se representaba también mediante secuencias de 20 nucleótidos. La combinación de nucleótidos se determinó de manera que se pudiera representar la unión entre las ciudades. Adleman formalizó la generación de estas secuencias de la siguiente manera: si dos ciudades v1 y v2 se componen de dos subsecuencias de 10 nucleótidos x1y1 y x2y2 entonces, el camino entre ellas (e1, 2) es el complemento de y1 y x2 (y1x2). De este modo, el camino, se une a la segunda mitad de la ciudad origen y a la primera de la ciudad destino, sirviendo de conector entre ambas ciudades. Con el objetivo de generar caminos aleatorios, se mezclan las secuencias correspondientes a las ciudades y las rutas, para que las mismas se renaturalicen formando cadenas de ADN de doble hebra. En adición a las secuencias mezcladas, se agregan otras dos secuencias, de modo, que si vin (xinyin) representa la ciudad inicio y vout (xoutyout) la ciudad destino, estas secuencias serían xin y yout. De esta forma, se complementa también a las dos subsecuencias que no se hubiesen complementado por no existir un camino de llegada a la ciudad inicio ni de salida de la ciudad destino.

Figura 3-2

2. En el segundo paso, se procede a la separación de todos los caminos que comienzan con vin y terminan con vout. Esto no se realiza separando las cadenas ADN que representan caminos que cumplen las condiciones de otros que no las cumplen, sino replicando los caminos deseados por medio de reacción en cadena de polimerasa (RCP). De esta manera, la proporción de caminos no deseados pasa a ser insignificante en relación a la proporción de los caminos que realmente interesan.

18

3. En esta etapa, se produce la separación de todos los caminos que contengan siete ciudades. Esto se lleva a cabo separando las cadenas por longitud e identificando todas aquellas que posean 140 nucleótidos. Este proceso se realiza mediante la técnica de electroféresis con gel. Las secuencias extraídas del gel, son replicadas o amplificadas por RCP. La secuencia de realizar electroféresis con gel, extraer y amplificar, se repite varias veces con el fin de purificar la muestra.

4. Este paso consiste en separar todos aquellos caminos que pasen por todas las

ciudades. Para ello, se utiliza un conjunto de secuencias magnetizadas. Las cadenas bicatenarias de ADN obtenidas del paso anterior se desnaturalizan para obtener una solución de ADN de cadena simple y luego mezclarlas con la secuencia magnetizada que corresponde al complemento de la ciudad inicio. Las secuencias que se unan se extraen magnéticamente y representan a los caminos que incluyen a la ciudad inicio. Este proceso se repite sobre el resultado obtenido de la extracción previa para cada ciudad del grafo. Finalmente, se obtienen únicamente aquellos caminos que incluyen a las siete ciudades.

5. Para finalizar el experimento, debe detectarse si existe alguna secuencia de ADN

resultado del paso anterior. Esto se realiza amplificando los resultados mediante RPC, y luego, aplicando electroféresis con gel para determinar si existe alguna cadena con la longitud apropiada. Cualquier cadena obtenida, será una solución al problema planteado.

A manera de ejemplificación, se presentará a continuación un esquema simplificado del experimento de Adleman. Dadas cuatro ciudades, Roma, París, Londres y Madrid conectadas entre sí como se muestra en el grafo, se desea encontrar el camino Hamiltoniano que conecta Roma con Madrid.

Figura 3-3

Para ello, se definen las secuencias de nucleótidos asociadas a cada ciudad: Roma = CTATGCCGAAGTC París = CAGCGTGCGAGGG Londres = CCCGTACGTATTT Madrid = AAAATCGAGCCTA

19

Por otro lado, se definen también los caminos entre las ciudades: Roma – París CAG GTC París – Londres CCC GGG Londres – Madrid AAA TTT París – Madrid CCC TTT

Si se mezclan todas las cadenas (ciudades y caminos), se obtienen como resultado dos cadenas dobles de ADN, cada una de las cuales representa un camino para llegar de Roma a Madrid. Estas cadenas serían: (Roma) (París) (Londres) (Madrid) CTATGCCGAAGTCCAGCGTGCGAGGGCCCGTACGTATTTAAAATCGAGCCTA CAGGTC CCCGGG AAATTT

(Roma) (París) (Madrid) CTATGCCGAAGTCCAGCGTGCGAGGGAAAATCGAGCCTA CAGGTC CCCTTT

Como puede verse, la segunda cadena de ADN sería eliminada de las posibles soluciones en el tercer paso, o sea, cuando se busquen aquellas cadenas que tengan cuatro ciudades (para este caso, 52 nucleótidos, 13x4). Al terminar con el experimento se obtendría como resultado, la primer cadena, aquella que une las cuatro ciudades partiendo de Roma y llegando a Madrid.

3.1.1 Conclusiones del experimento La principal importancia de este experimento fue el nacimiento de la computación con ADN. Con esta nueva concepción, aparece la posibilidad de realizar procesamiento masivamente paralelo. Esto puede notarse en el primer paso del experimento, en el cual se obtienen todos los posibles caminos a través del grafo. Adleman estima un límite de 1020 operaciones para el primer paso, con lo cual, plantea que este paralelismo masivo haría insignificante a cualquier tipo de demora que se produzca en alguno de los otros pasos. Como resultado de su trabajo, Adleman identifica algunas ventajas potenciales de la computación con ADN sobre la computación basada en silicio [Adl1]:

1. Velocidad: la computación basada en ADN permite el procesamiento altamente paralelo. Mientras que una computadora de escritorio ejecuta aproximadamente 106 operaciones por segundo y una supercomputadora ejecuta 1012 operaciones por segundo, la computación con ADN permite realizar aproximadamente 1020 operaciones por segundo.

2. Consumo de energía: la computación con ADN permite ejecutar 2x1019 operaciones

por Joule, mientras que un supercomputador sólo puede llevar a cabo 109 operaciones por Joule.

20

3. Densidad de información: el almacenamiento de información en moléculas de ADN

permite una densidad de aproximadamente 1 bit por nm3. Comparando con la densidad de almacenamiento de un video tape que es de aproximadamente 1bit por 1012 nm3, se deja a la vista la potencialidad del ADN en este aspecto.

Finalmente, resulta necesario aclarar que este experimento tomó aproximadamente siete días de trabajo de laboratorio y que varios de los pasos requirieron la intervención humana.

3.2 La primer representación binaria En 1995, Richard Lipton se apoyó en el experimento de Adleman para generar un conjunto con todas las cadenas binarias de longitud n [Lip]. El procedimiento de Lipton consiste en crear un grafo de longitud n, de modo que cada camino a través del mismo represente un determinado número binario de longitud n. El grafo se implementa del mismo modo en que lo hizo Adleman.

Figura 3-4

Un grafo Gn se halla compuesto por los nodos S0, B1, B1, S1,...., Sn. El grafo se construye de tal manera que todos los caminos comiencen por S0 y finalicen en Sn. En cada nodo Sk, el camino debe tomar una de dos posibles bifurcaciones. Si selecciona un vértice Bk, se codifica un 1. En caso de seleccionar un vértice Bk, se codifica un 0. De este modo, el camino S0B1S1B2S3 representa al número binario 01.

3.3 El Modelo de Stickers El modelo de stickers fue desarrollado por Sam Roweis junto a la colaboración de Leonard Adleman, entre otros. La publicación del mismo se realizó en mayo de 1996 [Row]. Las principales diferencias de este modelo con los modelos de computación con ADN hasta ese momento desarrollados residen en la posibilidad de contar con memoria de acceso aleatoria sin necesidad de extensión de cadenas, la no utilización de enzimas y la reusabilidad de los materiales utilizados.

21

Básicamente, el modelo de stickers presenta una nueva forma de representar la información mediante ADN y define una posible serie de operaciones básicas para esta representación.

3.3.1 Representación de la información El modelo de stickers emplea dos grupos básicos de cadenas simples de ADN. A las cadenas del primer grupo se las llama “hebras de memoria”. Formalmente, estas cadenas se encuentran compuestas por N bases, y son subdivididas en una serie de regiones K, cada una de las cuales posee M bases de longitud. Cada región identifica exactamente a una posición de un bit. Por el otro lado, se encuentra el grupo con las “hebras stickers” o simplemente “stickers”. Se diseña un número K de stickers diferentes, cada uno de los cuales tiene una longitud de M bases y es complementario a una y sólo una de las K regiones de memoria. Cuando un sticker se fusiona o naturaliza con su región complementaria, entonces el bit correspondiente a esa región pasa a encontrarse en 1. Si ningún sticker se fusiona a una región particular, el bit asociado a esa región posee el valor 0.

Figura 3-5

Cada hebra de memoria junto a sus stickers asociados, representa una cadena de bits. A diferencia de otros modelos previamente presentados, la presencia o ausencia de una subsecuencia particular en una cadena implica un bit en nivel alto o un bit en nivel bajo. En este modelo, cada cadena de bits se representa por una única asociación de hebras de memoria y de stickers, y por lo tanto, por una única molécula de ADN. La densidad de información con este esquema de almacenamiento es de 1/M bits/bases. A pesar de que el almacenamiento de información en ADN tiene un valor máximo teórico de 2 bits/base, en este modelo se prefiere sacrificar la densidad de información con el objetivo de simplificar las experimentaciones.

3.3.2 Operaciones con cadenas de bits El modelo de stickers presenta una serie de posibles operaciones a realizar sobre las cadenas de bits. Dichas operaciones son: combinación de dos conjuntos de cadenas formando un nuevo conjunto, separación de un conjunto de cadenas en dos nuevos conjuntos, y set y reset del enésimo bit de todas las cadenas de un conjunto. A continuación se detallan cada una de las mismas.

22

Ø La operación más básica consiste en combinar dos conjuntos de cadenas de bits en uno sólo. Este nuevo conjunto pasa a estar formado por la unión de todas las cadenas de los dos conjuntos de entrada.

Figura 3-6

Ø La separación de un conjunto de cadenas en dos nuevos conjuntos consiste en obtener

todas aquellas cadenas con un determinado bit en 1 formando uno de los conjuntos, y todas aquellas cadenas con el mismo bit en 0 para formar el otro conjunto. Esto se logra aislando del tubo con el conjunto de cadenas de entrada, aquellas con un sticker fusionado a la región en consideración.

Figura 3-7

Ø El seteo de un bit particular en todas las cadenas de un conjunto dado consiste en

fusionar el sticker apropiado para la región a cada una de las cadenas.

Figura 3-8

Ø El reset de un determinado bit de todas las cadenas del conjunto se realiza removiendo

el sticker correspondiente a ese bit de cada una de las cadenas.

23

Figura 3-9

El procesamiento en este modelo consiste en una secuencia de combinaciones, separaciones, sets y resets de bits. Esta secuencia se inicia sobre conjunto inicial de cadenas de bits y finalmente produce un conjunto de posibles cadenas resultado. Un paso importante para realizar el procesamiento consiste en la creación del tubo inicial, también llamado “tubo madre”. Este tubo debe contener una librería de cadenas (K, L), siendo K la longitud de cada cadena, que a su vez son generadas por todas las posibles cadenas de bits de longitud L seguidas por K – L ceros. De este modo, el tubo queda formado por 2L cadenas de longitud K. Por ejemplo, una librería de cadenas (7, 3) estaría formada por el conjunto {0000000, 0010000, 0100000, 0110000, 1000000, 1010000, 1100000, 1110000}. Dado un problema combinatorio con entradas de longitud L, se buscan las cadenas resultado procesando las 2L posibles entradas en paralelo, y eliminando todas aquellas que no apliquen al criterio de búsqueda. Debe destacarse que la hebra de memoria debe tener más que L regiones de bits. Los primeros L bits representan la codificación para la entrada, y los K – L bits restantes se usan de almacenamiento intermedio y codificación de resultados. Inicialmente esta última secuencia de bits se encuentra en 0. Cada uno de los bits pueden ser leídos o escritos a lo largo de todo el proceso. Finalmente, para obtener la solución al problema, debe aislarse cada cadena del tubo resultado y detectar la existencia de stickers fusionados. Alternativamente, debe detectarse la inexistencia de cadenas en el tubo resultado.

3.3.3 La máquina de Stickers Como parte de este modelo, se define también una máquina de stickers teórica que posibilita su implementación. Básicamente, esta máquina se compone de un rack de tubos, robots, bombas de fluídos, calentadores y refrigerantes, los cuales son controlados por una computadora central. Esta máquina almacena el ADN que representa la información en “tubos de datos”. Cada uno de estos tubos es un cilindro cerrado con un conector en cada extremo que permite el ingreso y egreso de fluídos. En uno de estos extremos se encuentra una membrana, la cual permite el paso de fluídos pero no de hebras de memoria ni de stickers. Cuando un tubo de datos no está siendo utilizado, el conector correspondiente al extremo donde se encuentra la membrana permanece hacia abajo y con las cadenas de ADN sobre la membrana. Cada cadena de bits se encuentra asociada a un determinado tubo de datos que contiene hebras de memoria y stickers que representan esa cadena. Del mismo modo, cada bit se asocia a un tubo de datos que contiene stickers correspondientes al bit en cuestión.

24

Por otro lado, en adición a los tubos de datos, se encuentran los “tubos operadores”. Estos tubos tienen una construcción externa similar a los anteriores, pero difiere su contenido. El “tubo blanco” es simplemente un tubo operador vacío con un conector en cada extremo. El “tubo de stickers” es idéntico al anterior, excepto por un filtro permanente en su interior que permite el paso de stickers pero no de hebras de memoria. Durante la operatoria de la máquina, sólo algunos tubos se encuentran en uso. Todos aquellos tubos que no se estén usando permanecen almacenados en un rack. Cualquier operación simple ocurre de la siguiente manera:

1. Bajo el control de la computadora central, un robot selecciona del rack dos tubos de datos y un tubo operador.

2. Cada tubo de datos, se conecta por el extremo donde se encuentra la membrana a uno de los extremos del tubo operador. Los extremos opuestos de los tubos de datos se empalman a una bomba.

3. La bomba se pone en funcionamiento haciendo ciclar la solución a través de los tres tubos. La dirección de flujo puede ser hacia el primer tubo, hacia el segundo, o una combinación de ambos. La temperatura, dirección y duración del flujo son controladas por la computadora central.

4. Una vez que cesa el flujo, uno o más tubos se desconectan y se colocan nuevamente en el rack.

Figura 3-10

Al terminar la operación, se seleccionan del rack nuevos tubos comenzando una nueva operación. Para ejemplificar la operatoria de la máquina, se detalla a continuación la ejecución de las operaciones de combinación y seteo de bits. En la operación de combinación, se utilizan dos tubos de datos y un tubo operador blanco. La bomba hace fluir la solución hacia el primer tubo de datos, con lo cual todas las cadenas de ADN se combinan en dicho tubo. En la operación de seteo de un determinado bit, se utilizan en principio dos tubos de datos (uno con las cadenas a setear y otro con los stickers adecuados) y un tubo operadores de stickers. Se hace fluir la solución en ambos sentidos, produciéndose la fusión de los stickers con las cadenas. Luego la solución fluye hacia el tubo de datos de stickers, por lo cual, los stickers no usados retornan a su tubo original y las cadenas quedan capturadas en el filtro del tubo operador. Se desconecta el tubo de datos de stickers retornándolo al rack, y se lo reemplaza por un tubo blanco. Se hace fluir la solución hacia el tubo de datos que

25

originalmente contenía las cadenas a setear, quedando todas las cadenas nuevamente en este tubo. En el Anexo I, se describe una aplicación de esta máquina de Stickers.

3.4 Operaciones aritméticas con ADN Frank Guarnieri presentó en 1996 un procedimiento para implementar la adición de dos números binarios positivos aplicando reacción en cadena [Mal]. A continuación se presenta un algoritmo en código pseudo-C que facilitará el posterior análisis del procedimiento molecular. int numero1[n]; /* Números binarios representados como arrays de bits */ int numero2[n]; carry = 0; /* Mantiene el valor de carry correspondiente al bit anterior */ x2 = 0; /* Variable intermedia que mantiene el valor de carry + numero2 */ for (i=0; i < n; i++) { if (numero2[i] == 0) /* Cálculo de carry + numero2 */ if (carry == 0) x2 = 0; else if (carry == 0) x2 = 1; else x2 = 2; if (numero1[i] == 0) /* Cálculo de numero1 + x2 */ switch (x2) { case 0: output(0); carry = 0; break; case 1: output(1); carry = 0; break;

case 2: output(0); carry = 1; break; } else switch (x2) { case 0: output(1); carry = 0; break; case 1: output(0); carry = 1; break;

case 2: output(1); carry = 1; break; } } if (carry == 1) output(1); /* Arrastra el último carry */ Como puede observarse, en el algoritmo anterior no se realiza explícitamente ninguna operación de suma. Este procedimiento es similar al utilizado por Guarnieri para sumar números binarios por medio de moléculas de ADN. A continuación se detalla la resolución de la operación binaria 11 + 11, por medio del método propuesto por Guarnieri.

26

1. La adición se realiza desde el bit menos al más significativo. La suma para la posición

binaria menos significativa es más simple que para las demás posiciones debido a que no existe carry correspondiente a la operación anterior. Inicialmente, el bit menos significativo de la cadena respuesta, es el mismo que el bit menos significativo del primer sumando (n1). Este bit se suma al bit menos significativo del segundo sumando (n2), y se obtiene como resultado en la cadena respuesta tanto la suma previamente realizada como una secuencia representando la presencia o ausencia de carry.

Figura 3-11

En términos moleculares, existen dos cadenas representando a n2 (una representa el caso en que el bit menos significativo de la respuesta, y por lo tanto de n1, es un 0, y la otra representa el caso en el que este bit equivale a un 1). Además, ambas cadenas incluyen el valor de la suma posicional y el valor del carry. En la figura anterior, se representan entre paréntesis las subsecuencias que codifican sumas parciales. Los valores no encerrados entre paréntesis, representan bits del resultado. Para este operación particular, la cadena n2 que representa el caso en el cual el bit menos significativo de n1 es 1, se fusiona con la cadena repuesta (esto se debe a que cada una de las cadenas n2 se codifican de modo que se complementen con la respuesta según el caso). Luego, por medio de polimerasa, se extiende la cadena respuesta complementando a la cadena n2. Como resultado, se obtiene una cadena respuesta, que incluye al bit 0 como el bit menos significativo del resultado, y la subsecuencia (1) representado el carry generado. Por último, la cadena respuesta se desnaturaliza en una única hebra de ADN.

2. Para la segunda posición de la cadena binaria, la adición se realiza en dos pasos. En el primero, se suma el carry a la segunda posición de n1. Luego, en un segundo paso, se adiciona el resultado anterior a la segunda posición de n2. Como puede observarse, el valor intermedio entre ambos pasos equivale a la variable x2 del algoritmo presentado anteriormente.

27

Figura 3-12

Molecularmente, el valor de n1 en su segunda posición se representa mediante dos cadenas. Una de ellas representa el caso en el cual no existió carry en la operación anterior, y la otra representa la existencia del mismo. Cada una de estas cadenas tiene asociado un valor intermedio x2. En esta suma particular, la cadena que considera la existencia de carry se fusiona con la cadena respuesta, la cual nuevamente se extiende complementando a la secuencia que representa a x2.

Figura 3-13

En el segundo paso, n2 posee tres cadenas que la representan. Cada una de estas cadenas equivale a cada caso del switch del algoritmo anterior, y por lo tanto, existe una cadena para cada resultado posible del paso anterior (x2). Como el resultado del paso anterior es 2, la cadena asociada a este caso se fusiona a la cadena respuesta. Una nueva extensión ocurre sobre esta cadena, que pasa a incluir un 1 como segundo bit de salida, y un 1 de carry.

3. Finalmente, se analiza la existencia de carry final para replicarlo en la salida. En este caso, existe una única cadena, la cual considera la existencia de carry en la última operación.

28

Figura 3-14

Como la operación anterior produjo carry, la cadena se fusiona con la cadena respuesta y se produce una nueva extensión de la misma. Esta extensión consiste, en un nuevo bit del resultado, correspondiente al arrastre del carry, y cuyo valor es 1.

El procedimiento de Guarnieri presenta como defecto que la codificación del número binaro de salida difiere de la codificación de los dos números de entrada. De esta manera, la salida no puede utilizarse en forma directa como entrada de una nueva operación sin pasar previamente por una traducción al formato de entrada.

3.5 El autómata de ADN La construcción de un autómata de ADN consiste en uno de los últimos y más importantes avances de la computación de ADN. Esta máquina fue desarrollada por el Weizmann Institute of Science de Israel y presentada en el 2001 [Sha1]. Una máquina de estados consiste en una cinta dividida en celdas, cada una de las cuales contiene un símbolo correspondiente a un alfabeto determinado, y un dispositivo de procesamiento que se rige por ciertas reglas de transición. El dispositivo se posiciona sobre una de las celdas, y dependiendo del símbolo leído y de su estado interno, siguiendo una determinada regla de transición, escribe un nuevo símbolo, cambia de estado y se mueve una celda hacia la izquierda o hacia la derecha. La máquina de Turing es la máquina de estados más general, con capacidad de escribir sobre la cinta y de moverse en ambas direcciones. Una clase de máquina de estados más restringida es el autómata finito. Un autómata finito es una máquina de Turing unidireccional de sólo lectura. La entrada a esta máquina consiste en una cadena finita de símbolos. Inicialmente, la máquina se encuentra en un estado interno inicial y comienza a leer símbolos de izquierda a derecha, con posibles cambios de estado en cada lectura. El software de esta máquina consiste en reglas de transición, cada una de las cuales especifica el siguiente estado, de acuerdo al estado actual y el símbolo leído. El procesamiento finaliza cuando se lee el último símbolo, obteniendo un estado final como salida. Alternativamente, el procesamiento se suspende cuando para el estado actual y el símbolo leído no puede aplicarse ninguna regla de transición. Se dice que el autómata acepta

29

una entrada si existe algún procesamiento del mismo que finalice en algunos de los estados previamente definidos como estados finales. Los autómatas finitos se representan mediante grafos, que muestran los estados de la máquina, y las transiciones entre los mismos de acuerdo al símbolo de entrada.

Figura 3-15

El autómata finito de ADN se implementó mediante cadenas doble de ADN, tanto para el software como para la entrada, y una enzima de restricción llamada FokI funcionando como hardware. A continuación se describe cada uno de los componentes del autómata. El estado actual y el símbolo de entrada se codifica por medio de cinco nucleótidos, donde los cuatro nucleótidos de la izquierda representan el estado S1 y el símbolo leído, y similarmente los cuatro nucleótidos de la derecha representan el estado S0 y la lectura realizada. Mediante secuencias especiales, se codifican los estados finales del autómata.

Figura 3-16

El hardware se encuentra compuesto por la enzima restrictiva FokI que identifica la secuencia GGATG y extrae nueve nucleótidos de una de las dos cadenas complementarias de entrada y trece de la otra.

Figura 3-17

30

El software se compone de varias cadenas, cada una de las cuales especifica una regla de transición, al detectar el estado actual y el símbolo de entrada y determinar el estado siguiente. Cada cadena está formada, de izquierda a derecha, por un sitio de identificación para la enzima FokI (GGATG), nucleótidos espaciadores de longitud variable que determinan el sitio de corte de FokI sobre la cadena de entrada definiendo el siguiente estado, y un detector del par <estado actual, símbolo>. Las cadenas sin espaciadores producen una transición del estado S1 a S0, las de un espaciador mantienen el estado actual y las de dos espaciadores transfieren del estado S0 a S1.

Figura 3-18

La entrada del autómata consiste en una doble cadena que comienza con la representación del estado inicial y el primer símbolo. Cada símbolo se codifica, como se explicó anteriormente, con cinco nucleótidos. Los símbolos se separan entre sí por medio de tres nucleótidos espaciadores.

Figura 3-19

El procesamiento del autómata se realiza a través de una cascada de ciclos de transición. En cada ciclo, el hardware, guiado por una determinada cadena de software, corta un símbolo de la cadena de entrada. De esta manera, el autómata queda en un nuevo estado actual y ante un nuevo símbolo de entrada para procesar. El proceso continúa hasta que ninguna cadena de software se complemente con la entrada, o bien, hasta encontrar en la entrada un estado final. La identificación de la secuencia de ADN correspondiente al estado final permite obtener la salida del autómata.

31

Figura 3-20

El aspecto más importante en la operación de este autómata reside en la utilización de la energía potencial libre, propia de las cadenas simples de ADN, como fuente energética en cada ciclo de transición. De este modo, el autómata es capaz de procesar entradas de cualquier longitud, por medio de una cantidad fija de moléculas de software y hardware, sin necesidad de ninguna fuente externa de energía [Sha2]. Otra característica destacable de esta máquina se encuentra en el reciclado del hardware y software utilizado en cada transición, quedando disponibles para ser utilizados en transiciones subsiguientes. Esto se debe a la disociasión espontánea de las cadenas de software y el símbolo de entrada cortado por el hardware. En relación a la performance de esta máquina, se destacan las siguientes características:

ü Procesamiento de 3x1012 autómatas/µl. ü Ejecución de 6.6x1010 transiciones/seg/µl.

ü Disipación de 5x10-9 W/µl como calor.

ü Velocidad de ejecución de cada autómata de 20 seg/transición.

En el Anexo II, se presentan los resultados experimentales de la implementación del autómata.

3.6 ADN sobre superficies Hasta el momento, todas las investigaciones presentadas se implementaron sobre soluciones de ADN. Sin duda, este tipo de implementación no puede considerarse una alternativa futura para el procesamiento basado en ADN. Por tal motivo, un grupo de

32

profesionales interdisciplinarios de la Universidad de Wisconsin llevaron a cabo un proyecto de inmovilización de cadenas de ADN sobre superficies sólidas [Cor]. Una de las ventajas más importantes que ofrece la inmovilización de ADN sobre superficies es un manejo más simple y automatizado de las cadenas, con un mayor control sobre las operaciones químicas. En contrapartida a esta facilidad, se tiene una pérdida en la densidad de las cadenas (de tres a dos dimensiones) y un desplazamiento más lento de las enzimas sobre la superficie. La inmovilización se logra a través de conexiones químicas entre las cadenas y la superficie. Uno de los extremos de las cadenas se prepara especialmente para la conexión, al igual que la superficie. Una buena conexión química asegura que las cadenas previamente preparadas se inmovilicen sobre la superficie a una alta densidad, y que no lo hagan aquellas cadenas sin preparación. Como superficie de inmovilización se utilizó una placa de cristal cubierta por una capa de oro delgada. Las operaciones que se implementaron como parte del proyecto consistieron en el marcado y selección de cadenas, la unión de nuevas cadenas a los extremos libres (no inmovilizados), la eliminación de estas nuevas cadenas agregadas, y la destrucción selectiva de cadenas. Este proyecto se considera de gran importancia por ser el primero en lograr la manipulación de ADN inmovilizado en una superficie sólida. A partir de este proyecto, surgieron nuevos proyectos en la Universidad de Wisconsin que intentan refinar el modelo inicialmente propuesto y hacerlo lo más genérico posible.

Análisis del nuevo

paradigma de procesamiento

34

4 Análisis del nuevo paradigma de procesamiento En este capítulo se presenta un análisis de la Computación con ADN como nuevo paradigma de procesamiento. Inicialmente, se demuestra la necesidad de investigar nuevos paradigmas de procesamiento ante las limitaciones propias de la tecnología actual. Posteriormente, se realiza una comparación de la computación con ADN y la computación electrónica tradicional resaltando ventajas y desventajas de cada una. Finalmente, se presenta el futuro campo de aplicación de la computación con ADN y se analiza la universalidad de la misma.

4.1 La necesidad de un nuevo paradigma La tecnología de procesamiento basado en silicio se encuentra actualmente en una constante evolución respecto a su capacidad de procesamiento. Sin embargo, esta tecnología presenta ciertas limitaciones que le impedirán satisfacer futuras necesidades de procesamiento. Estas limitaciones se vinculan en forma directa a los métodos utilizados actualmente para aumentar la velocidad de procesamiento [Ful]. Uno de los principales métodos para incrementar la velocidad de procesamiento consiste en reducir las distancias que recorren las señales eléctricas. Esto implica aumentar la densidad de transistores y de componentes electrónicos que constituyen la unidad central de proceso. El aumento de esta densidad se logra construyendo transistores de dimensiones cada vez más pequeñas. Desafortunadamente, el menor tamaño posible de un transistor se encuentra limitado al tamaño de un átomo. De esta manera, queda expuesta la primer limitación de esta tecnología, impuesta por las leyes de la física.

Figura 4-1

Otro de los métodos a los que se recurre actualmente para aumentar la velocidad de procesamiento se basa en incrementar la frecuencia de trabajo. El incremento de frecuencia

35

implica un incremento proporcional en el consumo de energía, y por lo tanto, en la disipación de calor. Esta característica es otra de las limitaciones de la tecnología actual de procesamiento. Aunque la tecnología actual provea la suficiente potencia de procesamiento para el manejo de aplicaciones cotidianas, el software del futuro necesario para actividades como planeamiento estratégico hiper-realístico, mapeo de rutas aéreas más eficientes, etc. demandará una capacidad de procesamiento que la tecnología semiconductora no será capaz de proveer. Por otro lado, los diseñadores de software se encuentran continuamente desarrollando aplicaciones que obligan a los fabricantes de hardware a aumentar la potencia de sus equipos. De continuar esta tendencia y teniendo en cuenta las limitaciones del paradigma actual de procesamiento, resulta imprescindible la búsqueda de nuevos paradigmas capaces de satisfacer las futuras necesidades de procesamiento.

4.2 Computación tradicional vs. computación con ADN A continuación se analizarán las diferencias fundamentales entre el paradigma actual de procesamiento y el procesamiento basado en ADN: ü Procesamiento paralelo

La computación con ADN permite, como se expresó anteriormente, procesamiento masivamente paralelo. Una computadora de ADN puede ejecutar 1014 MIPS (Millones de Instrucciones por segundo) mientras que la más veloz computadora actual ejecuta solamente 109 MIPS. Esto se debe a que las reacciones químicas sobre las moléculas de ADN ocurren a alta velocidad y en forma completamente paralela.

ü Consumo de energía

La computación con ADN presenta un muy bajo consumo de energía. Este consumo se encuentra únicamente presente durante la ejecución de determinados procesos químicos, como por ejemplo, la desnaturalización o la RCP. En modelos como el autómata finito de ADN anteriormente descripto, se demostró no requerir de ninguna fuente externa de energía. En estos casos, la energía potencial propia de las cadenas de ADN simple se utiliza como única fuente energética [Sha2]. En el lado opuesto se encuentran las computadoras actuales con un consumo de energía muy ineficiente. Una computadora de escritorio típica trabaja con una fuente de energía de 250 Watt. En el caso de los mainframes, el consumo es incluso mayor necesitando de energía adicional para mantener sistemas que impiden el sobrecalentamiento del equipo. Para tener una idea más clara de la eficiencia de cada una de estas máquinas respecto al consumo de energía, vale recordar el análisis realizado por Adleman, quien expresó la cantidad de operaciones por unidad de energía capaz de realizar cada máquina [Adl1]. Según su informe, la supercomputadora más potente de la actualidad ejecuta 1x109 operaciones/Joule mientras que una máquina de ADN es capaz de ejecutar

36

2x1019 operaciones/Joule. Esto indica un consumo de energía 20 mil millones de veces más eficiente de las computadoras de ADN.

ü Capacidad de memoria

La computación con ADN presenta una densidad de información extremadamente alta. Según cálculos de Adleman permite almacenar 1 bit/nm3 [Adl1]. Por lo tanto, en 1 gramo de ADN (1 cm3 o 1x1021 nm3), se pueden almacenar 1x1021 bits, o sea 115x109 GB. Dicho de otro modo, 1 gramo de ADN equivale a 200 mil millones de CDs.

ü Resolución de problemas NP Completos

La computación con ADN permite resolver problemas del tipo NP Completos (como el problema de los caminos Hamiltonianos) en razón de semanas. Las computadoras electrónicas son incapaces de resolver estos problemas, al menos en un tiempo razonable.

ü Velocidad para operaciones individuales

En forma contraria a la resolución de problemas NP Completos, el tiempo de resolución de operaciones individuales por medio de procesamiento con ADN es muy alto. Una operación básica como una suma o una función AND llevaría varias horas de ejecución (el mismo tiempo que insumiría la resolución de un problema combinatorio complejo) [Ful]. En cambio, los procesadores electrónicos actuales ofrecen una muy alta velocidad en la ejecución de operaciones individuales.

ü Velocidad de lectura

Actualmente, el proceso de búsqueda y lectura de una secuencia de ADN implica entre una y tres horas de procesamiento. Considerando estas velocidades de lectura, la computación con ADN queda acotada, al menos hoy en día, a aplicaciones en las cuales el tiempo de respuesta no sea un factor relevante.

En contraposición, la tecnología actual presenta tiempos de acceso a disco de 15ms.

ü Confiabilidad

Las computadoras convencionales no presentan problemas de confiabilidad debido a que los electrones “no cambian”. En cambio, el ADN muta naturalmente y en forma aleatoria, e incluso se deteriora.

Por otro lado, las manipulaciones de ADN son propensas a los errores. Respecto a la reutilización de material genético en más de un experimento, se realizaron una serie de estudios los cuales concluyeron que la restauración del ADN es una tarea de gran complejidad.

37

4.3 Aplicaciones Las perspectivas respecto las posibles aplicaciones de la computación con ADN son muy amplias. Entre las mismas se destacan: ü Resolución de problemas NP Completos

La capacidad de la computación con ADN para resolver este tipo de problemas ya quedó ampliamente demostrada.

ü Criptografía

Mediante computación con ADN, se logró romper el sistema de encriptación DES (Data Encryption Standard) [Adl2]. Este procedimiento de encriptación fue desarrollado por IBM y es ampliamente utilizado. Se basa en la encriptación de mensajes de 64 bits a partir de una clave de 56 bits. La seguridad de DES reside en la clave secreta de encriptación, ya que el procedimiento utilizado es conocido. Básicamente, la clave de encriptación se obtuvo aplicando la metodología de “fuerza bruta” sobre el conjunto de todas las posibles claves de 56 bits.

En el Anexo I, se describe más detalladamente esta aplicación. ü Memoria molecular

Dada la enorme capacidad de memoria que ofrece la computación con ADN, sería interesante la construcción de una memoria molecular con recuperación masivamente paralela de la información.

ü Reconocimiento de lenguajes regulares

A partir del autómata de ADN, se encuentra una nueva aplicación que consiste en el reconocimiento de lenguajes regulares. Específicamente, dichos lenguajes son usados en la construcción de analizadores léxicos y sintácticos en los lenguajes de programación contemporáneos.

ü Medicina

La computación con ADN encuentra también aplicación en el área de la medicina. La construcción de enzimas, secuencias de ARN y otras moléculas que se utilizan en bioingeniería requieren un proceso similar al de los modelos de computación con ADN [Ada].

ü Otras aplicaciones

38

La inteligencia artificial, el diseño y fabricación asistidos por computadora, el diseño electrónico automatizado y la robótica, se consideran también futuros campos de aplicación de la computación con ADN [Ada].

4.4 Universalidad del nuevo paradigma En el capítulo anterior, se demostró la capacidad de la computación con ADN para la resolución de problemas específicos, como el de los caminos hamiltonianos. Lo que aún no pudo demostrarse es la existencia de una máquina de ADN universal, o sea, capaz de procesar cualquier función procesable dada. A pesar de no existir actualmente una máquina de ADN universal, el autómata de ADN anteriormente presentado es una importante aproximación a dicha máquina. Sólo basta recordar que un autómata finito es una clase restringida de una máquina de Turing, y que a su vez, esta última es una máquina de procesamiento universal. De este modo, puede pensarse que la universalidad de la computación con ADN es factible, y que se alcanzará en un futuro no muy lejano. Una vez construida la máquina universal de ADN, habrá que analizar si la misma ofrece ventajas sobre el paradigma actual de procesamiento respecto a la resolución de problemas tradicionales, como ocurre con la resolución de problemas NP-Completos.

Modelo propuesto para el desarrollo

basado en Computación con ADN

40

5 Modelo propuesto para el desarrollo basado en Computación con ADN

La resolución de problemas mediante computación con ADN se encuentra hoy en día en un estado inicial, no existiendo aún un modelo que permita al desarrollador independizarse de la implementación del hardware o implementación biológica. Esto se debe a que no existe una separación clara entre el software y el hardware. De este modo, el desarrollador se encuentra obligado a poseer un conocimiento completo del hardware para poder llevar a cabo su solución. El objetivo de esta tesis es presentar un modelo que abstraiga al desarrollador de la implementación del hardware, permitiéndole focalizar en el desarrollo del software. Por otro lado, debe establecer una notación común a utilizar, estandarizando y formalizando el proceso de desarrollo. El primer paso en la definición de este modelo es enmarcarlo dentro de una serie de etapas o actividades que posibiliten un desarrollo consistente y estructurado. De este modo, se propone el siguiente modelo:

Figura 5-1

41

A continuación se detallan cada una de las fases o etapas que conforman el modelo propuesto:

1. Análisis del problema

En esta etapa, se obtiene todo el conocimiento respecto del problema a resolver. Un análisis y una comprensión adecuada del problema resultan de fundamental importancia para lograr el éxito en la implementación final. Un posible error en esta etapa sería continuar con el desarrollo sin tener una visión completa del problema en cuestión, con la idea de perfeccionar el conocimiento del mismo durante la ejecución de las subsiguientes etapas. La estandarización de esta etapa resulta de suma importancia para el desarrollador permitiéndole una más rápida comprensión de problemas resueltos por otras personas. Un análisis estandarizado libra al desarrollador de la tediosa labor de comprender un trabajo realizado sin la aplicación de técnicas formales. Para lograr esta estandarización, se define una notación común, mediante la cual se representan las entidades del problema, los valores que las mismas pueden tomar y los vínculos entre ellas. Las entidades son aquellos elementos o conceptos considerados relevantes por el desarrollador dentro del dominio del problema. La notación adoptada para las entidades es la siguiente: entidad <entidad 1> entidad <entidad 2> ... ... entidad <entidad n> Cada entidad puede tomar un conjunto de valores relativos al problema en cuestión. Cada uno de estos valores representan una instancia de la entidad y se los formaliza con la siguiente notación: valor <entidad 1, valor 1> valor <entidad 1, valor 2> ... ... valor <entidad n, valor m> A su vez, las distintas instancias de cada entidad se vinculan entre sí de diversas formas. La existencia de estos vínculos se representa de dos maneras, según afecte a todas las instancias de cada entidad o sólo a un subconjunto de ellas. Para el primer caso, se define la siguiente notación: vínculo <entidad 1 : entidad 2> ... ... vínculo <entidad n : entidad n>

42

En el segundo caso, en el cual sólo un subconjunto de instancias participan del vínculo, se debe especificar a cada una de ellas: vínculo <entidad 1, valor 1 : entidad 2, valor 2> ... ... vínculo <entidad n, valor n : entidad m, valor m>

2. Diseño de secuencias

En esta fase, el desarrollador diseña las secuencias de ADN a utilizar para la resolución del problema. Como parte de este modelo, se introduce también un formato de secuencias genérico. Este formato supone la existencia, para cada instancia de entidad, de un vínculo anterior y otro posterior.

Figura 5-2

De acuerdo a la notación de vínculo definida en la etapa anterior, toda instancia presente como segundo elemento del vínculo tiene un vínculo anterior con el primer elemento o instancia. De manera opuesta, toda instancia presente como primer elemento del vínculo tiene un vínculo posterior con el segundo elemento o instancia. Cada secuencia definida bajo este formato debe representar de manera única a cada instancia de entidad, con cada uno de sus vínculos anterior y posterior. Para ello, se propone la siguiente técnica de codificación:

ü Cada entidad definida durante el Análisis se codifica mediante una secuencia

única. ü Los valores de entidad se codifican también a través de secuencias únicas.

ü Se asigna una secuencia a cada vínculo definido en la fase anterior. A cada

instancia (entidad y valor), se asocia una secuencia como vínculo anterior y otra como vínculo posterior. A las instancias definidas como primer elemento de un vínculo, se asigna la secuencia asociada a tal vínculo como vínculo posterior. Por otro lado, a las instancias definidas como segundo elemento de un vínculo, se asigna, como vínculo anterior, a la secuencia complementaria asociada a dicho vínculo. Para aquellos casos en los cuales una instancia no posee vínculo anterior o posterior, debe definirse una secuencia común a utilizar, manteniendo de este modo la consistencia en el formato de codificación.

El diseño de secuencias puede convertirse en un trabajo muy arduo para problemas en los que intervengan un número elevado de instancias de entidad vinculadas entre sí. Precisamente, son estos casos en los cuales queda en evidencia la potencia del

43

procesamiento masivamente paralelo de la computación con ADN. Por tal motivo, es deseable contar en esta etapa con una herramienta de software que facilite esta tarea. Básicamente, la funcionalidad de esta herramienta consiste en generar automáticamente las diversas secuencias de ADN, a partir de las entidades, valores y vínculos definidos por el desarrollador en la entrada. Actualmente, no existe una herramienta con características similares a las planteadas, pero su futuro desarrollo sería de gran utilidad para el diseño de secuencias.

3. Selección de Operaciones Una vez definidas las secuencias de trabajo, es necesario especificar la operatoria a realizar con las mismas. Para ello, el modelo propone un conjunto de operaciones y una notación para representar la ejecución de las mismas.

A continuación, se presentan las posibles operaciones a realizar y la notación escogida para cada una de ellas:

ü Combinación: esta operación consiste en la mezcla física de un conjunto de

secuencias de ADN. Como resultado de su ejecución, se obtienen secuencias complementadas.

Figura 5-3

ü Selección por entidad: esta operación se basa en la extracción de todas aquellas

secuencias que posean un determinado valor para una entidad n, donde n es la posición de la entidad dentro de la secuencia.

Figura 5-4

ü Selección por inclusión: la selección por inclusión consiste en la extracción de

aquellas secuencias que incluyan a una determinada entidad o a una determinada instancia.

Figura 5-5

44

ü Selección por longitud: esta operación consiste en la selección de secuencias que posean una determinada longitud.

Figura 5-6

La notación a utilizar para una secuencia de operaciones completa sería:

Figura 5-7

4. Pruebas La etapa de Prueba implica la ejecución de la secuencia de operaciones definidas en la fase previa, con el fin de analizar los resultados obtenidos y determinar si los mismos son correctos o si es necesario realizar un ajuste sobre alguna de las etapas anteriores. La pruebas sobre un ambiente real son complejas ya que requieren del armado de todo un equipo de testeo. Por tal motivo, se plantea la necesidad del futuro desarrollo de una herramienta que permita simular un ambiente de procesamiento con ADN, facilitando de este modo la ejecución de pruebas. La prueba del algoritmo desarrollado se debe realizar empleando tanto el método de “caja blanca” como el de “caja negra”. La prueba de “caja blanca” implica un análisis de los resultados obtenidos luego de la ejecución de cada operación, sobre distintos conjuntos de secuencias de entrada. Cualquier desvío detectado en los resultados obliga a regresar a cada una de las etapas anteriores en busca de un error de diseño. La prueba de “caja negra” hace hincapié en el análisis del resultado final obtenido a partir de varios conjuntos de secuencias de entrada. Del mismo modo que en el caso anterior, un resultado no esperado implica un control sobre las etapas previas del modelo. Esta etapa finaliza cuando el desarrollador considera a su algoritmo libre de errores.

45

5. Implementación Una vez finalizadas las pruebas sobre el algoritmo diseñado, se pasa a la implementación final del mismo. En esta etapa, el algoritmo se ejecuta sobre un ambiente real de procesamiento con ADN. Cada una de las secuencias definidas durante el diseño se convierte en una molécula de ADN, y cada una de las operaciones en un proceso bioquímico.

Aplicación

del modelo propuesto

47

6 Aplicación del modelo propuesto Hasta el momento, el modelo que se propuso se definió de manera puramente teórica. Resulta sumamente importante a esta altura demostrar la interesante aplicación del mismo mediante la resolución de un caso práctico. En la búsqueda de dicho objetivo, se procede a realizar una selección detallada y cuidadosa que permita escoger un problema que resalte las ventajas que ofrece el modelo en cuestión.

6.1 Selección del problema Para seleccionar adecuadamente el problema es importante conocer previamente cómo se clasifican los mismos en cuanto a su complejidad computacional. Existen diversas técnicas para resolver problemas. Estas técnicas han sido aplicadas según diversos algoritmos. El modelo o técnica más fundamental es el de la Máquina de Turing. Los algoritmos considerados eficientes son aquellos cuyo tiempo de ejecución tiene su límite máximo en una función polinomial dependiente del tamaño de la entrada. Pero no todos los problemas pueden ser resueltos mediante algoritmos eficientes. Existen problemas para los cuales no existen, o aún no se conocen algoritmos de tiempo polinomial que los resuelvan. Debido a esa diferencia en la forma de resolución de los problemas, los mismos han sido agrupados en clases. La definición de clases para los diversos problemas es parte de la gran teoría de la complejidad computacional [FeV]. Definir la clase a la cual pertenecen los problemas y los algoritmos que los resuelven es muy importante para proveer los límites de tiempo de ejecución y de recursos. A su vez, los algoritmos pueden ser deterministas o no deterministas. Un algoritmo determinista es aquel cuyo resultado está determinado enteramente por sus entradas y su estado inicial. En cambio, en un algoritmo no determinístico, se presentan en ciertos puntos varios cursos de acción, como un árbol con posibilidad de procesamientos completos diferentes, con los nodos no terminales representando puntos de selección. Muchos algoritmos se expresan de manera más conveniente de esta última forma, pudiendo resolver problemas en un tiempo razonable e imposibles de llevar a cabo por un algoritmo determinista. La clase de todos los problemas que pueden ser resueltos por algoritmos determinísticos en tiempo polinomial es conocida como clase P. Estos problemas se dice que son tratables en el sentido que son abordables en la práctica. La clase de todos los problemas que tienen algoritmos de solución no determinísticos en tiempo polinomial se la denomina clase NP. Esto es, algoritmos no determinísticos en los cuales siempre hay un camino computacional exitoso que requiere tiempo polinomial en relación a la cadena de entrada. A pesar de esto, la realización de todas las combinaciones de entrada requiere un tiempo de ejecución exponencial. Como todo algoritmo o máquina determinista es un caso particular de una máquina no determinista, cualquier problema que cumple con los requisitos para pertenecer a P también cumple con los necesarios para pertenecer a NP. Así, P ⊆ NP. Todavía no se ha demostrado (ni a favor ni en contra) si el hecho de encontrar una solución polinomial sobre una máquina no determinista necesariamente implica que debe existir una solución polinomial de ese mismo problema sobre una máquina determinista. Es decir, no se sabe si NP ⊆ P, y por lo tanto, a partir de ambas inclusiones, si P = NP.

48

Existe una clase de problemas de mayor complejidad a los NP, y se la conoce como NP-Completa. Esta clase de problemas no pueden ser resueltos con algoritmos de tiempo polinomial, y tienen la característica de que todo problema NP se puede reducir polinomialmente a un problema de esta clase. Por lo tanto, es importante resolver problemas NP-Completos, porque si alguien puede resolver un problema NP-Completo en tiempo polinomial se podrán resolver todos los problemas NP en tiempo polinomial, así como también todos los problemas NP-Completos. Los problemas en los cuales no existe un algoritmo que pueda resolverlo en tiempo polinomial son considerados problemas computacionalmente intratables. Por ejemplo, si un algoritmo polinomial O(n²) siendo n el número de entradas del problema, requiere 1 microsegundo para resolver un problema de 10 entradas, requerirá 100 microsegundos para resolver un problema de 100 entradas. En cambio, si un algoritmo exponencial O(2n) necesita 1 microsegundo para resolver un problema de tamaño 10, necesitará 3,9 x 1013 centurias para resolver un problema de tamaño 100.

Figura 6-1

Sin duda, teniendo en cuenta la potencia de la computación con ADN para la resolución de problemas NP-Completos y que en la actualidad estos problemas son considerados intratables, resulta sumamente interesante que el modelo propuesto se aplique a un problema de esta clase. De este modo, queda acotado el espacio de búsqueda y sólo resta definir cúal de estos problemas se utilizará. Existe una gran variedad de problemas NP-Completos, destacándose el problema SAT, el de los caminos Hamiltonianos, Clique, entre otros [Sca]. El problema SAT o de satisfactibilidad fue el primer problema que se demostró ser NP-Completo, por lo que constituyó la piedra angular de la teoría de la complejidad computacional. En la práctica, SAT encuentra un gran campo de aplicación, como el diseño electrónico automatizado, la robótica, la planificación o scheluding, el diseño de arquitectura de computadoras, la gestión de redes informáticas, la inteligencia artificial, el diseño y fabricación asistidos por computadora, etc. [San]. SAT presenta la importante característica de poder plantear fácilmente otros problemas NP-Completos como SAT. Por todo lo enunciado anteriormente, SAT será el problema a resolver. Concretamente, el problema de satisfactibilidad consiste en encontrar una asignación de valores que hagan verdadera una función booleana expresada en Forma Normal Conjuntiva (FNC). La FNC es una conjunción de cláusulas, esto es, cláusulas unidas a través del conector lógico AND. A su vez, una cláusula es una disyunción de literales (literales unidas

49

mediante el conector lógico OR), y una literal es una variable booleana negada o no negada [Con]. A manera de ejemplo, se presenta la siguiente función lógica:

(x1 + ~x2 + ~x3) . (~x1 + ~x2 + x4) . (x2 + ~x3 + ~x4)

Las cláusulas pueden tener diferente número de literales. Los problemas con cláusulas de tres literales se los denomina 3-SAT, siendo tres el valor más pequeño para el cual SAT es NP-Completo. Para una fórmula con n variables, existen 2n posibles resultados. Este incremento exponencial, demuestra la dificultad del problema a medida que crece el número de variables.

6.2 Solución actual En la actualidad, existen diversos algoritmos de solución de SAT. Cada uno de ellos ha sido un intento de resolver SAT de la manera más eficiente posible. A pesar de esto, la resolución de problemas SAT de alta complejidad, o sea de muchas variables, se ve limitada por las capacidades de cómputo. Incluso, existen problemas incapaces de ser resueltos por la computación actual en un tiempo razonable. Uno de los algoritmos de solución de SAT más conocido es la búsqueda con backtracking [Lar]. La estrategia de este algoritmo es construir una solución parcial, la cual se va extendiendo hasta alcanzar una solución total. La extensión de una solución parcial a otra nueva solución parcial, implica la inclusión de una nueva variable. Cuando una solución no se puede extender porque la asignación de variables deja de satisfacer la fórmula, se procede al backtracking, que consiste en regresar a la solución parcial anterior. La búsqueda de la solución se realiza sobre un árbol de búsqueda. A cada nivel del árbol, se asocia una variable, sin tener en cuenta a la raíz. Los sucesores de cada nodo, son todos los posibles valores de la variable asociada a ese nivel.

Figura 6-2

La búsqueda se realiza mediante un recorrido en profundidad. Si el nodo que se está analizando lleva a descartar la solución parcial por no producir un resultado satisfactorio, el subárbol sucesor no se visita debido a que no contiene soluciones. En este caso, se dice que el

50

subárbol se poda, y se realiza el backtracking, retornando al nodo anterior y continuando el recorrido por la rama del nodo que no se visitó. Las soluciones al problema se obtienen al llegar a los nodos hoja del árbol y verificar que su valor junto al resto de los valores dejados atrás en el recorrido logran satisfacer la fórmula en cuestión. A continuación, se presenta un algoritmo de backtracking recursivo escrito en pseudocódigo que resuelve el problema de satisfactibilidad. funcion bt(x variable): booleano { para todo a ∈ [0,1] hacer { x := a si test(x, variablesPasadas) { variablesPasadas := variablesPasadas + x si bt(siguiente(x)) retornar Verdadero sino variablesPasadas := variablesPasadas - x } } retornar Falso } funcion test(x variable, P conjunto): booleano { para todo y ∈ P hacer { si (val(x), val(y)) ∉ rel(Rxy) retornar Falso /* rel(Rjk) = valores permitidos para Xj y Xk */ } retornar Verdadero }

Este algoritmo de backtracking tiene la desventaja de ser dependiente de la capacidades de cómputo disponibles. Esto se relaciona, como ya es conocido, con el alto consumo de recursos que involucra la recursividad. Problemas de alta complejidad llevan a un agotamiento de recursos antes de alcanzar la solución esperada.

6.3 Solución aplicando el modelo propuesto Como todo problema NP-Completo, SAT resulta de suma complejidad para la computación actual. Aprovechando las características propias de la computación con ADN para resolución de este tipo de problemas, se presenta a continuación la primer aplicación del modelo propuesto en esta tesis. La función booleana que se pretende satisfacer es la siguiente:

51

(x1 + ~x2 + ~x3) . (~x1 + ~x2 + x4) . (x2 + ~x3 + ~x4) Como puede verse, está función corresponde a un problema 3-SAT de no muy alta complejidad. La idea de trabajar con esta función es facilitar la comprensión del modelo simplificando la resolución del problema. 1. Análisis del problema

Una vez comprendido el problema que se intenta resolver, forma parte de esta etapa la identificación de entidades, instancias y vínculos. Se consideran entidades de este problema a las variables booleanas que forman parte de la función a resolver: entidad <x1> entidad <x2> entidad <x3> entidad <x4> A su vez, cada uno de los posibles valores que pueden tomar estas entidades determinan las distintas instancias del problema. Al ser variables booleanas, corresponden a cada entidad dos posibles valores: 0 y 1. Formalmente, las instancias identificadas son: valor <x1, 0> valor <x1, 1> valor <x2, 0> valor <x2, 1> valor <x3, 0> valor <x3, 1> valor <x4, 0> valor <x4, 1> Para concluir con esta etapa, sólo restan definir los vínculos entre las instancias. Los vínculos pueden identificarse de acuerdo a la ubicación de las variables dentro de la fórmula. Cada variable tiene como vínculo a sus variables adyacentes. De este modo, puede decirse que existe un vínculo entre las entidades x1-x2, x2-x3, x3-x1, x2-x4, x4-x2 y x3-x4.

Según se definió en el modelo, existen dos tipos posibles de vínculos: entre todas las instancias de las entidades vinculadas o entre un subconjunto de ellas. En este problema, se detectan únicamente vínculos del primer tipo. Esto puede notarse en el hecho de que x1 se relaciona con x2 tanto con su valor 0 como con su valor 1, y del mismo modo, x2 se relaciona con x1. Formalmente, los vínculos se denotan de la siguiente manera: vínculo <x1 : x2>

52

vínculo <x2 : x3> vínculo <x3 : x1> vínculo <x2 : x4> vínculo <x4 : x2> vínculo <x3 : x4>

2. Diseño de secuencias

Como se explicó anteriormente, el diseño de secuencias es una tarea que puede volverse muy ardua para determinados problemas si no se cuenta con la asistencia de un software de generación automática. Sin contar con esta herramienta y a los efectos de comprender mejor la aplicación del modelo, se diseñarán algunas de estas secuencias siguiendo detalladamente las especificaciones del mismo. Inicialmente, debe definirse una secuencia única para cada entidad. De este modo, se definen las siguientes secuencias, teniendo siempre en cuenta que las mismas no sean complementarias. entidad <x1> = ATCG entidad <x2> = TTAA entidad <x3> = CCGG entidad <x4> = ACGT Los valores que pueden tomar las distintas entidades se codifican también a través de secuencias únicas. Para este problema existen únicamente dos valores posibles para todas las entidades: 0 y 1. 0 = ACT 1 = TGG El modelo contempla también la definición de secuencias para cada uno de los vínculos identificados en la etapa anterior. Estas secuencias no deben ser complementarias entre sí. vínculo <x1 : x2> = GCGC vínculo <x2 : x3> = ATAT vínculo <x3 : x1> = CCCT vínculo <x2 : x4> = AAAT vínculo <x4 : x2> = GAGA vínculo <x3 : x4> = CTCG Asimismo, se define una secuencia común para aquellas instancias que no posean vínculos. Sin vínculo = ACAC Una vez realizada la codificación anterior, deben diseñarse las secuencias que realmente se utilizarán para la resolución del problema bajo el formato genérico descripto en el modelo.

53

Figura 6-3

Siguiendo este formato, se diseñan algunas de las secuencias finales a manera de ejemplo. ACACATCGACTGCGC Esta secuencia corresponde a la instancia con valor 0 de la entidad X1, la cual carece de vínculo anterior pero posee un vínculo posterior con X2. CGCGTTAATGGATAT Esta secuencia representa a la entidad X2 con valor 1, y con su vínculo anterior con X1 y posterior con X3. Nótese que el vínculo anterior con X1 es un complemento de la secuencia definida para el vínculo <x1 : x2>, según lo especificado por el modelo para los vínculos anteriores.

3. Selección de operaciones En esta etapa se determinan las operaciones a realizar sobre las secuencias definidas en la fase anterior. Como primer operación, debe ejecutarse una combinación de secuencias con el fin de generar automáticamente todo el espacio de soluciones posibles. Generadas todas las combinaciones de secuencias, deben seleccionarse sólo aquellas que posean la longitud correspondiente a secuencias de nueve entidades, ya que la fórmula se halla compuesta de nueve variables. Para realizar este filtro, se aplica una selección por longitud. Finalmente, deben seleccionarse aquellas secuencias cuyos valores de entidad satisfagan la fórmula booleana en cuestión. Con este objetivo, se realiza una selección por entidad para cada una de las literales de la primer cláusula, teniendo en cuenta que sus valores hagan que toda la cláusula tome valor 1. Para ello, se extraen las entidades no negadas en la cláusula con valor 1, y las negadas con valor 0. Una vez aplicadas las selecciones correspondientes a cada una de las tres variables de la primer cláusula, se aplica, sobre el subconjunto de secuencias obtenido, el mismo filtro para las variables de la segunda cláusula. Luego, se utiliza la misma lógica para filtrar por las variables de

Sin vínculo

X1

0

Vínculo con X2

Vínculo con X1

X2

1

Vínculo con X3

54

la tercer cláusula. Una vez aplicados estos sucesivos filtros de entidad, se obtienen como resultado las secuencias correspondientes a todas las posibles soluciones de la fórmula booleana. Aplicando la notación propuesta en el modelo, la secuencia de operaciones sería la siguiente:

Figura 6-4

4. Pruebas

En esta etapa, se verifica si el algoritmo desarrollado es correcto o es necesario realizar algún ajuste. Como lo indica el modelo, esta tarea debe realizarse con el soporte de alguna herramienta de software, dada la complejidad que implican las pruebas en un ambiente real.

5. Implementación

La implementación consiste en ejecutar el algoritmo solución sobre un ambiente real de procesamiento con ADN. La ejecución de esta etapa escapa del alcance de esta tesis.

Como pudo verse a lo largo de la resolución de este problema, el modelo propuesto permite al desarrollador abstraerse de la implementación biológica. Esto no ocurre en la etapa del diseño de secuencias, pero hay que recordar que la misma está pensada para ser ejecutada con la asistencia de una herramienta de software. De contar con dicha herramienta, la abstración permanece intacta, al menos hasta las etapas de prueba e implementación donde ya resulta necesario bajar al nivel biológico. Por otra lado, el modelo facilita la resolución y formalización de problemas NP-Completos a partir de un desarrollo consistente estructurado en etapas y apoyado por la notación común propuesta. En el Anexo III, se aplica el modelo propuesto a la resolución del problema de los caminos Hamiltonianos.

Conclusiones

56

7 Conclusiones Más allá de los pocos años de vida de la Computación con ADN, los avances logrados dejan a la vista su enorme potencial. El procesamiento masivamente paralelo, el bajo consumo de energía y la gran capacidad de memoria son las principales características que presenta este nuevo paradigma de procesamiento. Si se desea realizar un análisis respecto a la evolución que tendrá la Computación con ADN, se puede trazar un paralelo con la evolución de la Computación electrónica. Esta última nació en el año 1946 con la presentación del ENIAC (Electronic Numerical Integrator And Computer), una computadora capaz de realizar cientos de multiplicaciones por minuto. Su programa estaba físicamente determinado mediante el cableado del procesador, y cualquier modificación se realizaba en forma manual. El ENIAC pesaba 30 toneladas y contenía 18.000 válvulas de vacío. Los avances en electrónica fueron permitiendo la evolución progresiva de las computadoras hasta llegar a las potentes computadoras de la actualidad. Uno de los avances más importantes en este aspecto consistió en la creación del transistor. Si las Ciencias biológicas logran evolucionar como lo hizo la electrónica en la última mitad del siglo anterior, sin duda, se puede avizorar un futuro promisorio para la Computación con ADN. Se requiere, sobre todo, mejorar los métodos actuales de manipulación del ADN. En otras palabras, los biólogos deben lograr manipular las moléculas de ADN como los electrónicos lo hacen con los electrones. Hoy en día, dado que la mayoría de los avances giran en torno a la resolución de problemas de alta complejidad computacional, resulta fácil pensar que esta será la aplicación más próxima de la Computación con ADN. De este modo, se podrán resolver problemas de planeación, de diseño electrónico automatizado, de inteligencia artificial, etc., que actualmente no pueden ser resueltos con los recursos de hardware existentes. El modelo presentado en esta tesis es una aproximación a un modelo de Computación con ADN mucho más abstracto, que requiere menos conocimiento por parte del desarrollador de los detalles biológicos. A su vez, facilita la estandarización y formalización a lo largo de todo el proceso de desarrollo. Por todas estas características, este modelo se considera un importante aporte en el campo de la Computación con ADN.

7.1 Futuras líneas de investigación Dado el estado inicial en que se encuentra la Computación con ADN, resulta necesario continuar trabajando en torno a diversas líneas de investigación que se encuentran aún sin explorar. Por lo pronto, se deben buscar respuestas a los siguientes interrogantes que determinarán, en mayor o menor medida, el futuro de este nuevo paradigma:

ü ¿Se obtendrán tiempos de lectura aceptables?

Actualmente, la alta velocidad de procesamiento de la Computación con ADN se ve fuertemente perjudicada por los lentos procedimientos de lectura. En este aspecto, se requiere mejorar las técnicas de secuenciación del ADN.

57

ü ¿Se lograrán automatizar los procesos manuales? Los trabajos presentados hasta el momento requieren de la intervención humana en una o varias ocasiones durante la implementación de la solución. Resulta sumamente importante automatizar cada uno de estos procesos manuales.

ü ¿Se encontrará una solución al problema intrínseco de la transmisión de datos? Ningún investigador planteó aún un modelo aproximado de transmisión de datos para un entorno de Computación con ADN. Pensar en un sistema con interfaces electrónicas resulta, por lo pronto, lo más viable.

ü ¿Se podrá utilizar la Computación con ADN como paradigma de procesamiento universal? El autómata de ADN que se logró construir se considera una aproximación importante a la universalidad de la Computación con ADN. Sin embargo, es necesario seguir trabajando en este aspecto para poder determinar si el nuevo paradigma podrá en el futuro reemplazar al paradigma de procesamiento actual.

Respecto al modelo propuesto en esta tesis queda planteada, como se dijo anteriormente, la necesidad de desarrollar una herramienta de software que sirva de asistente para el diseño de secuencias. La funcionalidad básica de la misma consiste en generar las diversas secuencias de ADN a partir de las entidades, valores y vínculos definidos por el desarrollador en la entrada. Surge también del modelo, la necesidad de contar con una herramienta que permita simular un ambiente de procesamiento con ADN. Esta herramienta facilitaría las tareas que se realizan durante la etapa de pruebas evitando que las mismas tengan que ejecutarse sobre un ambiente biológico real, con todo lo que esto implica.

58

Anexo I Computación con ADN aplicada a la Criptografía La criptografía es uno de los campos donde la Computación con ADN encuentra una importante aplicación [Adl2]. A través del modelo de Stickers se logró romper el sistema de encriptación DES (Data Encryption Standard). DES fue desarrollado por IBM y se basa en la encriptación de mensajes de 64 bits a partir de una clave de 56 bits. El procedimiento de encriptación que utiliza es conocido y su seguridad se encuentra en la clave secreta. Actualmente, no existe ningún hardware especializado ni supercomputadora capaz de quebrar la seguridad de DES en un tiempo razonable. Básicamente, el problema en cuestión consiste en, dado un mensaje y su correspondiente mensaje cifrado, obtener la clave que se utilizó para tal encriptación. El procedimiento más sencillo se basa en encriptar el mensaje original con cada una de las 256 claves posibles hasta obtener el mensaje cifrado que le corresponde. Este procedimiento se lo conoce como “fuerza bruta”.

Figura I-1

El algoritmo molecular diseñado se basa en la utilización de 256 hebras de memoria, cada una compuesta por 11580 nucleótidos y dividida en 579 bloques contiguos (B0, B1, B2, ..., B578). A su vez, cada bloque se compone de 20 nucleótidos. Como lo indica el modelo de Stickers, existen 579 stickers (S0, S1, S2, ..., S578) complementarios a cada uno de los bloques. Cada cadena codifica 579 bits. El bloque o bit B0 se reserva para su posterior utilización durante la implementación del algoritmo. Los bloques B1 a B56 se utilizan para almacenar la clave, y los siguientes 64 bloques (B57 a B120) para almacenar el mensaje cifrado con la clave correspondiente. Los bloques restantes son destinados a resultados intermedios durante la ejecución. La máquina de Stickers trabaja bajo el control de un microprocesador. Este último es el encargado de almacenar el mensaje original, y es por eso, que no necesita ser representado en la cadenas de ADN. El algoritmo se implementa por medio de tres pasos básicos:

59

1. Entrada: inicialización de las hebras de memoria representando las 256 claves. 2. Encriptación: obtención, sobre cada hebra de memoria, del mensaje cifrado bajo la

clave representada por la hebra en cuestión.

3. Salida: selección de la cadena que contenga el mensaje cifrado dado, y lectura de su clave correspondiente.

Sin duda, el paso de mayor complejidad es el de encriptación. A continuación, se presenta el algoritmo de encriptación utilizado por DES y su implementación molecular. DES realiza cifrado de 16 ciclos. En cada ciclo, produce un resultado intermedio de 32 bits (R1, ..., R16). R15 y R16 se almacenan desde la ubicación B57 a B120 (espacio adyacente a la clave), mientras que R1, ..., R14 se almacenan desde la ubicación B121 a B568. R15 y R16 forman el mensaje cifrado. Los 32 bits de la izquierda y los 32 bits de la derecha del mensaje original se denotan como R-1 y R0 respectivamente. Los bits B569 a B578 se utilizan como espacio de trabajo, y se escriben y borran a lo largo de la ejecución. Básicamente, Ri se obtiene a partir de Ri-1 y Ri-2, por medio de la siguiente función:

Ri = Ri-2 ⊕ S(E(Ri-1) ⊕ Ki)

En la función anterior, ⊕ denota un OR exclusivo (XOR), Ki denota una selección de 48 bits de la clave dependiente del ciclo, E denota una función de expansión que toma 32 bits de Ri-1 y a partir de ellos genera 48 bits, y S es una función que recibe 48 bits de entrada y los mapea a 32 bits de salida. Las función E, S y K se encuentran implementadas en el microprocesador de control. La función S puede dividirse en ocho funciones independientes de transformación de 6 bits a 4 bits, conocidas como S-boxes. Por lo tanto, cada Ri puede ser calculado en ocho operaciones independientes, cada una de las cuales aporta 4 bits al resultado. Cada función S-box genera los 4 bits de salida a partir de 16 bits de entrada (6 bits de Ri-1, 6 bits de Ki y 4 bits de Ri-2). De este modo, el cálculo de los Ri se realiza de acuerdo a los siguientes pasos:

1. Se aplica la función XOR con los 6 bits de Ri-1 y los 6 bits de Ki, obteniendo 6 bits que se almacenan desde B569 a B574 del espacio de trabajo.

2. Una de las funciones S-box se aplica a los bits B569 a B574 y los 4 bits resultado se

almacenan en las ubicaciones B575 a B578 del espacio de trabajo.

3. Se aplica la función XOR con los 4 bits de B575 a B578 y los 4 bits de Ri-2, obteniendo los 4 bits finales que se almacenan en los cuatro bloques apropiados entre los destinados a resultados intermedios (B57 a B568).

4. Si los 4 bits obtenidos en el paso anterior no corresponden a los últimos 4 bits de R16,

el espacio de trabajo (B569 a B578) se limpia para su próximo uso.

Implementación Como se explicó anteriormente, la implementación se realiza por medio de una máquina de Stickers. Básicamente, esta máquina consiste en un rack de tubos (tubos de datos, tubos de

60

stickers, tubos de operadores y tubos blancos), bombas de fluídos, calentadores y refrigerantes, y un microprocesador que actúa de controlador. Esta máquina es capaz de realizar cualquiera de las siguientes operaciones propias del modelo de Stickers en forma paralela: separación, combinación, set y reset. La inicialización de las hebras de memoria consiste en generar 256 cadenas codificando cada una de las claves. Esto se realiza siguiendo los siguientes pasos:

1. Se dividen las hebras de memoria en dos tubos: A y B. 2. Se añade un exceso de stickers (S1 a S56) al tubo A, complementándose con las hebras

de memoria.

3. Se utiliza el complemento de B0 como una sonda de extracción para separar las cadenas complementadas de los stickers “sueltos”.

4. Se agrega el contenido del tubo B al tubo A.

5. Se caliente y enfría el tubo A sucesivamente para que los stickers se complementen

nuevamente y en forma aleatoria. La función XOR convierte dos bits de entrada en uno de salida (Bk = Bi ⊕ Bj) y se implementa de la siguiente manera:

1. Se ejecutan dos separaciones paralelas obteniendo cuatro tubos de datos, uno por cada valor posible de BiBj. La primer separación se realiza sobre Bi y la segunda sobre Bj.

Figura I-2 2. Se realiza un seteo paralelo de Bk por medio del sticker Sk en todos los tubos donde el

mismo es aplicable, o sea, cuando BiBj = 01 o 10.

61

Figura I-3

3. Se realiza la combinación paralela del contenido de los cuatro tubos de datos en un único tubo.

Figura I-4 Por último, una vez que se han generado los todos los mensajes cifrados, debe buscarse la cadena que contiene el mensaje cifrado dado. De este modo, se obtiene la clave buscada alcanzando el objetivo inicial. La búsqueda de la cadena que codifica el mensaje cifrado dado se lleva a cabo por medio de 64 operaciones de separación. Una vez obtenida la misma, se realiza la lectura de la clave que esta contiene. La implementación de esta máquina de Stickers requiere 96 tubos activos (tubos que se encuentran involucrados en el procesamiento en un mismo paso). A su vez, el rack debe tener un total 1271 tubos. El número de pasos u operaciones necesarias para la etapa de encriptación es de 6655. A esto se suman 64 pasos para la lectura de la clave resultado. De este modo, se requieren 6719 pasos para la ejecución completa del algoritmo. Finalmente, estimando que cada operación se completa en 1 minuto promedio, se logra quebrar la seguridad de DES en aproximadamente 5 días.

62

Anexo II Resultados experimentales del Autómata de ADN Como se explicó anteriormente, el Weizmann Institute of Science de Israel presentó en el 2001 un autómata de ADN. A continuación, se presentan resultados experimentales de esta implementación [Sha2]. Las pruebas se realizaron sobre tres autómatas finitos. Estos autómatas trabajan con un alfabeto compuesto por los símbolos {a; b}, y el objetivo y funcionamiento de cada uno de ellos es el siguiente:

ü Autómata A1: acepta un número par de símbolos a.

Figura II-1

ü Autómata A2: acepta un número par de símbolos.

Figura II-2

ü Autómata A3: finaliza con b.

Figura II-3

Las transiciones de los tres autómatas se definieron de la siguiente manera:

Figura II-4

A su vez, se utilizaron para las pruebas un conjunto de ocho cadenas de entrada.

Figura II-5

63

La siguiente imagen corresponde a la aplicación de electroféresis con gel sobre las ocho entradas y sobre las salidas obtenidas luego de la ejecución de cada uno de los autómatas.

Figura II-6

En la parte derecha de la imagen, se indican las marcas de longitud de las cadenas en cuanto a cantidad de nucleótidos. Del lado izquierdo, se pueden ver las marcas correspondientes a las longitudes de las entradas y salidas de cada autómata. Nótese que la entrada I8 es la de mayor longitud, y que las entradas I4 e I6 son de igual longitud, del mismo modo que I3 e I5. Debajo de cada carril de la placa de electroféresis, se indica la entrada que se aplica, el autómata empleado y el resultado esperado tras la ejecución. En la siguiente imagen, se muestra la ejecución completa del autómata A1 sobre la entrada I8.

64

Figura II-7

En la parte izquierda de la imagen, se indican las longitudes correspondientes a la entrada I8 y al estado final S0. Por otro lado, los resultados intermedios se indican en la parte derecha y por medio de la transición utilizada para llegar cada resultado. Debe observarse que la cadena de ADN inicial (I8), va reduciendo su tamaño luego de cada transición. Finalmente, se llega a la cadena de menor tamaño que corresponde al estado final alcanzado.

65

Anexo III Aplicación del modelo al problema de los Caminos Hamiltonianos Anteriormente se demostró la aplicación del modelo propuesto en esta tesis mediante la resolución del problema de satisfactibilidad o SAT. En este anexo, se utiliza el modelo para resolver el problema de los Caminos Hamiltonianos. Para ello, se recurre al mismo ejemplo utilizado para explicar el Experimento de Adleman. Dadas cuatro ciudades, Roma, París, Londres y Madrid conectadas entre sí como se muestra en el grafo, se desea encontrar el camino más corto que pasando por todas las ciudades conecte Roma con Madrid, sin pasar dos veces por la misma ciudad.

Figura III-1

A continuación se detalla la resolución de problema a través de cada una de las etapas del modelo:

1. Análisis del problema La única entidad que surge del problema es la entidad ciudad. entidad <ciudad> Como existen sólo cuatro ciudades, esta entidad puede tomar los siguientes cuatro valores: valor <ciudad, Roma> valor <ciudad, París> valor <ciudad, Londres> valor <ciudad, Madrid> Los vínculos entre las ciudades están dados por los caminos que las unen. De acuerdo al modelo, estos vínculos son entre un subconjunto de instancias de entidad y su notación es la siguiente:

66

vínculo <ciudad, Roma : ciudad, París> vínculo <ciudad, París : ciudad, Londres> vínculo <ciudad, París : ciudad, Madrid> vínculo <ciudad, Londres : ciudad, Madrid>

2. Diseño de secuencias

Inicialmente, se codifica cada entidad, valor y vínculo a través de secuencias únicas. entidad <ciudad> = ATCG valor <ciudad, Roma> = ACT valor <ciudad, París> = TGG valor <ciudad, Londres> = CCT valor <ciudad, Madrid> = ATA vínculo <ciudad, Roma : ciudad, París> = GCGC vínculo <ciudad, París : ciudad, Londres> = ATAT vínculo <ciudad, París : ciudad, Madrid> = CTCG vínculo <ciudad, Londres : ciudad, Madrid> = GAAG Sin vínculo = ACAC Una vez realizada esta codificación se procede a diseñar las secuencias completas a utilizar en la resolución del problema. De acuerdo al formato definido en el modelo, las secuencias finales son las siguientes: ACACATCGACTGCGC CGCGATCGTGGCTCG

GAGCATCGATAACAC

Sin vínculo

ciudad

Roma

Vínculo con París

ciudad

Vínculo con Roma París

Vínculo con Madrid

Vínculo con París

ciudad

Madrid

Sin vínculo

67

CGCGATCGTGGATAT TATAATCGCCTGAAG CTTCATCGATAACAC

3. Selección de operaciones

La primer operación a realizar consiste en la combinación de las secuencias definidas en la fase anterior. Como resultado, se obtienen todos los caminos posibles a través del grafo. En este caso, se generan dos caminos. Una vez generados los caminos, deben seleccionarse aquellos que partan de Roma y terminen en Madrid. Esto se realiza mediante dos selecciones por entidad. La primer selección es de aquellas soluciones cuya primer entidad sea la ciudad de Roma y la segunda es de aquellas cuya última entidad sea la ciudad Madrid. Como los dos caminos generados parten de Roma y terminan en Madrid, el espacio de soluciones permanece intacto tras la ejecución de las selecciones por entidad. Sabiendo que la solución debe pasar por todas las ciudades, deben seleccionarse sólo aquellas soluciones de cuatro ciudades. Para ello, se efectúa una selección por longitud. Dado que uno de los caminos pasa sólo por tres ciudades, quedará un único camino como posible solución. Finalmente, se deben obtener los caminos que incluyan a cada una de las ciudades. Para tal fin, se realiza una selección por inclusión para cada una de las ciudades del problema. Como resultado de esta operación, se obtiene una única solución dada por el camino que llega de Roma a Madrid pasando por París y Londres. La secuencia completa de operaciones sería la siguiente:

Figura III-2

Vínculo con Roma

ciudad

París

Vínculo con Londres

ciudad

Londres Vínculo con París

Vínculo con Madrid

ciudad

Madrid Vínculo con Londres

Sin vínculo

68

4. Pruebas

Como se explicó anteriormente, esta etapa debe realizarse con el apoyo de alguna herramienta de software que permita simular un ambiente de procesamiento biológico.

5. Implementación La implementación consiste en ejecutar el algoritmo propuesto en un ambiente biológico real.

69

Bibliografía [Ada] Joel C. Adams. “On the application of DNA Based Computation”. Faculty of Engineering Science. University of Western Ontario, 1998. [Adl1] Prof. Leonard Adleman. “Molecular Computation Of Solutions To Combinatorial Problems”. Department of Computer Science and Institute for Molecular Medicine and Technology. University of Southern California, 1994. [Adl2] Leonard Adleman. Paul Rothermund. Sam Roweis. Erik Winfree.“On applying Molecular Computation to the Data Encryption Standard”. Laboratory for Molecular Science. University of Southern California. [Con] Wilson A. Contreras Espinoza. José O. Maldonado Bautista. “El problema de la satisfactibilidad”. Universidad de Pamplona. Colombia, 2000. [Cor] Robert M. Corn. Anne E. Condon. Weiping Cai. Elton Graser. Zhendong Fei. Tony Frutos. Zhen Guo. Max G. Lagally. Qinghua Liu. Lloyd M. Smith. Andrew Thiel. “The power of Surface-Based DNA Computation”. University of Wisconsin. Agosto de 1996. [Ent] Dra. Carmen Entrala. “Técnicas de Análisis del ADN en Genética Forense”. Laboratorio de ADN forense, Depto. de Medicina Legal. Universidad de Granada, España, 2000. [FeV] José Luis Fernández Vindel. “Computabilidad y Complejidad”. Teoría de Autómatas II. Escuela Univ. de Informática UNED. [Ful] Kevin Fulk. “Biological Computing”. Bauer College of Business Administration. University of Houston. [Gar] Michael R. Garey. David S. Jonson. W. H. Freeman. “Computers and Intractability: a guide to the theory of NP-Completeness”. New York, 1979. [Gen] National Human Genome Research Institute. Educational Resources. Enero de 2002. [Kar] Lila Kari. “DNA Computing: the arrival of biological mathematics”. Department of Computer Science. University of Western Ontario, London. Noviembre de 2002. [Lar] Javier Larrosa. Pedro Meseguer. “Razonamiento con restricciones”. Tutorial CAEPIA. Barcelona, 2003. [Lip] Richard J. Lipton. Dan Boneh. Christopher Dunworth. Jiri Sgall. “On the Computational Power of DNA”. Department of Computer Science. Princeton University. [Liu] Tie-Fei Liu. Wei Fu. “On DNA Computing models: a survey”. Department of Computer Science. School of Computing. National University of Singapore. Noviembre de 2002.

70

[Mal] C. C. Maley. “DNA Computation: Theory, Practice, and Prospects”. Artificial Intelligence Laboratory. Massachusetts Institute of Technology. Octubre de 1999. [Ogi] Mitsunori Ogihara. Animesh Ray. “DNA Computing on a Chip”. Nature, vol 403. [PeJ] M.J. Pérez Jiménez. “Computación Molecular basada en ADN”. Dpto. de Ciencias de la Computación e Inteligencia Artificial. Universidad de Sevilla. [Qui1] Z. Frank Qui. Mi Lu. “Take advantage of the computing power of DNA computers”. Department of Electrical Engineering. Texas A&M University. [Qui2] Z. Frank Qui. Mi Lu. “A new solution for Boolean Circuit with DNA Computer”. Department of Electrical Engineering. Texas A&M University. Abril de 2000. [Rob] E. De Robertis. E. M. F. De Robertis (h). “Biología Celular y Molecular”. 1981. [Row] Sam Roweis. Erik Winfree. Richard Burgoyne. Nickolas Chelyapov. Myron Goodman. Leonard Adleman. Paul Rothermund. “A Sticker Based Model for DNA Computation”. Laboratory for Molecular Science. University of Southern California. Mayo de 1996. [San] Héctor Sanvicente Sánchez. Marco Antonio Cruz Chávez. “El problema de satisfactibilidad y su aplicación a problemas de planificación y scheluding”. ITESM. Morelos. [Sca] Eugenio Scalise. Rhadamés Carmona. “Análisis de Algoritmos y Complejidad”. Universidad Central de Venezuela. Facultad de Ciencias. Escuela de Computación. Septiembre de 2001. [Sem1] José M. Sempere. “Fundamentos de bioquímica y el experimento de Adleman”. Departamento de Sistemas Informáticos y Computación. Universidad Politécnica de Valencia. [Sem2] José M. Sempere. “Conceptos básicos de la teoría de la información y de la teoría de la complejidad”. Departamento de Sistemas Informáticos y Computación. Universidad Politécnica de Valencia. [Sha1] Ehud Shapiro. Yaakov Benenson. Tamar Paz-Elizur. Rivica Adar. Ehud Keinan. Zvi Livneh. “Programmable and autonomous computing machine made of biomolecules”. Department of Computer Science and Applied Mathematics. Department of Biological Chemistry. Weizmann Institute of Science. Israel. Noviembre de 2001. [Sha2] Ehud Shapiro. Yaakov Benenson. Tamar Paz-Elizur. Rivica Adar. Zvi Livneh. “DNA molecule provides a computing machine with both data and fuel”. Department of Computer Science and Applied Mathematics. Department of Biological Chemistry. Weizmann Institute of Science. Israel. Noviembre de 2001. [Tar] Dra. Gemma Rodríguez Tarduchy. “Secuenciación automática de ADN”. Instituto de Investigaciones Biomédicas.

71

[Wat] J.D. Watson. F.H.C. Crick. “Una estructura para el Ácido Desoxirribonucleico”. Nature. Abril de 1953.