Um Tutorial sobre

Gerando Permutaes usando a Representao Fatordica de Nmeros

Prof. Joel G. Silva Filho Instituto de Educao Superior de Braslia - IESB joel-iesb@joelguilherme.com 2012-01-05

Palavras-chave: permutaes, inverses, sistemas numricos, nmeros factordicos, gerao de permutaes.

Introduo A permutao de um conjunto ordenado de n elementos um conceito bem conhecido. Quaisquer que sejam os elementos do conjunto, por simplicidade e facilidade de manipulao, podemos sempre represent-lo pelo conjunto dos n primeiros inteiros no negativos, ou, em outras palavras, os inteiros mdulo-n: Zn = {0,1,2, ,n-1}. Uma permutao sobre este conjunto simplesmente uma reordenao de seus elementos, = ((0),(1), , (n-1)), onde (i) o elemento que substitui i na i-sima posio. Por exemplo, qualquer conjunto de 4 elementos pode ser representado por Z4 = {0,1,2,3}. Podemos ter ento, por exemplo, 2 = {0,2,1,3} - explicaremos mais tarde o porque do subscrito '2', onde 2(0) = 0, 2(1) = 2, 2(2) = 1 e 2(3) = 3. Conjuntos ordenados e suas permutaes encontram extensa aplicao e interesse em muitas reas, tais como matemtica discreta, combinatria, criptografia, cincia da computao, e outras. Uma questo bsica quando estudamos permutaes saber quantas permutaes distintas de um conjunto de n elementos podemos encontrar. Considerando que todos os elementos conjunto em questo sejam distintos, a resposta fcil de encontrar: temos n possveis posies para cada elemento, havendo n escolhas para o primeiro, (n-1) para o segundo, (n-2) para o terceiro, e assim por diante, at que para a ltima posio teremos apenas uma escolha, quando todos os outros j tiverem sido escolhidos, obtendo-se N = n(n-1)(n-2) 321 possibilidades totais de escolha, o qual um nmero que recebe a representao especial n! e chamado de fatorial de n (leia-se n fatorial). O conjunto de todas estas permutaes de n elementos usualmente denotada por Sn e forma a estrutura de um Grupo sob a operao de 'composio de permutaes', i.e. a aplicao de duas ou mais permutaes sobre um dado conjunto, que constitui o Grupo de Simetria de ordem n(1). Sistemas de Numerao Estamos acostumados a representaes numricas de base simples, tal como a base 10, que nos fornece os nmeros decimais de nosso dia a dia, e a base 2, que nos fornece os nmeros binrios, estes ltimos sendo a base para todas as operaes em computadores digitais. Dada uma base genrica b, podemos representar qualquer nmero nesta base como N = dn-1bn-1+dn-2bn-2+ +d2b2+d1b1+d0b0 onde di, i = 0, .. , (n-1) - para um nmero de n dgitos - so os dgitos nesta representao numricas, cada dgito estando na faixa [0 .. (b-1)]. Para a representao na base 10 os dgitos esto na faixa [0 .. 9], e para a representao binria (base 2) os dgitos esto na faixa [0,1]. Esta representao denominada uma representao polinomial, uma vez que cada dgito pode ser visto como o coeficiente de um polinmio na base b. Alm disso, a ordem, ou posio, de cada dgito assume um valor que proporcional correspondente potncia da base, e assim esta representao tambm vista como uma representao posicional. Sistemas sobre outras bases foram desenvolvidos atravs da histria, e mesmo sistemas sem uma base e no posicionais, como o sistema de numerao romana(2). Quando vrias bases esto em considerao, se costuma utilizar um subscrito aposto ao nmero para identificar a base em que est representado. Por exemplo, o nmero decimal 123 pode ser escrito como 12310, o que deve ser interpretado como N = 12310 = 12 + 21 + 30

