2017 Dr. Walter F. de Azevedo Jr.

01 Dr. Walter F. de Azevedo Jr. 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000 000000000111111111111111111111111000000 000000000011111111111111111111100000000 000000001111111111111111111111111000000 000011111111111111111111111111111000000 001111111111111111111111111111110000000 111111111111111111111111111110000000000 111111111111111111111111111110000000000 000011111111111111111111111111111110000 001111111111111111111111111111111111000 011111111111111111111111111111111111000 001111111111111111111111111111111111100 000000011111111111111111111111111111110 000000001111111111111111111111111111110 000000000001111111111111111111111111110 000000000000011111111111111111111111110 000000000000000111111111111111111111000 000000000000000000000000001111000000000 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000000000000000000000000000000 1

Notação Big-O Consideremos um algoritmo que tem um tempo de execução t dado t = n +1n+18 (linha azul do gráfico abaixo), onde n é o tamanho da entrada. Dizemos que este algoritmo tem um tempo de execução de ordem quadrática, ou O(n ) pois este é o termo de mais alto grau do polinômio. De uma forma geral, podemos determinar uma constante c para o qual a desigualdade n +1n+18 c.n se verifica, assim o tempo de execução é uma função quadrática. Quando usamos essa aproximação, estamos usando a notação Big-O. t = n t(s) t = n +1n+18 n

Algoritmos para Bioinformática O desenvolvimento de algoritmos para Bioinformática teve um grande crescimento nos últimos anos. Iremos descrever as ideias centrais das técnicas mais usadas na pesquisa científica em Bioinformática. Busca Exaustiva Branch-and-Bound Greedy Aprendizado de Máquina Algoritmos Randomizados Dividir e Conquistar Programação Dinâmica

Algoritmos para Bioinformática Para ilustrar os conceitos atrás das técnicas de desenho de algoritmos, vamos considerar um problema hipotético de procurarmos um telefone sem fio em casa. Para complicar a situação estamos com as duas mãos ocupadas e está escuro, de forma que não podemos confiar na visão, como indicado abaixo (Jones & Pevzner, 00). Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 00.

Algoritmo de Busca Exaustiva (ou Força Bruta) O algoritmo de busca exaustiva, ou força bruta, testa todas as alternativas do problema, para encontrar uma solução particular. No exemplo do telefone, ignoramos o som do toque do telefone, e, assim, simplesmente procuramos por cada cm da casa, até acharmos o telefone. Os algoritmos que seguem este desenho, são fáceis de entender, mas tem como principal problema o tempo de execução. Outra característica que podemos destacar, é como iremos dividir a casa para procurar o telefone, um parâmetro comumente considerado em algoritmos de busca. Por exemplo, se procurarmos em quadrados de 10 cm de lado teremos um tempo, e usarmos um quadrado de 1 cm de lado, teremos um tempo bem maior. Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 00.

Algoritmo do Tipo Branch-and-Bound Nesta classe de algoritmo, ao iniciarmos o algoritmo de foça bruta, podemos omitir certas alternativas, diminuindo o tempo da busca. No exemplo do telefone, considere que ao chegarmos no segundo andar da casa escutamos a campainha do telefone como vinda do andar de cima. Nesta situação, podemos ignorar o andar inferior. Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 00.

Algoritmo do Tipo Greedy Muitos algoritmos são iterativos, os algoritmos do tipo greedy consideram em cada iteração a alternativa mais promissora. Tomando-se o exemplo do telefone, podemos considerar que nos movimentaremos na direção de onde vem o som do telefone. Isto pode causar alguns problemas, como ilustrado abaixo, mas é uma forma de reduzirmos as alternativas testadas. Em cada aplicação temos que identificar como determinar a solução mais atrativa. Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 00.

Algoritmo com Aprendizado de Máquina Algoritmos de Aprendizado de Máquina (Machine Learning) usam o comportamento prévio do sistema para a decidir como varrer as alternativas. No exemplo do telefone, temos da experiência prévia que em 8 % da vezes o telefone estava sobre o sofá da sala, em % das vezes no quarto do casal, em % das vezes na cozinha, e em % em outros locais. Assim, podemos começar procurando no sofá da sala e seguimos a ordem indicada. % % 8 % Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 00. 8

