Réalisé par : Encadré par :

CHEBILA Chaimaâ Mme AKEF Fatiha

IDRISSI Safâa

OUALLA Aicha

RAHMOUNE Oumaima

Université Hassan 2 Casablanca

ENSET Mohammedia

Département Mathématiques et Informatique

GLSID2

RAPPORT DU

PROJET LISP

1

Sommaire

Introduction ......................................................................................................... 2

1. L'intelligence artificielle .............................................................................. 2

a. Définition .................................................................................................. 2

b. Les sous-domaines de l’IA .................................................................... 2

2. Le langage LISP ........................................................................................... 3

I. Problématique ............................................................................................... 4

1. Notion de prédicat ........................................................................................ 4

II. Le programme en LISP ............................................................................... 5

1. Fonction utilisées ......................................................................................... 5

a. PRINT ....................................................................................................... 5

b. SERQ ........................................................................................................ 5

c. APPEND ................................................................................................... 5

d. REVERSE ................................................................................................ 5

e. PUSH ........................................................................................................ 5

2. Code Source ................................................................................................. 6

III. RESULTATS ............................................................................................ 14

Conclusion .......................................................................................................... 18

2

Introduction

1. L'intelligence artificielle

a. Définition

Le but de l’Intelligence Artificielle (AI) est de concevoir des systèmes capables de reproduire

le comportement de l’humain dans ses activités de raisonnement.

L’IA se fixe comme but la modélisation de l’intelligence prise comme phénomène (de même

que la physique, la chimie ou la biologie qui ont pour but de modéliser d’autres phénomènes).

b. Les sous-domaines de l’IA

L’IA s’est divisée en de nombreuses sous-disciplines qui essaient chacune de traiter une partie

du problème. Voici les principales :

Représentation des connaissances et Raisonnement Automatique

Comme son nom le suggère, cette branche de l’IA traite le problème de lareprésentation des

connaissances (qui peuvent être incomplètes, incertaines, ou incohérentes) et de la mise en

œuvre du raisonnement.

Résolution de problèmes généraux L’objectif est de créer des algorithmes généraux pour

résoudre des problèmes concrets.

