You are on page 1of 71

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.


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

4
Introducción
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.

6
Conceptos fundamentales
de
biología molecular
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

8
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

9
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.

10
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.

11
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.

12
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].

13
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].

14
El estado
del arte
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

16
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.

17
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

18
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.

19
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.

20
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.

21
Ø 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.

22
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.

23
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

24
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.

25
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.

26
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.

27
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

28
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

29
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.

30
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

31
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.

32
Análisis
del nuevo
paradigma de
procesamiento
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

34
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

35
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.

36
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

37
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.

38
Modelo propuesto
para el desarrollo
basado en
Computación con ADN
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

40
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>

41
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

42
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

43
ü 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.

44
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.

45
Aplicación
del
modelo propuesto
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.

47
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

48
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

49
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:

50
(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>

51
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.

52
Figura 6-3

Siguiendo este formato, se diseñan algunas de las secuencias finales a manera de


ejemplo.

Sin vínculo 0

ACACATCGACTGCGC

X1 Vínculo con X2

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.

Vínculo con X1 1

CGCGTTAATGGATAT

X2 Vínculo con X3

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

53
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.

54
Conclusiones
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.

56
ü ¿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.

57
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:

58
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

59
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.

60
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.

61
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

62
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.

63
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.

64
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:

65
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:

Sin vínculo Roma

ACACATCGACTGCGC

ciudad Vínculo con París

Vínculo con Roma París

CGCGATCGTGGCTCG

ciudad Vínculo con Madrid

Vínculo con París Madrid

GAGCATCGATAACAC

ciudad Sin vínculo

66
Vínculo con Roma París

CGCGATCGTGGATAT

ciudad Vínculo con Londres

Vínculo con París Londres

TATAATCGCCTGAAG

ciudad Vínculo con Madrid

Vínculo con Londres Madrid

CTTCATCGATAACAC

ciudad Sin vínculo

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

67
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.

68
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.

69
[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.

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

71

You might also like