Prolog - 1 Prolog m Prolog concretiza o modelo de computação abstracto da Programação em Lógica q escolher o golo mais à esquerda na resolvente q (em vez.

Apresentação em tema: "Prolog - 1 Prolog m Prolog concretiza o modelo de computação abstracto da Programação em Lógica q escolher o golo mais à esquerda na resolvente q (em vez."— Transcrição da apresentação:

1 Prolog - 1 Prolog m Prolog concretiza o modelo de computação abstracto da Programação em Lógica q escolher o golo mais à esquerda na resolvente q (em vez da escolha não determinística da cláusula a usar na próxima redução) pesquisa sequencial das cláusulas em busca de unificação, acompanhada de retrocesso m equivale a uma pesquisa em profundidade da árvore de pesquisa q implementável por uma máquina de stack, onde se guardam os golos da resolvente

2 Prolog - 2 Paralelismo m outras opções no tratamento do não determinismo q percorrer em paralelo todos os ramos da árvore de pesquisa (paralelismo ou nas várias alternativas de uma cláusula) p  q1, q2 p  q3, q4 p  q5 q executar em paralelo os vários golos de uma resolvente (paralelismo e) p  q1(X), q2(X), q3 q Parlog, Concurrent Prolog, GHC p q1(X)q3q2(X) e p q1, q2q5q3, q4 ou

3 Prolog - 3 Retrocesso (backtracking) m um traço de uma computação pode continuar depois de uma falha q um f seguido a um golo significa golo falhado q o golo seguinte é o que seria escolhido pelo mecanismo de retrocesso m corresponde à chamada mais próxima em cujo procedimento existe uma cláusula alternativa a seguir às cláusulas já usadas q o novo golo é idêntico e tem as mesmas variáveis que uma sua anterior ocorrência no traço, ao mesmo nível q ponto de escolha q armazenar substituições e estado da resolvente i.e. qual a cláusula seguinte, para poder regressar

4 Prolog - 4 Traço com retrocesso avo( abraao, X ) progenitor( abraao, Y ), progenitor( Y,X )¶ pai( abraao, Y ), progenitor( Y, X ) progenitor( isaac, X )¶ {Y= isaac } pai( isaac, X )  {Y= isaac, X= jacob} ; progenitor( isaac, X )· {Y= isaac } mae( isaac,X ) f progenitor( abraao, Y ), progenitor( Y,X )· mae( abraao, Y ), progenitor( Y, X ) f não há mais pontos de escolha

5 Prolog - 5 Ordem das cláusulas determina a ordem por que as soluções são encontradas. corresponde a trocar a ordem dos ramos na árvore de pesquisa (como o Prolog escolhe sempre o da esquerda...) member( X, [X|Xs] ). member( X, [Z| Xs] )  member( X, Xs ). member( X, [X|Xs] ). member( X, [1,2,3] )  {X= 1} ; member( X, [1,2,3] ) member( X, [2,3] )  {X= 2} ; member( X, [2,3] ) member( X, [3] )  {X= 3} ; member( X, [3] ) member( X, [] ) f Ordem das cláusulas member( X, [1,2,3] ) member( X, [2,3] ) member( X, [3] ) member( X, [] ) f member( X, [3] ) {X= 3} ; member( X, [2,3] ) {X= 2} ; member( X, [ 1,2,3] ) {X= 1} ; no

6 Prolog - 6 Terminação m computação de um golo — cálculo de todas as soluções q troca de ordem das cláusulas não altera a árvore de pesquisa; só a percorre por ordem diferente q se existir um ramo infinito a computação nunca termina m não terminação — só com recursão  evitar a recursão à esquerda sao_irmaos( X, Y )  irmao( X, Y ). sao_irmaos( X, Y )  irmao( Y, X ).  a terminação depende também do estado de instanciação dos argumentos — caso do append/3 com o 1º e 3º argumentos listas incompletas, ou member/2, com 2º variável  caso perigoso: recursão à esquerda, golo recursivo é o primeiro no corpo  programa irmao( X, Y )  irmao( Y, X )  traço irmao( lot, milcah ) irmao( milcah, lot ) irmao( lot, milcah )

7 Prolog - 7 antepassado( A, X )  antepassado( Y, X), progenitor( A, Y ). antepassado( A, X )  progenitor( A, X ). Ordem dos golos determina a árvore de pesquisa. definição recursiva à esquerda, com ramo infinito — trocar a ordem dos golos padrão de instanciação dos argumentos determina a ordem óptima dos golos objectivo é falhar depressa! avo( A, N )  progenitor ( Y, N ), progenitor( A, Y ). neto( A, N )  progenitor ( A, Y), progenitor( Y, N ). Ordem dos golos m pode a ordem dos resultados ser alterada m pode a árvore ser de dimensão muito diferente m pode a diferença ser existir ou não um ramo infinito

8 Prolog - 8 Repetições m em muitas situações, convém evitar repetições nas soluções minimum( X, Y, X )  X=< Y. minimum( X, Y, Y )  X>= Y. q minimum( 2, 2, M ) tem duas soluções iguais, M=2 q basta corrigir a lógica para evitar a redundância minimum( X, Y, Y )  X> Y. q noutros casos, é necessário alterar até a semântica do predicado

9 Prolog - 9 m ideal da PL m o Prolog encarregar-se-ia do Controlo deixando aos utilizadores apenas a Lógica das definições axiomáticas m estas seriam, por assim dizer, directamente executáveis m infelizmente, é necessário conhecer pormenores do modelo de execução do Prolog Algoritmo = Lógica + Controlo Equação da PL

10 Prolog - 10 % factorial( N, F )  F é o n-ésimo factorial factorial( N, F )  N > 0, N1 is N-1, factorial( N1, F1 ), F is N * F1. factorial( 0, 1 ). Aritmética avaliada m Objectivo: ter acesso ao processador aritmético da máquina (eficiência)  soma( X, Y, Z )  Z is X + Y  X, Y têm que estar instanciados  a expressão é avaliada e o resultado colocado em Z m Perde-se:  múltiplos usos do predicado (especializa-se para um uso: soma( X, 2, 5) dá erro) q e a estrutura recursiva dos números (não se pode usar unificação mas sim cálculo explícito)

11 Prolog - 11 Aritméticos +, -, *, /, mod Comparação =, =:=, =\= Avaliação is Predicados de sistema q Z is 2+4{Z=6} q 4 is 2 + Xerro, se X não for exp aritmética yes, se X for 2 no, se X for inteiro  2 q 2+4 = 3+3no q X= 5-2{X= 5-2} unifica q 2+4 =:= 3+3yes avalia q 2*3 =< 24/4yes q X \= 8no não unifica q 8 mod 3 \= 2yes q 8 mod 3 =\= 2no q X is X + 3erro, se X não for exp aritmética no, cc q 7 is 28/4yes

12 Prolog - 12 m implementação da recursão: cada chamada implica guardar uma estrutura na stack com as variáveis temporárias que podem vir a ser precisas q espaço ocupado linear no número de chamadas recursivas m não há construções iterativas, mas há implementações iterativas de programas recursivos q quando o golo recursivo é o último do corpo da cláusula, não há mais pontos de escolha e portanto o espaço ocupado pela chamada anterior pode ser reaproveitado Iteração

13 Prolog - 13 Programa iterativo  ao chamar, N e T já não são mais precisos e F é sempre o mesmo, pois só na última chamada recebe o valor no acumulador q trata-se de recursão à direita ou recursão na cauda  comparar com factorial/2 atrás, que não tem recursão à direita % factorial  F é o factorial de N factorial( N, F )  factorial( N, 1, F ). factorial( N, T, F )  N > 0, T1 is T*N, N1 is N-1, factorial( N1, T1, F ). factorial( 0, F, F ).

14 Prolog - 14 Pontos de escolha m na variante 1 não se criam pontos de escolha q a unificação do golo com a outra cabeça é impossível, pelo que não há cláusulas alternativas utilizáveis q a criação de um ponto de escolha é pesada: armazenar o ponto da execução, mais o estado de instanciação das variáveis m variante 2: cria ponto de escolha q está-se a atrasar a unificação para dentro do corpo da cláusula, em vez de resolver logo com a unificação na cabeça m Variante 1 lista([]). lista([X|Xs]) :- lista( Xs ).  Chamada: lista( [1,2,3]) m Variante 2 lista(Xs) :- Xs = []. lista(X) :- X=[X|Xs], lista( Xs ).  Chamada: lista( [1,2,3])

15 Prolog - 15 Meta-variável m em Prolog, tanto os dados como os programas são representados como termos lógicos q é possível manipular os programas como se fossem dados e vice-versa q através do meta-predicado call(X) meta-predicado, porque a sua execução é chamar o seu argumento como se fosse um golo [read( G ), call( G ) — lê um termo da entrada e executa-o] q meta-variável — simplificação sintáctica: em vez de call( X ) usar simplesmente X [read( G ), G ] definição da disjunção: % X ; Y  X ou Y X ; Y  X. X ; Y  Y. se, no momento da chamada, a meta-variável estiver por instanciar, dá erro

16 Prolog - 16 Programa errado % fib( N, F )  F é o número de Fibonnacci de ordem N fib( 1, 1 ). fib( 2, 1 ). fib( N, F )  N1 is N-1, N2 is N-2, fib( N1, F1 ), fib( N2, F2 ), F is F1+F2. série: 1 1 2 3 5 8 13 21 34...

17 Prolog - 17 fib( 3, F ) N1 is 3-1, N2 is 3-2, fib( N1, F1 ), fib( N2, F2 ), F is F1+F2 fib( 1, F2 ), F is 1+F2 {F= 2} F is 1+1 {F2=1} fib( 2, F1 ), fib( 1, F2 ), F is F1+F2  N1a is 1-1, N2a is 1-2, fib( N1a, F1a ), fib( N2a, F2 a), F2 is F1a+F2a, F is 1+F2 fib( 0, F1a ), fib( -1, F2 a), F2 is F1a+F2a, F is 1+F2 N1b is 2-1, N2b is 2-2, fib( N1b, F1b ), fib( N2b, F2 b), F1 is F1b+F2b, fib( 1, F2 ), F is F1+F2 {N1=2, N2=1} {F1=1} {N1a=0, N2a=-1} Programa errado

18 Prolog - 18 % fib( N, F )  F é o número de Fibonnacci de ordem N fib( 1, 1 ). fib( 2, 1 ). fib( N, F )  N>2, N1 is N-1, N2 is N-2, fib( N1, F1 ), fib( N2, F2 ), F is F1+F2. guarda a guarda funciona como uma espécie de extensão da unificação na cabeça a provocar um retrocesso superficial (logo no 1º golo) assim o programa computa só as soluções pretendidas Solução com guarda

19 Prolog - 19 fib( 3, F ) 3>2, N1 is 3-1, N2 is 3-2, fib( N1, F1 ), fib( N2, F2 ), F is F1+F2 fib( 1, F2 ), F is 1+F2 {F= 2} F is 1+1 {F2=1} fib( 2, F1 ), fib( 1, F2 ), F is F1+F2  1>2, N1a is 1-1, N2a is 1-2, fib( N1a, F1a ), fib( N2a, F2 a), F2 is F1a+F2a, F is 1+F2 2>2, N1b is 2-1, N2b is 2-2, fib( N1b, F1b ), fib( N2b, F2 b), F1 is F1b+F2b, fib( 1, F2 ), F is F1+F2 {N1=2, N2=1} {F1=1} Solução com guarda

20 Prolog - 20 Solução com cut % fib( N, F )  F é o número de Fibonnacci de ordem N fib( 1, 1 )  !. fib( 2, 1 )  !. fib( N, F )  N1 is N-1, N2 is N-2, fib( N1, F1 ), fib( N2, F2 ), F is F1+F2. fib/2 fica determinista

21 Prolog - 21 fib( 3, F ) N1 is 3-1, N2 is 3-2, fib( N1, F1 ), fib( N2, F2 ), F is F1+F2 fib( 1, F2 ), F is 1+F2 {F= 2} F is 1+1 {F2=1} fib( 2, F1 ), fib( 1, F2 ), F is F1+F2  N1a is 1-1, N2a is 1-2, fib( N1a, F1a ), fib( N2a, F2 a), F2 is F1a+F2a, F is 1+F2 fib( 0, F1a ), fib( -1, F2 a), F2 is F1a+F2a, F is 1+F2 N1b is 2-1, N2b is 2-2, fib( N1b, F1b ), fib( N2b, F2 b), F1 is F1b+F2b, fib( 1, F2 ), F is F1+F2 {N1=2, N2=1} {F1=1} !, fib( 1, F2 ), F is F1+F2 !, F is 1+F2 Solução com cut

22 Prolog - 22 qo cut (!) é um predicado de sistema que expressa determinismo se um golo unificou com a cabeça fib( 1, 1 ), não há hipótese de encontrar outra solução, usando outra cláusula Tratamento do cut — o golo cut sucede e comete o Prolog com todas as escolhas feitas desde que o golo pai unificou com a cláusula onde o cut ocorre. Cut q o cut corta todas as cláusulas abaixo dele (na definição do mesmo predicado) q o cut corta todas as soluções alternativas dos golos que lhe ficam à esquerda na cláusula q o cut não corta os golos que lhe ficam à direita na cláusula estes podem produzir várias soluções em retrocesso retrocesso no cut falha e provoca a escolha da última alternativa antes da escolha da cláusula que contém o cut

23 Prolog - 23 Cut verde m cut verde — cut que, se retirado, não afecta as soluções produzidas q só serve para evitar ao Prolog o trabalho de percorrer ramos falhados da árvore de pesquisa [seria o caso de fib/3 com cuts e com a guarda N>2] m problema: a formulação do efeito do cut é muito operacional e destrói, em muitos casos, a declaratividade das definições de predicados q só simulando a execução se percebe o comportamento do programa

24 Prolog - 24 Predicado determinista m exemplo de cuts verdes — predicado determinista, isto é, em cada caso só uma cláusula é aplicável q optimização da recursão na cauda, garantida pondo um cut antes do último golo, porque deixa de haver pontos de escolha para a computação do golo dessa cláusula % fusao( Xs, Ys, Zs )  Zs é a lista ordenada com a fusão das listas ordenadas Xs e Ys fusao( [X|Xs], [Y|Ys], [X|Zs] )  X<Y, !, fusao( Xs, [Y|Ys], Zs ). fusao( [X|Xs], [Y|Ys], [X,Y|Zs] )  X=Y, !, fusao( Xs, Ys, Zs ). fusao( [X|Xs], [Y|Ys], [Y|Zs] )  X>Y, !, fusao( [X|Xs], Ys, Zs ). fusao( Xs, [], Xs )  !. fusao( [], Ys, Ys )  !.

25 Prolog - 25 Cut vermelho m cut vermelho — cut que, se retirado, altera as soluções produzidas q usa-se para implementar (parcialmente) a negação por falha; q para eliminar soluções indesejadas [a segunda cláusula de ordena/2 só se atinge se não se passar pelo cut na primeira]: é perigoso! Basta alterar a ordem das cláusulas para ter resultados errados; q evitar o cálculo de ordenada/1, a negação da condição de cima % ordena( Xs, Ys )  Ys é a lista ordenada dos elementos de Xs ordena( Xs, Ys )  append( As, [X, Y|Bs], Xs ), X>Y, !, append( As, [Y, X|Bs], Xs1 ), ordena( Xs1, Ys ). ordena( Xs, Xs ). %  ordenada( Xs ), !.

26 Prolog - 26 % nao( X )  não se consegue provar X nao( X )  X, !, fail. nao( X ). Implementação da negação m este cut é vermelho (se o retirar, nao(X) sucede sempre) m trocar a ordem das cláusulas não se limita a trocar a ordem das soluções — passa a dar soluções erradas m a negação dá resultados inesperados se o golo for chamado com argumentos não fechados

27 Prolog - 27 Uso do cut % estudante_solteiro( X ) ¬ X é estudante e X não é casado estudante_solteiro( X )  nao( casado(X) ), estudante( X ). estudante( quim ). casado( ze ). q golo estudante_solteiro( X ) falha porque casado( X ) sucede com X=ze, embora X=quim seja uma solução; trocando a ordem já sucede porque chama nao( casado( quim ) ) fechado

28 Prolog - 28 % minimo( X, Y, Z )  Z é o mínimo entre X e Y minimo( X, Y, Z )  (X= Z=X ; Z=Y). % minimo( X, Y, Z )  Z é o mínimo entre X e Y minimo( X, Y, X )  X=<Y, !. minimo( X, Y, Y ). Se-então-senão % P -> Q ; R  se P então Q, senão R P -> Q ; R  P, !, Q. P -> Q ; R  R. q este cut é vermelho, porque se baseia na supressão da condição da 2ª cláusula P -> Q ; R  not P, R. a vantagem é precisamente evitar a duplicação da avaliação de P