Life Leonardo Lemos (lal)Paulo Oliva (pbo)& Controle de Fluxo * de predicados: Como em Prolog: fail. conjunção (A,B). disjunção (A;B). Diferente de Prolog:

Apresentação em tema: "Life Leonardo Lemos (lal)Paulo Oliva (pbo)& Controle de Fluxo * de predicados: Como em Prolog: fail. conjunção (A,B). disjunção (A;B). Diferente de Prolog:"— Transcrição da apresentação:

1

2 Life Leonardo Lemos (lal)Paulo Oliva (pbo)&

3 Controle de Fluxo * de predicados: Como em Prolog: fail. conjunção (A,B). disjunção (A;B). Diferente de Prolog: succeed (em Prolog, true). * de funções: disjunção {A;B}. * Cut (!): como Prolog exceto com disjunção de funcões. * grandparent(X,Z) :- parent(X,Y), parent(Y,Z). * pessoa(X) :- mulher(X); homem(X). * A = {1;2;3;4} A=1, A=2, A=3 ou A=4. * P(A) :- !, write(A). P(X:{1;2;3})? 1 2 3 * Q(A:{1;2;3}) :- !, write(A). Q(X)? 1

4 Controle de Fluxo * Condicionador cond(B,T,F) Ex.: abs(V:real) -> cond(V>=0,V,-V). * Tal que | * função call_once(P) Tente provar P: t se P é verificado devolve true t se P falha devolve false Ponte entre funções e predicados * Ap3([ ],L,R) -> true | R=L. * Ap3([X|L1],L2,R) -> true | R=[X|L3], Ap3(L1,L2,L3). * call_once(person(John)).

