Separamos este capítulo para a aplicação computacional de alguns exemplos já vistos, usando o pacote KBMAG do sistema GAP. Suas principais funções bem como a sintaxe para seu uso são exibidas e explicadas no Apêndice A, de modo a permitir a boa compreensão dos exemplos aqui expostos.
Os algoritmos usados por KBMAG são descritos de forma específica em [2].
Não estamos interessados em detalhar os procedimentos empregados pelo KBMAG ao reescrever um sistema, mas usá-lo como um recurso opcional para a obtenção de alguns resultados alcançados com o procedimento KBS.
O objetivo principal do KBMAG é encontrar formas normais para os elementos de G em função dos geradores de uma estrutura livre F. Realizar isso é precisamente estabelecer um sistema de reescrita confluente no grupo G.
Assumindo que X seja o conjunto de geradores para G e que as relações para G formem um sistema de reescrita R em relação a alguma ordenação de X±∗, concluímos que G é isomorfo como um monoide ao monoide quociente de X±∗
módulo a congruência gerada por R. Dessa forma, KBMAG emprega o algoritmo de Knuth-Bendix no sistema R e busca encontrar um sistema confluente finito que novamente será as relações para uma apresentação de G. Se isto é feito, então todo elemento de G pode ser definido por uma palavra irredutível de X±∗, isto é, todo elemento de G pode ser reescrito em sua forma normal. Como definido no Capítulo 1, representamos um grupo G por meio de uma apresentação monoidal.
Analisemos alguns exemplos.
Exemplo 4.1
Consideramos Go grupo abeliano livre dado por G=ha, b | ba=abi
73
Tomando a ordenação shortlex para o conjunto das palavras sobreX={a, b}
com a≺a−1≺b≺b−1 temos que as relações de Gformam um sistema de reescrita, o mesmo definido no exemplo 3.2. Encontrar um sistema confluente reduzido equivalente a este garante que todo elemento de Gpode ser definido por uma única palavra irredutível em X.
Apliquemos o pacote KBMAG neste exemplo. Veja o Apêndice A para maiores detalhes.
Para utilizar o pacote KBMAG é preciso que este seja carregado ao iniciar uma sessão com o GAP , a menos que o KBMAG esteja listado em GAPInfocomo um dos pacotes para carregamento automático. Para carregá-lo deve ser feita uma chamada aLoadPackage("kbmag"). O GAP retorna "true"caso o pacote tenha sido corretamente carregado.
gap> LoadPackage("kbmag");
Loading kbmag 1.5 (Knuth-Bendix on Monoids and Automatic Groups) by Derek Holt (http://www.warwick.ac.uk/~mareg).
Homepage: http://www.warwick.ac.uk/~mareg/kbmag true
Feito isso, começamos a definir as estruturas de que precisamos. A primeira dessas é um grupo livre em dois geradores, atribuindo um identificador a cada elemento.
gap> F:= FreeGroup("a", "b");
<free group on the generators [ a, b ]>
gap> a:=F.1;
a
gap> b:=F.2;
b
Agora definimos o grupo Gcomo um quociente do grupo livre considerado.
Cada relação deve ser colocada como um relator, isto é, como uma palavra definindo a identidade.
gap> G:=F/[ b*a*b^-1*a^-1];
<fp group on the generators [ a, b ]>
Agora usamos o comando KBMAGRewritingSystem(G)para que o GAP retorne um sistema de reescrita formado pelas relações de G. Entretanto, o modo como GAP imprime este sistema não corresponde necessariamente como ele é arquivado internamente.
gap> R:=KBMAGRewritingSystem(G);
74
rec(
isRWS := true, silent := true,
generatorOrder := [_g1,_g2,_g3,_g4], inverses := [_g2,_g1,_g4,_g3],
ordering := "shortlex", equations := [
[_g3*_g1,_g1*_g3]
] )
Os geradores monoidais denotados por g1, g2, g3 e g4 são de uso interno e correspondem aos geradores a, a−1, b e b−1 de G. O próximo comando retorna verdadeiro caso um sistema confluente seja encontrado através do Knuth-Bendix. Se esse for o caso, podemos pedir para que nos seja retornado o sistema confluente.
gap> KnuthBendix(R);
true gap> R;
rec(
isRWS := true, isConfluent := true,
silent :=true,
generatorOrder := [_g1,_g2,_g3,_g4], inverses := [_g2,_g1,_g4,_g3],
ordering := "shortlex", equations := [
[_g1*_g2,IdWord], [_g2*_g1,IdWord], [_g3*_g4,IdWord], [_g4*_g3,IdWord], [_g3*_g1,_g1*_g3], [_g4*_g1,_g1*_g4], [_g3*_g2,_g2*_g3], [_g4*_g2,_g2*_g4]
] )
Agora podemos construir uma função que retorne o sistema confluente em função dos geradores de F dados no início.
75
gap> RelatorsOfRWS:= function(R)
>local ru, rel, x;
> ru:= Rules(R);
>rel:= [];
> for x in ru do
> Add(rel, InternalWordToExternalWordOfRewritingSystem(R, x[1])/
InternalWordToExternalWordOfRewritingSystem(R, x[2]));
> od;
return rel;
end;
onde InternalWordToExternalWordOfRewritingSystem(R, w) é usado para conver-ter a palavra w dada nos geradores internos gi em função dos geradores do grupo livre. Agora aplicando esta função em R obtemos
gap> RelatorsOfRWS(R);
[<identity...>,<identity...>,<identity...>, <identity...>,
b*a*b^-1*a^-1, b^-1*a*b*a^-1, b*a^-1*b^-1*a, b^-1*a^-1*b*a ]
que é precisamente o sistema que obtemos no exemplo 3.2. Note que <identity...>
é uma das relações triviais. Essas novas relações ainda definem o grupo G, pois a Proposição3.1 mostra que a congruência gerada pelo sistema confluente é a mesma gerada pelo sistema não confluente.
Agora, como discutido no Exemplo 3.3, podemos tomar G conside-rando seus geradores livres em uma ordem diferente. Por exemplo, com a≺b ≺ b−1 ≺ a−1, onde ≺ ainda é a ordenação shortlex, notamos que KBS não ter-mina sua execução. Também o pacote KBMAG não encontra um sistema con-fluente reduzido. Para que possamos reordenar os geradores usamos a função ReorderAlphabetOfKBMAGRewritingSystem(R,p), onde p é uma permutação dos índices dos geradores monoidais que indica qual a nova ordem desejada. Dessa forma, considerando a nova ordem nos geradores temos
gap> F:= FreeGroup("a", "b");
<free group on the generators [ a, b ]>
gap> a:=F.1;; b:=F.2;;
gap> G:=F/[ b*a*b^-1*a^-1];
<fp group on the generators [ a, b ]>
gap> R:=KBMAGRewritingSystem(G);
rec(
isRWS :=true, silent := true,
76
generatorOrder := [_g1,_g2,_g3,_g4], inverses := [_g2,_g1,_g4,_g3],
ordering := "shortlex", equations := [
[_g3*_g1,_g1*_g3]
] )
gap> ReorderAlphabetOfKBMAGRewritingSystem(R, (2,4,3));
# (2,4,3) indica que g_2 ocupa a posição de g_4 que deve ocupar a
#posição de g_3 e este a de g_2.
gap> R;
rec(
isRWS := true, silent := true,
generatorOrder := [_g1,_g3,_g4,_g2], inverses := [_g2,_g4,_g3,_g1],
ordering := "shortlex", equations := [
[_g3*_g1,_g1*_g3]
] )
gap>SetInfoLevel(InfoRWS,1);
gap> KnuthBendix(R);
#I Calling external Knuth-Bendix program
Podemos usar outro nível de diagnóstico para a variável INFO e verificar algumas das leis encontradas na tentativa de encontrar um sistema confluente. No entanto, a execução não termina. ( Isso por si só, claro, não garante que o sistema não seja confluente. O GAP em algum momento poderia encontrar um sistema confluente depois de muito tempo, mas vimos no capítulo anterior que de fato o sistema confluente não é finito).
Exemplo 4.2
Consideremos agora a seguinte apresentação para A4. A4=Da, b | a2, b3, (ab)3E
As relações para este grupo são as leis dadas no Exemplo 3.4, que formam um sistema de reescrita em relação à ordenação shortlex com a≺b≺b−1. Podemos obter seu sistema confluente reduzido usando o KBMAG.
77
[ a^2, <identity ...>, <identity ...>, b^3, b^-1*a*(b^-1*a^-1)^2, b^-3,
78
b*a*(b*a^-1)^2, b^-1*(a*b)^2*a^-1*b^-1, a*b*a*b^-2*a^-1*b, b*(a*b^-1)^2*a^-1*b, a*b^-1*a*b^2*a^-1*b^-1 ]
que podem ser verificadas serem as mesmas encontradas antes.
A função Size(R) nos fornece o número de palavras irredutíveis no sistema de reescrita confluente R. Uma vez que o sistema é confluente, este número coincide com a ordem do grupo definido pelo sistema R. A função EnumerateReducedWords(R,a,b) lista todas as palavras irredutíveis de tamanhos entre os inteiros positivos a eb. Usando estas funções no último exemplo temos gap> Size(R);
12
gap> Size(G);
12
gap> EnumerateReducedWords(R,0,4);
[ <identity ...>, a, a*b, a*b*a, a*b^-1, a*b^-1*a, b, b*a, b*a*b^-1, b^-1, b^-1*a, b^-1*a*b ]
Esta última lista consiste de todos os elementos de A4. Exemplo 4.3
Considere G o grupo dado pela seguinte apresentação G=ha, b, c | ca=ac, cb=bc, ba=abci
As relações paraGformam um sistema de reescrita em relação à ordenação do produto wreath básico, considerando c≺c−1 ≺b ≺b−1 ≺a ≺a−1, conforme discutido no Exemplo 3.5.
Para executar as funções do pacote KBMAG neste exemplo, devemos mudar a ordenação padrão shortlex para o produto wreath. Isso é feito executando a função SetOrderingOfKBMAGRewritingSystem(R, "wreathprod", [lista] ), onde [lista]
é uma lista de inteiros que corresponde aos novos pesos dados aos geradores.
gap> F:=FreeGroup("a", "b", "c");; a:=F.1;; b:=F.2;; c:=F.3;;
gap> G:=F/[ c^-1*c, c*a*c^-1*a^-1, c*b*c^-1*b^-1, b*a*c^-1*b^-1*a^-1];
<fp group on the generators [ a, b, c ]>
gap> R:=KBMAGRewritingSystem(G);;
gap> SetOrderingOfKBMAGRewritingSystem(R, "wreathprod", [5,6,3,4,1,2]);
gap> R;
rec(
isRWS := true,
79
80
[_g6*_g1,_g1*_g6], [_g5*_g4,_g4*_g5], [_g6*_g3,_g3*_g6], [_g4*_g1,_g1*_g4*_g6], [_g6*_g2,_g2*_g6], [_g6*_g4,_g4*_g6], [_g3*_g2,_g2*_g3*_g6], [_g4*_g2,_g2*_g4*_g5]
] )
gap> Size(R);
infinity
gap> RelatorsOfRWS(R);
[ <identity ...>, <identity ...>, <identity ...>, <identity ...>,
<identity ...>, <identity ...>, c*a*c^-1*a^-1, c*b*c^-1*b^-1,
b*a*c^-1*b^-1*a^-1, c*a^-1*c^-1*a, c^-1*a*c*a^-1, c*b^-1*c^-1*b, c^-1*b*c*b^-1, b^-1*a*c*b*a^-1, c^-1*a^-1*c*a, c^-1*b^-1*c*b, b*a^-1*c*b^-1*a, b^-1*a^-1*c^-1*b*a ]
Escrevendo cada um dos relatores da lista acima como leis de reescrita com lados esquerdo maiores que os respectivos lados direito, vemos que as leis obtidas consistem das mesmas leis para o sistema confluente reduzido do Exemplo 3.5 ao executar o KBS. Esté é um exemplo menos trivial de um grupo infinito para o qual a execução do KBS termina. Em [10] há outros exemplos de grupos infinitos para os quais Knuth-Bendix processa um sistema confluente.
No próximo capítulo analisamos alguns exemplos interessantes para grupos que tenham apresentações com características especiais.