INTRODUCTION À

L’INTELLIGENCE ARTIFICIELLE
Filière: Transformation Digitale Industrielle (TDI)
Professeur : Ayoub Esswidi
2024/2025
Logique formelle et inférence

■ Contenu
– Logique classique
– Logique des propositions (LP)
– Logique des prédicats du premier ordre (LPO)
– Système Expert à base de règles de production
– Le langage ProLog

Introduction à l'IA 2
 Prolog

■ Définition
■ Prolog est un langage de programmation déclaratif basé sur la logique formelle,
spécifiquement la logique du premier ordre.
■ Le nom Prolog vient de Programmation Logique.
■ Prolog sert à répondre à nos questions (requêtes), sans que l’on ait à lui dire
comment construire sa réponse.
■ En Prolog,
– on déclare des relations et des contraintes, (base de connaissances)
– laissant le moteur d'inférence pour déterminer la manière d'atteindre les
objectifs définis par ces déclarations.

Introduction à l'IA 3
 Base de connaissances

■ Définition
■ Une base de connaissance est composée de:
– Des Faits
– Des Règles

■ Par la suite:
– L’utilisateur pose des Questions/requêtes
– Le programme donne sa Réponse

Introduction à l'IA 4
 Base de connaissances

■ Prédicats
■ En Prolog, on ne parle pas de fonction, mais de « prédicat ». Un prédicat s'organise
en « clauses ».
■ Une clause ne retourne pas de valeur: soit elle s'exécute, soit elle échoue.
■ On affecte les valeurs des variables passées en paramètres par « unification ». Par
convention, les variables en entrée sont placées à gauche et les variables en sortie
sont placées à droite, mais l'unification peut se faire dans les deux sens.
■ Exemple de prédicat (1 clause) : habite(samir, beni_mellal).
■ Cette clause exprime la phrase « samir habite à beni mellal ».

Introduction à l'IA 5
 Base de connaissances

■ Les Faits: ■ Requêtes:

Introduction à l'IA 6
 Base de connaissances

■ Les Faits:
■ Les faits sont des données élémentaires que l’on considère vraies.
■ Un fait en Prolog se compose :
– d'un prédicat (une relation),
– d'arguments (les objets ou entités impliqués dans cette relation).
■ Syntaxe: predicat(arg1, arg2, ..., argN).
■ Types d'arguments
– Constantes : Utilisées pour représenter des valeurs fixes, comme des noms
(samir, mohamed).
– Variables : Les variables en Prolog commencent par une Majuscule et
représentent des éléments inconnus que Prolog peut chercher à unifier lors
d'une requête (par exemple, X, Y).
Introduction à l'IA 7
 Base de connaissances

■ Les Règles:

■ Requêtes:

Introduction à l'IA 8
 Base de connaissances

■ Les Règles:
■ Enoncent la dépendance d’un prédicat par rapport à d’autres prédicats.
■ Un programme Prolog contient presque toujours des règles, cependant ce n’est pas
une obligation.
■ les faits sont les hypothèses de travail, les règles sont des relations qui permettent
à partir de ces hypothèses d’établir de nouveaux faits par déduction en utilisant la
règle de Modus Ponens
– (si on a démontré F1 et F1⇒F2 alors on a démontré F2).

■ Syntaxe: P :- Q (P est vrai, à condition que Q soit vrai).

■ ( P:-Q ) équivaut à ( 𝑄 ⇒ 𝑃 )
■ Le « si » s’écrit « :- » en Prolog et correspond à l’implication ⟸

Introduction à l'IA 9
 Base de connaissances

■ Les Commentaires:
■ Commentaire sur plusieurs lignes
/* ligne1
Ligne2 de commentaires
encore
le texte entre slash étoile et étoile slash
*/
■ Commentaire sur une seule ligne
% l’interprète ignore le texte après le caractère pourcent

Introduction à l'IA 10
 Les termes

■ Les variables:
■ En Prolog, les variables sont représentées par un identificateur commençant par
« _ » ou une lettre majuscule (exemple: X, Var, Liste…).
■ Tant qu'on n'affecte pas de valeur à une variable, on parle de « variable libre ».
■ Une fois qu'une valeur est affectée, on parle de « variable liée »; appelle le principe
d'« unification ».
■ Les variables utilisées dans un fait ou une règle sont universellement quantifiées
par Prolog, avec le quantificateur ∀ (« quel que soit » ou « pour tout »).
■ Les variables utilisées dans une requête sont existentiellement quantifiées par
Prolog, avec le quantificateur ∃ (« existe-t-il »).

Introduction à l'IA 11
 Les termes

