Computação com DNA - Modelo baseado em Stickers

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

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

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
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
●
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
●
Stickers
– Exemplos: AGTAT, CGTGA, AGTAT (…)
– Complementares às regiões
– Região sem sticker: 0
– Região com sticker: 1

7

8
●
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
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
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
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
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
● T = {1101, 1101, 1110, 0111}

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
● T = {1001, 1001, 1010, 0011}

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
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
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
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
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
●
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
●
Seta os bits dos objetos de acordo com os objetos
presentes em cada bolsa (conjunto C).

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

22
●
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
●
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
●
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
●
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
Algoritmo – Parte Final
●
Leitura dos tubos
– ler(T1), se for vazio ler(T2), se for vazio ler(T3) (…)

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

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

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
Set
def set(self, tube, bit):
for strand in self.tubes[tube]:
strand[bit] = 1
print('set:t', self.tubes)

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

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
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
Display
def display(self):
print('t', self.tubes)

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

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

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
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
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
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
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
Implementação Física do Modelo
Operações:
●
Combinar
●
Separar
●
Setar
●
Resetar

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

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

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

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

Classificação dos tubos utilizados

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.

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

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

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

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

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.

Referências
FILHO, I. E. Uma Metodologia para computação com DNA.
2004.
http://pt.slideshare.net/sathish3/dnacomputing13793615.
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.

Computação com DNA - Modelo baseado em Stickers

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Computação com DNA - Modelo baseado em Stickers

Mais de Marcos Castro

Computação com DNA - Modelo baseado em Stickers