Théorème de Kirchhoff

On présente ici un résultat important de la théorie des graphes pourtant méconnus des étudiants. Le but de cet exercice est de démontrer le théorème de Kirchhoff, aussi appelé matrix tree theorem. Ce théorème donne une formule pour compter le nombre d’arbres couvrants d’un graphe.

Cet exercice nécessite une bon maîtrise mathématique de la notion de matrice et de déterminant.

Exercice

Soit G=(S,A) un graphe non orienté, avec n=|S| et m=|A|. On associe chaque sommet de S à un élément de l’ensemble {1,,n} et on pose A={a1,,am}. Enfin, on note τ(G) le nombre d’arbres couvrants de G.

Soit M matrice de Mn(R) et i,jn. On note Mi,j la valeur de M à la coordonnée i,j. On définit M[i] comme la matrice M où on a supprimé la i-ème ligne de M et M[i,j] comme la matrice M où on a supprimé la i-ème ligne et j-ème colonne de M.

On considère maintenant LMn(R) la matrice Laplacienne de G. Pour rappel, elle est définie ainsi. Pour i,jn :

Li,j={ degré de i si i=j1 si (i,j)A0 sinon 

On pose B la matrice de Mn,m(R) définie pour xm, et (i,j)=ax avec i<j, par Bi,x=1, Bj,x=1, et toutes les autres coordonnées sont égales à 0.

1. Prouver que L=BBT.

2. Prouver que pour tout i, L[i,i]=B[i]B[i]T.

Soit U un ensemble d’arêtes de A. On définit BU comme la matrice B dont on ne garde la colonne i que si aiU.

3. Montrer que tout ensemble de n1 arêtes de G forme un arbre couvrant si et seulement si il ne possède pas de cycles.

4. Soit UA de taille n1 tel que U ne forme pas un arbre couvrant. Pour tout in, calculer det(BU[i]).

5. Soit UA de taille n1 tel que U forme un arbre couvrant. Montrer que pour tout i, det(BU[i])=±1.

Donnons la formule de Binet-Cauchy. Soit C et D des matrices de Mn,m(R) et Mm,n(R). Pour tout ensemble U{1,,m} de n éléments, on note CU la sous-matrice de C dont on n’a gardé que les colonnes de U et DU la sous-matrice de D dont on n’a gardé que les lignes de U. On a alors l’égalité suivante :

det(CD)=U{1,,m}|U|=ndet(CU)det(DU)

6. En déduire que pour tout in on a det(L[i,i])=τ(G).


Correction

1. Pour tout i, on note Ai l’ensemble des arêtes de G contenant i. Soit M=BBT. On a :

Mi,i=xABi,xBTx,i=xAiBi,xBTx,i=xA1Mi,i=|Ai|

Ainsi, Mi,i est bien égal au degré de i et donc à $L_{i,i}.

Pour ij, s’il n’existe pas d’arête (i,j) on a pour toute arête aA, soit Bi,x=0, soit Bj,x=0. De ce fait, Mi,j=0=Li,j.

Enfin, si (i,j)A, on a Bi,(i,j)Bj,(i,j)=1 et pour tout a de A différent de (i,j), Bi,aBj,a=0. Donc Mi,j=1=Li,j.

En conclusion on a donc bien prouvé l’égalité suivante :

L=BBT


2. Si on considère que les lignes sont indicées par les sommets, on peut écrire : pour tout j,k différents de i on a L[i,i]j,k=Lj,k. De plus Lj,k=xABj,xBTx,k. Or pour tout x, Bj,x=B[i]j,x. On a donc bien :

L[i,i]=B[i]B[i]T


3. Tout d’abord, on rappelle qu’un arbre est un graphe connexe sans cycle. Il ne reste donc qu’à prouver qu’un sous ensemble d’arêtes sans cycle de taille n1 est connexe.

Commençons par préciser que tout arbre couvrant de G a exactement n1 arêtes. Pour s’en convaincre, il suffit d’enraciner l’arbre dans un de ses sommets. Chaque autre sommet possède alors exactement un parent et chaque arête définit une relation parent-enfant. Donc, il y a autant d’arêtes que de parents. De ce fait, il y a exactement n1 arêtes.

Ainsi, si un sous-ensemble sans cycle de n1 arêtes n’est pas connexe, on peut le prolonger en un arbre couvrant de taille strictement supérieure à n1, ce qui n’est pas possible.

De ce fait, tout ensemble de n1 arêtes de G forme un arbre couvrant si et seulement si il ne possède pas de cycles.


4. Si U ne forme pas d’arbre couvrant, par la question précédente, on en déduit que U possède un cycle. Soit C les arêtes traversées dans le cycle de taille minimale de U. On s’intéresse à la matrice BC[i]. Pour toute arête x=(i,j)C avec i<j, on pose λx qui vaut 1 si notre cycle va de i à j et 1 si on parcourt l’arête dans l’autre sens. On note que pour tout i on a :

xCλxBi,x=0

En effet, si i est un sommet apparaissant dans notre cycle, il apparaît dans exactement deux arêtes, pour assurer que C soit bien un cycle minimal. Soit x l’arête qui emmène à i et y celle qui en part. On a alors Bi,x=1 et Bi,y=1. Donc Bi,x+Bi,y=0. De plus, si i n’apparaît pas dans notre cycle, alors pour tout xC, Bi,x=0.

Ainsi, les colonnes de BC sont linéairement dépendantes, donc les colonnes de BC[i] et de BU[i] aussi. De ce fait, det(BU[i])=0.


5. Pour prouver ce résultat, on procède par récurrence sur n2, le nombre de sommets dans G. On pose donc P(n)= « Pour tout graphe G à n sommets et pour tout sous-ensemble U d’arêtes de G formant un arbre couvrant, on a pour tout sommet i, det(BU[i])=±1 ».

Pour le cas n=2, on note que BU est une matrice à une colonne et deux lignes ayant pour termes ±1. De ce fait, BU[i] est une matrice de dimension 1 de valeur ±1.

On suppose donc que P(n) est vrai pour n2. Montrons que P(n+1) est vrai. Soit G un graphe à n+1 sommets et U un ensemble de n arêtes de G formant un arbre couvrant. Soit i un sommet de G. On considère BU[i]. Soit aS une arête de U touchant i. Cette arête existe par définition d’arbre couvrant. Dans la colonne de BU[i] associé à a, on a donc un seul élément, ligne j, non nul et qui vaut ±1. On développe alors suivant cette colonne. On a alors :

det(BU[i])=±det(BU[i][j,a])

Maintenant, on considère le graphe G=(S,A) dans lequel on a contracté l’arête a. C’est à dire, on supprime le sommet j et pour toute arête (j,k), on ajoute l’arête (i,k). On note que le sous graphe (S,U) qui correspond à la contraction de l’arête a dans le graphe (S,U), est également un arbre couvrant. De ce fait, on peut appliquer notre hypothèse de récurrence sur G pour obtenir det(BU[i][j,a])=±1. On a donc montré :

det(BU[i])=±1


6. Soit i un sommet de G. On a prouvé que L[i,i]=B[i]B[i]T.

Appliquons la formule de Binet-Cauchy sur det(B[i]B[i]T). On note, T l’ensemble des sous-ensembles de taille n1 de A formant un arbre couvrant, et ˉT ceux de taille n1 qui contiennent un cycle. On obtient alors :

det(L[i,i])=det(B[i]B[i]T)=U{1,,m}|U|=n1det(BU[i])det(BU[i]T)=U{1,,m}|U|=n1det(BU[i])2=UTdet(BU[i])2+UˉTdet(BU[i])2det(L[i,i])=UT1+UˉT0

Cela nous permet donc de conclure :

det(L[i,i])=τ(G)


Codage de Gray

Exercice

Le but du codage de Gray est de représenter les entiers de telle sorte qu’un seul bit soit modifié à chaque incrémentation. Pour n un entier strictement positif, on définit la fonction Γn de {0,,2n1} dans {0,1}n, qui à un entier associe son codage de Gray sur n bits. On définit de même la fonction Bn de {0,,2n1} dans {0,1}n qui à un entier associe son écriture binaire sur n bits.

On définit récursivement Γn : Γ1(0)=0, Γ1(1)=1 et n2,k<2n :

Γn(k)={0Γn1(k) si k<2n1 1Γn1(2nk1) sinon 

1.a) Donner la table des valeurs de Γ3.

b) Prouver que pour tout entier n et pour tout entier k<2n1, les représentations Γn(k) et Γn(k+1) ne diffèrent que d’un seul bit.

