Discussion :

[CosmoKnacki]

Bonjour, ça fait un bail que j'ai laché l'affaire avec ce genre de mathématiques, donc désolé d'avance si ce que je demande relève de la question de cours.

Soit A, l'ensemble des matrices carrées 9x9 à coefficients dans {0;1} tel que pour chaque colonne et pour chaque ligne la somme des coefficients est égale à 5.

Soit M la matrice de A suivante:


Est-il possible d'engendrer A (i.e. d'obtenir n'importe quel élément de A) à partir de cette seule matrice M à laquelle on appliquerait 2 matrices de permutations P et P' (l'une pour permuter les lignes, l'autre pour les colonnes)?

Autrement dit, peut-on écrire:


Si non, quel type de transformation(s) pourrait permettre d'engendrer A à partir de cet unique élément.

[dourouc05]

Tu pourras générer toutes les matrices avec exactement autant de zéros et de uns avec uniquement des permutations (une matrice suffit). Si tu te limites à un nombre de uns par ligne et par colonne, je pense que tu ne dois pas générer plus que des permutations (pour faire toutes les matrices 9x9, vu que tes colonnes forment une base orthogonale, tu peux effectuer des combinaisons linéaires jusqu'à générer n'importe quelle matrice 9x9, en utilisant des matrices de changement de base plutôt que de permutation). Plus clairement : je dirais qu'il suffit de permutations, mais je n'apporte pas de preuve formelle.

[tbc92]

Je ne suis pas d'accord.

A partir de la matrice de départ, je ne pense pas qu'on puisse arriver à celle-ci :
1 1 1 1 1 0 0 0 0
1 1 1 1 1 0 0 0 0
1 1 1 1 1 0 0 0 0
1 1 1 1 1 0 0 0 0
1 0 0 0 0 1 1 1 1
0 1 0 0 0 1 1 1 1
0 0 1 0 0 1 1 1 1
0 0 0 1 0 1 1 1 1
0 0 0 0 1 1 1 1 1
Disons le autrement.
A partir de cette matrice, on peut alterner lignes et colonnes autant qu'on veut, on aura toujours 5 colonnes et 4 lignes quelque part, avec des 1 aux 20 cases définies par ces 5 colonnes et 4 lignes.
Et dans la matrice proposée, on n'a pas cette configuration.

[anapurna]

Salut

une simple permutation devrais suffir du fait que le nombre de 0 et de 1 sont invariant
ce n'est que leur position qui differe de ligne en ligne
le premier 1 a la position x devient 0 et la valeur a la position (x+5) modulo 9 de vient 1
a chaque ligne x s'increment de 1

[tbc92]

Je reste très sceptique.

Dans ces questions, on parle souvent d'invariant.
Prenons tous les quadruplets de lignes, tous les quadruplets de colonnes, et pour chaque configuration, on calcule la somme des 16 valeurs obtenues.
Et on retient le maximum pour cette somme.
Et ce nombre, on va dire que c'est la signature de la grille.
Pour la grille que je propose, la signature est de 16. (en choisissant par exemple les 4 premières lignes et les 4 premières colonnes)
Pour la grille initiale, la signature est de 14 (lignes 1 à 4, colonnes 3 à 6)
Partant d'une grille quelconque, on peut faire des permutations de lignes et/ou de colonnes, cette signature ne change pas. La signature est un invariant.
Donc ces 2 grilles sont dans 2 familles différentes. Il n'y a aucune succession de permutations qui permet de passer d'une grille de signature 14 à une grille de signature 16.

Ici, la signature que je propose est loin d'être suffisante. On peut certainement avoir 2 grilles qui ont la même signature, et qui ne sont pas 'joignables' par une suite de permutations.

[CosmoKnacki]

