> with(group);

 > f:=x->1-x; g:=x->1/x; e:=x->x;

 > f(g(x));

 > h:=x->f(g(x));h(x);

 > k:=x->g(f(x));k(x);

 > l:=x->f(k(x));normal(l(x));

 > G:=[e,f,g,h,k,l];G[2](x);

 > Table:=A->Matrix(nops(A),(i,j)->simplify(A[i](A[j](x))));Table(G);

 > map(G,x);

 > TableCloture:=A->Matrix(nops(A),(i,j)->evalb(normal(A[i](A[j](x))) in normal(map(A,x))));TableCloture(G);

 >

Groupe de Permutations

 > S:=permgroup(4,{[[1,2]],[[3,4]]});

 > grouporder(S);

 > U:= permgroup(4, {[ ]});

 > cosets(S,U);elements(S);

 >

 > S2:= permgroup(4, {[[3,4]]});cosets(S2,U);cosets(S,S2);

Multiplier des permutations

 > mulperms([[1,2]],[[3,4]]);

 > mulperms([[1,2]],[[1,2]]);mulperms([[1,2]],[]);

 > mulperms([[1,2]],[[2,3]]);

Orbites d'un élément et d'un ensemble

 > orbit({[[1,2]]},1);orbit({[[1,2]]},3);op(op([[1,2]]));

 > S:=permgroup(4,{[[1,2]],[[3,4]]});orbit(S,1);orbit(S,3);

 > Orbitg:=proc(g,S,k) local s,Or,l; l:=convert(g,'permlist',k); Or:={}; for s in S do Or:=Or union {op(s,l)} od; end;

 > Orbitg([[1,2]],{1,2},4);Orbitg([[1,2]],{1},4);orbit({[[1,2]]},1);orbit({[[1,2]]},3);

 > OrbitG:=proc(G,S,k) local g,Or; Or:={}; for g in elements(G) do Or:={op(Or),Orbitg(g,S,k)} ;od; end;

 > OrbitG(S,{1,2},4);OrbitG({[[1,2]],[[3,4]]},{1,3},4);

 >

Stabilisateur d'un élément

 > stabg:=proc(G,x,k) local S,l,g; S:={[]}; for g in elements(G) do  if g<>[] then  l:=convert(g,'permlist',k);  if op(x,l)=x  then S:=S union {g}; end if; fi; od; return S; end;

 >

Stabilisateur d'un sous-ensemble

 > stabg2:=proc(G,Set,k) local S,l,g,flag; S:={[]}; for g in elements(G) do  if g<>[] then  l:=convert(g,'permlist',k); flag:=true; for s in Set do  if not (op(s,l) in Set)  then flag:=false; fi; od; if flag=true then S:=S union {g}; end if; fi; od; return S; end;

 >

Warning, `s` is implicitly declared local to procedure `stabg2`

 > undebug(stabg);S:=permgroup(5,{[[1,2]],[[3,4]],[[1,3,5]]});grouporder(S);

 >

 > stabg(S,4,5);nops(stabg(S,4,5)); OrbitG(S,{4},5);

 > undebug(stabg2);stabg2(S,{3,4},5);nops(stabg2(S,{3,4},5)); undebug(OrbitG);OrbitG(S,{3,4},5);

 > Sn:=permgroup(5,{seq([[i,i+1]], i=1..4)});Sstab:=stabg(Sn,1,5);nops(Sstab);nops(elements(permgroup(5,Sstab)));

Générer le groupe Sn pour différents n

 > Sn:=permgroup(5,{seq([[i,i+1]], i=1..4)});

 > U:= permgroup(5, {[ ]});grouporder(Sn);cosets(Sn,U):elements(Sn):

 > OrbitG(Sn,{1},5);

 > SnPrime:=permgroup(5,{seq([[i,i+1]], i=1..3)});

 > cosets(Sn,SnPrime);

 > orbit(Sn,5);

 > orbit(SnPrime,5);

 > map([[1,2]],{3});

 >

Définir un groupe par générateurs et relations

 >

Le groupe cyclique d'ordre 4

 > C4:=grelgroup({a},{[a,a,a,a]}); grouporder(C4);

 > U:=subgrel({e=[]},C4);

 > CC4:=cosets(U);

 >

 >

Le groupe dihedral Dn, groupe de symétries d'un régulier polygone à n cotés noté 1,...,n. Généré par la rotation d'angle 2*pi/n et la symétrie axiale d'axe passant par le sommet 1 et le centre du polygone (associe chaque i à n +2 - i mod n). Pour D4, on a :

 > D4:=grelgroup({a,b,1/a,1/b},{[a,1/a],[b,1/b],[a,a,a,a],[b,b],[b,a,1/b,1/a]});

 > U:=subgrel({e=[]},D4); cosets(U);

 >

On obtient une liste des éléments du groupe mais peu de chose sont prévues pour, par exemple, faire des manipulations simples sur ces groupes comme : multiplier deux éléments ou déterminer si deux produits sont égaux. On va procéder autrement et définir ces groupes comme sous-groupes d'un groupe de permutation Sn, ce qui est toujours possible pour un groupe d'ordre n (on peut même faire mieux parfois).

Dans le cas des groupes cycliques et dihédraux cela peut être fait facilement.

Remarquer que le générateur a de C4 correspond à une rotation de pi/2 des sommets d'un carré et donc à la permutation : [1,2,3,4] (pour une bonne numérotation des sommets!).

De même la symétrie axiale b de D4, correspond à la permutation de S4 : [2,4] (et laisse invariante les sommets 1 et 3).

Re-définir les groupes C4 et D4 puis donner leur table de multiplications.

 > C4:=permgroup(4,{[[1,2,3,4]]}); elements(C4);

 > D4:=permgroup(4,{[[1,2,3,4]],[[2,4]]}); elements(D4);

 > Cayley:=A->Matrix(nops(A),(i,j)->mulperms(A[i],A[j]));Cayley(elements(C4));

 > Cayley(elements(D4));

 >