dando origem aos valores posicionais familiares de unidades, dezenas, centenas, e assim por diante. Este mesmo nmero pode tambm ser representado em binrio como N = 12310 = 11110112 = 16 + 15 + 14 + 13 + 02 + 11 + 10 . Nmeros Fatordicos Agora, o que um nmero fatordico? Um nmero fatordico tambm uma representao posicional para um nmero onde uma base distinta utilizada para cada dgito, mas o valor da posio no proporcional a uma potncia da base, mas sim ao seu fatorial. Sendo assim, este sistema visto como um sistema de base mista. A conjuno dos termos fatorial e base mista (em ingls) levou ao termo fatordico, embora outros termos tenham sido cunhados e utilizados na literatura(3). Qualquer nmero N < n! pode ser representado por um nmero fatordico nico de n dgitos, na forma N! = dn-1.(n-1)!+dn-2.(n-2)!+ +d2.2!+d1.1!+d0.0! o que, de forma compacta, escrevemos como N! = (dn-1dn-2 d2d1d0)!, do mesmo modo como o fazemos para um nmero em qualquer sistema ordinrio de base fixa. Observe o uso do subscrito '!' para indicar que o nmero est em notao fatordica. Deve tambm ser observado que, para um nmero fatordico: o i-simo dgito da direita para a esquerda, i = 0 .. (n-1), um dgito base-(i +1), de modo que devemos ter di i; o 1o dgito, aquele para i = 0, sempre ser zero, tal que ele no no contribui efetivamente para o valor total do nmero (e poderia mesmo ser omitido, sem perda de representao, como fazem alguns autores); o valor posicional do i-simo dgito i!. Por exemplo, um nmero que seja menor que 5! ( = 120 10 ) pode ser expresso como um nmero fatordico de 5 dgitos N! = (d4d3d2d1d0)! e, tomando como exemplo N = 8310, ento temos N! = 31210! = 34! + 13! + 22! +11! + 00! = 324 + 16 + 22 +11 + 01 = 72 + 6 +4 + 1 + 0 = 8310 De agora em diante, aonde no indicado de outra forma, utilizaremos nmeros sem subscritos para expressar nmeros decimais, de modo que escreveremos 31210! = 83.
n1

Por induo, pode-se provar que

n! =

ii ! + 1.
i=0

Como exemplo, o maior nmero

fatordico de 5 dgitos (n = 5) 43210!, o qual tem como prximo valor (43210!+1) = 100000!. Em outras palavras, 4 4!+3 !+2 !+1 !+! = 119 e, 5! =120 = 119+1. Isto estabelece que, realmente, qualquer inteiro no negativo tem uma representao nica como um nmero fatordico. A converso de um nmero decimal em sua representao fatordica pode ser feita pelo mtodo direto de divises sucessivas pelo valor posicional de cada dgito, iniciando pelo posio de maior ordem, i = n-1, tomando-se os quocientes como os correspondentes dgitos fatordicos. O resto de cada diviso ento dividido pelo prximo valor posicional, e assim por diante. Considerando o exemplo anterior poderamos ter computado

83 = 324 + 11 11 = 1 + 5 5 = 2 + 1 1 = 1 + 0 0 = 0 + 0 Inverses Considere um conjunto de n = 5 elementos, representado por Z5 = {0,1,2,3,4}, e vamos denominar os elementos do conjunto como pi, para i = 0 .. (n-1). Uma possvel permutao deste conjunto 0 = (0,1,2,3,4), que representa a permutao identidade, uma vez que a ordem original dos elementos no foi alterada. Uma outra permutao poderia ser 83 = (3,1,4,2,0) - como mencionado antes, vamos esclarecer o uso destes subscritos posteriormente. Diz-se que uma inverso ocorreu na posio i, para qualquer dada permutao, quando pi > pj, para algum j > i. Em 83, para i = 0 ns temos 3 inverses, uma vez que 4 > 2, 3 e 1. Da mesma forma, para i = 1 temos 1 inverso, para i = 2 temos 2 inverses, para i = 3 temos 1 inverso, e para i = 4 temos 0 inverses. Ns sempre teremos 0 inverses para i = (n-1) uma vez que este o ltimo elemento. Se colocarmos estas contagens de inverses na forma de um vetor teremos o que denominado de vetor de inverses da permutao, ou tabela de inverses, ou ainda o cdigo de Lehmer (4,5), L. Para o caso geral podemos escrever L() = [l0(), l1(), , ln-1()], onde li() = |{j > i: (i) > (j)}|. Pode ser mostrado que toda permutao tem um cdigo de Lehmer nico associado, existindo assim uma correspondncia biunvoca entre cdigos de Lehmer e permutaes(3). Retornando ao nosso exemplo anterior, verificamos que L83 = [3,1,2,1,0]. Agora, a beleza dessa construo: 83 = 31210!, o que nos mostra que podemos associar cada nmero fatordico distinto de n dgitos com cada permutao pertencente a Sn. Isto finalmente justifica o uso dos subscritos para identificar as permutaes exemplificadas anteriormente e nos d uma forma muito simples de enumerar todas as permutaes em Sn com um simples ndice decimal que conta de 0 a (n! - 1). Outro importante resultado desta ordenao das permutaes como nmeros fatordicos que a sequncia das mesmas corresponde ordenao natural, ou lexicogrfica. Como mais um pequeno exemplo, tomemos n = 3 e vamos construir uma tabela associando todos os 6 elementos de S3 aos seus correspondentes ndices, tanto em decimal quanto na representao fatordica, como mostrado na tabela 1 abaixo:
Tabela 1: permutaes e ndices associados para n = 3.