Algoritmo Estocástico No algoritmo estocástico, a faixa de alternativas a serem testadas é escolhida de forma aleatória. Assim, no exemplo do telefone, consideremos que temos uma casa com seis cômodos, podemos atribuir números de 1 a aos cômodos e jogar um dado para escolher que cômodo começar. Podemos também pensar que jogamos uma moeda e decidimos se começamos com os cômodos da parte superior ou da inferior. Em todo caso, temos um componente aleatório na decisão. Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 00. 9

Algoritmo do Tipo Dividir e Conquistar A ideia atrás desta classe e dividir um problema maior em subproblemas, independentes. Depois os subproblemas são resolvidos e combinados de forma a obtermos a solução do problema original. O ponto crítico nesta classe de algoritmos é como combinar as soluções dos subproblemas para obtermos a solução do problema principal. Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 00. 10

Algoritmo do Programação Dinâmica O algoritmo de programação dinâmica tem uma abordagem mais refinada do algoritmo de dividir em conquistar. Ao dividir o problema, em subproblemas menores, o algoritmo evita repetir computações já realizadas, usando valores armazenados de iterações anteriores. Vamos dar como exemplo o jogo das pedras. No jogo das Pedras consideramos dois jogadores e duas pilhas de pedras. Cada jogador pode tirar uma pedra da pilha 1, ou uma pedra do pilha, ou duas pedras, sendo uma de cada pilha. Os jogadores não podem tirar duas pedras da mesma pilha. Vence o jogador que tirar a última pedra. Vamos montar um gráfico que ilustra o mapa de como ganhar o jogo. Para exemplificar, vamos considerar que temos duas pilhas de 10 pedras cada. 11

Jogo das Pedras O W considera a situação ganhadora e L a perdedora. A situação é ganhadora quando há pelo menos um movimento que leva você a vencer. Montaremos um mapa bidimensional considerando todas as situações para duas pilhas de 10 pedras. 0 1 8 9 10 0 W 1 W W 8 9 10 Pilha A Pilha B 1

Jogo das Pedras Inicialmente consideremos um jogo com uma pedra na pilha A e zero pedras na pilha B, como indicado no mapa abaixo, ou seja, um jogo J 1,0, usando-se a notação matricial. Esta é uma situação vencedora, visto que ao tirar a pedra o jogador vence. J 1,0 0 1 W 8 9 10 Pilha A 0 1 8 9 10 Pilha B 1

Jogo das Pedras O mesmo é verdadeiro para um jogo J 0,1, que indica uma pedra na pilha B. 0 1 8 9 10 0 W 1 W 8 9 10 Pilha A Pilha B 1

Jogo das Pedras Quando o jogador encontra-se na situação J 1,1, ele está numa situação vencedora, visto que ele pode tirar uma pedra de cada pilha. 0 1 8 9 10 0 W 1 W W 8 9 10 Pilha A Pilha B 1

Jogo das Pedras No jogo J,0 temos uma situação perdedora, pois só podemos tirar uma pedra da pilha A, o que leva a situação do jogo J 1,0, que é vitoriosa para o adversário. 0 1 8 9 10 0 W 1 W W L 8 9 10 Pilha A Pilha B 1

Jogo das Pedras O mesmo é verdadeiro para no jogo J 0,. Observe que o jogo é simétrico, o que vale para J i,j é mantido para J j,i. 0 1 8 9 10 0 W L 1 W W L 8 9 10 Pilha A Pilha B 1

Jogo das Pedras No jogo J 1, temos uma situação de vitória, pois podemos escolher tirar uma pedra da pilha A, o que leva o adversário a um jogo J 0,, onde ele perde. 0 1 8 9 10 0 W L 1 W W W L 8 9 10 Pilha A Pilha B 18

Jogo das Pedras Por simetria. 0 1 8 9 10 0 W L 1 W W W L W 8 9 10 Pilha A Pilha B 19

Jogo das Pedras No jogo J, não importa o movimento, o adversário ganha, então temos uma situação perdedora. Aplicando-se o mesmo raciocínio podemos preencher o mapa. 0 1 8 9 10 0 W L 1 W W W L W L 8 9 10 Pilha A Pilha B 0

Jogo das Pedras 0 1 8 9 10 0 W L 1 W W W L W L W 8 9 10 Pilha A Pilha B 1