Traitement du langage naturel Ce sous-domaine vise `à la compréhension, la traduction, ou

la production du langage (écrit ou parlé).

Vision artificielle Le but de cette discipline est de permettre aux ordinateurs de comprendre

les images et la vidéo (par exemple, de reconnaitredes visages ou des chiffres).

Robotique Cette discipline vise à réaliser des agents physiques qui peuvent agir dans le

monde

3

Apprentissage automatique Dans cette branche de l’IA, on essaie de concevoir des

programmes qui peuvent s’auto-modifier en fonction de leur expérience.

Il existe bien entendu des liens très forts entre ces sous-domaines. Par exemple, les langages

développés dans la représentation des connaissances peuvent servir de base à des systèmes

experts. Ou encore, beaucoup d’algorithmes pour la reconnaissance des formes sont

développés en utilisant des méthodes d’apprentissage. Il y a aussi de forts liens entre l’IA et

d’autres domaines tels que la philosophie, la psychologie, les neurosciences, les sciences

cognitives, la linguistique, et l’économie.

2. Le langage LISP

LISP est un des plus anciens langages de programmation : ses premières implémentations ont

vu le jour à la fin des années 60, quelques années seulement après FORTRAN.

LISP a été conçu par John McCarthy pour le traitement d’expressions symboliques. Dès son

origine, il a été utilisé pour écrire des programmes de calcul symbolique différentiel et

intégral, de théorie des circuits électriques, de logique mathématique et de la programmation

de jeux.

LISP est également un des langages de programmation les plus répandus : il existe

pratiquement sur tous les ordinateurs, de toute taille et de toute origine.

LISP est un des langages de programmation les plus vivants. Le nombre étonnant de versions

différentes, telles que MACLISP, INTERLISP, Common-LISP, VLISP, LE_LISP, etc. En

témoigne. De plus, signalons l’apparition de machines utilisant une architecture spécialement

conçue pour l’implémentation de LISP, par exemple les ordinateurs de Symbolics ou de la

LISP-Machine Company, ou l’ordinateur Maia, actuellement en développement à la CGE.

En LISP, de même que dans les langages-machine, la représentation des données et la

représentation des programmes sont identiques : ainsi un programme LISP peut construire

d’autres programmes LISP ou se modifier au fur et à mesure de son exécution. Surtout, cette

identité de représentation permet d’écrire LISP en LISP même.

4

LISP est un langage interactif avec un environnement de programmation intégré. Ceci

implique non seulement que tous les programmes et toutes les données sont accessibles,

modifiables et analysables en LISP même, sans sortir du langage, mais également que la

construction des programmes s’accélère considérablement : le cycle ’édition de texte →

compilation → édition de liens → chargement → exécution’des langages compilés classiques

se réduit au cycle ’lecture → évaluation’.

I. Problématique Créer un système de démonstration automatique par réfutation en langage LISP qui permet de

satisfaire les 9 Clause de HORN qui expriment les hypothèses suivantes :

Marc est Blond.

Jean est Brun.

Pierre est le père de Jean.

Marc est le père de Pierre.

Jean est le père de Renne.

Une personne est le père d’une autre si celle-ci est le fils de la première.

Une personne est grand-père d’une autre personne P si P est père de quelqu’un

et si quelqu’un est père de P.

Marc est fils George.

On veut prouverque :

H : Il existe un grand-père qu’est Blond

Voici les 8 clauses de HORN qui expriment les hypothèses :

BLOND (marc)

BRUN (jean)

PERE (pierre, jean)

PERE (marc, pierre)

PERE-DE (jean, rene)

PERE-DE (x,y) U ¬FILS(y,x)

GRAND-PERE-DE (x,y) U ¬PERE(x,z) U ¬ PERE(z,y)

FILS-DE (marc,georges)

Voici la 9éme clause de HORN qui exprime la négation de la conjoncture :

¬H: ¬GRAND-PERE(x,y) U¬BLOND(x)

Notion de prédicat

Le calcul propositionnel reste très limité, et ne permet essentiellement que d’exprimer des

opérations booléennes sur des propositions. Si l’on veut pouvoir raisonner sur des assertions

mathématiques, il nous faut autoriser des constructions plus riches.

5

Définition :

Fonction qui met en œuvre un ou plusieurs arguments et dont le résultat est vrai ou faux.

Note :

Par exemple, dans « le chat est noir », « chat » est l'argument et « est noir » est le prédicat ou

bien seul « est » est le prédicat ; dans ce dernier cas, il sert à établir une relation entre les deux

arguments (« chat » et « noir »). Le prédicat peut également s'appliquer à plusieurs arguments

: « le chat, le chien et le mouton sont noirs ». Tout prédicat implique la création de deux

ensembles disjoints, l'ensemble des arguments pour lesquels le prédicat est vrai et celui pour

lesquels il est faux.

L'utilisation du prédicat est fréquente dans les langages de programmation en intelligence

artificielle; le calcul des prédicats est aussi couramment appliqué dans les systèmes experts.

II. Le programme en LISP On doit déclarer les cinq premiers Clause de HORN en LISP comment étant des listes dans

une base.

1. Fonction utilisées Parmi les fonctions utilisées dans notre code est comme suite :

a. PRINT

C’est la fonction LISP utilisée pour imprimer des valeurs, à nombre quelconque d’arguments.

A l’appel chacun des arguments sera évalué et imprimé sur le périphérique standard de sortie

(écran de visualisation…). La valeur du dernier argument sera ensuite ramenée en valeur, de

la même manière que toutes les autres fonctions ramènent une valeur utilisable dans la suite

du calcul.

b. SERQ

C’est une fonction d’affectation : une manière pour donner des valeurs à des variables. L’effet

de l’évaluation d’un appel de la fonction SETQ est de donner a‘ la variable premier argument

comme nouvelle valeur le résultat de l’évaluation de l’expression deuxième argument. C’est

donc une fonction de modification de la C-valeur des atomes (sans possibilité de restauration

automatique ultérieure). La valeur de l’évaluation d’un appel de la fonction SETQ est le

résultat de l’évaluation de l’expression.

c. APPEND

La fonction APPEND concaténer deux listes.

d. REVERSE

Cette fonction permet de décrire des activités répétitives.

e. PUSH

Il fait une nouvelle cellule cons rempli par un terme comme car et une valeur précedente

comme cdr …

6

2. Code Source Le code suivant représente la création des cinq listes (Clause) en LISP.

Voici les variable qu’on va utiliser dans ce programme

Stocker les cinq premiers Clause de HORN dans une base

Après on va ajouter les grands-pères

L’affichage de la base est la valeur qu’on va changer

Dans cette partie nous avons changé le nom de la variable x par le terme pierre :

7

Cette partie permet d’afficher le résultat après le changement de la variable x :

Changement du nom de la variable y par le terme george :

Affichage du résultat après le changement de la variable y :

Changement du nom de la variable z par le terme mark :

8

Affichage après le changement de la variable z :

Ajout d’an grand père pour un grand-fils U :

Changement du nom de la variable u par le terme jean :

Affichage après le changement de u :

9

Le bout du code ci-dessous nous permet d’ajouter un troisième grand-père et puis on

affiche la base avant qu’on change la variable.

Cette fonction nous permet de changer la variable w par Renne.

Affichage du résultat.

10

On ajoute les fils pour avoir la clause 8 et la clause 6 qui représentent les pères et puis

on affiche la base avant le changement de la variable.

Cette fonction permet de changer la variable B par le terme (Mark).

Affichage du changement de la variable B par le terme (Marc).

11

Le bout de code ci-dessous nous permet de changer le nom de la variable a par

George.

Affichage du changement après la variable a.

Ce code nous la permet d’ajouter le deuxième fils et on affiche la base par la suite

avant changement de la base.

12

Cette fonction nous permettons de changer la variable c par le terme Piere

Après le changement un affichage des résultats est nécessaire

L’extrait de programme si dessous nous permettons d’ajouter notre troisième fils et

par la suite afficher la base avant d’appliquer le changement avec le terme convenable.

13

Fonction relative au changement de la variable d par le terme Jean

Affichage des résultats après le changement de la variable d par le terme Jean

L’ajout de quatrième fils et l’affichage de la base avant le changement du variable e

par le terme convenable.

Fonction permettant de changer la variable e par le terme Renne

14

Affichage des résultats après le changement de la variable e par le terme Renne

Après la création des 8 clauses de l’hypothèse G : quatre fils et leurs pères, o passe à la

neuvième clause (Il existe un grand père blond) représentant la conjonction.

Pour arriver a se but il est nécessaire de tester est-ce qu’il y a quelqu’un blond et par la

suite tester si il est un grand père.

Le grand père qui est blond est Mark.

III. RESULTATS

Pour qu’on puisse tester le fonctionnement de notre programme nous devons se rediriger vers

le dossier cotonnant notre fichier .lisp .

Par la suite exécuter le programme par la commandeclisp projet.lisp

Affichage du résultat après le changement de la variable x :

15

Affichage du résultat après le changement de la variable y :

Affichage du résultat après le changement de la variable z :

Affichage du résultat après le changement de la variable u :

Résultat de l’ajout du troisième grand père et le changement de la variable w par

Renne.

16

Le résultat de l’ajout du premier fils et le changement de la variable B par Mark pour

satisfaire la clause numéro 6 et 8.

Le résultat de la modification de la variable A par George qui est le père de Mark et

que ce dernier est fils de George.

Ajout du deuxième fils et changement de la variable c par le terme piere

17

Ajout du troisième fils et changement de la variable d par le terme jean

Ajout du quatrième fils et changement de la variable e par le terme renne

Résultat de teste d’avoir un grand père blond

18

Conclusion

Le projet consistait à créer un système de démonstration automatique par réfutation en

langage LISP nous a permet d’améliorer nos connaissances en intelligence artificiel et de

passer de tous se qui est concept théorique en pratique.

Nous avons arrivé à créer l’arbre de la famille (3 grand-père, 4 père, 4 fils) a divers

génération : grand père George, Mark, Pierre, Jean et Renne.