corrige du partiel décembre 2005

Mathématiques pour l'informatique
examen partiel
12 décembre 2005
corrigé
I. Relations d'équivalence
1. Soit F l'ensemble des français et R une relation sur F définie par « x R y si et seulement si x et y
habitent dans le même département ». Montrer que R est une relation d'équivalence.
X habite dans le même département que lui-même, donc X R X pour tout X. donc R réflexive
si X habite dans le même département que Y, alors Y habite dans le même département que X.
Donc R symétrique.
Si X habite dans le même département D que Y et que Y habite dans le même département que Z,
alors comme Y habite dans D, Z habite dans D, comme X. donc X R Z. Donc R transitive
R réflexive, symétrique et transitive => R relation d'équivalence
1. Soient R 1 et R 2 deux relations d'équivalence définies sur un ensemble E. Soit R 3 une relation
définie sur E par « x R 3 y si et seulement si x R 1 y ou x R 2 y ». R 3 est-elle une relation
d'équivalence ? Justifier.
Soit x élément de E. alors x R1 x puisque R1 relation d'équivalence. Donc x R3 x par déf. De R3.
Donc R3 réflexive.
Soient x et y 2 éléments de E. alors si x R3 y soit x R1 y soit x R2 y. Comme R1 et R2 relations
d'équivalence, R1 et R2 symétriques, donc soit y R1 x soit y R2 x. Donc y R3 x. Donc R3
symétrique
Soient x, y et z deux éléments de E tels que x R3 y et y R3 z. on peut avoir
x R1 y et y R1 z => x R1 z => x R3 z
x R1 y et y R2 z => on ne peut rien déduire
x R2 y et y R1 z => on ne peut rien déduire
x R2 y et y R2 é => x R2 z => x R3 z
Donc R n'est pas transitive, donc R n'est pas une relation d'équivalence.
II. Relation d'ordre, diagrammes de Hasse et treillis
1. On note Dn l'ensemble des diviseurs de n strictement inférieurs à n. On définit la relation R
suivante sur ℕ\{0,1} : « n R m si et seulement si max(Dn) ≤ max(Dm) ».
a. R est-elle une relation d'équivalence ?
max(Dx) <= max(Dx) => x R x : R réflexive
Prenons x = 6 et y = 10. max(D6) = 3 ; max (D10) = 5. donc 6 R 10. Par contre, on n'a pas 10 R 6.
Donc R pas relation d'équivalence
b. R est-elle une relation d'ordre ?
Non car pas antisymétrique. Par exemple, x = 6 et y = 9. max(D6) = 3 ; max (D9) = 3. On a donc
x R y et y R x. Pourtant, on n'a pas x = y.
1/5
2. Soit la relation R définie sur E={1,2,3,4,5,6,7,8,9,10,11,12} représentée par le diagramme de
Hasse suivant :
1
2
3
4
10
5
6
7
9
8
12
11
a. (E,R) constitue-t-il un treillis ? Justifier
Non : inf(11,12) n'existe pas
b. On considère maintenant le sous-ensemble F = {2, 4, 5, 6, 7, 8, 9, 11} de E.
i. (F, R) est-il un treillis ?
2
4
5
6
7
9
8
11
Oui : inf et sup existent pour tout couple (x,y) de F et appartiennent à F.
ii. (F, R) est-il modulaire ?
Non car contient un sous-treillis de type K :
4
6
9
7
11
iii. (F, R) est-il distributif ?
Non car non modulaire
2/5
c. Donner la matrice représentant la relation R sur le sous-ensemble G = {3, 4, 6, 8, 10, 12} de E.
V
V
V
V
V
V
F
V
V
V
F
V
F
F
V
F
F
F
F
F
F
V
F
F
F
F
F
V
V
V
F
F
F
F
F
V
Programmation
On se propose d'écrire une classe Relation permettant de représenter une relation entre les n
premiers naturels. « n » doit donc être un paramètre du constructeur de la classe et il ne peut être
modifié. La relation sera représentée en interne dans la classe par une matrice booléenne carrée. La
classe Relation contiendra deux variables d'instance : taille, l'entier correspondant au
paramètre « n » passé au constructeur, et rel, la matrice booléenne.
1. Donner le code du constructeur à un paramètre entier de la classe Relation.
public Relation(int n) {
int i,j;
taille = n;
rel = new boolean [n][n];
for (i = 0 ; i < taille; i++) {
for (j = 0 ; j < taille; j++) {
rel[i][j] = false;
}
}
}
2. Ecrire une méthode void ajouterLien(int x, int y) permettant d'ajouter à une
relation un lien entre deux éléments x et y.
public void ajouterLien(int x, int y) {
rel[x][y] = true;
}
3. Ecrire une méthode boolean lienExiste(int x, int y) informant si x R y est vrai.
public boolean lienExiste(int x, int y) {
return rel[x][y];
}
4. Ecrire une méthode void ajouterReflexivite() qui augmente la relation R en
rajoutant la réflexivité.
public void ajouterReflexivite() {
int i;
for (i = 0 ; i < taille ; i++) {
rel[i][i] = true;
}
}
3/5
5. Ecrire une méthode void ajouterSymétrie() qui augmente la relation R en rajoutant la
symétrie.
public void ajouterSymétrie() {
int i,j;
for (i = 0 ; i < taille ; i++) {
for (j = 0 ; j < taille = j++) {
if (!rel[i][j] && rel[j][i]) {
rel[i][j] = true;
}
}
}
}
6. Ecrire une méthode void ajouterTransitivité() qui augmente la relation R en
rajoutant la transitivité.
public void ajouterTransitivite() {
boolean modifie = true;
int i, j, k;
while (modifie) {
modifie = false;
for (i = 0 ; i < taille; i++) {
for (j = 0 ; j < taille ; j++) {
if (rel[i][j]) {
for (k = 0 ; k < taille ; k++) {
if (rel[j][k] && !rel[i][k]) {
rel[i][k] = true;
modifier = true;
}
}
}
}
}
}
}
7. Ecrire une méthode Relation equiv() qui renvoie une nouvelle relation qui est la plus
petite relation d'équivalence incluant la relation à laquelle elle est appliquée.
public Relation equiv() {
Relation retour;
int i,j;
retour = new Relation (taille);
for (i = 0 ; i < taille; i++) {
for (j = 0 ; j < taille ; j++) {
retour.rel[i][j] = rel[i][j];
}
}
4/5
retour.ajouterReflexivite();
retour.ajouterSymetrie();
retour.ajouterTransitivite();
return retour;
}
8. Ecrire une méthode boolean estAntiSym() précisant si la relation est antisymétrique.
public boolean estAntiSym() {
boolean anti = true;
int i,j;
for (i = 0 ; i < taille ; i++) {
for (j = i+1 ; j < taille ; j++) {
if (rel[i][j] && rel[j][i] && i != j) {
anti = false;
}
}
}
return anti;
}
9. Ecrire une méthode Relation conjuguer(Relation r2) qui renvoie une nouvelle
relation r3 qui doit être telle que deux éléments sont en relation par R3 s'ils le sont via r2 ou via
la relation r1 à laquelle est appliquée la méthode conjuguer. Cette méthode devra également
fonctionner si r1 et r2 ne sont pas définis sur le même sous-ensemble de ℕ.
public Relation conjuguer (Relation r2) {
int t3;
Relation r3;
int i,j;
boolean b1, b2;
if (r2.taille > taille) {t3 = r2.taille;}
else {t3 = taille;}
r3 = new Relation(t3);
for (i = 0 ; i < t3 ; i++) {
for (j = 0 ; j < t3 ; j++) {
if (i < taille && j < taille) {b1 = rel[i][j];}
else {b1 = false;}
if (i < r2.taille && j < r2.taille) {b2 = rel[i][j];}
else {b2 = false;}
r3.rel[i][j] = b1 || b2;
}
}
return r3;
}
5/5