1/11 Mathématiques pour l`Informatique Jérôme Gensel 1

Université Pierre Mendès France
U.F.R. Sciences de l'Homme et de la Société
MASTER Information, Cognition, Création et Apprentissages
Spécialité Double Compétence : Informatique et Sciences Sociales
Mathématiques pour l’Informatique
Jérôme Gensel
1 Numération (d’après Benoît Lemaire)
Dans un ordinateur, on a besoin de représenter différents types d'information, des images, des sons,
des vidéos, des textes, mais elles se ramènent toutes à des nombres. Ainsi,
• les images sont découpées en pixels et la couleur de chaque pixel est codée par un nombre ;
• les sons sont échantillonnés, découpés tous les X millisecondes et l'information dans cette tranche
de temps est codée ;
• les vidéos sont des suites d'images, donc des suites de nombres ;
• les textes sont des suites de caractères, chacun représenté par un code.
Il faut donc représenter des nombres dans un ordinateur. Dans un ordinateur, l'unité minimale de
représentation de l'information est un fil sur lequel il y a du courant ou il n'y a pas de courant. On
peut le représenter par 0 ou 1. On appelle cela un bit (binary digit). Par 8, on appelle cela un octet
(byte). Ensuite, on les multiples (ko, Mo, Go, etc.). Comment on a beaucoup de mémoire dans un
ordinateur, on peut représenter beaucoup de 0 et de 1...
On pourrait représenter un nombre comme 28 par 28 fois le nombre 1, mais ce ne serait pas très
efficace. Avant de voir quelles solutions les informaticiens ont imaginé, on peut étudier rapidement
quelques systèmes de représentations des nombres.
Les Babyloniens avaient deux signes, le clou et le chevron.
1 : I, 2 : II, 3 : III, 4 : IIII, 5 : IIIII... 9 : IIIIIIIII
ensuite on utilise l'autre symbole qui représente le 10 :
10 : <, 11 : <I, 12 : <II, 13 : <III...
20 : <<, 21 : <<I, 22 : <<II...
46 : <<<<IIIIII
59 : <<<<<IIIIIIIII
ensuite, on réutilise le symbole I pour représenter 60, et on recommence :
60 : I
91 : I<<<I
137 : II<IIIIIII = 60*2 + 17
On est en base 60. Cette base a traversé les siècles et est encore utilisé chez nous : une heure = 60
minutes, un tour complet = 360°.
L'inconvénient est qu'on n'a pas de moyen de distinguer le 1 et le 60. En fait, il manque le zéro qui
permet d'indiquer les positions non occupées. D'ailleurs, le mot chiffre vient de l'arabe sifr (vide).
L'autre inconvénient est que cela produit un code dont la taille varie beaucoup au fur et à mesure
qu'on progresse dans les nombres.
Notre système est lui en base 10, avec un symbole différent pour chaque chiffre, mais le
mécanisme est le même : On a 9 symboles plus le zéro. Quand on a épuisé les symboles, on met le
premier symbole et le zéro et on recommence :
11, 12, 13... 19, 20, 21...
On pourrait faire la même chose dans d'autres bases. Par exemple, en base 4, on n'aurait que 3
symboles plus le zéro :
0,1,2,3,10,11,12,13,20,21,22,23,30,31,32,33,100,101,102,103,110,111,112...
Après 3, on a épuisé tous les chiffres, donc on marque un 1 qui représente 1 paquet de 3 unités et
un 0 pour représenter 0 unités.
Passer de la base b à la base 10
Le 5 de (345)7 représente 5 unités, c'est facile.
Le 4 de (345)7 représente 4 paquets de 7, donc 28 en base 10.
1/11
Le 3 de (345)7 représente 3 paquets de 7 paquets de 7, donc 3*7*7 et donc : (345)7 = 5*70 + 4*71 +
3*72 = 5 + 28 + 147 = 180
De manière générale :
i= p
(ap ap-1 ... a1 a0)b =
∑
aibi
i =0
Passer de la base 10 à la base b
On va décomposer le nombre en paquets de b.
180 : 7 = 25 et il reste 5. On sait donc que le chiffre de droite est un 5. Il faut maintenant écrire 25
en base 7. On recommence.
25 : 7 = 3 et il reste 4. On sait donc que le chiffre de droite est un 4. Il faut maintenant écrire 3 en
base 7. Comme il est plus petit que 7, il s'écrit 3.
Résultat : 180 = (345)7
De manière générale, le nombre en base b d'un nombre en base 10 est la suite inversée des restes
des divisions successives par b.
La base 2 est très utilisée en informatique.
Exercice :
a) Quel est le nombre décimal correspondant à 101, 1100, 1001011 ?
b) écrire les nombres suivants en base 2 : 7, 32, 41, 63, 100
Vous savez maintenant comment on représente une image, un texte, un fichier son, etc. dans un
ordinateur.
La base 2 permet aussi facilement de faire des additions. Il y a des circuits spéciaux qui permettent
cela dans un ordinateur.
00101011 (43)
+
00001001 (9)
_____________________________
=
00110100 (52)
La base 16 est aussi utilisée en informatique, parce qu'elle donne des nombres plus concis et parce
qu'elle permet de passer très facilement à la base 2 puisque 16 est une puissance de 2. Il nous faut
16 symboles ; aux 10 symboles de la base 10 on ajoute A, B, C, D, E, F. Comme précédemment, on
compte 1, 2, 3, ... 9, A, B, C, D, E, F, 10 (un paquet de 16 et 0 unités), 11, 12, ... 19, 1A, 1B...
Exercice :
a) Quel est le nombre décimal correspondant à 16, 3A, F2 ?
b) écrire les nombres suivants en base 16 : 24, 48, 255, 100
L'intérêt de la base 16 est qu'on peut décomposer chaque symbole directement dans les quatre
symboles de la base 2 correspondants. Par exemple : A84 s'écrit : 1010 1000 0100. De la même
manière, 10 0110 0111 1100 0001 0110 1111 s'écrit aussi 267C16F
(attention à regrouper à partir de la droite !).
Les nombres fractionnaires sont représentés en codant la partie entière, puis la partie décimale.
En base 10, 63,426 représente 6 dizaines d'unités, 3 unités, 4 dizièmes d'unités, 2 dizièmes de
dizièmes d'unités, etc. Donc 63,426 = 3*100 + 4*10-1 + 2*10-2 +6*10-3.
De la même manière, 13,5 s'écrit 1101,1 puisque le dernier 1 représente 1*2-1 = 0,5.
6,25 = 110,01 (1*22 + 1*21 + 0*20 + 0*2-1 + 1*2-2). Pour convertir, on cherche combien de fois
il y a ½ dans la partie décimale, combien de fois il y ½ de ½ dans ce qui reste, etc.
On va donc diviser la partie décimale par ½ et donc la multiplier par 2 !
0,25 * 2 = 0,5. on marque 0 et il reste 0,5
0,5 * 2 = 1,0. on marque 1 et il reste 0 !
Autre exemple : 11,421 en base 2 ?
0,421 * 2 = 0,842. on marque 0 et il reste 0,842
0,842 * 2 = 1,684. on marque 1 et il reste 0,684
0,684 * 2 = 1,368. on marque 1 et il reste 0,368
2/11
0,368 * 2 = 0,736. on marque 0 et il reste 0,736
0,736 * 2 = 1,472. on marque 1 et il reste 0,472
0,472 * 2 = 0,944. on marque 0 et il reste 0,944
etc.
donc 11,421 = (1011,011010...)2
C'est la même chose dans une autre base.
11,421 en base 8 ?
0,421 * 8 = 3,368. on marque 3 et il reste 0,368
0,368 * 8 = 2,944. on marque 2 et il reste 0,944
etc.
donc 11,421 = (13,32...)8
On remarque qu'on écrit trois fois plus de lignes en base 2 et que, pris 3 par trois, on retrouve les
mêmes nombres. C'est normal : 23=8 !
Certains nombres peuvent être infinis dans une base et finis dans une autre. Par exemple, 1/3 s'écrit
0,333333 en base 10 et 0,1 en base 3 !
Exercice :
a) Ecrire 1/3 en base 2.
b) Ecrire 123,456 en bases 2, 3, 4
c) Ecrire 147,2 en base 16
Pour représenter des nombres négatifs, on aurait pu décider de représenter un bit pour le signe,
mais il y a mieux puisque cela aurait obligé à perdre tout le temps un bit. De plus, on aurait eu deux
représentations pour le zéro. On aurait aussi des difficultés pour faire des opérations. Par exemple
si on représente -6 par 10000110 et 5 par 00000101, on aura une erreur si on fait une simple
addition puisque le résultat sera 100001011, ce qui fait -11 !!!
On utilise donc d'autres méthodes.
Première méthode : le complément vrai.
Il faut maintenant penser que, dans un ordinateur, on représente toujours les nombres dans un
espace limité (8 bits, 16 bits, 32 bits, etc.).
L'idée est la suivante. Supposons que nos nombres ont 4 chiffres :
B-A = (B-A)+(9999+1-10000) = B+(9999-A+1)-10000
9999-A+1 est le complément vrai de A. Pour soustraire A à B, on peut donc ajouter à B le
complément vrai de A et soustraire 10000 (ce qui ne change rien sur 4 chiffres). Le complément
vrai est le complément logique (9999-A) +1. Le complément logique est obtenu en prenant le
complément à 9 de chaque chiffre.
Exemple :
4324
2817
--------=
4324
+
7183
--------11507
La méthode du complément vrai pour représenter les négatifs a trois avantages :
– elle préserve l'addition ;
– le complément vrai du complément vrai redonne le nombre initial (1234 --> 8766 -->1234)
– elle n'empiète pas sur les positifs. En effet, on cherche à représenter autant de négatifs que de
positifs, sans ques les uns empiètent sur les autres !
Par exemple, avec 4 chiffres décimaux, on peut représenter 10.000 nombres (de 0 à 9999). On
pourra donc représenter 5000 positifs ou nul de 0 à 4999) et 5000 négatifs (de 5000
3/11
à 9999). 5000 représente -5000, 5001 représente -4999, 5003 représente -4998, ... 9998 représente 2 et 9999 représente -1.
Passons dans d'autres bases maintenant
Exercice :
a) Ecrire le complément logique de (1E56AB)16, (10233144)5, (10001101)2
b) Ecrire le complément vrai de (AF1629)16, (11011000)2, (21020)3
Supposons que l'on veuille représenter des entiers sur 8 bits. On peut représenter 256 valeurs (28).
Avec la représentation des négatifs en complément vrai, on peut donc représenter 127 positifs et
128 négatifs.
Représentation en excédent 2n
Dans une représentation à n bits, on représente la tranche de nombres de -2n-1 à 2n-1-1 en ajoutant
2n-1 à tous les nombres. De la sorte, on n'a plus que des positifs et on les représente comme
d'habitude. Par exemple, sur 8 bits, on ajoute 128 (10000000)2 à tous les nombres qu'on veut
représenter. Le nombre -50 s'écrit donc -50+128=78= (01001110)2. Le nombre 10 s'écrit
10+128=138=(10001010)2.
On remarque que, cette fois-ci, les négatifs ont un 0 sur le bit le plus à gauche et les positifs un 1
(puisqu'on leur a ajouté 2n-1 qui s'écrit (100...00)2).
Comparaisons entre les deux modes de représentation sur 4 bits :
Sur 4 bits, on peut représenter un nombre de -24-1 à 24-1-1, c'est-à-dire de -8 à +7.
Nombre en décimal
Représentation
complément Représentation excédent
vrai
-8
1000
0000
-7
1001
0001
-6
1010
0010
-5
1011
0011
-4
1100
0100
-3
1101
0101
-2
1110
0110
-1
1111
0111
0
0000
1000
1
0001
1001
2
0010
1010
3
0011
1011
4
0100
1100
5
0101
1101
6
0110
1110
7
0111
1111
Additions en complément à 2
Lorsque les négatifs sont représentés en complément à 2, on peut effectuer des additions
directement. Le bit le plus à gauche renseigne sur un débordement éventuel. Si on ajoute deux
positifs (resp. négatifs), on doit trouver un positif (resp. négatif) ; dans le cas contraire, on a un
débordement. L'addition d'un positif et d'un négatif ne provoque pas de débordement. Il peut aussi
y avoir un report qui sera oublié si l'addition donne un 1 sur le n+1 ième bit.
Exemple : 36+(-48) sur 8 bits.
36 = 00100100
-12 = 11010000
-----------------------11110100 (son complément vrai = 00001100 = 12)
Exemple : -64+(-80) sur 8 bits
-64 = 11000000
-80 = 10110000
4/11
------------------------101110000 (débordement : le 8e bit indique qu'on a un positif !).
Représentations en "virgule flottante" (d’après un cours de Michel Crucianu et Wikipédia)
Les nombres sont d'abord mis sous forme normale :
N= (±0,a-1a-2a-3…) avec , )*b±n avec a-1 ≠ 0 (normalisation).
a-1a-2a-3… s'appelle la mantisse et n l’exposant.
Par exemple :
(±56,3125)10 = (+111000,0101)2 = ±0,1110000101 × 26.
Des bits sont réservés pour représenter le signe, l'exposant et la mantisse.
En simple précision (IEEE 754), 32 bits sont employés pour la représentation.
Ainsi, le nombre 1,f × 2e-127 est représenté sous la forme suivante :
signe
e
f
31
30
23 22
0
Par exemple :
1 10000001 01000000000000000000000 représente :
signe = 1 → nombre négatif
e - 127 = (10000001)2 - 127 = 129 - 127 = 2
f = (0,01)2 = 0,25
donc le nombre représenté est -1,25 × 22 = -5.
+0,25 = (0,01)2 est représenté par :
nombre positif → signe = 0
(0,01)2 = 1,0 × 2-2 = 1,0 × 2125-127
donc +0,25 est représenté par 0 01111101 00000000000000000000000
Interprétation complète des codes possibles :
e
f
0
0
0
≠0
0 < e < emax
∀f
emax = 255
0
emax = 255
≠0
représente
±0
±0,f × 2-127
±1,f × 2e-127
±∞
NaN (Not a Number)
NaN est le résultat, par exemple, de − 1 ou de log(-1) ; le résultat d'une opération dont un des
arguments est NaN doit être NaN. ±∞ est le résultat, par exemple, des divisions par 0 ou de log(0) ;
±∞ peut intervenir dans des calculs, par exemple 1/±∞ = ±0.
Autre exemple
Codons le nombre décimal −118,625 en utilisant le mécanisme IEEE 754.
1. Premièrement, nous avons besoin du signe, de l'exposant et de la partie fractionnaire. C'est
un nombre négatif, le signe est donc "1".
2. Puis nous écrivons le nombre (sans le signe) en binaire. Nous obtenons 1110110,101.
3. Ensuite, nous décalons la virgule vers la gauche, en laissant seulement un 1 sur sa gauche :
1110110,101 = 1,110110101 × 26. C'est un nombre flottant normalisé. la mantisse est la
partie à droite de la virgule, remplie de 0 vers la droite pour obtenir 23 bits. Cela donne
11011010100000000000000.
4. L'exposant est égal à 6, et nous devons le convertir en binaire et le décaler. Pour le format
32-bit IEEE 754, le décalage est 127. Donc 6 + 127 = 133. En binaire, cela donne
10000101.
C 2 E D 4 0 0 0 (hexa)
On a donc −118,625 (dec) = 1100 0010 1110 1101 0100 0000 0000 0000 (float)
5/11
2 Logique propositionnelle (d’après Benoît Lemaire)
C'est la partie de la logique qui traite des propositions, c'est-à-dire des assertions qui ne peuvent
être que vraies ou fausses. On l'oppose à la logique des prédicats dans lequel on a des assertions
avec variables.
Les tables de vérités. Comme chaque proposition n'a que deux valeurs de vérité possibles (V/F,
1/0, T/⊥), un ensemble de n propositions ne donnera lieu qu'à 2n situations différentes. Par
exemple, avec les trois propositions « il pleut », « c'est un dimanche », « mon ordinateur est en
panne », on aura les 8 situations suivantes :
1. il pleut, c'est un dimanche et mon ordinateur est en panne
2. il pleut, c'est un dimanche et mon ordinateur n'est pas en panne
3. il pleut, ce n'est pas un dimanche et mon ordinateur est en panne
4. il pleut, ce n'est pas un dimanche et mon ordinateur n'est pas en panne
5. il ne pleut pas, c'est un dimanche et mon ordinateur est en panne
6. il ne pleut pas, c'est un dimanche et mon ordinateur n'est pas en panne
7. il ne pleut pas, ce n'est pas un dimanche et mon ordinateur est en panne
8. il ne pleut pas, ce n'est pas un dimanche et mon ordinateur n'est pas en panne
On peut chercher parmi ces situations celles qui vérifient une combinaison de propositions avec des
connecteurs particuliers. Par exemple, celles correspondant à « il pleut ou ce n'est pas un dimanche
» sont 1,2,3,4,7,8. On peut pour cela écrire une table de vérité qui donnera une valeur de vérité à
cette combinaison de propositions.
p (pleut)
d (dimanche)
en panne (e)
p ou (non d)
V
V
V
V
F
F
F
F
V
V
F
F
V
V
F
F
V
F
V
F
V
F
V
F
V
V
V
V
F
F
V
V
Connecteurs usuels : le et (conjonction), le ou (disjonction), le non (négation)
p
q
p∧q
p∨q
¬p
F
F
V
V
F
V
F
V
F
F
F
V
F
V
V
V
V
V
F
F
L'implication p ⇒ q est vraie, sauf si p est vrai et q faux, ce qui donne :
p
q
p⇒q
F
F
V
F
V
V
V
F
F
V
V
V
p ⇒ q est équivalent à ¬p ∨ q, ce qui n'est pas forcément intuitif!
p ⇒ q ≡ ¬q ⇒ ¬p (appelée contraposition)
Exercice. Ecrire les tables de vérité des opérateurs suivants et indiquer leur signification
p ⇔ q ≡ (p ⇒q) ∧ (q⇒p)
p⊕q ≡ (p∨q) ∧ ¬(p∧q)
p|q ≡ ¬p ∧ ¬q
L'équivalence est p ⇔ q :
p
q
p⇔q
6/11
F
F
F
V
V
F
V
V
Le ou exclusif (XOR) est :
p
q
F
F
F
V
V
F
V
V
V
F
F
V
p⊕q
F
V
V
F
Une tautologie est une proposition toujours vraie, quelle que soit les valeurs de vérité des
propositions qui la constituent. Par exemple : p ⇒ p, p ∨ ¬p
Une contradiction est le contraire, une proposition toujours fausse. Par exemple : p ∧ ¬p,
¬p ∧ ¬(p⇒q)
Lois de Morgan :
¬(p∧q) ≡ (¬p ∨ ¬q)
¬(p∨q) ≡ (¬p ∧ ¬q)
Ces deux lignes de code Java sont donc équivalentes :
while (!(i>N || t [i]==0))
while (i<N && t[i]!=0)
Exemple : Une année est bissextile si elle est multiple de 4, les années séculaires n'étant
pas bissextiles, sauf si elle sont multiples de 400. Ceci s'écrit donc en logique :
(mult4 ∧ ¬mult100) ∨ mult400
non bissextile s'écrit donc :
¬((mult4 ∧ ¬mult100) ∨ mult400) ≡ (¬mult4 ∨ mult100) ∧ ¬mult400
Distributivité
p∨ (q ∧ r) ≡ ( p∨ q) ∧ ( p∨ r)
p ∧ (q ∨ r) ≡ ( p ∧ q) ∨ ( p ∧ r)
Exercice. Vérifier que ces formules sont des tautologies
p ⇒ (q⇒p)
(¬p ⇒p)⇒p
((p⇒q)∧p)⇒q
(p⇒q)∨(r⇒p)
(p⇒q) ⇒ ((q⇒r) ⇒ (p⇒r))
Modus ponens
C'est une règle d'inférences qui permet de déduire de nouvelles propositions :
p
p⇒q
-------q
Ainsi, si l'on dispose de la règle (s'il pleut, les escargots sortent) et que l'on observe qu'il pleut, on
peut en déduire que les escargots sortent.
C'est une règle essentielle qui a donné naissance dans les années 70-80 aux systèmes experts,
dans lesquels la connaissance d'un domaine est représentée sous forme de règles. On y ajoute des
faits pour déduire de nouvelles informations.
Exemple :
SI temperature_élevée ET vomissements ET maux_de_tête ALORS méningite
7/11
SI méningite ET .... ALORS méningite_virale
SI méningite_virale ET ...
Les règles sont de la forme : a1 ∧ a2 ∧ ... ∧ an ⇒ r
Les faits sont de la forme : ai, aj ...
Deux stratégies : le chaînage avant et le chaînage arrière
En chaînage avant, on part des faits pour déclencher les règles dont toutes les prémisses sont vraies.
Cela augmente les faits vrais et on recommence jusqu'à obtenir le but ou ne plus rien pouvoir
déduire.
En chaînage arrière, on part du but et on cherche les règles qui concluent sur ce but.
Cela donne de nouveaux buts et on recommence sur chacun d'eux jusqu'à ce que tous les buts
fassent partie des faits ou que l'on ne puisse plus rien induire.
Exercice avec :
si B et D et E alors F
si D et G alors A
si C et F alors A
si C alors D
si D alors E
si A alors H
si B alors X
si X et C alors A
Faits : B, C
But : H?
On peut aussi avoir une solution mixte, dans lequel on fait du chaînage arrière sur les buts donnés
par l'utilisateur, on pose une question à l'utilisateur et on fait du chaînage avant sur ce nouveau fait.
Puis on repart en chaînage arrière, etc.
Puissance d'expression du langage
On peut exprimer plus de chose si on autorise des variables. On passe alors en logique des prédicats
(ordre 1). Exemple :
si ancetre(X,Y) et pere(Y,Z) alors ancetre(X,Z)
Le problème est que cela est beaucoup plus compliqué à gérer parce que plusieurs faits peuvent
correspondre à une même règle. Généralement, on se contente d'une représentation intermédiaire,
dite 0+ ou attribut/valeur.
si temperature > 39 et maux_de_tete et... alors maladie=méningite
En logique propositionnelle, on n'aurait pu faire mieux que
si temperature_forte et maux_de_tête et... alors méningite
Coefficients de vraisemblance
Dans certains cas, on a besoin d'ajouter des coefficients de certitude pour différencier des règles
sûres et des règles plus incertaines.
Exemple (tiré du système expert Mycin):
si site=sang et forme=batonnet et hote=a_risque alors organisme=domania
aeruginosa (0.6)
Question : quel est le coefficient de A ∧ B ? celui de A ∨ B ? celui de ¬A ? celui de A si deux
règles aboutissent sur ce fait ?
Une solution avec des coefficients entre -1 (sur que faux) et 1 (sur que vrai) :
coeff( A ∧ B) = min(A,B)
coeff( A ∨ B) = max(A,B)
coeff(¬A) = -coeff(A)
8/11
Si on a la règle : si C1 et C2 et... et Cn alors Conc (cr) on calcule le coefficient cp des prémisses à
partir des coeffcients de Ci. La règle est pertinente si ce coefficient est suffisamment élevé (cp >
seuil). On calcule le coefficient de la conclusion c = cp * cr. Il y a deux cas :
– Conc n'était pas dans l'ensemble des faits connus : on l'ajoute avec son coefficient c
– Conc était déjà dans l'ensemble des faits connus avec un coefficient c' : on remplace c' par c'' avec
les formules suivantes :
c''=c+c'-c.c' (si c et c' sont positifs)
c''=c+c'+c.c' (si c et c' sont négatifs)
c''=(c+c')/(1-min(|c|,|c'|) (sinon)
Exercice.
On dispose de l'ensemble des faits suivants :
A(.85)
B(.9)
C(.7)
D(.75)
Quel est le résultat de l'application de cette règle ?
si A et (B ou C) alors D (.8)
On suppose que le seuil de déclenchement des règles est à 0.8.
Gestion de la négation en condition de règles
1er cas : pas de traitement particulier, nonA est vrai si « nonA » est parmi les faits connus. On a
donc des faits positifs et des faits négatifs
2e cas (négation par absence) : si A n'est pas parmi les faits connus, nonA est vrai.
Problème, A peut devenir vrai plus tard et nonA devenir faux.
Exemple :
R1 : si nonA alors B
R2 : si C alors A
R3 : si E alors C
BF : {E}
On peut déduire B vrai et B faux selon l'ordre d'application des règles
3e cas: négation par échec : nonA est vrai si A ne peut être déduit. Dans l'exemple précédent, la
règle R1 se déclenche si A ne peut être déduit. Comme A peut l'être, R1 ne s'applique pas. C'est un
mécanisme plus complexe.
Le principe de la réfutation
On veut une méthode pour pouvoir démontrer automatiquement des théorèmes. Par exemple, à
partir des informations suivantes :
– les gens qui ont la rougeole doivent prendre le médicament X ;
– les gens qui ont de la fièvre et des points rouges au fond de la gorge ont la rougeole
– les gens qui ont une température supérieure à 38°C ont de la fièvre
– Jean a des points rouges au fond de la gorge et une température de 39°C.
On veut savoir s'il faut donner à Jean le médicament X, c'est-à-dire si « Jean doit prendre le
médicament X » est un conséquence logique des informations précédentes.
Avec le chaînage avant expliqué précédemment, qui utilise la règle du modus ponens, on arrive à la
conclusion que « Jean doit prendre le médicament X » est un théorème. En effet, les formules sont
les suivantes :
rougeole ⇒ prendreX (1)
fièvre ∧ pointsRouges ⇒ rougeole (2)
tempSup38 ⇒ fièvre (3)
pointsRouges (4)
tempSup38 (5)
A partir de (5) et (3), on déduit fièvre (6)
A partir de (4), (6) et (2), on déduit rougeole (7)
A partir de (7) et (1), on déduit prendreX (8)
Le problème est qu'on ne sait pas trop dans quelle direction aller dès lors que le nombre de
formules est important, on va donc plutôt utiliser la technique du chaînage arrière, en partant du but
9/11
à démontrer, ou plutôt de la négation du but. En effet, pour démontrer que C se déduit d'un
ensemble de formules S, il suffit de montrer que S ∪ {¬C} conduit à une contradiction.
Le principe de la résolution
Pour pouvoir passer d'un pas de démonstration au suivant, on va utiliser une règle d'inférence
particulière qui s'appelle la résolution. Cette règle dit que de X ∨ A et de ¬X ∨ B, on peut déduire
A ∨ B. En effet, X ∨ A ≡ ¬A ⇒ X. De même, ¬X ∨ B ≡ X ⇒ B. On déduit donc ¬A ⇒ B, qui est
équivalent à A ∨ B.
Cette règle s'écrit plus généralement :
X ∨ A1 ∨ A2 ... ∨ An
X ∨ B1 ∨ B2 ... ∨ Bp
----------------------------------------A1 ∨ A2 ... ∨ An ∨ B1 ∨ B2 ... ∨ Bp
Clauses
Pour pouvoir utiliser cette règle, il faut écrire les formules sous la forme de disjonctions de littéraux
(un littéral est quelque chose de minimal comme A ou ¬A). Heureusement, on peut toujours
transformer une formule en une (ou plusieurs) clause(s).
Pour cela, on :
1) remplace les ⇒
2) réduit la portée des négations, de sorte qu'une négation ne porte plus sur une formule entière,
mais sur un littéral.
3) applique la distributivité et la loi d'absorption (A ∧ (A ∨ B) ≡ A, A ∨ (A ∧ B) ≡ A).
Reprenons l'exemple précédent.
rougeole ⇒ prendreX (1)
fièvre ∧ pointsRouges ⇒ rougeole (2)
tempSup38 ⇒ fièvre (3)
pointsRouges (4)
tempSup38 (5)
L'écriture sous forme de clauses est la suivante :
¬ rougeole ∨ prendreX (1)
¬fièvre ∨ ¬pointsRouges ∨ rougeole (2)
¬ tempSup38 ∨ fièvre (3)
pointsRouges (4)
tempSup38 (5)
On ajoute la négation du but, mis sous forme de clause :
¬ prendreX (6)
De (1) et (6), on déduit la résolvante ¬ rougeole (7)
De (7) et (2), on déduit la résolvante ¬fièvre ∨ ¬pointsRouges (8)
De (8) et (4), on déduit la résolvante ¬fièvre (9)
De (9) et (3), on déduit la résolvante ¬ tempSup38 (10)
De (10) et (5), on déduit la clause vide (contradiction)
On a donc démontré que prendreX découle logiquement des formules initiales.
On peut aussi utiliser la réfutation par résolution pour démontrer des tautologies, en considérant
uniquement la négation de la formule (pas de formules initiales).
Exercice.
Mettre sous forme de clauses (p ⇒ (q ⇔ ¬ r)) ∧ (r ⇔ ¬ s)
Exercice.
Traduire en formule logiques les énoncés suivants :
Marc est de Pompéi.
10/11
Ceux de Pompéi sont des romains.
Les romains sont soit loyaux à César, soit détestent César.
Si quelqu'un veut assassiner César, c'est qu'il ne lui est pas loyal.
Marc veut assassiner César.
Montrer que cet énoncé découle logiquement des autres :
Marc déteste César.
Exercice.
Démontrer, en utilisant la réfutation par résolution que ces formules sont
des tautologies :
(p ⇒ q) ∨ (r ⇒ p )
(p ⇒ q) ⇒ ((q ⇒ r) ⇒ (p ⇒ r))
Vers la logique des prédicats
Parfois, la logique propositionnelle n'est pas suffisante pour représenter tout ce que l'on veut. On a
besoin d'exprimer des choses de la forme « tous les hommes sont mortels » ou « il existe un homme
mortel ». On introduit donc des variables et deux quantificateurs : ∀ et ∃ . De plus, on n'écrit pas
seulement des littéraux, mais des prédicats. Par exemple, on pourrait écrire le fameux syllogisme
grec : tous les hommes sont mortels, Socrate est un homme, donc Socrate est mortel.
Mise sous forme de clauses
C'est un peu plus compliqué... On peut utiliser le fait que :
¬∀x P(x) ≡ ∃x ¬P(x)
¬∃x P(x) ≡∀x ¬P(x)
De plus, pour enlever les quantificateurs existentiels (∃), on peut les remplacer par des constantes
s'ils ne sont sous la portée d'aucun quantificateur universel, ou par des fonctions des variables de
ces quantificateurs universels sinon.
Par exemple :
∀x (∃y P(x,y)) ≡ ∀x P(x,f(x)))
Exemple de résolution avec variables
Quiconque sait lire est instruit : ∀x (lire(x) ⇒ instruit(x))
Les dauphins ne sont pas instruits : ∀x (dauphin(x) ⇒ ¬instruit(x))
Certains dauphins sont intelligents : ∃x (dauphin(x) ∧ intelligent(x))
On veut montrer que certains êtres intelligents ne savent pas lire :
∃x (intelligent(x) ∧¬lire(x))
On transforme les trois premières et la négation de la dernière en clauses et on essaie d'aboutir à un
contradiction.
Les clauses de Horn
Pour rendre la démonstration automatique de théorèmes encore plus efficace, on peut décider de
n'utiliser que des clauses de Horn. Ce sont des clauses qui ont au plus un littéral positif. Elles
s'écrivent donc :
a0 ∨ ¬a1 ∨ ¬a2 ∨ ... ∨ ¬an
qui correspond en fait à
a1 ∧ a2 ∧ ... ∧ an ⇒ a0
on retrouve les règles des systèmes experts.
Exemple d'applications : le langage Prolog
Prolog est un langage de programmation qui permet d'écrire des clauses de Horn en logique des
prédicats.
11/11