5 Cálculos Aritméticos * Funções Aritméticas Binárias Soma (A+B) Diferença (A-B, -A) Produto (A*B) Divisão (A/B) Parte inteira da divisão (A//B) * fatorial em Prolog fat(0, 1). fat(N, R) :- N1 is N - 1, fat(N1, A), R is N * A. * fatorial em LIFE fat(0) ->1. fat(N) -> N * fat(N - 1).

6 Cálculos Aritméticos * Funções Aritméticas bit a bit. E lógico de A com B, A / \ B. Ou lógico de A com B, A \ / B. Right Shift de A, B vezes, A >> B. Left Shift de A, B vezes, A << B. Negação de A, (\A). * 12 /\ 5 = 4 1100 /\ 0101 = 0100 * 12 \/ 5 = 13 1100 \/ 0101 = 1101 * 12 >> 1 = 6 1100 >> 1 = 0110 * 12 << 1 = 24 01100 << 1 = 11000 * \12 = 3 * \...001100 =...110011

7 Cálculos Aritméticos * Funções Aritméticas Unárias. Maior inteiro menor ou igual a A, floor(A). Menor inteiro maior igual a A, ceiling(A). Raiz quadrada de A, sqrt(A). e elevado a A, exp(A). Logarítmo na base 10, log(A). Seno, Cosseno e Tangente t sin(A), cos(A), tan(A). * floor(4.5) = 4.0 * ceiling(4.5) = 5.0 * sqrt(4.0) = 2.0 * exp(1) = 2.7189... * log(100) = 2 * sin(3.1415) = 0.0 * sin(1.57) = 1.0

8 Cálculos Aritméticos * Gerador de números aleatórios initrandom(S:Real) random(N:Int) genint * initrandom(10). * random(30)? 4 * random(30)? 23 * random(30)? 4 * genint? 234 * genint? 931

9 Comparação Aritmética * Maior (A>B) * Maior igual (A>=B) * Menor (A<B) * Menor igual (A<=B) * Igualdade (A=:=B) * Diferença (A=\=B) > maior2(X) :- X > 2. > maior2(A)? *** Yes A = real~. --1> A = 3? *** Yes A = 3. ----2> *** No A = real~. --1>

10 Aritmética Booleana * E (A and B) * Ou (A or B) * Ou exclusivo (A xor B) Não existem em Prolog * Negação (not A) Lógica, não por falha. > person1(X) -> man(X) or woman(X). true/false > person2(X) -> man(X); woman(X). succeed/fail

11 * Exemplos: greater_lower_bound t glb(c,d) = {a;b} least_upper_bound t lub(a,b) = {c;d} parents(a) = {c;d} parents(c) = [@] children(c) = {a;b} children(a) = [ ] subsort(a,a) = true subsort(a,a(b=>2)) = true least_sorts = {a;b} d a c @ b {} Cálculo de Sorts

12 Comparação de Sorts * Maior (c:>d = false) * Maior igual (c:>=c = true) * Menor (b:<d = true) * Menor igual (b:<=d = true) * Igual na hierarquia dos sorts (a:==a = true) * Se os sorts são comparáveis (a:><d = true) d a c @ b {}

13 Comparação de Sorts d a c @ b {} * Não maior (c:\>d = true) * Não maior igual (c:\>=c = false) * Não menor (b\:<d = false) * Não menor igual (b:\<=d = false) * Não igual na hierarquia dos sorts (a:\==a = false) * Se os sorts não são comparáveis (a:\><d = false)

14 Cálculo de Strings * É tratada como um sort e usa menos mémoria que termos. * Tamanho da string, strlen(abcdef) = 6. * Parte de string, substr(abcdef,5, 2) = ef. * Concatenar strcon(abc, def) = abcdef. * Código ASCII de S, asc(S:String). * Carácter do código ASCII, chr(I:Int). * Transforma a string em um termo. str2psi(foo) = foo * Inverso de str2psi, psi2str(X). psi2str(int) = int

15 Comparação de Strings * Maior (A$>B) * Maior igual (A$>=B) * Menor (A$<B) * Menor igual (A$=<B) * Igual (A$= =B) * Não igual (A$\= =B) * aba $> bab? false * a $< aa? true * jaca $== caja? false

16 Verificação de Tipo * ap1([ ], L) -> L ap1([X|L1], L2) -> [X|ap1(L1,L2)] * ap2 ([ ],L,L). ap2 ([X|L1],L2,[X|L3]) :- ap2(L1,L2,L3). * is_function(ap1). True. * is_predicate(ap1). False. * is_sort(ap2). False. * Se X é um @ sem argumentos: var(X) * Se X não é @ ou tem argumentos: nonvar(X) * Se X é um termo persistente: is_persistent(X)

17 Variáveis globais * Variável lógica cujo nome é visível em todo o programa. (módulo) * Devem ser declaradas. * Comporta-se com um parâmetro extra passado para todos os predicados, funções e conjuntos. * Não contribuem para a manutenção do programa * Usadas para rastrear programas sem usar parâmetros extras. > global (warfare)? % declarar variável gb. *** yes > warfare=34? % unificar com 34 *** yes --1> write (warfare)? % escrever o valor 34 *** yes ----2>. > write (warfare)? % backtracking desfaz @ % a unificação *** yes

18 Termos e variáveis persistentes * Termos Persistentes É um termo que não muda o valor no backtracking. São termos apenas de leitura que só pode ser modificado por chamadas explícitas por atribuições não-backtracking (<<-) Um termo persistente pode ser armazenado em uma variável padrão. Toda interação entre termos locais e termos persistentes é feita através de matching. Unificar dois termos persistentes gera erro. * Variável Persistente: É um termo persistente armazenado em uma variável global. O valor nunca fica inacessível. Tem que ser declaradas. Atualmente não diferencia entre variáveis persistentes e globais

19 Exemplo de Variável Persistente > persistent (trouble)? *** yes > trouble<<-with_harry? *** yes --1> write (trouble)? with_harry *** yes ----2>. > write (trouble)? with_harry *** yes > global (trouble)? *** yes > trouble<<-with_harry? *** yes --1> write (trouble)? with_harry *** yes ----2>. > write (trouble)? @ *** yes

20 Atribuição Destrutiva * Atribuição destrutiva Life provê uma integração limpa de atribuições destrutivas. Utiliza dois tipos de termos: normais e persistentes. Dois tipos de atribuições destrutivas: * Atribuição destrutiva backtrackable X sobrepõe Y. Backtracking recupera os valores originais de X. (X <- Y) > X=5, (X<-6;X<-7;succeed), write(X), nl, fail? 6 7 5 *** No

21 Atribuição Destrutiva não-Backtrackable * X sobrepõe Y. Backtracking não recupera os valores originais de X. (X <<- Y) > X=5? *** yes X = 5. --1> X <<- 10? *** yes X = 10. ----2> X <<- 20? *** yes X = 20? ------3> *** no X = 20. ----2> X = 5.

22 Gramáticas de Cláusulas Definidas (GCD) * Notação popular de gramática: Backus-Naur Form, BNF, para a linguagem a n b n ::= a b ::= a b * Notação DCG (definite clause grammar) s --> [a], [b]. s --> [a], s, [b]. * Diretamente utilizável para os processamentos morfológico e sintático na interpretação de LN (parsing) * Também utilizado para os processamentos semântico e pragmático na interpretação de LN. * Noção de Difference List [1,2,3] = [1,2,3,4] - [4] [x] = [x|A] - A [a,b,c,d] = [a,b,c,d] - [ ]

23 Conversão de GCD para Prolog * f(T,F) :- sn(T,R), gv(R, F). * f(T,F) :- sn(T,R1), gv(R1,R2), sn(R2,F). * sn(T,F) :- nome(T,F). * sn(T,F) :- det(T,R), subs(R,F). * gv(R,F) :- v(T,F). * v([come|F],F). * v([canta|F],F). * subs([pera|F],F). * nome([ana|F],F). * det([pera|F],F). * F --> SN, GV. * F --> SN, GV, SN. * SN --> Nome * SN --> Det, Subs. * GV --> V. * V --> [come]. * V --> [canta]. * Nome --> [ana]. * Subs --> [pera]. * Det --> [a].

24 Parsing Bottom-Up com GCDs f([Ana,come,a,pera],[]) sngvsn nome ana v comea detsubs pera * f(T,F) :- sn(T,R), gv(R, F). * f(T,F) :- sn(T,R1), gv(R1,R2), sn(R2,F). * sn(T,F) :- nome(T,F). * sn(T,F) :- det(T,R), subs(R,F). * gv(R,F) :- v(T,F). * v([come|F],F). * v([canta|F],F). * subs([pera|F],F). * nome([ana|F],F). * det([pera|F],F).

25 Rastreamento do Parsing... * ? f([ana,come,a,pera],[]). 1) 0 CALL: f([ana,come,a,pera][]) ? 2) 1 CALL: sn([ana,come,a,pera],_72) ? 3) 2 CALL: nome([ana,come,a,pera],_72) ? 4) 3 CALL: C(ana,[ana,come,a,pera],_72) {dec10} ? 4) 3 EXIT: C(ana, [ana,come,a,pera],[come,a,pera]) 3) 2 EXIT: nome([ana,come,a,pera],[come,a,pera]) 2) 1 EXIT: sn([ana,come,a,pera],[come,a,pera]) 5) 1 CALL: gv([come,a,pera],[]) ? 6) 2 CALL: v([come,a,pera],[])? 7) 3 CALL: C(come,[come,a,pera],[]) {dec10} ? 7) 3 FAIL: C(come,[come,a,pera],[]) 8) 3 CALL: C(canta,[come,a,pera],[]) {dec10} ?....

26 Utilização de Restrições com Argumentos * GCD f(Num, Gen) --> sn(Num, Gen), gv(Num, Gen). * PROLOG f(T, F, Num, Gen) :- sn(T,R,Num,Gen), gv(R,F,Num,Gen). * ?- f(Num,Gen,[ana,come,as, peras], []). Num = sing, Gen = fem More(y/n)? N yes ?- f(Num,Gen,[ana,come,as, pera], []). no ?- f(Num,Gen,[as,peras,come, ana], []). no

27 Thats all folks!!