N 0 1 2 3 4 5

N! (0,0,0) (0,1,0) (1,0,0) (1,1,0) (2,0,0) (2,1,0)

N (0,1,2) (0,2,1) (1,0,2) (1,2,0) (2,0,1) (2,1,0)

De Permutaes para Nmeros Fatordicos e Vice-versa Mostramos como representar uma dada permutao como um nmero fatordico, simplesmente construindo-se seu vetor de inverses. Agora resta apenas mostrarmos como determinar a permutao particular associada a um dado nmero fatordico ou a seu decimal equivalente. existem muitas e muitas formas de se gerar permutaes, incluindo gerao sequencial e gerao aleatria. O ponto importante em relao gerao via o nmero fatordico associado a possibilidade de gerar qualquer permutao sem se ter que passar por processos intermedirios, assim como, dada uma permutao, se obter facilmente um ndice para a mesma, considerando um ordenamento lexicogrfico dos elementos de Sn. Para obter a permutao de n elementos a partir de seu correspondente valor fatordico, ou equivalentemente, seu cdigo de Lehmer, ou vetor de inverses, apenas uma questo de trafegarmos ao contrrio em relao construo anterior. Considere o caso de n = 5, tal que o conjunto original possa ser considerado como S = 0 = {0,1,2,3,4}. Vamos supor que queremos determinar quem 51. Considerando que N = 51 = 20110!, ento podemos escrever L(51) = [l0, l1, l2, l3, l4] = [2,0,1,1,0]. Iniciando com i = 0, observamos que l0 = 2 corresponde contagem de inverses para aquela posio. Assim, para determinarmos o correspondente elemento em 0 simplesmente o que temos que fazer buscar o elemento do conjunto original que maior que 2 outros elementos, o que, por sua vez, se mostra ser o elemento de ordem 2 em 0, ou ainda, 51(0) = 0(l0) = 0(2) = 2. Agora ns removemos este elemento, 2, do conjunto original (j foi utilizado em 51), obtendo 0' = {0,1,3,4}. Considere agora o prximo elemento de L, l1 = 0. O mesmo processo agora se aplica a 0', fornecendo 51(1) = 0'(l1) = 0'(0) = 0, e assim sucessivamente, at obtermos todos os elementos da permutao desejada. Na tabela 2 que se segue est melhor ilustrado este processo de construo de 51:
Tabela 2: Construindo a permutao 51 (n=5) a partir de seu cdigo de Lehmer.

i 0 1 2 3 4

li 2 0 1 1 0

Lehmer Code [2,0,1,1,0] [2,0,1,1,0] [2,0,1,1,0] [2,0,1,1,0] [2,0,1,1,0]

Set S (0) (0,1,2,3,4) (0,1,3,4,_) (1,3,4,_,_) (1,4,_,_,_) (1,_,_,_,_)

Perm 51 (2,_,_,_,_) (2,0,_,_,_) (2,0,3,_,_) (2,0,3,4,_) (2,0,3,4,1)

Observe que ln-1 sendo sempre zero, ele corresponde a qualquer que seja o ltimo elemento restante em 0' no ltimo passo do processo. Gerando uma permutao Dada o ordem n e um ndice decimal N < (n-1)! podemos gerar a permutao correspondente atravs deste simples algoritmo, em pseudo linguagem:
1. Define variables: N,n: int; // Decimal integer and order of the set i,j,r,v: int; // indexes to arrays S: array[0..n-1]; // original set Perm: array[0..n-1]; // permuted set PlaceValue: array[0..n-1]; // fatoradic place values [0!,1!,2!,..,(n-1)!] Factoradic:array[0..n-1]; // fatoradic digits corresponding to N 2. Initialize variables 2.1 read n,N 2.2 for i from 0 to (n-1) do S[i] = I PlaceValue[i] = i! enddo

3. Convert N to factoradic 3.1 V = N 3.2 for i from (n-1) downto 0 do Factoradic[i] = V div PlaceValue[i] V = V mod PlaceValue[i] enddo 4. Convert Factoradic to permutao for i from 0 to (n-1) do j = (n-1)-i r = Factoradic[j] Perm[i] = S[r] // delete S[r] by shifting left greater order elements for j from r to (n-2) do S[j] = S[j+1] enddo END

