Ceux qui ont le privilège de savoir ont le devoir d'agir.
Ensemble, mettons un terme à la corruption et à la pauvreté.
(Avec la Résolution en losange) (Sans la Résolution en Losange)
Résolution Polynomiale : le problème des 400 étudiants.
À propos
Cet ouvrage nécessite avoir lu le Référentiel de SCI Volume 1 pour le comprendre.
Ce manuscrit résout le 3e problème de Smale (P=NP). Un logiciel accompagne ce tutoriel (P_NP_V2.gmk). Cette open-source s'ouvre avec Game Maker 8.0 pro, et le «gml 8» est le langage utilisé.
Cette version de la résolution polynomiale fait partie de l'ensemble théorique de la résolution en losange, garantissant un nombre minimum de variable exploitée, et une géodésie logique de la Formule de SCI utilisé.
Problème : Les 400 étudiants.
Il y a 400 étudiants et 100 Places. Lorsqu'un étudiant prend une place, une ou plusieurs incompatibilités peuvent avoir lieu, empêchant d'autres étudiants d'avoir des places.
Question
Est-ce possible de résoudre le problème de façon polynomiale, tout en ayant une solution vérifiée en temps réel?
Réponse Théorique
Oui, il est possible grâce à une formule de SCI (Suite de Chaîne Itérée).
Voici un exemple avec 8 étudiants et 4 places:
Tableau P1
| Étudiants
1 2 3 4 5 6 7 8
Étudiants 1 | [3] X X X
2 | X [3] X X
3 | [4] X X
4 | X [5] X X
5 | X X [3] X
6 | [4] X
7 | X [2]
8 | X X [2]
Les X représentent les incompatibilités. Les nombres en diagonal à la position P1[i,i] représente le nombre total d'incompatibilité que possède un étudiant.
Tableau R
| Incompatibilité
Étudiant 1 | 2,3,4
2 | 1,4,8
3 | 1,5,6,7
4 | 1,2,5,6,8
5 | 3,4,6
6 | 3,4,5,7
7 | 3,6
8 | 2,4
Pour chaque incompatibilité d'un étudiant, il faut noter la valeur totale des incompatibilités.
Tableau P[ n , (L1+1) ]
| Valeur du nombre total d'incompatibilité
Étudiant 1 | 12
2 | 10
3 | 12
4 | 15
5 | 13
6 | 14
7 | 8
8 | 8
Ensuite, une formule doit être respectée. Pour l'étudiant « i », Si l'étudiant n'a pas été rejeté ou déjà placé, il faut calculer la somme d'incompatibilité au carré que possède l'étudiant « i », moins la somme des incompatibilités que possède chaque incompatibilité de l'étudiant i. Puis, choisir de placer l'étudiant ayant la valeur la plus basse et rejeter les autres étudiants.
Dans cet exemple, l'étudiant #1 est incompatible avec 2,3,4. Pour 3 incompatibilités de l'étudiant #1, ses incompatibilités comptent au total de 12. Le #2 arrive à un total de 10, le #3 à 12 et le #4 à un total de 15.
L'étudiant #1 a une valeur de -3 (3² -12)
Le #2 a une valeur de 1 (3² -10)
Le #3 a une valeur de 4 (4² -12)
Et le #4 a une valeur de 10 (5² -15)
L'étudiant #1 a la plus petite valeur, il est donc choisi et les 3 autres étudiants rejetés. Puis nous les retirons des calculs.
Tableau R
| Incompatibilité
Étudiant 1 | 2,3,4 [Choisi]
2 | 1,4,8 [Rejeté]
3 | 1,5,6,7 [Rejeté]
4 | 1,2,5,6,8 [Rejeté]
5 | 6
6 | 5,7
7 | 6
8 |
Tableau P[ n , (L1+1) ]
| Valeur du nombre total d'incompatibilité
Étudiant 5 | 2
6 | 1
7 | 2
8 | 0
Poursuivons avec l'étudiant #5. Cet étudiant est incompatible avec l'étudiant #6. Nous répétons la même formule.
L'étudiant #5 a une valeur de -1 (1²-2)
L'étudiant #6 a une valeur de 3 (2²-1)
L'étudiant #5 est choisi, et le #6 rejeté.
Tableau R
| Incompatibilité
Étudiant 1 | 2,3,4 [Choisi]
2 | 1,4,8 [Rejeté]
3 | 1,5,6,7 [Rejeté]
4 | 1,2,5,6,8 [Rejeté]
5 | 6 [Choisi]
6 | 5,7 [Rejeté]
7 |
8 |
Tableau P[ n , (L1+1) ]
| Valeur du nombre total d'incompatibilité
Étudiant 7 | 0
8 | 0
Pour terminer, comme l'étudiant #7 et #8 ont une valeur d'incompatibilité de 0, ils sont choisis tous les 2. Pour conclure l'exemple, nous avons 4 places de prises : #1, #5, #7, #8.
Cette méthode peut être appliquée mathématiquement. Voici comment exploiter informatiquement la résolution polynomiale.
Réponse Mathématique
#SO()== // Système d'Origine. /* Calcul du Pole :
2 Variables de Limitation OL : 2-1=1
OM(1)
Le maximum de dimension d'itération des Variables Primitives est 2:
OM(1+2)
Il n'y a qu'une seule Variable P : 1-1=0
OM(3+0)
Il n'y a qu'une seule Variable R : 1-1=0
OM(3+0)
La valeur total des variable isolé de l'OP est de 2 :
OM(3+2)
*/
OM(5) ;
// L1 = 400 Étudiants.
// L2 = 100 Places.
OL(400,100) ;
// P[i,j] = Liste d'incompatibilité.
// P[i,i] = Nombre d'incompatibilité.
// P[i,(L1+1)] = Valeur des incompatibilités.
// R[i,j] = ID des incompatibilité.
// R[i,(L1+1)] = Couche de calcul en cour.
// M.i = État de sélection de l'étudiant.
OP( L1,(L1+1)0² ¦ L1,(L1+1)0² ¦ L201 ) ;
PN() ;
#PN()==
// Initialise les variables et choisi au hasard les incompatibilités.
PR²( L1 , i , j )
{ RA( i = j )
{ P[i,i] = 0
P[i,(L1+1)] = 0
R[i,(L1+1)] = 0
} !
{ RA( (ir(1,100)) = 1 )
{ P[i,j] = 1
} !
{ P[i,j] = 0
}
}
R[i,j] = 0
}
PR( L2 , i )
{ M.i = 0
}
SLP() ;
#SLP()==
// Par défaut, la première place est sélectionnée.
m = 1 ;
// Pour chaque Étudiant:
PR( L1 , i )
{ // Vérifie s'il reste assez d'étudiant pour remplir les places.
RA( (L2-m) > (L1-i) )
{ break ;
}
// Vérifie si toutes les places sont prises.
RA( L2 = (m-1) )
{ break ;
}
// Excluant les étudiants déjà triés,
RA( P[ i, (L1+1) ] != L1² )
{ // Si l'étudiant n'est pas pleinement mesuré:
RA( R[ i , (L1+1) ] = 0 )
{ // Mesure l'étudiant i.
SL.1( i ) ;
}
// S'il n'y a pas d'incompatibilité restant avec l'étudiant i :
RA( P[i,i] = 0 )
{ // Choisi l'étudiant i.
RF.1( i )
// Déclare l'étudiant i comme étant calculé.
P[ i , (L1+1) ] = L1² ;
} ! // Sinon:
{ // Déclare que l'étudiant est en cour de calcul.
R[ i , (L1+1) ] = 2 ;
// Et calcul l'étudiant i.
SL.2() ;
}
}
}
// Vérifie si toute les places sont prises.
RA( L2 = (m-1) )
{ msg( "Toute les places sont prises." )
} !
{ msg( "Il n'y a pas de pattern valide." )
}
#SL.1()== // SOLUTION DE MESURE EN CONSERVANT L'INFORMATION.
// Pour chaque possibilité d'incompatibilité,
PR( L1 , j )
{ // Excluant avec soi-même,
RA( a1 != j )
// Et excluant les étudiants déjà triés,
&( P[ j , (L1+1) ] != L1² )
{ // S'il y a une incompatibilité entre l'étudiant a1 et l'étudiant j:
RA( P[a1,j] = 1 )
|( P[j,a1] = 1 )
{ // Si l'incompatibilité n'a jamais été mesurée:
RA( R[ j , (L1+1) ] = 0 )
{ // Ajoute +1 au nombre total d'incompatibilité.
P[a1,a1] += 1
P[j,j] += 1 ;
// Ajoute l'identifiant de chacun.
R[ a1 , P[a1,a1] ] = j
R[ j, P[j,j] ] = a1 ;
}
}
}
}
#SL.1()== // SOLUTION DE MESURE OPTIMISÉ EN SUPPRIMANT L'INFORMATION.
// Pour chaque possibilité d'incompatibilité,
PR(L1,j)
{ // Excluant avec soi-même,
RA( a1 != j )
// Et excluant les étudiants déjà triés,
&( P[ j , (L1+1) ] != L1² )
{ // S'il y a une incompatibilité entre l'étudiant a1 et l'étudiant j:
RA( ( P[a1,j] = 1 ) | ( P[j,a1] = 1 ) )
{ // Ajoute +1 au nombre total d'incompatibilité.
P[a1,a1] += 1
P[j,j] += 1 ;
// Ajoute l'identifiant de chacun.
R[ a1 , P[a1,a1] ] = j
R[ j, P[j,j] ] = a1
// Déclare (2 pour l'aspect visuel; 0 pour détruire l'information), que la mesure est fait.
P[ a1,j ] = 2
P[ j,a1 ] = 2 ;
}
}
}
#SL.2()==
// Pour chaque incompatibilité de i,
PR( P[i,i] , k )
{ // Excluant les étudiants déjà triés:
RA( P[ R[i,k] , (L1+1) ] != L1² )
{ // Si l'étudiant k n'a jamais été mesuré:
RA( R[ R[i,k] , (L1+1) ] = 0 )
{ // Mesure l'étudiant k.
SL.1( R[i,k] )
// Déclare l'étudiant k comme étant mesuré.
R[ R[i,k] , (L1+1) ] = 1 ;
}
// Si l'étudiant k n'est pas déjà calculé:
RA( R[ R[i,k] , (L1+1) ] != 2 )
{ // Échange les valeurs d'incompatibilité entre les étudiants i et k.
P[ i , (L1+1) ] += P[ R[i,k] , R[i,k] ]
P[ R[i,k] , (L1+1) ] += P[ i,i ]
// Déclare l'étudiant k comme étant en cour de calcul.
R[ R[i,k] , (L1+1) ] = 3 ;
// Calcul l'incompatibilité.
SL.3( R[i,k] ) ;
}
}
}
// Choisi un étudiant et rejette ses incompatibilités.
AF.2() ;
#SL.3()==
// Pour chaque incompatibilité de l'incompatibilité,
PR( P[a1,a1] , l )
{ // Excluant les étudiants déjà triés,
RA( P[ R[a1,l] , (L1+1) ] != L1² )
{ // Si l'étudiant l n'a jamais été calculé:
RA( R[ R[a1,l] , (L1+1) ] != 2 )
{ // Si l'étudiant l n'a jamais été mesuré:
RA( R[ R[a1,l] , (L1+1) ] = 0 )
{ // Mesure l'étudiant l.
SL.1( R[a1,l] )
// Déclare l'étudiant l comme étant mesuré.
R[ R[a1,l] , (L1+1) ] = 1
}
// Ajoute la valeur de l'incompatibilité l à l'étudiant a1.
P[ a1 , (L1+1) ] += P[ R[a1,l] , R[a1,l] ] ;
}
}
}
#SL.4()==
// L'étudiant choisi est déclaré comme étant trié.
P[a1,(L1+1)] = L1² ;
// Pour chaque l'étudiant rejeté:
PR( P[a1,a1] , j )
{ // Déclare les étudiants rejetés comme étant triés.
P[ R[a1,j] , (L1+1) ] = L1² ;
// Pour chaque incompatibilité des étudiants rejetés,
PR( P[R[a1,j],R[a1,j]] , k )
{ // Excluant les étudiants déjà triés,
RA( P[ R[R[a1,j],k] , (L1+1) ] != L1² )
{ // Si l'incompatibilité a déjà été calculé:
RA( R[ R[R[a1,j],k] , (L1+1) ] = 2 )
{ // Retire la valeur de l'étudiant rejeté à chacune de ses incompatibilités.
P[ R[R[a1,j],k] , (L1+1) ] -= P[ R[a1,j] , R[a1,j] ] ;
}
// Suite Logique #5 imbriquée.
// Pour chaque incompatibilité des incompatibilités des étudiants rejetés,
PR( P[ R[R[a1,j],k] , R[R[a1,j],k] ] , l )
{ // Si l'incompatibilité d'incompatibilité de l'étudiant rejeté correspond à l'étudiant rejeté:
RA( R[R[R[a1,j],k],l] = R[a1,j] )
{ /* L'incompatibilité d'incompatibilité de l'étudiant rejeté est remplacé par
le dernier étudiant incompatible.
*/
R[R[R[a1,j],k],l] = R[ R[R[a1,j],k],P[ R[R[a1,j],k] , R[R[a1,j],k] ] ]
// Nous retirons pareillement 1 au nombre d'étudiant incompatible.
P[ R[R[a1,j],k] , R[R[a1,j],k] ] -= 1 ;
}
// Si l'incompatibilité d'incompatibilité de l'étudiant rejeté n'est pas déjà trié,
RA( P[ R[R[R[a1,j],k],l] , (L1+1) ] != L1² )
{ // Et si son calcul est déjà fait:
RA( R[ R[R[R[a1,j],k],l] , (L1+1) ] = 2 )
{ // Retire 1 à la valeur total des incompatibilités.
P[ R[R[R[a1,j],k],l] , (L1+1) ] -= 1 ;
}
}
}
}
}
}
#RF.1()==
// Choisi l'étudiant a1.
M[m] = a1
// Change de place pour le prochain étudiant.
m += 1 ;
#AF.2()==
// Par défaut, l'étudiant choisi est i.
j = i ;
// Pour chaque incompatibilité de i,
PR( P[i,i] , k )
{ // Excluant les incompatibilités déjà triés,
RA( P[ R[i,k] , (L1+1) ] != L1² )
{ // Si l'étudiant incompatible a une valeur plus petite que l'étudiant sélectionné:
RA( ( P[R[i,k],R[i,k]]² - P[ R[i,k] , (L1+1) ] ) < ( P[j,j]² - P[ j , (L1+1) ] ) )
{ // Sélectionne l'incompatibilité.
j = R[i,k] ;
}
// Déclare les incompatibilités comme étant calculé.
R[ R[i,k] , (L1+1) ] = 2 ;
}
}
// Choisi l'étudiant sélectionné.
RF.1( j )
// Actualise les valeurs de mesure et de calcul.
SL.4( j ) ;
Problème Alternatif des 400 étudiants.
Il y a 400 étudiants. Lorsqu'un étudiant est sélectionné, une ou plusieurs incompatibilités peuvent avoir lieu, empêchant d'autres étudiants d'avoir des places.
Question
Par Résolution Polynomiale, comment sélectionner le plus grand nombre d'étudiant?
Réponse Mathématique
#SO()== // Système d'Origine.
/* Calcul du Pole :
1 Variables de Limitation OL : 1-1=1
OM(0)
Le maximum de dimension d'itération des Variables Primitives est 2:
OM(0+2)
Il n'y a qu'une seule Variable P : 1-1=0
OM(2+0)
Il n'y a qu'une seule Variable R : 1-1=0
OM(2+0)
La valeur total des variable isolé de l'OP est de 2 :
OM(2+2)
*/
OM(4) ;
// L = 400 Étudiants.
OL(400) ;
// P[i,j] = Liste d'incompatibilité.
// P[i,i] = Nombre d'incompatibilité.
// P[i,(L1+1)] = Valeur des incompatibilités.
// R[i,j] = ID des incompatibilité.
// R[i,(L1+1)] = Couche de calcul en cour.
// M.i = État de sélection de l'étudiant.
OP( L,(L+1)0² ¦ L,(L+1)0² ¦ L01 ) ;
PN() ;
#PN()==
// Initialise les variables et choisi au hasard les incompatibilités.
PR²( L , i , j )
{ RA( i = j )
{ P[i,i] = 0
P[i,(L+1)] = 0
R[i,(L+1)] = 0
} !
{ RA( (ir(1,100)) = 1 )
{ P[i,j] = 1
} !
{ P[i,j] = 0
}
}
R[i,j] = 0
}
PR( L , i )
{ M.i = 0
}
SLP() ;
#SLP()== // Par défaut, la première place est sélectionnée.
m = 1 ;
// Pour chaque Étudiant:
PR( L , i ) {
// Excluant les étudiants déjà triés,
RA( P[ i, (L+1) ] != L² )
{ // Si l'étudiant n'est pas pleinement mesuré:
RA( R[ i , (L+1) ] = 0 )
{ // Mesure l'étudiant i.
SL.1( i ) ;
}
// S'il n'y a pas d'incompatibilité restant avec l'étudiant i :
RA( P[i,i] = 0 )
{ // Choisi l'étudiant i.
RF.1( i )
// Déclare l'étudiant i comme étant calculé.
P[ i , (L+1) ] = L1² ;
} ! // Sinon:
{ // Déclare que l'étudiant est en cour de calcul.
R[ i , (L+1) ] = 2 ;
// Et calcul l'étudiant i.
SL.2() ;
}
}
} // Vérifie si toute les places sont prises.
#SL.1()== // SOLUTION DE MESURE EN CONSERVANT L'INFORMATION.
// Pour chaque possibilité d'incompatibilité,
PR( L , j )
{ // Excluant avec soi-même,
RA( a1 != j )
// Et excluant les étudiants déjà triés,
&( P[ j , (L+1) ] != L² )
{ // S'il y a une incompatibilité entre l'étudiant a1 et l'étudiant j:
RA( P[a1,j] = 1 )
|( P[j,a1] = 1 )
{ // Si l'incompatibilité n'a jamais été mesurée:
RA( R[ j , (L+1) ] = 0 )
{ // Ajoute +1 au nombre total d'incompatibilité.
P[a1,a1] += 1
P[j,j] += 1 ;
// Ajoute l'identifiant de chacun.
R[ a1 , P[a1,a1] ] = j
R[ j, P[j,j] ] = a1 ;
}
}
}
}
#SL.1()== // SOLUTION DE MESURE OPTIMISÉ EN SUPPRIMANT L'INFORMATION.
// Pour chaque possibilité d'incompatibilité,
PR(L,j)
{ // Excluant avec soi-même,
RA( a1 != j )
// Et excluant les étudiants déjà triés,
&( P[ j , (L+1) ] != L² )
{ // S'il y a une incompatibilité entre l'étudiant a1 et l'étudiant j:
RA( ( P[a1,j] = 1 ) | ( P[j,a1] = 1 ) )
{ // Ajoute +1 au nombre total d'incompatibilité.
P[a1,a1] += 1
P[j,j] += 1 ;
// Ajoute l'identifiant de chacun.
R[ a1 , P[a1,a1] ] = j
R[ j, P[j,j] ] = a1
// Déclare (2 pour l'aspect visuel; 0 pour détruire l'information), que la mesure est fait.
P[ a1,j ] = 2
P[ j,a1 ] = 2 ;
}
}
}
#SL.2()== // Pour chaque incompatibilité de i,
PR( P[i,i] , k )
{ // Excluant les étudiants déjà triés:
RA( P[ R[i,k] , (L+1) ] != L² )
{ // Si l'étudiant k n'a jamais été mesuré:
RA( R[ R[i,k] , (L+1) ] = 0 )
{ // Mesure l'étudiant k.
SL.1( R[i,k] )
// Déclare l'étudiant k comme étant mesuré.
R[ R[i,k] , (L+1) ] = 1 ;
}
// Si l'étudiant k n'est pas déjà calculé:
RA( R[ R[i,k] , (L+1) ] != 2 )
{ // Échange les valeurs d'incompatibilité entre les étudiants i et k.
P[ i , (L+1) ] += P[ R[i,k] , R[i,k] ]
P[ R[i,k] , (L+1) ] += P[ i,i ]
// Déclare l'étudiant k comme étant en cour de calcul.
R[ R[i,k] , (L+1) ] = 3 ;
// Calcul l'incompatibilité.
SL.3( R[i,k] ) ;
}
}
}
// Choisi un étudiant et rejette ses incompatibilités.
AF.2() ;
#SL.3()== // Pour chaque incompatibilité de l'incompatibilité,
PR( P[a1,a1] , l )
{ // Excluant les étudiants déjà triés,
RA( P[ R[a1,l] , (L+1) ] != L² )
{ // Si l'étudiant l n'a jamais été calculé:
RA( R[ R[a1,l] , (L+1) ] != 2 )
{ // Si l'étudiant l n'a jamais été mesuré:
RA( R[ R[a1,l] , (L+1) ] = 0 )
{ // Mesure l'étudiant l.
SL.1( R[a1,l] )
// Déclare l'étudiant l comme étant mesuré.
R[ R[a1,l] , (L+1) ] = 1
}
// Ajoute la valeur de l'incompatibilité l à l'étudiant a1.
P[ a1 , (L+1) ] += P[ R[a1,l] , R[a1,l] ] ;
}
}
}
#SL.4()==
// L'étudiant choisi est déclaré comme étant trié.
P[a1,(L+1)] = L² ;
// Pour chaque l'étudiant rejeté:
PR( P[a1,a1] , j )
{ // Déclare les étudiants rejetés comme étant triés.
P[ R[a1,j] , (L+1) ] = L² ;
// Pour chaque incompatibilité des étudiants rejetés,
PR( P[R[a1,j],R[a1,j]] , k )
{ // Excluant les étudiants déjà triés,
RA( P[ R[R[a1,j],k] , (L+1) ] != L² )
{ // Si l'incompatibilité a déjà été calculé:
RA( R[ R[R[a1,j],k] , (L+1) ] = 2 )
{ // Retire la valeur de l'étudiant rejeté à chacune de ses incompatibilités.
P[ R[R[a1,j],k] , (L1+1) ] -= P[ R[a1,j] , R[a1,j] ] ;
}
// Suite Logique #5 imbriquée.
// Pour chaque incompatibilité des incompatibilités des étudiants rejetés,
PR( P[ R[R[a1,j],k] , R[R[a1,j],k] ] , l )
{ // Si l'incompatibilité d'incompatibilité de l'étudiant rejeté correspond à l'étudiant rejeté:
RA( R[R[R[a1,j],k],l] = R[a1,j] )
{ /* L'incompatibilité d'incompatibilité de l'étudiant rejeté est remplacé par
le dernier étudiant incompatible.
*/
R[R[R[a1,j],k],l] = R[ R[R[a1,j],k],P[ R[R[a1,j],k] , R[R[a1,j],k] ] ]
// Nous retirons pareillement 1 au nombre d'étudiant incompatible.
P[ R[R[a1,j],k] , R[R[a1,j],k] ] -= 1 ;
}
// Si l'incompatibilité d'incompatibilité de l'étudiant rejeté n'est pas déjà trié,
RA( P[ R[R[R[a1,j],k],l] , (L1+1) ] != L² )
{ // Et si son calcul est déjà fait:
RA( R[ R[R[R[a1,j],k],l] , (L+1) ] = 2 )
{ // Retire 1 à la valeur total des incompatibilités.
P[ R[R[R[a1,j],k],l] , (L+1) ] -= 1 ;
}
}
}
}
}
}
#RF.1()==
// Choisi l'étudiant a1.
M[a1] = 1
#AF.2()==
// Par défaut, l'étudiant choisi est i.
j = i ;
// Pour chaque incompatibilité de i,
PR( P[i,i] , k )
{ // Excluant les incompatibilités déjà triés,
RA( P[ R[i,k] , (L1+1) ] != L² )
{ // Si l'étudiant incompatible a une valeur plus petite que l'étudiant sélectionné:
RA( ( P[R[i,k],R[i,k]]² - P[ R[i,k] , (L1+1) ] ) < ( P[j,j]² - P[ j , (L1+1) ] ) )
{ // Sélectionne l'incompatibilité.
j = R[i,k] ;
}
// Déclare les incompatibilités comme étant calculé.
R[ R[i,k] , (L+1) ] = 2 ;
}
}
// Choisi l'étudiant sélectionné.
RF.1( j )
// Actualise les valeurs de mesure et de calcul.
SL.4( j ) ;
NOTE : L'exemple reproductible est fait avec Game Maker Pro 8.0 .