On note cependant que cette définition ne nous permet pas de passer rapidement d’un entier en binaire à sa représentation en codage de Gray.

Soit n1 et k<2n. On considère la fonction Φn de {0,,2n1} dans {0,1}n définie par :

Φn(k)=Bn(k)Bn(k2)

où l’opérateur correspond au XOR bit à bit.

2. Prouver que la fonction Φn est bijective.

3. Soit 0r<2n. Prouver la relation :

Bn+1(2n+r)Bn+1(2nr1)=111n+1 fois

4. Déduire que pour tout n et tout k<2n, on a Γn(k)=Φn(k).

5. Donner une méthode directe pour passer de Γn(k) à Bn(k) et de Bn(k) à Γn(k).

Maintenant que nous pouvons aisément représenter les entiers par un codage de Gray, il nous reste à savoir comment incrémenter les entiers sans repasser par le codage binaire. Pour ce faire on présente la méthode suivante : soit k<2n1. On connaît Γn(k) et on cherche Γn(k+1). Si le nombre de 1 dans Γn(k) est pair, alors on inverse le bit le plus à droite. Sinon, on inverse le bit à gauche du bit à 1 le plus à droite.

6. Prouver la correction de cette méthode.


Correction

1. a) Calculons Γ3.

Γ1(0)=0Γ1(1)=1Γ2(0)=00Γ2(1)=01Γ2(2)=11Γ2(3)=10Γ3(0)=000Γ3(1)=001Γ3(2)=011Γ3(3)=010Γ3(4)=110Γ3(5)=111Γ3(6)=101Γ3(7)=100