Jogo das Pedras 0 1 8 9 10 0 W L W 1 W W W L W L W 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W 1 W W W L W L W W 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W 1 W W W W L W L W W 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W 1 W W W W L W L W W W 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W 1 W W W W L W L W W W W 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W 1 W W W W L W L W W W W W 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W 1 W W W W L W L W W W W W L 8 9 10 Pilha A Pilha B 8

Jogo das Pedras 0 1 8 9 10 0 W L W L 1 W W W W L W L W W W W W L 8 9 10 Pilha A Pilha B 9

Jogo das Pedras 0 1 8 9 10 0 W L W L 1 W W W W L W L W W W W W L W 8 9 10 Pilha A Pilha B 0

Jogo das Pedras 0 1 8 9 10 0 W L W L 1 W W W W W L W L W W W W W L W 8 9 10 Pilha A Pilha B 1

Jogo das Pedras 0 1 8 9 10 0 W L W L 1 W W W W W L W L W W W W W L W L 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W L 1 W W W W W L W L W L W W W W L W L 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W L 1 W W W W W L W L W L W W W W L W L W 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W L 1 W W W W W L W L W L W W W W W L W L W 8 9 10 Pilha A Pilha B

Jogo das Pedras 0 1 8 9 10 0 W L W L 1 W W W W W L W L W L W W W W W L W L W L 8 9 10 Pilha A Pilha B

Jogo das Pedras Abaixo temos a tabela completa. 0 1 8 9 10 0 W L W L W L W L W L 1 W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha A Pilha B

Jogo das Pedras Completamos com o jogo J 0,0 como uma situação hipotética de derrota. 0 1 8 9 10 0 L W L W L W L W L W L 1 W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha A Pilha B 8

Jogo das Pedras A implementação da tabela abaixo identifica se dada uma posição de início, o jogador ganha ou perde. 0 1 8 9 10 0 L W L W L W L W L W L 1 W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha A Pilha B 9

Jogo das Pedras Chamaremos este algoritmo, de programação dinâmica, de Rocks(n,m), ele retorna a string W ou L e tem como entrada o números de pedras em cada pilha. 0 1 8 9 10 0 L W L W L W L W L W L 1 W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha A Pilha B 0

Algoritmo do Programação Dinâmica (Rocks) Segue o pseudocódigo de Rocks(n,m). Rocks(n,m) J 0,0 = L Para i de 1 até n Se J i-1,0 == W J i,0 = L Senão J i,0 = W Para j de 1 até m Se J 0, j-1 == W J 0,j = L Senão J 0,j = W Para i de 1 até n Para j de 1 até m Se J i-1, j-1 == W e J i, j-1 == W e J i-1, j == W J i,j = L Senão J 0,j = W Retorna J n,m 1

Algoritmo do Programação Dinâmica (FastRocks) Se olharmos com atenção para a tabela veremos um padrão que facilita a programação. Veja que, quando i e j são pares, temos L. Nos outros casos temos W. Pilha A 0 1 8 9 10 0 L W L W L W L W L W L 1 W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W L W L W L W L W L W L W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha B

Algoritmo do Programação Dinâmica (FastRocks) Segue o pseudocódigo de FastRocks(n,m). FastRocks(n,m) Se n e m são ambos pares retorna L Senão retorna W

Algoritmo de Needleman & Wunsch O algoritmo de Needleman & Wunsch (Needleman and Wunsch, 190) tem como foco o alinhamento global de sequências de DNA e proteínas. Com a explosão dos dados genômicos no final do século passado, um problema central nos estudos genômicos foi o alinhamento de sequências. Esses alinhamentos permitem inferir similaridade sequencial e relacionar com as aspectos biológicos, como evolução, função, conservação de estrutura tridimensional entre outros. O algoritmo de Needleman & Wunsch será descrito aqui como modelo para entendermos as principais características computacionais do alinhamento de sequências. Referência: Needleman, S. B. & Wunsch, C. D. (190) "A General Method Applicable to the Search for Similarities in the Amino Acid Sequence of Two Proteins," J. Mol. Biol., 8, -.

