***une idée... ***
de ce qui était attendu
en septembre 2000
***uv16472***


1-preuves : (4 points)

   


2-Prolog et sémantique structurelle : (5 points)

 :- op(900 , xfx , '<->').
 :- op(900 , xfx , '<-').
 :- op(600 , xfy , v).
 :- op(300 , xfy , &).
 
 
 
complete2Prolog(P '<->' D , LS) :- impl2Prolog(P , D , LS).

impl2Prolog(P , C v  D1, LS) :- 
	impl2Prolog(P , C , LS1),
	impl2Prolog(P , D1, LS2),
	append(LS1 , LS2 , LS).
impl2Prolog(P , C , [P :- Q]) :- 
	conj2Prolog(C , Q).

conj2Prolog(P & true , P) :- !.
conj2Prolog(true & C , Q) :- conj2Prolog(C , Q).
conj2Prolog(P & C , (P,Q)) :- conj2Prolog(C , Q).
conj2Prolog(P , P) :- member(P , [p,q,r,s,t , false]).

  

3-DCG : (6 points)

/*
 * construction de l'AST selon la syntaxe abstraite ci dessus
 */
fcompl(equiv(P , D)) --> prop(P) , ['<->'] , disj(D).
disj(D) --> conj(D).
disj(ou(C , D)) --> conj(C) , [v] , disj(D).
conj(P) --> prop(P) .
conj(true) --> [true] .
conj(false) --> [false] .
conj(et(P , C)) --> prop(P) , [&] , conj(C).
conj(et(true , C)) --> [true] , [&] , conj(C).
conj(et(false , C)) --> [false] , [&] , conj(C).
prop(X) --> [X] , {member(X , [p,q,r,s,t])}.

%exemple de but :
?- fcompl(AST , [p,'<->',q,&,r,&,s, v, t,&,q, v, r] , []) , fcomplete2Prolog(AST , L).

AST = equiv(p, ou(et(q, et(r, s)), ou(et(t, q), r)))
L = [ (p:-q, r, s),  (p:-t, q),  (p:-r)] 

avec le programme précédent modifié...

fcomplete2Prolog(equiv(P , D) , L) :- implInv2Prolog(P , D , L).

implInv2Prolog(P , ou(C , D), L) :- 
	implInv2Prolog(P , C , L1),
	implInv2Prolog(P , D , L2),
	append(L1 , L2 , L).
implInv2Prolog(P , C , [P :- Q]) :- 
	conjonc2Prolog(C , Q).

conjonc2Prolog(et(P , true) , P) :- !.
conjonc2Prolog(et(true , C) , Q) :- conjonc2Prolog(C , Q).
conjonc2Prolog(et(P , C) , (P,Q)) :- conjonc2Prolog(C , Q).
conjonc2Prolog(P , P) :- member(P , [p,q,r,s,t , false]).
	



4-Java : (5 points)

//public 
class Fcompl{
    private Prop p;
    private Disj d;

    public Fcompl(Prop tete,Disj alter){
        p=tete;
        d=alter;
    }
    public String getTete(){
        return p.getNom();
    }
    public String toString(){
        return p.getNom() + " <-> " + d.toString();
    }
    public String toProlog(){ //règle sémantique structurelle rf
        return new Impl(p,d).toProlog();
    }
}



//public 
class Impl{
    private Prop p;
    private Disj d;
 
    public Impl(Prop tete,Disj alter){
        p=tete;
        d=alter;
    }
    public String getTete(){
        return p.getNom();
    }
    public String toString(){
        return p.getNom() + " <- " + d.toString();
    }
    public String toProlog(){
        if (d instanceof Ou){			// règle sémantique rd1
            return 
		new Impl( p , ((Ou)d).c).toProlog()
            + new Impl( p , ((Ou)d).d).toProlog();
            
        } 
        if (d instanceof Conj){ 		// règle sémantique rd2
             return p.getNom()+ " :- " + d.toProlog()+ ".\n";
        }
        return "erreur de syntaxe...";
    }
}

//public 
abstract class Disj{

    public abstract String toString();
    public abstract String toProlog();
}

//public 
class Ou extends Disj{

    public Conj c;
    public Disj d;


    public Ou(Conj mg , Disj md){
        c = mg;
        d = md;
    }
    
    public String toString(){
        return c.toString() + " v " + d.toString();
    }
    public String toProlog(){
        return "";
    }
}

//public 
abstract class Conj extends Disj {

}

//public 
class Prop extends Conj{

    private String nom;

    public Prop(String n){
        nom=n;
    }
    public String getNom(){
        return nom;
    }
    public String toString(){
        return nom;
    }
    public String toProlog(){		// règle sémantique rq2
        return nom;
    }
}
//public 
class Et extends Conj {


    private Prop p;
    private Conj c;

    public Et(Prop mg,Conj md){
        p = mg;
        c = md;
    }
    public String toString(){
        return p.toString() + " & " + c.toString();
    }
    public String toProlog(){		// règle sémantique rq1
        return p.toProlog() + " , " + c.toProlog();
    }
}
//public 
class False extends Conj{
    public String toString(){
        return "False";
    }

    public String toProlog(){
        return " false ";
    }
}

//public 
class True extends Conj{
    public String toString(){
        return "True";
    }
    public String toProlog(){
        return " true ";
    }
}

public class TestFCompl{
    public static void main(String [] args){

      Fcompl f=new Fcompl(
                              new Prop("p") , 
                              new Ou(
                                  new Et(
                                      new Prop("q") ,
                                      new Et(new Prop("r") , new Prop("s"))),
                                  new Ou(
                                      new Prop("t"),
                                      new Et(new Prop("q"),new True())
                                      )));

        System.out.println(f.toString());
        System.out.println(f.toProlog());
    }

}


>java TestFCompl
p <-> q & r & s v t & q v True
p :- q , r , s.
p :- t , q.
p :- true.

le graphe des classes :