Uma implementao de demonstrao em FreePascal deste algoritmo mostrada abaixo, junto com sua sada para n = 5 e N = 51, como feito no exemplo mostrado:
program Dec2Perm; (* Program for generating a permutao of a set of n elements from a given Decimal index, based on the representation of a permutao as a "factoradic number", i.e. a number represented in the mixed base [(n-1)!,(n-2)!,...,2!, 1!, 0!]. We have limited 'n' to 12, as this is just a demo program and 12! fits into a 32-bit CPU word. *) uses SysUtils; const progname = 'Dec2Perm'; version = 'v0.9 - 12.01.03'; author = ' (Joel Guilherme)'; nmax = 12; type aset = array[0..(nmax-1)] of byte; // a set of integers mod-n bset = array[0..(nmax-1)] of longword; // a set of integers var n: byte; D,V: longword; Dmax: longword; i,j,r: byte; Code: word; // // // // // the order of the set decimal to be converted to a permutao maximum value for D indexes to arrays indicates input conversion error this will hold the original, ordered permutao (0,1,2,...,n-1) the permutao associated to N array with fatoradic place values [0!,1!,2!,..,(n-1)!] array with a fatoradic number digits corresponding to N

S: aset; // Perm: aset; // PlaceValue: bset; // Factoradic: bset; //

procedure ShowSet(msg: string; span: byte; var Arr: aset); // writes a set to console var r,m: byte; begin m := span-1; write(msg); for r := 0 to m do begin if (r = 0) then write('[',Arr[r]) else write(',',Arr[r]); end; writeln(']'); end; { ShowSet } procedure ShowFac(msg: string; span: byte; var Arr: bset); // writes a factoradic array to console var r,m: byte; begin m := span-1; write(msg);

for r := m downto 0 do begin if (r = m) then write('[',Arr[r]) else write(',',Arr[r]); end; writeln(']'); end; { ShowFac } function factorial(x: longword): longword; begin if (x=0) or (x=1) then factorial := 1 else factorial := x*factorial(x-1); end; procedure Help; // Shows a "help" message if wrong parameters passed begin writeln('usage:'); writeln(' > nextperm <N> <n>'); writeln(' where'); writeln(' - N is a decimal index to a lexicographically permuted set'); writeln(' - n is the order of the set to be permuted'); writeln; halt(1); end; procedure Error(msg: string); begin writeln(msg,'! Aborting!'); halt(1); end; procedure Initialize; // initialize arrays and variables begin Dmax := factorial(n); for i := 0 to (n-1) do begin S[i] := i; PlaceValue[i] := factorial(i); end; end; { Main Program } begin writeln; writeln(Progname,' ',version); writeln('Program for generating a lexicographically ordered '); writeln('permutao from a given decimal index. - ',author); writeln; if paramcount < 2 then Help; val(paramstr(1),D,Code); if Code > 0 then Error('Error reading input N'); val(paramstr(2),n,Code); if Code > 0 then Error('Error reading input n'); if n > nmax then Error('Given order ''n'' is too big. Maximum is 12'); Initialize; if D > Dmax then Error('Given decimal ''N'' is too big. Maximu is (n! - 1)'); // Convert N to Factoradic V := D; for i := (n-1) downto 0 do begin Factoradic[i] := V div Placevalue[i]; V := V mod Placevalue[i]; end; writeln('For n = ',n,':'); ShowSet('Perm(0) = ',n,S); ShowFac('Factoradic('+inttostr(D)+') = ',n,Factoradic); // Convert Factoradic to permutao for i := 0 to (n-1) do begin j := (n-1) - i; r := Factoradic[j]; Perm[i] := S[r]; // delete S[r] from S (by shifting left all greater order elements) for j := r to (n-2) do S[j] := S[j+1]; end; ShowSet('Perm('+inttostr(D)+') = ',n,Perm); writeln; end.

O programa foi compilado com FreePascal 2.4.0 para o Linux-Ubuntu 10.04. Uma sada de amostra para o programa :
$ ./Dec2Perm 51 5 Dec2Perm v0.9a - 12.01.03 Program for generating a lexicographically ordered permutation from a given decimal index. - (Joel Guilherme) For n = 5: Perm(0) = [0,1,2,3,4] Factoradic(51) = [2,0,1,1,0] Perm(51) = [2,0,3,4,1]

Bibliografia (1) Symmetric group, http://en.wikipedia.org/wiki/Symmetric_group - acessado em 11/12/2011. (2) Positional notation, http://en.wikipedia.org/wiki/Positional_notation - acessado em 11/12/2011. (3) Factorial number system, http://en.wikipedia.org/wiki/Factorial_number_system - acessado em 11/12/2011. (4) permutao, http://en.wikipedia.org/wiki/permutao - acessado em 11/12/2011. (5) Enumerating permutation using inversion vectors and factoradic numbering, http://lin-ear-thinking.blogspot.com/2012/11/enumerating-permutaos-using.html - . acessado em 11/12/2011.