b) Prouvons par récurrence sur n1 que pour tout k<2n1, Γn(k) et Γn(k+1) ne diffèrent que d’un seul bit.

La table des valeurs de Γ1 ci-dessus nous permet de vérifier le cas 1. On suppose maintenant la propriété vraie au rang n, montrons qu’elle le reste au rang n+1.

Soit k<2n+11.

Si k<2n1 : on a par hypothèse de récurrence que Γn(k) et Γn(k+1) ne diffèrent que d’un seul bit. Or :

Γn+1(k)=0Γn(k) et Γn+1(k+1)=0Γn(k+1)

Ainsi Γn+1(k) et Γn+1(k) ne diffèrent que d’un seul bit.

Si 2n1<k<2n+11 : on a Γn+1(k)=1Γn(2n+1k) et Γn+1(k+1)=1Γn(2n+1k1). Or, par hypothèse de récurrence, Γn(2n+1k) et Γn(2n+1k1) ne diffèrent que d’un seul bit, et donc Γn+1(k) et Γn+1(k+1) aussi.

Enfin, si k=2n+11 : on a Γn+1(k)=0Γn(k) et Γn+1(k+1)=1Γn(k). Ces deux mots ne diffèrent que sur le premier bit, donc Γn+1(k) et Γn+1(k+1) ne diffèrent que d’un unique bit.

Cela prouve la propriété au rang n+1 et achève la récurrence.


2. On note Bn(k)=b1b2bn. On a alors Bn(k2)=0b1b2bn1. De ce fait, en écrivant Φn(k)=a1a2an on a les relations suivantes :v

a1=b1a2=b1b2a3=b2b3=an=bn1bn

On considère la fonction Fn de {0,1}n dans {0,2n} définie par Fn(a1a2an)=uu a pour représentation binaire u1u2un avec

u1=a1u2=a1a2u3=a1a2a3=un=a1a2an

On note que Fn(Φn(k))=k. De ce fait Φn est bijective. 


3. Cette relation signifie simplement que tous les bits de la représentation en binaire de 2n+r et 2nr1 sont distincts. Pour le prouver, on procède par récurrence forte sur (n,r). Soit nN et r<2n. On note H(n,r)= « Tous les bits de la représentation en binaire sur n+1 bits de 2n+r et 2nr1 sont distincts ».

On vérifie à la main pour n=0 et n=1.

Pour tout n, on a :

Bn(2n)=1000n fois  et Bn(2n1)=0111n fois 

Ce qui prouve H(n,0).

Soit n1 et 2n1>r0. On suppose H(m,k) vrai pour tout m<n, k<2m et H(n,l) vrai pour 0lr. Prouvons H(n,r+1).

On note Bn+1(2n+r)=b1b2bn+1. Par hypothèse de récurrence on a :

Bn+1(2nr1)=¯b1¯b2¯bn+1

¯bi est le bit inverse de bi.

