O documento descreve um modelo computacional baseado em fitas de DNA chamado "Sticker Based Model". O modelo representa informação usando fitas de DNA divididas em regiões e "stickers" complementares que se ligam às regiões para representar bits. O modelo suporta operações básicas como combinar, separar, definir e resetar bits manipulando a ligação e remoção dos stickers.

1. A Sticker Based Model for DNA
Computation
Hanniere de Faria
Julio César Eiras Melanda
Marcelo Suzuki
Marcos Castro

2. 2
Computação com DNA
●
O que é?
●
Motivação
●
Programação com DNA e programação convencional
●
Modelos teóricos

3. 3
The Sticker Based Model
●
Complementaridade de Watson-Crick
●
Utiliza fitas de DNA
●
Memória de acesso aleatória
●
Não requer extensão da fita

4. 4
Representação da informação
●
Fita de memória = fita simples de DNA
●
Considere uma fita de memória de N bases dividida em
K regiões onde cada região possui M bases:
– N = K * M
●
Exemplo:
– ATCGG TCATA GCACT
– N = 15, K = 3, M = 5

5. 5
Representação da informação
●
região = bit (variável booleana 1 ou 0)
●
Voltando ao exemplo:
– ATCGG TCATA GCACT
– ATCGG é o bit 1, TCATA é o bit 2 …
●
Cada região corresponde a um bit.
●
região = bit = subsequência = subfita etc.

6. 6
Representação da informação
●
Stickers
– Exemplos: AGTAT, CGTGA, AGTAT (…)
– Complementares às regiões
– Região sem sticker: 0
– Região com sticker: 1

7. 7
Representação da informação

8. 8
Representação da informação
●
Associação entre fita de memória e stickers é um
complexo de memória.
●
Coleção de complexos de memória = tubo
●
Expressando uma matriz:

9. 9
Operações
●
As quatros principais operações:
– Combinar (unir) conjuntos de strings
– Separar um conjunto em dois novos conjuntos
– Setar o i-ésimo bit de cada string de um conjunto
– Resetar (clear) o i-ésimo bit de cada string de um
conjunto
– Convenções:
● String = complexo de memória
● Conjunto = tubo

10. 10
Operação combinar
●
combinar(T1, T2) = T1 U T2 (união)
– Seja T1 = {1001, 1101}
– Seja T2 = {1110, 0011}
– T3 = T1 U T2 = {1001, 1101, 1110, 0011}
●
combinar(T1, T2, .., Tn) = T1 U T2 U (…) U Tn

11. 11
Operação separar
●
separar(T1, T2, T3, i)
– Seja T1 = {1001, 1101, 1110, 0011}
– Separa com base no i-ésimo bit
● Convenção: da esquerda para direita
– Se i = 2, temos que:
● T2 = {1101, 1110}
● T3 = {1001, 0011}

12. 12
Operação setar
●
setar(T, i)
– Seja T = {1001, 1101, 1110, 0011}
– Seta (para 1) o i-ésimo bit de cada sequência de T
● Convenção: da esquerda para direita
– Se i = 2, temos que:
● T = {1101, 1101, 1110, 0111}

13. 13
Operação resetar (clear)
●
resetar(T, i)
– Seja T = {1001, 1101, 1110, 0011}
– Reseta (para 0) o i-ésimo bit de cada sequência de T
● Convenção: da esquerda para direita
– Se i = 2, temos que:
● T = {1001, 1001, 1010, 0011}

14. 14
Tubo inicial
●
Criação de um tubo mãe.
●
Seja K a quantidade de regiões, (K, L) é um conjunto de
strings de tamanho K geradas por todas as possíveis
sequências de bits de tamanho L seguidas de (K-L)
zeros.
●
Exemplo com K = 4 e L = 2 → (4, 2)
– 00, 01, 10, 11 são todas as possíveis sequências de
bits de tamanho L = 2.
– Tubo mãe = {0000, 0100, 1000, 1100}
– O conjunto possui 2^L elementos = 2^2 = 4