Algoritmo de Needleman & Wunsch Considerando-se os tipos de algoritmos vistos até o momento, temos que o algoritmo de Needleman & Wunsch é de programação dinâmica. O algoritmo de Needleman & Wunsch é dividido nas seguintes etapas: 1) Inicialização da matriz caminho; ) Preenchimento da matriz caminho; ) Alinhamento. Para ilustrar o funcionamento do algoritmo, vamos considerar o alinhamento de duas sequências: GAATTCAGTTA (sequência #1) (temos m bases na sequência) GGATCGA (sequência #) (temos n bases na sequência)

Algoritmo de Needleman & Wunsch (Inicialização) Na fase de inicialização do algoritmo, montamos uma matriz m x n, como indicado abaixo. Essa matriz é chamada matriz caminho (path matrix). Na matriz caminho, às primeiras coluna e linha atribuímos zero, visto que estamos considerando um alinhamento sem penalidade de gap inicial. 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 G 0 A 0 T 0 C 0 G 0 A 0

Algoritmo de Needleman & Wunsch (Preenchimento) Para o preenchimento da matriz, consideramos o início a partir da esquerda superior da matriz. Para cada elemento M i,j da matriz, determinaremos a seguinte função escore: M i,j = MAXIMUM[ M i-1, j-1 + S i,j (coincidência ou não na diagonal da matriz), M i,j-1 + w (gap na sequência #1), M i-1,j + w (gap na sequência #)] Onde w é o peso para inserção de um gap (intervalo), consideramos w = 0. S i,j = 1 se a base na posição i da sequência #1 é a mesma da posição j na sequência # (escore de coincidência), caso contrário, S i,j = 0 (escore para não coincidência)

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1,1 = MAXIMUM[ M 0, 0 + S 1,1 (coincidência ou não na diagonal da matriz), M 1,0 + w (gap na sequência #1), M 0,1 + w (gap na sequência #)] = MAXIMUM[1,0,0], ou seja, M 1,1 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 A 0 T 0 C 0 G 0 A 0 8

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,1 = MAXIMUM[ M 1, 0 + S,1 (coincidência ou não na diagonal da matriz), M,0 + w (gap na sequência #1), M 1,1 + w (gap na sequência #)] = MAXIMUM[1,0,1], ou seja, M,1 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 T 0 C 0 G 0 A 0 9

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,1 = MAXIMUM[ M, 0 + S,1 (coincidência ou não na diagonal da matriz), M,0 + w (gap na sequência #1), M,1 + w (gap na sequência #)] = MAXIMUM[0,0,1], ou seja, M,1 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 C 0 G 0 A 0 0

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,1 = MAXIMUM[ M, 0 + S,1 (coincidência ou não na diagonal da matriz), M,0 + w (gap na sequência #1), M,1 + w (gap na sequência #)] = MAXIMUM[0,0,1], ou seja, M,1 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 1 C 0 G 0 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,1 = MAXIMUM[ M, 0 + S,1 (coincidência ou não na diagonal da matriz), M,0 + w (gap na sequência #1), M,1 + w (gap na sequência #)] = MAXIMUM[0,0,1], ou seja, M,1 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 A 0

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,1 = MAXIMUM[ M, 0 + S,1 (coincidência ou não na diagonal da matriz), M,0 + w (gap na sequência #1), M,1 + w (gap na sequência #)] = MAXIMUM[1,0,1], ou seja, M,1 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,1 = MAXIMUM[ M, 0 + S,1 (coincidência ou não na diagonal da matriz), M,0 + w (gap na sequência #1), M,1 + w (gap na sequência #)] = MAXIMUM[0,0,1], ou seja, M,1 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1, = MAXIMUM[ M 0, 1 + S 1, (coincidência ou não na diagonal da matriz), M 1,1 + w (gap na sequência #1), M 0, + w (gap na sequência #)] = MAXIMUM[0,1,0], ou seja, M 1, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1, = MAXIMUM[ M 0, + S 1, (coincidência ou não na diagonal da matriz), M 1, + w (gap na sequência #1), M 0, + w (gap na sequência #)] = MAXIMUM[0,1,0], ou seja, M 1, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1, = MAXIMUM[ M 0, + S 1, (coincidência ou não na diagonal da matriz), M 1, + w (gap na sequência #1), M 0, + w (gap na sequência #)] = MAXIMUM[0,1,0], ou seja, M 1, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1, = MAXIMUM[ M 0, + S 1, (coincidência ou não na diagonal da matriz), M 1, + w (gap na sequência #1), M 0, + w (gap na sequência #)] = MAXIMUM[0,1,0], ou seja, M 1, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 8

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1, = MAXIMUM[ M 0, + S 1, (coincidência ou não na diagonal da matriz), M 1, + w (gap na sequência #1), M 0, + w (gap na sequência #)] = MAXIMUM[0,1,0], ou seja, M 1, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 9

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1, = MAXIMUM[ M 0, + S 1, (coincidência ou não na diagonal da matriz), M 1, + w (gap na sequência #1), M 0, + w (gap na sequência #)] = MAXIMUM[0,1,0], ou seja, M 1, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 0

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1,8 = MAXIMUM[ M 0, + S 1,8 (coincidência ou não na diagonal da matriz), M 1, + w (gap na sequência #1), M 0,8 + w (gap na sequência #)] = MAXIMUM[1,1,0], ou seja, M 1,8 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1,9 = MAXIMUM[ M 0, 8 + S 1,9 (coincidência ou não na diagonal da matriz), M 1,8 + w (gap na sequência #1), M 0,9 + w (gap na sequência #)] = MAXIMUM[0,1,0], ou seja, M 1,9 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1,10 = MAXIMUM[ M 0, 9 + S 1,10 (coincidência ou não na diagonal da matriz), M 1,9 + w (gap na sequência #1), M 0,10 + w (gap na sequência #)] = MAXIMUM[0,1,0], ou seja, M 1,10 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M 1,11 = MAXIMUM[ M 0, 10 + S 1,11 (coincidência ou não na diagonal da matriz), M 1,10 + w (gap na sequência #1), M 0,11 + w (gap na sequência #)] = MAXIMUM[0,1,0], ou seja, M 1,11 = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M 1, 1 + S, (coincidência ou não na diagonal da matriz), M,1 + w (gap na sequência #1), M 1, + w (gap na sequência #)] = MAXIMUM[1,1,1], ou seja, M, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, 1 + S, (coincidência ou não na diagonal da matriz), M,1 + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[,1,1], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, 1 + S, (coincidência ou não na diagonal da matriz), M,1 + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[1,1,], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, 1 + S, (coincidência ou não na diagonal da matriz), M,1 + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[1,1,], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 8

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, 1 + S, (coincidência ou não na diagonal da matriz), M,1 + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[1,1,], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 9

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, 1 + S, (coincidência ou não na diagonal da matriz), M,1 + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[,1,], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 0

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M 1, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M 1, + w (gap na sequência #)] = MAXIMUM[1,1,1], ou seja, M, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M 1, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M 1, + w (gap na sequência #)] = MAXIMUM[1,1,1], ou seja, M, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M 1, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M 1, + w (gap na sequência #)] = MAXIMUM[1,1,1], ou seja, M, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M 1, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M 1, + w (gap na sequência #)] = MAXIMUM[1,1,1], ou seja, M, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M 1, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M 1, + w (gap na sequência #)] = MAXIMUM[1,1,1], ou seja, M, = 1 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,8 = MAXIMUM[ M 1, + S,8 (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M 1,8 + w (gap na sequência #)] = MAXIMUM[,1,1], ou seja, M,8 = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,9 = MAXIMUM[ M 1, 8 + S,9 (coincidência ou não na diagonal da matriz), M,8 + w (gap na sequência #1), M 1,9 + w (gap na sequência #)] = MAXIMUM[1,,1], ou seja, M,9 = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,10 = MAXIMUM[ M 1, 9 + S,10 (coincidência ou não na diagonal da matriz), M,9 + w (gap na sequência #1), M 1,10 + w (gap na sequência #)] = MAXIMUM[1,,1], ou seja, M,10 = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 8

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,11 = MAXIMUM[ M 1, 10 + S,11 (coincidência ou não na diagonal da matriz), M,10 + w (gap na sequência #1), M 1,11 + w (gap na sequência #)] = MAXIMUM[1,,1], ou seja, M,11 = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 9

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[,,1], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 80

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[,,], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 81

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[,,], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 8

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[1,,1], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 8

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M, = MAXIMUM[ M, + S, (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M, + w (gap na sequência #)] = MAXIMUM[,,1], ou seja, M, = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 88

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,8 = MAXIMUM[ M, + S,8 (coincidência ou não na diagonal da matriz), M, + w (gap na sequência #1), M,8 + w (gap na sequência #)] = MAXIMUM[1,,], ou seja, M,8 = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 89

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério temos: M,9 = MAXIMUM[ M, 8 + S,9 (coincidência ou não na diagonal da matriz), M,8 + w (gap na sequência #1), M,9 + w (gap na sequência #)] = MAXIMUM[,,], ou seja, M,9 = 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 90

Algoritmo de Needleman & Wunsch (Preenchimento) Aplicando-se o critério para o restante da matriz, temos o resultado abaixo. 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 9

Algoritmo de Needleman & Wunsch (Alinhamento) No alinhamento iniciamos onde temos o maior escore, na posição,11, indicada pelo círculo vermelho abaixo. Para escolher o próximo movimento, vemos as posições anteriores, indicadas por flechas. Todas tem escore, assim movemos na diagonal. Movimento na diagonal significa alinhamento das duas bases. 0 1 8 9 10 11 0 1 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 9 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Alinhamento) O alinhamento parcial está indicado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 9

Algoritmo de Needleman & Wunsch (Alinhamento) Analisando-se os escores vizinhos, vemos que o maior está à esquerda (), o que indica uma inserção de gap na sequência, como mostrado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A Gap 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 9

Algoritmo de Needleman & Wunsch (Alinhamento) Analisando-se os escores vizinhos, vemos que o maior está à esquerda () de novo, o que indica uma nova inserção de gap na sequência, como mostrado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 9

Algoritmo de Needleman & Wunsch (Alinhamento) Analisando-se os escores vizinhos, temos em todos, assim seguimos na diagonal, o que indica uma coincidência, como mostrado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 98

Algoritmo de Needleman & Wunsch (Alinhamento) O maior escore entre os vizinhos é, o que indica a inserção de um novo gap na sequência, como mostrado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 99

Algoritmo de Needleman & Wunsch (Alinhamento) Novo movimento na diagonal, temos o alinhamento abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 100 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Alinhamento) O escore mais alto está à esquerda (), o que representa a inserção de gap na sequência, como mostrado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 101 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Alinhamento) Temos agora movimento na diagonal, e coincidência, como indicado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 10 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Alinhamento) O maior escore localiza-se à esquerda (), o que representa a inserção de gap na sequência, como mostrado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 10 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1

Algoritmo de Needleman & Wunsch (Alinhamento) Agora temos um deslocamento na diagonal, o que leva a uma coincidência no alinhamento, como mostrado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 10

Algoritmo de Needleman & Wunsch (Alinhamento) Temos o maior escore na posição acima, o que representa uma inserção de gap na sequência 1, como indicado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 10

Algoritmo de Needleman & Wunsch (Alinhamento) Por último temos um deslocamento na diagonal, o que representa uma coincidência, como indicado abaixo. G - A A T T C A G T T A G G A - T - C - G - - A 0 1 0 1 8 9 10 11 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 10

Algoritmo de Needleman & Wunsch (Alinhamento) Completamos o alinhamento. O algoritmo apresentado é uma simplificação, ficou faltando um valor para a penalidade de gap na montagem da matriz. Programas de alinhamento modernos, como Clustaw e outros, levam em conta as penalidades. Além disso, é feito uso de matrizes de escore, para pontuar diferentes alinhamentos, como no caso de aminoácidos. G - A A T T C A G T T A G G A - T - C - G - - A 10

Algoritmo de Needleman & Wunsch (Implementação) Abaixo temos o programa algo_nw1.py, que realiza o alinhamento de duas sequências de DNA, a partir do algoritmo de Needleman & Wunsch. O programa é relativamente longo, assim apresentaremos por partes. Inicialmente importamos a biblioteca NumPy, que traz recursos matemáticos como matrizes e vetores. As matrizes e vetores são implementados como arrays, que assemelham-se a listas, mas com um tipo somente de dados. Em seguida definimos as sequências a serem alinhadas e determinamos o tamanho delas. Somamos 1 ao tamanho das sequências, pois estes números serão usados para definir a matriz caminho (n1xn), que tem uma coluna e uma linha extras. # Import library import numpy as np # Sequences to align seq1 = "GAATTCAGTTA" seq = "GGATCGA" # Length of sequences n1 = len(seq1)+1 n = len(seq)+1 108

Algoritmo de Needleman & Wunsch (Implementação) Agora definimos a matriz caminho, a ser atribuída à variável M. Usamos o recurso np.array(). Veja que as variáveis n1 e n definem os números de linhas e colunas da matriz caminho. Em seguida temos dois loops for, para mostrar as sequências na tela. # Set up path matrix M = np.array([[0]*n1]*n,int) # Show sequence print("sequences to be aligned:") for i in range(n1-1): print(seq1[i],end="") print() for j in range(n-1): print(seq[j],end="") # np.array([[0]*column]*row,int) 109

Algoritmo de Needleman & Wunsch (Implementação) Abaixo temos o trecho do código que define a matriz caminho (path matrix), com 1 atribuído quando as bases coincidem. Esses valores serão usados posteriormente para os elementos S i,j usados no cálculo dos elementos da matriz caminho para o alinhamento. # Define path matrix # Looping through matrix for i in range(1,n): for j in range(1,n1): if seq1[j-1] == seq[i-1]: M[i][j] = 1 110

Algoritmo de Needleman & Wunsch (Implementação) Para a construção da matriz caminho completa, usamos a condição já vista para o alinhamento, M i,j = MAXIMUM[ M i-1, j-1 + S i,j (coincidência ou não na diagonal da matriz), M i,j-1 + w (gap na sequência #1), M i-1,j + w (gap na sequência #)] # Build path matrix for i in range(1,n): for j in range(1,n1): my_array = [M[i-1][j-1] + M[i][j], M[i][j-1],M[i-1][j]] M[i][j] = np.max(my_array) 111

Algoritmo de Needleman & Wunsch (Implementação) Como atribuímos 1 aos elementos da matriz M quando havia coincidência, o elemento S i,j a ser usado na soma é o elemento M i,j. M i,j = MAXIMUM[ M i-1, j-1 + S i,j (coincidência ou não na diagonal da matriz), M i,j-1 + w (gap na sequência #1), M i-1,j + w (gap na sequência #)] É o mesmo que o S ij da equação acima # Build path matrix for i in range(1,n): for j in range(1,n1): my_array = [M[i-1][j-1] + M[i][j], M[i][j-1],M[i-1][j]] M[i][j] = np.max(my_array) 11

Algoritmo de Needleman & Wunsch (Implementação) Veja que montamos um array auxiliar atribuído à variável my_array. Esse array recebe os três elementos da matriz caminho e identificamos o máximo com o método max, como mostrado abaixo. M i,j = MAXIMUM[ M i-1, j-1 + S i,j (coincidência ou não na diagonal da matriz), M i,j-1 + w (gap na sequência #1), M i-1,j + w (gap na sequência #)] # Build path matrix for i in range(1,n): for j in range(1,n1): my_array = [M[i-1][j-1] + M[i][j], M[i][j-1],M[i-1][j]] M[i][j] = np.max(my_array) 11

Algoritmo de Needleman & Wunsch (Implementação) Agora mostramos a matriz caminho na tela. # Show path matrix print("\n\npath matrix:") for i in range(n): for j in range(n1): print(m[i][j],end=" ") print() 11

Algoritmo de Needleman & Wunsch (Implementação) Abaixo atribuímos valores para variáveis i e j que serão usadas em loops. Definimos strings vazias para irmos montando as sequências alinhadas. # Set up initial values for i and j i = n-1 j = n1-1 11 # Set up empty strings s1 = "" s = "" 11

Algoritmo de Needleman & Wunsch (Implementação) Abaixo temos um loop while que monta as sequências alinhadas, que vão sendo atribuídas às variáveis s1 e s. Podemos pensar neste trecho de código como o responsável pelo retorno no matriz caminho, a partir do elemento maior. # while loop while( i > 0 or j >0): my_array = [M[i-1][j-1], M[i][j-1],M[i-1][j]] m1 = np.max(my_array) if m1 == M[i-1][j-1]: s1 += seq1[j-1] s += seq[i-1] i -= 1 j -= 1 elif m1 == M[i][j-1]: s1 += seq1[j-1] s += "-" j -= 1 elif m1 == M[i-1][j]: s1 += "-" s += seq[i-1] i -= 1 11

Algoritmo de Needleman & Wunsch (Implementação) Agora mostramos os resultados na tela. Como montamos as sequências invertidas, temos que inverter as strings, usando-se o comando s1[::-1]. Este comando inverte a sequência de bases atribuídas à variável s1. print("\naligned sequences:") print(s1[::-1]) print(s[::-1]) 11

Algoritmo de Needleman & Wunsch (Implementação) Abaixo temos o resultado para execução do código. Sequences to be aligned: GAATTCAGTTA GGATCGA Path matrix: 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 0 1 0 1 0 1 0 1 0 1 Aligned sequences: G-AATTCAGTTA GGA-T-C-G--A 118

Exercício de Programação Implemente o Algoritmo de Needleman & Wunsch usando-se a abordagem de Programação Orientada a Objeto. Considere que o programa tem um método para a leitura das sequências a serem alinhadas a partir de dois arquivos no formato FASTA. Chame o novo programa de algo_nw.py. 119

Colophon This material was produced in a HP Pavillon dm notebook with GB of memory, a 00 GB hard disk, and an Intel Core i M0 CPU @. GHz running Windows Professional. Text and layout were generated using PowerPoint 00 and graphical figures were generated by Visual Molecular Dynamics (VMD)(Humphrey W, Dalke A, Schulten K.VMD: visual molecular dynamics. J Mol Graph. 199; 1(1):-8, -8.) and Matplotlib. Additional figures on the slides -10 were taken from the book: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 00. This material uses Arial font. 10

Author I graduated in Physics (BSc in Physics) at University of Sao Paulo (USP) in 1990. I completed a Master Degree in Applied Physics also at USP (199), working under supervision of Prof. Yvonne P. Mascarenhas, the founder of crystallography in Brazil. My dissertation was about X- ray crystallography applied to organometallics compounds (De Azevedo Jr. et al.,199). During my PhD I worked under supervision of Prof. Sung-Hou Kim (University of California, Berkeley. Department of Chemistry), on a split PhD program with a fellowship from Brazilian Research Council (CNPq)(199-199). My PhD was about the crystallographic structure of CDK (Cyclin- Dependent Kinase ) (De Azevedo Jr. et al., 199). In 199, I returned to Brazil. In April 199, I finished my PhD and moved to Sao Jose do Rio Preto (SP, Brazil) (UNESP) and worked there from 199 to 00. In 199, I started the Laboratory of Biomolecular Systems- Department of Physics-UNESP - São Paulo State University. In 00, I moved to Porto Alegre/RS (Brazil), where I am now. My current position is coordinator of the Laboratory of Computational Systems Biology at Pontifical Catholic University of Rio Grande do Sul (PUCRS). My research interests are focused on application of computer simulations to analyze protein-ligand interactions. I'm also interested in the development of bioinspired computing and machine learning algorithms. We apply these algorithms to molecular docking simulations, protein-ligand interactions and other scientific and technological problems. I published over 10 scientific papers about protein structures and computer simulation methods applied to the study of biological systems (Hindex: ). These publications have over 000 citations. I am editor for the following journals: 11

Referências ALBERTS, B. et al. Biologia Molecular da Célula. a edição. Porto Alegre: Artmed editora, Porto Alegre, 00. -BRESSERT, Eli. SciPy and NumPy. Sebastopol: O Reilly Media, Inc., 01. p. -DAWSON, Michael. Python Programming, for the absolute beginner. ed. Boston: Course Technology, 010. p. -HETLAND, Magnus Lie. Python Algorithms. Mastering Basic Algorithms in the Python Language. Nova York: Springer Science+Business Media LLC, 010. 1 p. -IDRIS, Ivan. NumPy 1.. An action-packed guide dor the easy-to-use, high performance, Python based free open source NumPy mathematical library using real-world examples. Beginner s Guide. Birmingham: Packt Publishing Ltd., 011. 1 p. -KIUSALAAS, Jaan. Numerical Methods in Engineering with Python. ed. Nova York: Cambridge University Press, 010. p. -LANDAU, Rubin H. A First Course in Scientific Computing: Symbolic, Graphic, and Numeric Modeling Using Maple, Java, Mathematica, and Fortran90. Princeton: Princeton University Press, 00. 81p. -LANDAU, Rubin H., PÁEZ, Manuel José, BORDEIANU, Cristian C. A Survey of Computational Physics. Introductory Computational Physics. Princeton: Princeton University Press, 008. 8 p. -LUTZ, Mark. Programming Python. ed. Sebastopol: O Reilly Media, Inc., 010. 18 p. -MODEL, Mitchell L. Bioinformatics Programming Using Python. Sebastopol: O Reilly Media, Inc., 011. 18 p. -TOSI, Sandro. Matplotlib for Python Developers. Birmingham: Packt Publishing Ltd., 009. 9 p. Última atualização: 8 de dezembro de 01. 1