Si bn+1=0 : on a alors Bn+1(2n+r+1)=b1b2bn1 et Bn+1(2nr2)=¯b1¯b2¯bn0. Donc les représentations binaires de 2n+r+1 et 2nr2 sur n+1 bits sont bien distinctes bit à bit.

Si bn+1=1 : on a r impair.

Soit k=r+12. On a alors 2(2n1+k)=2n+r+1. On rappel que pour représenter le double d’un entier en binaire, il suffit d’ajouter un 0 à la fin, ce qui nous donne donc :

Bn+1(2n+r+1)=Bn(2n+r12+1)0

De même Bn+1(2nr2)=Bn(2n1k1)1.

Or, par hypothèse de récurrence, Bn(2n1k1)=¯Bn(2n1+k).

Il en résulte que Bn+1(2n+r+1)=¯Bn+1(2nr2). Cela prouve donc H(n,r+1) et achève notre récurrence.


4. Pour ce faire, il nous suffit de montrer que Γ1=Φ1, ce qui est immédiat ; puis que la récurrence suivante est satisfaite pour n2 :

Φn(k)={0Φn1(k) si k<2n1 1Φn1(2nk1) sinon 

Si k<2n1 on a bien Φn(k)=0Φn1(k).

Si k2n1 on pose r=k2n1. On a alors k=2n1+r et 2nk1=2n1r1. On écrit Bn(k)=b1b2bn. La question précédente nous donne Bn(2n1r1)=¯b1¯b2¯bn. On note de plus que b1=1. Ainsi :

Φn(k)=1(b1b2)(bn1bn)=1u

Avec u un mot binaire sur n1 bits.

Et de plus :

Φn(2n1r1)=0(¯b1¯b2)(¯bn1¯bn)=0(b1b2)(bn1bn)Φn(2n1r1)=0u

Donc Φn1(2n1r1)=u et Φ satisfait notre relation de récurrence.

On a donc bien prouvé que pour tout n et pour tout k<2n :

Γn(k)=Φn(k)


5. Pour passer de Γn(k) à Bn(k) on utilise la représentation binaire de la fonction F définie plus haut. Autrement dit, pour un mot a1a2an codage de Gray d’un nombre, la représentation en binaire sur n bits de ce nombre est b1b2bn avec :

b1=a1b2=a1a2b3=a1a2a3=bn=a1a2an

Pour passer d’un codage binaire b1b2bn à un codage de Gray a1a2an on pose :

a1=b1a2=b1b2a3=b2b3=an=bn1bn

On note que ces deux opérations peuvent être chacune réalisées avec n1 portes XOR.


6. On pose |u|1 le nombre de 1 dans le mot u.

Encore une fois, on va procéder par récurrence sur n, la taille de notre représentation. Montrons que pour les représentations de taille n notre méthode effectue bien l’incrémentation sur les entiers représentés avec le codage de Gray.

Le cas n=1 se vérifie aisément.

On suppose la propriété vraie au rang n, prouvons qu’elle le reste au rang n+1. Soit k un entier positif inférieur strictement à 2n+11. Si k est inférieur strictement à 2n1 notre méthode fonctionne par hypothèse de récurrence, et on peut calculer le codage de Gray de k+1. Sinon, si k=2n1, on a Γn(k)=100. Et par notre définition, Γn+1(k)=0100 et Γn+1(k+1)=1100. Or Γn+1(k) possède un nombre impair de 1. Notre méthode fonctionne donc bien.

Enfin, si k2n on considère 2n+1k1 qui est inférieur à 2n.

Comme on modifie un bit à chaque incrémentation, on change également la parité du nombre de 1 dans notre codage. Il en résulte que |Γn+1(k)|1 est de même parité que k. Il en résulte que |Γn+1(k)|1 est de même parité que |Γn+1(2n+1k2)|1.

Si k est pair, 2n+1k2 est également pair et on a montré précédemment que pour passer de Γn+1(2n+1k2) à Γn+1(2n+1k1) il suffisait de changer le bit le plus à droite. Donc, pour passer de Γn+1(k+1) à Γn+1(k), il faut changer le bit le plus à droite. Autrement dit, on doit bien changer le dernier bit pour passer de Γn+1(k) à Γn+1(k+1).

Le cas impair se résout de même.

On a donc prouver le cas n+1, ce qui achève la récurrence.

On a donc bien une méthode simple pour implémenter l’incrémentation avec le codage de Gray.