15. 15
Cobertura mínima de conjunto
●
Dado um conjunto U e subconjuntos S = {S1, …, Sn) de
U, o problema consiste em determinar a quantidade
mínima de subconjuntos de S que possua todos os
elementos de U.
●
Exemplo:
– U = {1, 2, 3, 4, 5}
– S = {S1, S2, S3, S4}
– S1 = {1, 2}, S2 = {3, 4}, S3 = {5} e S4 = {3, 4, 5}
– Exemplo de cobertura: {S1, S2, S3}
– Mínima cobertura: {S1, S4}

16. 16
Cobertura mínima de conjunto
●
B = {1, …, B} → conjunto de bolsas
●
A = {1, …, A} → tipos de objetos
●
C = {C1, …, CB} é composto por subconjuntos de A.
●
Problema: determinar qual o menor subconjunto de B
que possua todos os elementos de A.
●
Exemplo:
– B = {1, 2, 3}, A = {1, 2, 3}
– C1 = {1, 2}, C2 = {1} e C3 = {3}
– Mínima (única) cobertura: {C1, C3} → bolsas 1 e 3

17. 17
Algoritmo
●
Para a explicação do algoritmo, considere os dados:
– B = {1, 2, 3} → |B| = 3 bolsas
– A = {1, 2, 3} → |A| = 3 tipos de objetos
– Se |B| = 3, então |C| = 3
– Supor C = {C1, C2, C3} onde:
● C1 = {1, 2}
● C2 = {1}
● C3 = {3}

18. 18
Algoritmo – Parte 1
●
Projetar uma fita de memória com K = B + A regiões.
●
Se B = {1, 2, 3}, |B| = 3
●
Se A = {1, 2, 3}, |A| = 3
●
K = B + A = 3 + 3 = 6 regiões de bits.
●
Os B primeiros bits correspondem às bolsas escolhidas
e os últimos A bits representam os objetos presentes.
●
Exemplo: 110110
– bolsas escolhidas: 1 e 2
– objetos presentes: 1 e 2

19. 19
Algoritmo – Parte 2
●
Gera-se todas as possibilidades de escolhas de bolsas
com os B bits.
●
Como B = 3, temos que:
– {000, 001, 010, 011, 100, 101, 110, 111}
– Completa-se cada sequência com (K – B) zeros:
– {000000, 001000, 011000, 100000, (…), 111000}
– Esse é o nosso conjunto inicial (K, B).
– Todos esses complexos de memória estarão
inicialmente no tubo T0.

20. 20
Algoritmo – Parte 3
●
Seta os bits dos objetos de acordo com os objetos
presentes em cada bolsa (conjunto C).

21. 21
Algoritmo – Parte 3
●
Exemplo para i = 1
– T0 = {000000, 001000, (…), 111000}
– Ton = {100000, 101000, 110000, 111000}
– Toff = {000000, 001000, 010000, 011000}

22. 22
Algoritmo – Parte 3
●
O loop interno percorre os elementos do conjunto de
objetos da i-ésima bolsa (Ci).
●
Seta (para 1) o j-ésimo bit de todas as sequências de
Ton.
considere: N = B

23. 23
Algoritmo – Parte 3
●
Se temos 100000 em Ton e C1 = {1, 2} para i = 1:
– Seta os bits (B + 1) e (B + 2): 4º e 5º bits.
– Ton = {100110, 101110, 110110, 111110}
considere: N = B

24. 24
Algoritmo – Parte 4
●
Descarta todas as sequências que não possuem todos
os tipos de objetos.
●
Precisamos garantir a cobertura (todos os objetos).
●
Exemplos de sequências que serão descartadas:
– 010100, 100110, 011101 (…)

25. 25
Algoritmo – Parte 5
●
Conta a quantidade de bolsas:
●
T0 = {111111, 101111}, T1 = {}, T2 = {}, T3 = {}
●
T0 = {}, T1 = {111111, 101111}, T2 = {}, T3 = {}
●
T0 = {}, T1 = {101111}, T2 = {111111}, T3 = {}
●
T0 = {}, T1 = {101111}, T2 = {}, T3 = {111111}
●
T0 = {}, T1 = {}, T2 = {101111}, T3 = {111111}

