1)

   ?-  f(g(X,a),Y)=f(Y,g(b,Z)).
X = b,
Y = g(b,a),
Z = a ? ;   
no



   ?-  X==3.
no


?-  not(X==3).

true ?
yes


  ?-  X is 3.
X = 3 ? ;
no

   ?- not(X is 3).
no

  ?-  [X,a|R]=[3,Y,1].
R = [1],
X = 3,
Y = a ? ;
no


   ?-  !,false.
no


 ?-  !;false.
yes


  ?-  assert(p(a)),assert(p(b)),p(X).
X = a ? ;
X = b ? ;
no


  ?-  assert(p(a)),assert(p(b)),setof(X,p(X),R).
R = [a,b] ? ;
no


2)
le predicat a(n,m) reussit si et seul. si m est la somme des entiers
de 1 a n. Le premier parametre est d'entree.


le predicat b(n,m,r) reussit si et seul. si r est egal
a n a la puissance m. Le premier et le deuxieme parametres
sont d'entree.

le predicat c(n,l,r) reussit si et seul. si r est la liste obtenue
en retirant les n premiers elements de l. Le premier 
paarmetre et d'entree.

le predicat d(l,r) reussit si et seul. si r est la liste obtenue
en duplicant tous les elts de l.

le predicat a(a,b,l) reussit si et seul. si les termes
a et b sont consectifs dans la liste l.

3)

est_arbre(N):-integer(N).
est_arbre(arbre(N,G,D)):-integer(N),est_arbre(G),est_arbre(D).

somme(N,N):-integer(N).
somme(arbre(N,G,D),R):-somme(G,P),somme(D,Q),R is P + Q + N.

valide([],N):-integer(N).
valide([gauche|L],arbre(_,G,_)):-valide(L,G).
valide([droite|L],arbre(_,_,D)):-valide(L,D).

concat([],L,L).
concat([X|L],G,[X|R]):-concat(L,G,R).

prolonge(L,T,R):-concat(L,R,P),valide(P,T).


4)

a)
p(X):-q(Y),r(Z), s(T), X is Y*Z+T,!.

?- p(X).
X = 7 ? ;
no


b)
p(X):-q(Y),r(Z),s(T),!, X is Y*Z+T.

  ?- p(X).
X = 7 ? ;
no   

c)
p(X):-q(Y),r(Z),!,s(T), X is Y*Z+T.

?- p(X).
X = 7 ? ;
X = 8 ? ;
no

d)
p(X):-q(Y),!,r(Z),s(T), X is Y*Z+T.

   ?- p(X).
X = 7 ? ;
X = 8 ? ;
X = 19 ? ; 
X = 20 ? ;
no

e)
p(X):-!,q(Y),r(Z),s(T), X is Y*Z+T.

 ?- p(X).
X = 7 ? ;
X = 8 ? ;
X = 19 ? ;
X = 20 ? ;
X = 13 ? ;
X = 14 ? ;
X = 37 ? ;
X = 38 ? ;
no


4,2) Le plus petit arbre correspond aux cas a ou b ci dessus:

       p(X)
        |
        |
q(Y),r(Z),!,s(T), X is Y*Z+T,!.
        |
        | Y=2
        |
 r(Z),s(T), X is 2*Z+T,!.
        |
        | Z=3
        |
   s(T), X is 2*3+T,!.
        |
        | T=1
        |
   X is 2*3+1,!.
        |
        | X=7
        |
        !
        |
        |
        |
       [] (clause vide)

lors du retour a la coupure, p(X) echoue.

4,3) Dans une regle de la forme

p(X):-...,!,...,!,...

la premiere occurrence de coupure est inutile, car 
lors d'un retour en arriere, des qu'on revient a la deuxieme
occurrence de coupure, p(X) echoue.
Donc la regle est simulee par 

p(X):-......,!,...

5)

a)
?- p(X).
X = c ? ;
no

b)  
?- p(X).
X = b ? ;
no

c)  
?- p(X).
no

d)

 ?- p(X).
no

e)

 p(X).
X = a ? ;
no


6)

U_1={a}
H_1 est l'interprétation sur le domaine D={a} 
telle que [| p |]=D.
meme chose pour P2.

Un elt. de B_1 qui n'est pas dans C_1: p(0).
Un  elt. de C_1 qui n'est pas dans B_2: p(a).

7)

L'idee est la suivante:
l'automate est simule par un predicat a trois
parametres: le premier represente l'etat de
l'automate, le 2eme (qui est une liste) l'entree et le 3eme 
(aussi une liste) la pile.
La fonction de transition de l'automate 
delta(q,a,b)=(q',c1..cn) 
est representee par la regle:

p(q,[a|L],[b|R]):-p(q',L,[c1,..,cn|R])

l'acceptation (etat finale et pile vide):
p(qf,[],[]).