Bien vu tbc92! En effet, la multiplication par une matrice inversible (comme le sont les matrices de permutation) conserve le rang de la matrice de départ. Comme celle que je propose est de rang 9 (9 vecteurs indépendants qui forment une base comme l'a souligné dourouc05), on ne peut donc pas produire par des permutations une matrice de rang 6 (à vue de nez) comme celle proposée par tbc92 à partir de celle-ci. Donc mon hypothèse de départ est fausse.

Peut-être que pour engendrer A uniquement avec des permutations, il faudrait disposer d'une matrice (respectant les contraintes) par rang possible. Reste à les trouver.

Merci à tous pour vos messages.

[anapurna]

salut

je ne comprend pas pourquoi veut tu absolument trouvé ta matrice
il dit bien qu'a partir de la matrice de base et de permutation
quelque soit les permutation celle-ci se verifira ..

On peut ajouter qu'il existe une symetrie dans cette matrice
donc quelque soit la permutation de ligne ou de colonne le resultat seras toujours le meme 5
la tu nous parle de changer les valeurs de la matrice originel
en creant des "doublon de colonne et de ligne" forcement cela ne fonctionne plus
ce n'est plus des permutation de ligne ou de colonne mais des permutation de cellule que tu dois generer pour y parvenir ...
Remarque que les suite de cellules de 1 ou de zero se trouve non continue avec ta matrice

[CosmoKnacki]

A partir de cette matrice, on peut alterner lignes et colonnes autant qu'on veut, on aura toujours 5 colonnes et 4 lignes quelque part...

Non pas forcément, regarde:

Code txt :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
0 0 0 0 0 0 1 0 0     1 1 1 1 1 0 0 0 0     0 0 0 0 0 0 1 0 0     0 0 1 0 0 1 1 1 1     0 0 0 0 0 0 1 0 0     1 0 1 1 0 1 0 0 1
0 0 0 0 1 0 0 0 0     1 1 1 1 1 0 0 0 0     1 0 0 0 0 0 0 0 0     1 0 0 0 0 1 1 1 1     1 0 0 0 0 0 0 0 0     1 1 1 0 0 1 0 0 1
0 0 0 1 0 0 0 0 0     1 1 1 1 1 0 0 0 0     0 0 0 0 0 0 0 0 1     1 1 1 1 1 0 0 0 0     0 0 0 0 0 0 0 0 1     0 1 0 1 1 0 1 1 0
1 0 0 0 0 0 0 0 0     1 1 1 1 1 0 0 0 0     0 0 1 0 0 0 0 0 0     1 1 1 1 1 0 0 0 0     0 0 1 0 0 0 0 0 0     0 1 0 1 1 0 1 1 0
0 0 0 0 0 0 0 1 0  x  1 0 0 0 0 1 1 1 1  x  0 0 0 1 0 0 0 0 0  =  0 0 0 1 0 1 1 1 1  x  0 0 0 1 0 0 0 0 0  =  1 0 1 0 1 1 0 0 1
0 0 0 0 0 0 0 0 1     0 1 0 0 0 1 1 1 1     0 0 0 0 0 1 0 0 0     0 0 0 0 1 1 1 1 1     0 0 0 0 0 1 0 0 0     1 0 1 0 0 1 1 0 1
0 1 0 0 0 0 0 0 0     0 0 1 0 0 1 1 1 1     0 0 0 0 1 0 0 0 0     1 1 1 1 1 0 0 0 0     0 0 0 0 1 0 0 0 0     0 1 0 1 1 0 1 1 0
0 0 0 0 0 1 0 0 0     0 0 0 1 0 1 1 1 1     0 1 0 0 0 0 0 0 0     0 1 0 0 0 1 1 1 1     0 1 0 0 0 0 0 0 0     1 0 1 0 0 1 0 1 1
0 0 1 0 0 0 0 0 0     0 0 0 0 1 1 1 1 1     0 0 0 0 0 0 0 1 0     1 1 1 1 1 0 0 0 0     0 0 0 0 0 0 0 1 0     0 1 0 1 1 0 1 1 0

On obtient quelque chose de relativement bien brouillé (sans les successions de uns de la matrice de départ), par contre il y a toujours 4 fois le même vecteur (colonnes 1,3,6,9) comme dans la matrice de départ (colonnes 6,7,8,9).

[tbc92]

Oui, c'est ce que je disais. Le 'paquet' avec 16 1 va toujours exister, quoi qu'on fasse.

[anapurna]

Non pas forcément, regarde:

Code txt :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
0 0 0 0 0 0 1 0 0     1 1 1 1 1 0 0 0 0     0 0 0 0 0 0 1 0 0     0 0 1 0 0 1 1 1 1     0 0 0 0 0 0 1 0 0     1 0 1 1 0 1 0 0 1
0 0 0 0 1 0 0 0 0     1 1 1 1 1 0 0 0 0     1 0 0 0 0 0 0 0 0     1 0 0 0 0 1 1 1 1     1 0 0 0 0 0 0 0 0     1 1 1 0 0 1 0 0 1
0 0 0 1 0 0 0 0 0     1 1 1 1 1 0 0 0 0     0 0 0 0 0 0 0 0 1     1 1 1 1 1 0 0 0 0     0 0 0 0 0 0 0 0 1     0 1 0 1 1 0 1 1 0
1 0 0 0 0 0 0 0 0     1 1 1 1 1 0 0 0 0     0 0 1 0 0 0 0 0 0     1 1 1 1 1 0 0 0 0     0 0 1 0 0 0 0 0 0     0 1 0 1 1 0 1 1 0
0 0 0 0 0 0 0 1 0  x  1 0 0 0 0 1 1 1 1  x  0 0 0 1 0 0 0 0 0  =  0 0 0 1 0 1 1 1 1  x  0 0 0 1 0 0 0 0 0  =  1 0 1 0 1 1 0 0 1
0 0 0 0 0 0 0 0 1     0 1 0 0 0 1 1 1 1     0 0 0 0 0 1 0 0 0     0 0 0 0 1 1 1 1 1     0 0 0 0 0 1 0 0 0     1 0 1 0 0 1 1 0 1
0 1 0 0 0 0 0 0 0     0 0 1 0 0 1 1 1 1     0 0 0 0 1 0 0 0 0     1 1 1 1 1 0 0 0 0     0 0 0 0 1 0 0 0 0     0 1 0 1 1 0 1 1 0
0 0 0 0 0 1 0 0 0     0 0 0 1 0 1 1 1 1     0 1 0 0 0 0 0 0 0     0 1 0 0 0 1 1 1 1     0 1 0 0 0 0 0 0 0     1 0 1 0 0 1 0 1 1
0 0 1 0 0 0 0 0 0     0 0 0 0 1 1 1 1 1     0 0 0 0 0 0 0 1 0     1 1 1 1 1 0 0 0 0     0 0 0 0 0 0 0 1 0     0 1 0 1 1 0 1 1 0

On obtient quelque chose de relativement bien brouillé (sans les successions de uns de la matrice de départ), par contre il y a toujours 4 fois le même vecteur (colonnes 1,3,6,9) comme dans la matrice de départ (colonnes 6,7,8,9).

salut tu as aussi 4 fois les memes Vecteurs (
lignes 2,3,7,8) comme dans la matrice de départ (Ligne 1,2,3,4)

en fait je ne sais pas pourquoi mais cela me fait penser au RuBik's Cube ... bien sur ce n'est qu'une face et c'est un carre de neuf par neuf
c'est peut etre juste la matrice et les permutation qui me donne l'impression de retrouver les meme principe

[tbc92]

Oui, on est dans la théorie des groupes si je ne m'abuse, on est exactement dans la même problématique que le Rubik's Cube.
A partir d'une position donnée, quelles sont toutes les positions qu'on peut atteindre (=Quelles sont toutes les positions qui sont dans la même classe d'équivalence, quelles sont toutes les positions qui ont la même signature)

Je parlais d'invariant ; si on recherche 'invariant Rubik's Cube', on trouve des documents très étoffés sur ce sujet.

[mathieu]

j'aime beaucoup les mathématiques, les formules et les algorithmes qui permettent d'aller vite. mais là je sèche un peu donc j'ai fait un code barbare qui calcule toutes les combinaisons
et comme ce code n'est pas optimisé, il est long. j'ai fini les calculs pour la taille 5 et les calculs pour la taille 7 devraient finir dimanche vers 10 h 00.

donc pour la taille 5, je suis parti de cette matrice :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
		[1 1 1 0 0]
		[0 1 1 1 0]
		[0 0 1 1 1]
		[1 0 0 1 1]
		[1 1 0 0 1]

et j'ai cherché à obtenir :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
		[1 1 1 0 0]
		[1 1 1 0 0]
		[1 0 0 1 1]
		[0 1 0 1 1]
		[0 0 1 1 1]

il y a 5! = 120 matrices de permutations et donc mon code a testé 14 400 combinaisons et aucune n'arrive à ce but. et toutes les combinaisons donnent une matrice différente comme résultat.

en revanche en taille 3, il y a 6 matrices de permutations, 36 combinaisons et 6 de ces combinaisons donnent la matrice recherchée.
donc ces tests ne me permettent pas encore de prévoir ce qu'il se passera en taille 9.

une idée à creuser serait de calculer le nombre théorique de matrices différentes dans l'ensemble A.
on sait qu'il y a 9! matrices de permutations et donc (9!)² combinaisons. et donc si on trouve qu'il y a un plus grand nombre de matrices dans A, ça prouvera qu'on ne peut pas toutes les générer avec les permutations.

en fait je ne sais pas pourquoi mais cela me fait penser au RuBik's Cube ... bien sur ce n'est qu'une face et c'est un carre de neuf par neuf
c'est peut etre juste la matrice et les permutation qui me donne l'impression de retrouver les meme principe

avant de faire mon code d'attaque par force brute, j'avais fait une interface ou je définissais les 2 matrices de permutations en cliquant sur des boutons et j'ai aussi eu cette sensation

[tbc92]

Faisons beaucoup plus simple, comme déjà dit.
Partons de ta 2ème matrice, elle est plus visuelle. Elle a en bas à droite 2 colonnes et 3 lignes avec des 1 aux 6 emplacements.
Tu effectues une série aléatoire de 5 ou 10 permutations. Et tu analyse la matrice résultat. Y a-t-il dans la matrice résultat 2 colonnes et 3 lignes ..oui.
Et tu répètes l'expérience 100 fois, ou 1000 fois, toujours tu trouveras ces 2 colonnes x 3 lignes qui donnent 6 fois le nombre 1.

Y-a-t-il dans la matrice initiale Cette configuration avec 2 colonnes x 3 lignes qui donnent 6 fois le nombre 1 ? non. Donc partant de la 2ème grille, on n'obtiendra jamais la 1ère grille.

Et idem en 9x9 avec les 2 grilles proposées au début.

L'exercice beaucoup plus compliqué, ce serait de déterminer le nombre de familles (le nombre de classes d'équivalences avec un jargon mathématique). Et là, je n'ai pas vraiment d'idée.

[CosmoKnacki]

salut tu as aussi 4 fois les memes Vecteurs (
lignes 2,3,7,8) comme dans la matrice de départ (Ligne 1,2,3,4)

Effectivement, et c'est normal je dirais, car la transposition d'une matrice (une rotation de 90°) ne change pas son rang (qui est bien 6, j'ai calculé). Autrement dit lorsque tu as 4 colonnes liées (ici elles sont mêmes carrément égales), tu as aussi 4 lignes qui le sont.

en fait je ne sais pas pourquoi mais cela me fait penser au RuBik's Cube ... bien sur ce n'est qu'une face et c'est un carre de neuf par neuf
c'est peut etre juste la matrice et les permutation qui me donne l'impression de retrouver les meme principe

Il y a de ça. Sauf qu'un Rubik's cube on peut le démonter, le dégommer à coups de marteau ou le faire fondre au four.

[tbc92]

J'ai joué un peu avec cette question.
Pour simplifier le vocabulaire, je vais dire que 2 matrices sont équivalentes ssi on peut aller de l'une à l'autre par une succession de permutation.
On retrouve la notion de relation d'équivalence et de classes d'équivalence (si a~b et b~c alors a~c)

J'ai généré 1 Million de matrices aléatoires.
Pour chaque matrice, je calcule une 'signature'. La formule que j'ai retenue est la suivante.
On prend tous couples de colonnes, tous les couples de lignes, et pour chacun, on a donc 2x2=4 éléménts de la matrice, et on fait la somme de ces 4 éléments.
On obtient un nombre entre 0 et 4.
Et je compte combien de fois on obtient 0, combien de 1, ... combien de 4.
Par exemple, pour cette matrice :
[101111000]
[011100011]
[011011100]
[110100101]
[100110110]
[000111101]
[100010111]
[111001010]
[011001011]
J'obtiens : Signature= 23;232;552;412;77
Il y a 23 carrés avec (0,0,0,0), et 77 carrés avec (1,1,1,1)

Je fais ensuite le recensement de toutes les signatures que j'ai rencontrées. Si 2 matrices n'ont pas la même signature, on a l'assurance qu'elles ne sont pas équivalentes.

J'obtiens ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
New Signature 23;232;552;412;77 | 1 0
New Signature 26;220;570;400;80 | 2 1
New Signature 32;196;606;376;86 | 3 3
New Signature 27;216;576;396;81 | 4 5
New Signature 24;228;558;408;78 | 5 8
New Signature 30;204;594;384;84 | 6 11
New Signature 21;240;540;420;75 | 7 12
New Signature 29;208;588;388;83 | 8 14
New Signature 20;244;534;424;74 | 9 15
New Signature 25;224;564;404;79 | 10 19
New Signature 22;236;546;416;76 | 11 29
New Signature 31;200;600;380;85 | 12 40
New Signature 28;212;582;392;82 | 13 63
New Signature 19;248;528;428;73 | 14 74
New Signature 33;192;612;372;87 | 15 75
New Signature 36;180;630;360;90 | 16 271
New Signature 34;188;618;368;88 | 17 461
New Signature 38;172;642;352;92 | 18 610
New Signature 44;148;678;328;98 | 19 732
New Signature 18;252;522;432;72 | 20 785
New Signature 37;176;636;356;91 | 21 931
New Signature 35;184;624;364;89 | 22 1029
New Signature 39;168;648;348;93 | 23 2007
New Signature 41;160;660;340;95 | 24 3056
New Signature 42;156;666;336;96 | 25 4678
New Signature 40;164;654;344;94 | 26 14442
New Signature 46;140;690;320;100 | 27 36686
New Signature 47;136;696;316;101 | 28 62134
New Signature 52;116;726;296;106 | 29 186144
New Signature 51;120;720;300;105 | 30 905260
New Signature 49;128;708;308;103 | 31 1656845

Les 2 dernières colonnes sont là uniquement pour information.
Par exemple, la signature 52;116;726;296;106 a été rencontrée pour la 1ère fois à la 186144ème matrice.
On constate que le 1er nombre de cette signature suffit pour connaître les 4 autres.
Combien de carrés (0,0,0,0) y-a-t-il dans la matrice ... ça suffit pour connaître les 4 autres compteurs.
Et clairement, il y a quelques configurations très rares, mais oubliées ici (48 ou 45 dans la première colonne)
Les configurations avec un 1° nombre entre 20 et 30 apparaissent très vite, elles sont très fréquentes ; par contre, les configurations avec un nombre entre 44 et 51 en 1ère colonne sont très rares.

On a donc au minimum 33 familles. C'est à dire 33 classes d'équivalence. Si 2 matrices n'ont pas la même signature, on sait qu'elles ne sont pas équivalentes.
Reste à vérifier si quand 2 matrices ont la même signature, elles sont équivalentes, mais j'ai peur que non.
A suivre.

[anapurna]

salut

ce qui m'etonne c'est les 23 carrés blancs
normalement tu devrais en avoir 4*9 => 36
vu qu'il faut 4x0 et 5x1 par ligne
je n'ai pas tout compris a l'explication

[tbc92]

Quand je compte les 0, je parle de 0, ou de cases, mais pas de carré. Un carré (j'aurais dû parler de rectangle), ce sont 4 cases, disposées aux 4 coins d'un rectangle.

Prenons cette grille du message précédent :
[101111000]
[011100011]
[011011100]
[110100101]
[100110110]
[000111101]
[100010111]
[111001010]
[011001011]

J'ai remplacé 4 nombres 0 par des A, et 4 autres avec des B, et encore 4 autres avec des C ; j'ai mis en évidence 3 de mes 23 'carrés'.
[1011110CC]
[011100011]
[0110111CC]
[11A10A101]
[100110110]
[000111101]
[10A01A111]
[1110B1B10]
[0110B1B11]

Je peux faire toutes les permutations imaginables, les 4 0 que j'ai remplacés par des C continueront de faire un rectangle. Le nombre de rectangles avec des 0 aux 4 coins est un invariant, il vaut 23 pour cette matrice.

En fait, j'ai un peu avancé depuis hier, au moins dans la réflexion.
Pour tester si 2 matrices A et B sont équivalentes, je peux expérimenter les 126 permutations de lignes, combinées avec les 126 permutations de colonnes à partir de la matrice A, et voir si j'arrive à la matrice B.
Mais c'est long.
J'ai choisi de réduire chaque matrice. Ca veut dire quoi.
Une matrice, c'est un vecteur de 9 colonnes du plus petit au plus grand. Je peux trier ces 9 vecteurs, j'obtiens une autre matrice, équivalente à la première.
Puis je trie les 9 lignes.
J'obtiens une matrice dont la première ligne est forcément '000011111' , la 2ème sera souvent '000101111' etc.
Notons r(A) la matrice obtenue ainsi à partir de A.

Théorème 1 : si r(A)=r(B) alors A~B (avec les notations du précédent message) ; ce résultat est évident.
Théorème 2 : si A~B alors r(A)=r(B) : là je suis à peu près sûr, mais pas à 100%.

L'idée serait donc de générer quelques millions de matrices aléatoires, et de réduire chaque matrice, puis de compter le nombre de matrices réduites distinctes que l'on obtient, ainsi que la fréquence pour chaque matrice réduite.
A suivre.

[anapurna]

salut

ne peut ton pas jouer sur les symetrie pour savoir
si la matrice est "acceptable"

en reprenant vos deux matrices exemple
en ne prenant que des carres de 4 x 4
il semble evident qu'il y ai symetrie
Etant donné que la somme des lignes et celle des colonne aussi doivent etre egale a 5
ce quiu implique que la somme des "demi" tableau est egale a 20 ce qui oblige un certain equilibre
les mediane servant de tampon compensateur dans la repartition le cas echeant

[tbc92]

Je suppose que ce que tu appelles matrice 'acceptable', c'est une matrice qui vérifie les 2 contraintes : Exactement 5 1 sur chaque ligne, et exactement 5 1 sur chaque colonne.

Effectivement, quand on génère aléatoirement des grilles, si on n'aide pas un petit peu le destin on tombe très rarement sur une grille qui vérifie ces contraintes, c'est le moins qu'on puisse dire.

Mais ici, ce n'est pas trop ça la question.
On considère qu'on a généré toutes les matrices 9x9 qui vérifient ces contraintes. Quelques milliards de matrices.
Et on se demande si en prenant 2 matrices au hasard, on va pouvoir passer de l'une à l'autre par une série de permutations de lignes et/ou de colonnes.
Clairement, non. On a des familles (des classes d'équivalence pour parler matheux).
Le jeu maintenant est d'identifier ces familles, combien de familles par exemple. Et combien de matrices dans chaque famille. Clairement, la famille de la matrice proposée par Cosmoknacki dans le tout premier message contient beaucoup plus de matrices que la famille de la matrice que je proposais dans ma première réponse.
9! x 9! , contre (9! x 9!)/(4! x 4!)

[tbc92]

J'ai continué de m'amuser avec cet exercice.
J'ai laissé tomber l'histoire de matrice réduite.
Pour chaque matrice, je calcule différents invariants.
Comme dans la version précédente, le 23 tel qu'il était expliqué.
Autre calcul : On prend 2 lignes, et on compte combien de colonnes ont 1 et 1
Exemple, avec 100111001 et 110010011, on a 3 positions où on a 1 à la fois sur la ligne 1 et sur la ligne 2.
Et en répétant ce calcul sur les 36 couples de 2 lignes, on a un invariant. Si par exemple on a 2 lignes qui ont 5 1 en commun (donc 2 lignes totalement identiques dans ce cas), on pourra faire toutes les permutations imaginables, on aura toujours 2 lignes identiques sur la matrice résultat. Et si j'ai 2 lignes avec un seul 1 en commun (111110000 et 000011111 par exemple), pareil, en faisant des permutations de lignes ou de colonnes, j'aurais toujours cette configuration.
Et idem pour quelques autres invariants.
Chaque matrice a ainsi une signature. Si 2 matrices n'ont pas la même signature, on est sûr qu'elles ne sont pas équivalentes, mais si elles ont la même signature, on n'est toujours pas assuré qu'elles soient équivalentes.
Au final, en générant 1 Million de lignes, j'obtiens 2482 signatures différentes. Certaines n'apparaissent qu'une fois sur 1 million de tirages. On peut donc imaginer que d'autres signatures existent, mais qu'on ne les a pas rencontrées.
Et les signatures les plus fréquentes sont apparues 4422 fois, 4289 fois et 3691 fois.
Avec 2 grilles prises au hasard, il y a donc peu de chances qu'elles soient équivalentes.