26. 26
Algoritmo – Parte Final
●
Leitura dos tubos
– ler(T1), se for vazio ler(T2), se for vazio ler(T3) (…)

27. 27
Simulador
●
Um simulador foi implementado em Python para que
pudessem ser testadas os algoritmos utilizando o
modelo baseado em stickers. Segue o endereço:
https://github.com/julioeiras/UNIFESP-Sticker

28. 28
Código com o simulador

29. 29
Simulador
●
Implementação em Python
●
4 operações básicas
– Set
– Clear
– Combine
– Separate

30. 30
Simulador
●
Operações auxiliares
– Init (cria um tubo com as possibilidades dos bits
utilizados
– Discard (descarta um tubo e todo seu conteúdo)
– Display (mostra o conteúdo dos tubos)

31. 31
Set
def set(self, tube, bit):
for strand in self.tubes[tube]:
strand[bit] = 1
print('set:t', self.tubes)

32. 32
Clean
def clear(self, tube, bit):
for strand in self.tubes[tube]:
strand[bit] = 0
print('clear:t', self.tubes)

33. 33
Separate
def separate(self, bit, tube_origin, tube_on,
tube_off=None):
tube1 = []
tube2 = []
for strand in self.tubes[tube_origin]:
if strand[bit]:
tube1.append(strand)
else:
tube2.append(strand)
if tube_off == None:
tube_off = tube_origin
else:
del(self.tubes[tube_origin])
self.tubes[tube_on] = tube1
self.tubes[tube_off] = tube2
print('sep:t', self.tubes)

34. 34
Combine
def combine(self, tube1, tube2, tube_destination=None):
t1 = self.tubes[tube1] if tube1 in self.tubes else []
t2 = self.tubes[tube2] if tube2 in self.tubes else []
result_tube = t1 + t2
if tube2 in self.tubes:
del(self.tubes[tube2])
if tube_destination == None:
tube_destination = tube1
else:
del(self.tubes[tube1])
self.tubes[tube_destination] = result_tube
print('comb:t', self.tubes)

35. 35
Display
def display(self):
print('t', self.tubes)

36. 36
Discard
def discard(self, tube):
if tube in self.tubes:
del(self.tubes[tube])
print('disc:t', self.tubes)

37. 37
Display
def display(self):
print('t', self.tubes)

38. 38
Init
def init(self, tube_name):
tube = []
for i in product(*[(0, 1)] * self.l):
tube.append(list(i) + [0] * (self.k-self.l))
self.tubes[tube_name] = tube
print('init:t', self.tubes)

39. 39
XOR
●
Problema
– Verdadeiro quando as entradas são diferentes
●
Conjunto de entrada
– (0, 0), (0, 1), (1, 0), (1, 1)
●
Saída
– (0, 0, 0), (0, 1, 1), (1, 0, 1), (1, 1, 0)

40. 40
XOR no Simulador
from sticker import Stickers
s = Stickers(3, 2)
s.init(0)
s.separate(0,0,1)
second bit
s.separate(1,1,3)
second bit
s.separate(1,0,2)
first and second bit
s.combine(1,2)
s.set(1,s.l)
s.combine(0,3)
s.combine(0,1)
s.display()

41. 41
Conjunto Independente Máximo
●
Problema
– Maior conjunto de nós não conectados num grafo
– Entrada (0, 4), (4, 1), (1, 3), (3, 2)
– Saída (1, 1, 1, 0, 0)
0
4
1
3
2

42. 42
Independent Set no Simulador
from sticker import Stickers
s = Stickers(5, 5)
s.init(0)
edges = ((0, 4), (4, 1), (1, 3), (3, 2))
for e in edges:
s.separate(e[0], 0, 1)
s.separate(e[1], 1, 2, 3)
s.combine(0, 3)
for i in range(1, 5):
s.discard(i)
for i in range(5):
for j in range(i, -1, -1):
s.separate(i, j, -(j+1))
s.combine(j+1, -(j+1))
for a in range(6):
if s.tubes.get(a):
print(a, s.tubes[a])
break

43. 43
Implementação Física do Modelo
Operações:
●
Combinar
●
Separar
●
Setar
●
Resetar

44. 44
Combinar
●
Objetivo: agrupar complexos de memória de diferentes
tubos
●
Reidratação da solução
●
Bombeamento ou vazamento
●
Manuseio Delicado
●
DNA preso nas paredes dos tubos, bombas, pipetas,
etc

45. 45
Separar
●
Objetivo: Separar fisicamente um complexo de acordo
com um determinado Sticker
●
Hibridização de DNA utilizando sondas marcadas com
radioisótopo
●
A sonda possui afinidade menor
●
Memória com bit “off” recuperada após aquecimento

46. 46
Setar
●
Objetivo: Ligar um Sticker na respectiva região da
memória
●
Adicionar uma grande quantidade de Sticker
correspondente ao respectivo bit
●
O Sticker se liga na posição oposta ao bit alvo
●
Excesso é removido por filtragem

47. 47
Resetar
●
Objetivo: Remover os Stickers apenas da respectiva
região da memória
●
Deixar a ligação do respectivo bit mais “fraca”
●
Invasão de fita por PNA
●
Procedimento ainda não conhecido experimentalmente
●
Operação mais problemática do modelo

48. 48
Inicialização
●
Produzir 2L
copias idênticas de uma fita de memória com
K >= L regiões
●
Separá-las em dois tubos iguais
●
Adiciona-se Stickers em excesso para os bits de 1...L
em um tubo
●
Tubos são recombinados, aquecidos e resfriados em
seguida
●
Ligação feita randomicamente com 50% de chances dos
bits ligados em cada fita memória
●
63% de chance da string correta ser criada

49. 49
Resultado
●
Detectar os complexos de memória por rotulagem
fluorescente das fitas de memória
●
Separar as fitas de cadeias simples na solução
●
Detectar os Stickers ligados por imagem direta do DNA
com microscopia eletrônica
●
Detectar utilizando separação bit a bit

50. 50
Resultado

51. Proposta de implementação de uma
máquina do Modelo de Stickers
●
Foi pensado somente na engenharia
●
Diversas questões não foram abordadas, como
viabilidade e custo

52. Componentes necessários
●
Uma de estação de trabalho
●
Equipamentos robóticos
●
Bombas
●
Aquecedores / Resfriadores
●
Microprocessador
●
Tubos

53. Classificação dos tubos utilizados
●
Tubo de Dado
●
Tubo de Operador Em Branco (Blank)
●
Tubo de Operador Sticker
●
Tubo de Operador Separador (Separation)

54. Classificação dos tubos utilizados

55. Funcionamento
●
Microprocessador faz o controle dos equipamentos
robóticos, bombas, aquecedores e resfriadores
●
Nem todos os tubos estarão sendo utilizados
●
Alguns operadores de sticker criam ou descartam tubos.

56. Procedimento de execução de um
operador do Modelo de Sticker
1) Dois tubos de dados são selecionados.
2) Um tubo de operador é selecionado.
3) Cada tubo de dado é conectado ao tubo de operador
4) Os tubos de dados são conectados a um equipamento
de controle de fluxo.
5) Uma solução flui pelos três tubos
6) É feito o controle do sentido do fluxo e temperatura.
7) Fim da execução do operador de sticker

57. Procedimento de execução de um
operador do Modelo de Sticker
●
Configuração genérica da conexão para a execução de
um operador de Sticker

58. Operadores de Sticker
●
Operador combinar (combination) e separar (separation)

59. Operadores de Sticker
●
Operador setar e resetar (set e clear)

60. Considerações finais
●
Este modelo permite paralelismo.
●
Para uma aplicação real é necessário grande volume de
DNA.
●
É necessário um grande investimento para que se torne
viável.

61. Referências
FILHO, I. E. Uma Metodologia para computação com DNA.
2004.
http://pt.slideshare.net/sathish3/dna­computing­13793615.
Acessado: 05 de maio de 2015.
ROWEIS, S. A Sticker Based Model for DNA Computation.
1996.
TAGHIPOUR, H. Solving the independent set problem by
sticker based DNA computers. 2012.