■ Les variables:
■ elles sont utilisées dans les règles afin de les généraliser :
■ Exemple:
grandpere(abdulah, kamal) :- pere(abdulah, mohamed), pere(mohamed, kamal).
Généralisé par :
– grandpere(X,Y) :- pere(X,Z), (pere(Z,Y) ; mere(Z,Y))
■ La variable muette « _ » Représente un objet dont on ne souhaite pas connaître la
valeur.
■ ?- invite(X,_). /* Prolog ne donnera que les valeurs pour X */

Introduction à l'IA 12
 Les termes

■ Les constantes:
■ Une constante commence toujours par une lettre minuscule (ex. : jean, belfort…).
■ Il est également possible de définir des chaînes de caractères en les entourant
de guillemets simples (ex. : ‘chaine de caracteres').
■ Constantes peuvent êtres entiers ou flottants ou chaînes constituent des atomes.

Introduction à l'IA 13
 Les termes

■ Les constantes:
■ Objets atomiques : atomes, nombres, variables et chaines de caractères
■ Chaines de caractères sont notées entre ‘’ , Il existe des prédicats prédéfinis
permettant la manipulation des chaines.
■ les listes : listes de valeurs entre [ ], exemple : [a, 2, c]
■ arbre Prolog: une structure de données plus complexe qui représente les données
sous forme des arbres.
■ les dictionnaires.
■ …

Introduction à l'IA 14
 Opérations arithmétiques

■ L'unification en Prolog
■ est l'un des concepts clés du langage. Elle est utilisée pour associer des variables
à des valeurs ou pour vérifier si deux termes (comme des constantes, des
variables, des structures) sont identiques ou compatibles.
■ Ex:
?- 5 = 5. ?- X = 5.
?- parent(X, Y) = parent(mohamed, ali).
true. X = 5.
X = mohamed,
?- 5 = 6. ?- X = Y.
Y = ali.
false. X = Y.

Introduction à l'IA 15
 Opérations arithmétiques

■ L'opérateur = sert exclusivement à l'unification.

■ Pour effectuer des opérations arithmétiques, il faut utiliser l'opérateur is, par
exemple X is Y+1.
■ Les variables à droite du is doivent avoir été unifiées.
■ L’évaluation d’une expression se fait par l’utilisation de l'opérateur is par exemple
dans X is 3 - 2.
■ Operations arithmétiques:
addition (+), soustraction (-),
multiplication (*), division entière (//),
division flottante (/), modulo (mod), puissance(^)

Introduction à l'IA 16
 Opérations arithmétiques

■ Fonctions mathématiques prédéfinies :

abs(X), log(X), sqrt(X), exp(X), sign(X), random(X),
sin(X), cos(X), tan(X), min(X,Y), max(X,Y), pi, etc.

■ Comparaison des expressions arithmétiques:

X =:= Y se traduit par X est égal à Y
X =\= Y se traduit par X est différent de Y
X < Y (X est inférieur ou égale Y), X =< Y , X>Y, X >= Y

Introduction à l'IA 17
 Opérations arithmétiques

■ Comparer deux termes :

▪ T1==T2 réussit si T1 est identique à T2
▪ T1\==T2 réussit si T1 n’est pas identique à T2
▪ T1=T2 réussit si T1 est unifiable avec T2
▪ T1\=T2 réussit si T1 n’est pas unifiable à T2
▪ Exemple:
?- f(X)==f(x).
false.
?- f(X)=f(x).
X = x.
?- f(X)\=f(x).
false.
?- f(X)\==f(x).
true.
Introduction à l'IA 18
 Entrées/Sorties

■ Pour afficher un message sur la console sont principalement basées sur les prédicats:
– write(‘texte ou valeur d’une variable’):
– writeln(‘message avec un retour à la ligne’):
– writeq(‘permet d'afficher les valeurs de variables avec des guillemets si elles contiennent
des espaces ou des caractères spéciaux’)
– print(): similaire à write
– format('la valeur de x est ~w et la valeur de y est ~w.~n', [x, y]).
– writef(): similaire avec format
– ….
– % Exemple
afficher :- X = 20, atom_concat('La valeur est : ', X, Message), write(Message), nl.
Introduction à l'IA 19
 Entrées/Sorties

■ Autres prédicats utiles:

– nl: saute ligne.
– tab(N): affiche N espaces.
– get(c): lit un caractère et l’unifie avec c.
– \t : remplace un terme.

■ Exemple:
affiche(Y) :- writef("ceci %t l'%t \n et j'affiche X=%t \n la valeur de Y = %t",[est,"exemple
numero",2,Y])

Introduction à l'IA 20
 Entrées/Sorties

■ prédicats permettent de lire des entrées du clavier

– read(Terme).
– read_line_to_string(user_input, Ligne).
– get_char(Caractere): pour lire un seul caractere.
– …
– % Exemple
lire_chaine :- write('Entrez une ligne : '),
read_line_to_string(user_input, Ligne),
write('Vous avez entré : '), write(Ligne), nl.

Introduction à l'IA 21
Entrées/Sorties

Introduction à l'IA 22