Le nombre d'états d'un Cube

[Morphocode]

Un état est une configuration (des autocollants) provenant des rotations de base en respectant l'orientation du Cube (pas bouger, pas tourner le Cube) , de plus si le Cube a des pièces indiscernables (comme le Revenge, Professor, V-Cube, ...) alors les états doivent être visuellement distingues.

Donc avant de parler le nombre d'états d'un Cube, il faut fixer le Cube (orienter le Cube), traditionnellement on fixe le Cube ainsi :
Haut=blanc, Bas=jaune, Avant=vert, Postérieur=klein, Gauche=orange, Droite=rouge

ET préciser quels sont les rotations standards (les rotations de base)
Les configurations provenant des rotations standards se nomment les états du Cube.

Par ex
=> pour l'Helicopter les rotations standards sont les 12 rotations d'arêtes à 180°, les autres rotations sont non-standards
=> pour le Rubik's Cube les rotations standards sont {H,B,A,P,G,D} , les autres rotations tranches h,d,a ... sont non-standards
Quand on parle d'états du Rubik's Cube ce sont des états provenant des rotations de base {H,B,A,P,G,D}.
=> Pour le Skewb , les rotations standards sont les 8 rotations sommets à 120°.

Exemples :
==========
Le nombre d'états du Rubik's Cube
=============================

Pour calculer le nombre d'états du Rubik's Cube on suit la recette suivante:

Pour le Rubik's Cube:
=> On a 12 arêtes qui baladent partout en restant dans leur camp, donc le nombre de permutations est 12! (à connaitre par coeur)
=> Chaqu' arête a 2 orientations, donc le nombre d'orientations est 212 (à connaitre par coeur)
=> On a 8 sommets qui baladent partout en restant dans leur camp, donc le nombre de permutations est 8!
=> Chaque sommet a 3 orientations, donc le nombre d'orientations est 38
donc le nombre de configurations est :
12!.212 x 8!.38
Mais on a des contraintes (des lois), pour avoir le nombre d'états il faut donc diviser le nombre de configurations par les contraintes:

=> loi des flips => /2 (car on a 2 choix)
=> loi des twists => /3 (car on a 3 choix)
=> loi de parité => /2 (car on a 2 choix)
Finalement le nombre d'états du Rubik's Cube vaut:
g = 12!.212 x 8!.38 /2.3.2




==========
Le nombre d'états du Revenge
=============================

Pour calculer le nombre d'états du Revenge on suit la recette suivante:

Pour le Revenge:
=> On a 8 sommets qui baladent partout en restant dans leur camp, donc le nombre de permutations est 8!
=> Chaque sommet a 3 orientations, donc le nombre d'orientations est 38
=> On a 24 ailes qui baladent partout en restant dans leur camp, donc le nombre de permutations est 24! (à connaitre par coeur)
=> On a 24 centres qui baladent partout en restant dans leur camp, donc le nombre de permutations est 24!

donc le nombre de configurations est :
8!.38 x 24! x 24!
Mais on a des contraintes (des lois), pour avoir le nombre d'états il faut donc diviser le nombre de configurations par les contraintes:

=> loi des twists => /3 (car on a 3 choix)
=> loi de parité (sommets et centres en phase) => /2 (car on a 2 choix)
=> visuellement distinct => /(4!6/2) (le nombre permutations des centres)

Finalement le nombre d'états du Revenge vaut:
g = 8!.38 x 24! x 24! /3 .2 . (4!6/2)
g = 8!.37 x (24!)² / 4!6




Le nombre d'états du Skewb
=========================
Les sommets du Skewb sont divisés en deux camps : le camp Impair et le camp Pair


Pour le Skewb:
=> On a 4 sommets Impairs qui baladent partout dans son camp, donc le nombre de permutations est 4! (à connaitre par coeur)
=> Chaque sommet Impair a 3 orientations, donc le nombre d'orientations est 34 (à connaitre par coeur)
=> On a 4 sommets Pairs qui baladent partout dans son camp, donc le nombre de permutations est 4! (à connaitre par coeur)
=> Chaque sommet Pair a 3 orientations, donc le nombre d'orientations est 34 (à connaitre par coeur)
=> On a 6 centres qui baladent partout en restant dans leur camp, donc le nombre de permutations est 6!

donc le nombre de configurations est :
4!.34 x 4!.34 x 6!
Mais on a des contraintes (des lois), pour avoir le nombre d'états il faut donc diviser le nombre de configurations par les contraintes:

=> loi des twists pour les sommets Impairs => /3 (car on a 3 choix)
=> loi des twists pour les sommets Pairs => /3 (car on a 3 choix)
=> loi de parité pour les sommets Impairs => /2 (car on a 2 choix)
=> loi de parité pour les sommets Pairs => /2 (car on a 2 choix)
=> loi de parité pour les centres => /2 (car on a 2 choix)

Finalement le nombre d'états du Skewb vaut:
g = 4!.34 x 4!.34 x 6! /3.3. 2.2.2

[Morphocode]

On peut calculer le nombre d'états d'un twist par GAP de la façon suivante:

1) On numérote les autocollants (comme on veut !)
2) On désigne les rotations de base {X, Y, Z, T, ...}
3) On définit les permutations associées au rotations de base PX, PY, PZ, PT ...
4) On forme le groupe Λ engendré par les permutations PX, PY, PZ, PT ...
5) On calcule l'ordre de Λ = < PX, PY, PZ, PT ... >

*Pas de pièces indiscernables : |Λ| = le nombre d'états
*Avec des pièces indiscernables (Rubik n x n x n, .. ): |Λ|/C = le nombre d'états
où C est le nombre de permutations des centres (=visuellement distingues).
C = (4!6/2))(k-1)² ;n=2k
C = (4!6/2) )(k-1)k ;n=2k+1

Pour le Pocket:
===============

Code : Tout sélectionner

#gap_pocket.txt
#         5     7
#            H   
#         3     1
#25    23|21    19|17    31|29    27
#   G    |   A    |   D    |   P 
#43    37|39    33|35    45|47    41
#         11    9
#            B   
#         13    15
# Pocket=le groupe Pocket (= Rubik sans arêtes)
pH :=  (1,3,5,7)(17,21,25,29)(19,23,27,31) ;
pB :=  (9,15,13,11)(33,45,41,37)(35,47,43,39);
pA :=  (1,35,11,23)(17,9,37,3)(19,33,39,21);
pP :=  (7,25,13,45)(29,27,41,47)(31,5,43 ,15);
pG :=  (3,39,13,27)(21,11,41,5)(23,37,43,25);
pD :=  (1,29,15,33)(17,31,45,35)(19,7,47,9);

LAMBDA := Group( pH, pB, pA, pP, pG, pD );

Print( "\n |LAMBDA| = ", Size( LAMBDA ) , "\n" );



[Morphocode]

On peut calculer le nombre d'états du Domino par GAP de la façon suivante:

1) On numérote les autocollants (comme on veut !)
2) On désigne les rotations de base {X, Y, Z, T, ...}
3) On définit les permutations associées au rotations de base PX, PY, PZ, PT ...
4) On forme le groupe Λ engendré par les permutations PX, PY, PZ, PT ...
5) On calcule l'ordre de Λ = < PX, PY, PZ, PT ... >


|Λ| = le nombre d'états

Pour le Domino:
===============

Code : Tout sélectionner


# gap_domino.txt
#         5  6  7
#         4  H  8
#         3  2  1
#25 28 23|21 26 19|17 32 31|29 30 27
#43 44 37|39 42 33|35 48 45|47 46 41
#         11 18 9
#         20 B  24
#         13 22 15
#H=49,B=50
#
#Domino : sommets et arêtes n'ont pas d'orientations !!
pH := (2,4,6,8)(26,28,30,32) (1,3,5,7)(17,21,25,29)(19,23,27,31);;
pB := (18,24,22,20)(42,48,46,44) (9,15,13,11)(33,45,41,37)(35,47,43,39);;
pA := (2,18)(26,42) (1,11)(17,37)(19,39)(3,9)(23,35)(21,33);;
pP := (6,22)(30,46) (7,13)(31,43)(29,41)(5,15)(25,45)(27,47);;
pG := (4,20)(28,44) (3,13)(21,41)(23,43)(5,11)(27,39)(25,37);;
pD := (8,24)(32,48) (1,15)(19,47)(17,45)(7,9)(29,33)(31,35);;

LAMBDA := Group( pH,pB, pA,pP, pG, pD );;
Print( "\n |LAMBDA| = ",Size( LAMBDA ), "\n" );





[Morphocode]

Le nombre d'états (cubique) du Square-1 :

1) On numérote les autocollants (comme on veut !)
2) On désigne les rotations de base :
3
3B
S = 1/3/-1
Q = 1/3B/-1
E = -B/3/B
T = -B/3B/B

3) On définit les permutations associées au rotations de base P3, P3B, PS, PQ , PE, PT
4) On forme le groupe Λ engendré par les permutations P3, P3B, PS, PQ , PE, PT
5) On calcule l'ordre de Λ = < P3, P3B, PS, PQ , PE, PT >

|Λ| = le nombre d'états

Pour le Square-1:
===============

Code : Tout sélectionner

