miniserveur@ifrance.com writes:

comment puis je afficher aussi le fait negatif ???

J'aimerais afficher dans l'exemple le mercredi est le bon jour
                                                 le jeudi est le
mauvais jour.


enfin avec la méthode de Pascal Bourguignon de modification de la base
de prolog comment je fais un "SI"

par exemple  :

on_dit(non(X)) :- retract(X),!.
on_dit(X) :- assert(X).

:- dynamic(il_y_a/2).

remplacement(mardi).

:- on_dit(il_y_a(foot,jeudi)).
:- on_dit(non(il_y_a(foot,jeudi))).
:- on_dit(il_y_a(foot,mercredi)).
:- on_dit(il_y_a(une_activité,mercredi)).

ici je voudrais dire que si il y une activité  le mercredi cela
implique qu'il n'y a pas de foot le mercredi et donc qu'on pourrais le
remplacer par mardi.

Si tu veux faire ça, il ne faut pas "oublier" le fait qu'on a parlé de
mercredi.  retract oublie l'assertion!

comment faire avec les :-

j'ai essayé ceci :

:- on_dit(il_y_a(une_activité,mercredi)) :- :-
on_dit(non(il_y_a(foot,mercredi))).

sa ne marche pas :( et ensuite comment remplacer avec ma variable de
remplacement ?

ici je voudrais dire que si il y une activité  le mercredi cela
implique qu'il n'y a pas de foot le mercredi et donc qu'on pourrais le
remplacer par mardi.

Il faut que tu modélise explicitement les élements de ta logique.



% Tu veux parler de jours, d'activités, et de relations entre les jours
% et les activités.  Alors, disons le. D'abord, les jours:

jour(lundi).
jour(mardi).
jour(mercredi).
jour(jeudi).
jour(vendredi).
jour(samedi).
jour(dimanche).


% Les jours de la semaine ont un ordre circulaire:

jour_suivant(lundi,mardi).
jour_suivant(mardi,mercredi).
jour_suivant(mercredi,jeudi).
jour_suivant(jeudi,vendredi).
jour_suivant(vendredi,samedi).
jour_suivant(samedi,dimanche).
jour_suivant(dimanche,lundi).

jour_precedent(A,B):-jour_suivant(B,A).


% Ensuite, tu parle des activités; pour le moment on n'a pas besoin de
% les "énumérer". On va simplement collecter les activités à partir de
% ce qu'on en dit:

activite(Activite) :- on_a_dit(il_y_a(Activite,_));
                      on_a_dit(non(il_y_a(Activite,_))).


% On a dit des choses sur la relation entre jour et activité:

on_a_dit(il_y_a(foot,jeudi)).
on_a_dit(non(il_y_a(foot,jeudi))).
on_a_dit(il_y_a(foot,mercredi)).
on_a_dit(il_y_a(une_activité,mercredi)).
on_a_dit(il_y_a(piscine,mardi)).
on_a_dit(il_y_a(foot,lundi)).


% Maintenant il faut que tu définisse ce que ça veut dire qu'il y a
% une activité un certain jour:

il_y_a(Activite,Jour) :- jour(Jour),
                         on_a_dit(il_y_a(Activite,Jour)),
                         not(on_a_dit(non(il_y_a(Activite,Jour)))).

% (le nom il_y_a  est mal choisi, car le résultat de la planification
% pourra  donner mettre une activité à un autre jour).


% Et finalement, il faut indiquer comment on planifie les activités.

% Tu semble dire qu'une activité est planifié le jour où on le dit,
% sauf s'il y a une autre activité le même jour, auquel cas, on essaye
% la veille.  D'accord, mais quelle activité choisi-t-on pour mettre
% la veille?  Pour le moment on a:
%
% 4 ?- il_y_a(A,J).
%
% A = foot
% J = lundi ;
%
% A = piscine
% J = mardi ;
%
% A = foot
% J = mercredi ;
%
% A = une_activité
% J = mercredi ;
%
% No
%
%
% Pourquoi doit on mettre foot le mardi et pas une_activité?
% Si tu donnais une règle, on pourrai la donner à prolog...


% On va faire un plan, qui sera une liste de il_y_a(A,J):

planifier(Activite,Jour,Ancien_plan,Nouveau_plan) :-
    %% Cas où l'activité est déjà planifiée:
    member(il_y_aura(Activite,_),Ancien_plan),!,Nouveau_plan = Ancien_plan;
    %% Voyons si le jour est déjà pris...
    member(il_y_aura(_,Jour),Ancien_plan),!,
    %% Cas où le jour est déjà pris, on essaye un autre jour:
    jour_precedent(Jour,Precedent),
    planifier(Activite,Precedent,Ancien_plan,Nouveau_plan);
    %% Sinon tout va bien, on peut planifier l'activité au jour indiqué:
    Nouveau_plan = [il_y_aura(Activite,Jour)|Ancien_plan].


% La première activité, on peut  la planifier le jour dit:

planifier(Activite,Jour,[],[il_y_aura(Activite,Jour)]).



% Maintenant, il faut collecter toutes les activités, et les planifier.

% On balaye la liste d'activité en planifiant la première et le reste:
planifier_des_activites([Activite|Reste],Ancien_plan,Nouveau_plan) :-
    il_y_a(Activite,Jour),
    planifier(Activite,Jour,Ancien_plan,Intermediaire),
    planifier_des_activites(Reste,Intermediaire,Nouveau_plan).

planifier_des_activites([],Plan,Plan).


planifier_toutes_les_activites(Plan) :-
    setof(Activite,activite(Activite),Toutes),
    planifier_des_activites(Toutes,[],Plan).


% Comme il peut y avoir des plans en double, on peut éliminer les
% doublons en les mettant dans un ensemble :

application :-
    setof(Plan,planifier_toutes_les_activites(Plan),Resultat),
    write(Resultat).




% 1 ?- ['foot.pl'].
% % foot.pl compiled 0.00 sec, 5,020 bytes
%
% Yes
% 2 ?- planifier_toutes_les_activites(P).
%
% P = [il_y_aura(une_activité, mercredi),
%      il_y_aura(piscine, mardi),
%      il_y_aura(foot, lundi)] ;
%
% P = [il_y_aura(une_activité, mercredi),
%      il_y_aura(piscine, mardi),
%      il_y_aura(foot, lundi)] ;
%
% P = [il_y_aura(une_activité, lundi),
%      il_y_aura(piscine, mardi),
%      il_y_aura(foot, mercredi)] ;
%
% P = [il_y_aura(une_activité, lundi),
%      il_y_aura(piscine, mardi),
%      il_y_aura(foot, mercredi)] ;
%
% No
% 3 ?- application.
% [[il_y_aura(une_activité, lundi),
%   il_y_aura(piscine, mardi),
%   il_y_aura(foot, mercredi)],
%  [il_y_aura(une_activité, mercredi),
%   il_y_aura(piscine, mardi),
%   il_y_aura(foot, lundi)]]
%
% Yes
% 4 ?-


Bien entendu, les règles implémentées sont celles que j'ai deviné.  Il
faut que tu définisse par exemple ce qu'on fait quand on a dit qu'il y
a foot le mercredi et le lundi.  Dans mon cas, je ne planifie le foot
qu'un seul jour (mais on a deux possibilités).  Peut être as tu une
autre règle.  Il suffit que tu explicite toutes tes règles et que tu
les traduise à prolog.

Il faut noter qu'on a donc plusieurs façons de modéliser ses données:

- sous forme de règles comme:

     jour(lundi).

  ce qui permet de les sélectionner avec une expression: jour(J),

- sous forme de règles dynamiques, ce qui permet de les ajouter et de
  les enlever avec assert et retract; l'avantage est qu'elles
  s'utilisent alors comme ci-dessus.

- sous forme de valeur liées à des variables, comme les listes Plan ou
  Toutes; on peut alors naviguer dans ces structures de données avec
  des règles effectuant une reconnaissance de motif (pattern matching)
  comme:
 
    planifier(Activite,Jour,Ancien_plan,Nouveau_plan) :- ... .
    planifier(Activite,Jour,[],[il_y_aura(Activite,Jour)]).

    planifier_des_activites([Activite|Reste],Ancien_plan,Nouveau_plan) :- ... .
    planifier_des_activites([],Plan,Plan).

  Ici on a des listes, mais on peut aussi travailler sur des
  structures de données plus complexes. Par exemple, un arbre:

    chercher(Cle,arbre(Etiquette,Gauche,Droit),Noeud) :-
         Cle = Etiquette,!,arbre(Etiquette,Gauche,Droit) = Noeud;
         Cle < Etiquette,!,chercher(Cle,Gauche,Noeud);
         chercher(Cle,Droit,Noeud).
    chercher(Cle,feuille(Etiquette),Noeud):-
         Cle = Etiquette,!,feuille(Etiquette) = Noeud.

        
    ?- chercher(1,arbre(4,arbre(2,feuille(1),feuille(3)),
                       arbre(6,feuille(5),feuille(7))),Noeud).

    Noeud = feuille(1) ;

    No
    ?- chercher(2,arbre(4,arbre(2,feuille(1),feuille(3)),
                          arbre(6,feuille(5),feuille(7))),Noeud).

    Noeud = arbre(2, feuille(1), feuille(3)) ;

    No

Je trouve le PROLOG assez déroutant au début mais fort interessant,
les possibilités ont l'air enorme !!!

--
__Pascal Bourguignon__                     http://www.informatimago.com/
Grace personified,
I leap into the window.
I meant to do that.