#gap_square-1.txt
#12  1  9
#2   H  3
#11  4  10
#---------
#13  6  16
#5   B  7
#14  8  15

p3 := (1,3,4,2)(9,10,11,12) ;
p3B := (5,8,7,6)(13,14,15,16) ;
pS := (2,8,7,4)(12,15,16,11) ;
pQ := (1,3,6,5)(9,10,13,14) ;
pE := (2,1,7,6)(11,12,15,16) ;
pT := (3,4,5,8)(9,10,13,14) ;

LAMBDA :=  Group(p3, p3B, pS, pQ, pE, pT);
Print( "\n |LAMBDA| = ", Size( LAMBDA ) , "\n" );



[Morphocode]

On peut calculer le nombre d'états du Revenge par GAP de la façon suivante:

1) On numérote les autocollants (comme on veut !)
2) On désigne les 12 rotations de base {H, B, A, P, G, D, h, b, a, p, g, d}
3) On définit les permutations associées au rotations de base PH, PB, ..., Pg, Pd
4) On forme le groupe Λ engendré par les permutations PH, PB, ..., Pg, Pd
5) On calcule l'ordre de Λ = < PH, PB, ..., Pg, Pd >


*Il y a des pièces indiscernables donc : |Λ|/C = le nombre d'états
où C est le nombre de permutations des centres (=visuellement distingues).
C = 4!6/2


Pour le Revenge:
===============

Code : Tout sélectionner


#gap_revenge.txt
#decomposition nbr premeirs
Decomposer := function(n)
   local gg, ff ;
   
gg := n ;;
ff := Collected( Factors( gg ) );;
ff := String(ff);;
ff := ReplacedString( ff, "],", "." );;
ff := ReplacedString( ff, "]", "" );;
ff := ReplacedString( ff, "[ ", "" );;
ff := ReplacedString( ff, ", ", "^" );;   
   
   return ff;
end;;
###############


pH := (64,67,79,76)(65,71,78,72)(66,75,77,68)(69,70,74,73)(96,48,47,16)(1,49,46,17)(2,50,45,18)(3,51,44,19);
pB := (80,83,95,92)(81,87,94,88)(82,91,93,84)(85,86,90,89)(12,28,35,60)(13,29,34,61)(14,30,33,62)(15,31,32,63);
pA := (96,3,15,12)(1,7,14,8)(2,11,13,4)(5,6,10,9)(16,83,63,76)(20,82,59,77)(24,81,55,78)(28,80,51,79);
pP := (32,35,47,44)(33,39,46,40)(34,43,45,36)(37,38,42,41)(64,60,95,19)(65,56,94,23)(66,52,93,27)(67,48,92,31);
pG := (48,51,63,60)(49,55,62,56)(50,59,61,52)(53,54,58,57)(96,80,32,64)(4,84,36,68)(8,88,40,72)(12,92,44,76);
pD := (16,19,31,28)(17,23,30,24)(18,27,29,20)(21,22,26,25)(3,67,35,83)(7,71,39,87)(11,75,43,91)(15,79,47,95);
ph := (4,52,43,20)(5,53,42,21)(6,54,41,22)(7,55,40,23);
pb := (8,24,39,56)(9,25,38,57)(10,26,37,58)(11,27,36,59);
pa := (72,17,87,62)(73,21,86,58)(74,25,85,54)(75,29,84,50);
pp := (68,61,91,18)(69,57,90,22)(70,53,89,26)(71,49,88,30);
pg := (1,81,33,65)(5,85,37,69)(9,89,41,73)(13,93,45,77);
pd := (2,66,34,82)(6,70,38,86)(10,74,42,90)(14,78,46,94);
LAMBDA := Group( pH, pB, pA, pP, pG, pD, ph, pb, pa, pp, pg, pd );
N := 3*2 ;;
C := (24^6)/2 ;;
Gp := Factorial(8) * (3^8) * Factorial(24)  *   Factorial(24) ;;
Gd := Gp/N ;;
Print( "\n |LAMBDA| = ", Size( LAMBDA ) , "\n" );
Print( "\n N = ", N , "\n" );
Print( "\n C = ", C , "\n" );
Print( "\n |G+| = ",Gp, "\n" );
Print( "\n |G#| = |G+|/N = ", Gd, "\n" ) ;
Print( "|G| = |G#|/C = ",  Gd/C , "\n" );
Print( "\n |LAMBDA| = |G#| \n" );
Print( "\n |G| = |LAMBDA|/C = ",Size( LAMBDA )/C , "\n" );
ll := Size( LAMBDA )/C ;;
gg := Decomposer(ll) ;;
Print("\n |G| = ", gg, "\n" );