He aquí otra respuesta que presenta un giro adicional a la problema de contar collares primitivos, a saber Grupo de potencia Enumeración (tal como lo presentan Harary y Palmer y Fripertinger, en una publicación diferente), con el grupo actuando en las ranuras donde el $N$ colores se colocan siendo el grupo cíclico $C_n$ en $n$ elementos y el grupo que actúa sobre los colores es el grupo simétrico sobre $N$ elementos $S_N$ .
Esto trata el problema de contar collares primitivos donde los colores pueden intercambiarse sin que los collares resultantes se consideren diferentes.
Como en la otra respuesta tenemos la relación $$\sum_{d|n} p_d = q_n,$$ pero ahora $q_n$ se calcula mediante Enumeración de grupos de potencia . No se pero explicaremos cómo calcular $q_n$ y presentar el código Maple correspondiente. El valor deseado para primitivo collares entonces sigue por $$p_n = \sum_{d|n} \mu(n/d) q_d.$$
Podemos calcular el número $q_n$ de configuraciones por el lema de Burnside que dice promediar el número de asignaciones fijadas por los elementos del grupo de potencias, que tiene $N!\times |C_n|$ elementos y $|C_n|=n$ . Pero este número es fácil de calcular. Supongamos que tenemos una permutación $\alpha$ de $C_n$ y una permutación $\beta$ de $S_N.$ Si colocamos el número apropiado de copias completas, dirigidas y consecutivas de un ciclo de $\beta$ en un ciclo de $\alpha$ entonces esta asignación es fija bajo la acción del grupo de potencia, y esto es posible si la longitud del ciclo de $\beta$ divide la duración del ciclo de $\alpha$ y hay tantas asignaciones como la longitud de $\beta.$
Ahora el cálculo Burnside se hace mejor con un CAS, aquí está el código Maple.
with(numtheory);
pet\_cycleind\_symm :=
proc(n)
option remember;
if n=0 then return 1; fi;
expand(1/n\*add(a\[l\]\*pet\_cycleind\_symm(n-l), l=1..n));
end;
pet\_flatten\_term :=
proc(varp)
local terml, d, cf, v;
terml := \[\];
cf := varp;
for v in indets(varp) do
d := degree(varp, v);
terml := \[op(terml), seq(v, k=1..d)\];
cf := cf/v^d;
od;
\[cf, terml\];
end;
pet\_cycleind\_cyclic :=
proc(n)
1/n\*add(phi(d)\*a\[d\]^(n/d), d in divisors(n));
end;
q :=
proc(n, N)
option remember;
local idx\_colors, res, a, b,
flat\_a, flat\_b, cyc\_a, cyc\_b, len\_a, len\_b, p, q;
if n=1 then
idx\_colors := \[a\[1\]\]
else
idx\_colors := pet\_cycleind\_symm(N);
fi;
res := 0;
for a in pet\_cycleind\_cyclic(n) do
flat\_a := pet\_flatten\_term(a);
for b in idx\_colors do
flat\_b := pet\_flatten\_term(b);
p := 1;
for cyc\_a in flat\_a\[2\] do
len\_a := op(1, cyc\_a);
q := 0;
for cyc\_b in flat\_b\[2\] do
len\_b := op(1, cyc\_b);
if len\_a mod len\_b = 0 then
q := q + len\_b;
fi;
od;
p := p\*q;
od;
res := res + p\*flat\_a\[1\]\*flat\_b\[1\];
od;
od;
res;
end;
p := (n, N) -> add(mobius(n/d)\*q(d,N), d in divisors(n));
Esto da para dos colores ( $N=2$ ) la secuencia $$1, 1, 1, 2, 3, 5, 9, 16, 28, 51, 93, 170,\ldots$$ que es OEIS A000048 .
Para tres colores ( $N=3$ ) $$1, 1, 2, 4, 8, 22, 52, 140, 366, 992, 2684, 7404,\ldots$$ que es OEIS A002075 .
Por último, para cuatro colores ( $N=4$ ) $$1, 1, 2, 5, 10, 35, 102, 360, 1232, 4427, 15934, 58465,\ldots$$ que es OEIS A056300 .
Vinculación adicional. Para $N=5$ encontramos una secuencia $$1, 1, 2, 5, 11, 38, 122, 496, 2005, 8707, 38364, 173562,\ldots$$ que es OEIS A056301 .
Para $N=6$ encontramos la secuencia $$1, 1, 2, 5, 11, 39, 125, 532, 2301, 11010, 54681, 284023,\ldots$$ que es OEIS A056302 .
Para $N=7$ encontramos la secuencia $$1, 1, 2, 5, 11, 39, 126, 536, 2353, 11606, 60498, 336399,\ldots$$ que aún no figura en la OEIS.
Adenda sáb 21 abr 2018. El algoritmo que acabamos de presentar admite un mejora considerable, a saber, que no es necesario aplanar las permutaciones porque podemos calcular la contribución de los ciclos de un par $(\alpha, \beta)$ multiplicando el número de coberturas de un tipo de ciclo de $\alpha$ por el número de instancias del ciclo de $\beta$ elevando el resultado a la potencia del número de instancias del tipo de ciclo de $\alpha.$
El resultado es el siguiente código Maple.
with(numtheory);
pet\_cycleind\_symm :=
proc(n)
option remember;
if n=0 then return 1; fi;
expand(1/n\*add(a\[l\]\*pet\_cycleind\_symm(n-l), l=1..n));
end;
pet\_cycleind\_cyclic :=
proc(n)
1/n\*add(phi(d)\*a\[d\]^(n/d), d in divisors(n));
end;
q := proc(n, N)
option remember;
local idx\_slots, idx\_colors, res, term\_a, term\_b,
v\_a, v\_b, inst\_a, inst\_b, len\_a, len\_b, p, q;
if n = 1 then
idx\_slots := \[a\[1\]\];
else
idx\_slots := pet\_cycleind\_cyclic(n);
fi;
if N = 1 then
idx\_colors := \[a\[1\]\];
else
idx\_colors := pet\_cycleind\_symm(N);
fi;
res := 0;
for term\_a in idx\_slots do
for term\_b in idx\_colors do
p := 1;
for v\_a in indets(term\_a) do
len\_a := op(1, v\_a);
inst\_a := degree(term\_a, v\_a);
q := 0;
for v\_b in indets(term\_b) do
len\_b := op(1, v\_b);
inst\_b := degree(term\_b, v\_b);
if len\_a mod len\_b = 0 then
q := q + len\_b\*inst\_b;
fi;
od;
p := p\*q^inst\_a;
od;
res := res +
lcoeff(term\_a)\*lcoeff(term\_b)\*p;
od;
od;
res;
end;
p := (n, N) -> add(mobius(n/d)\*q(d,N), d in divisors(n));
0 votos
¿Los collares permutados cíclicamente se consideran el mismo collar?
0 votos
@AlexanderGruber collar binario es una clase de equivalencia de cadenas binarias bajo rotación. Si las cadenas tienen longitud n, entonces el tamaño de la clase de equivalencia es como máximo n (en realidad es un divisor de n). Llamamos primitivo al collar si el tamaño de la clase de equivalencia es lo más grande posible; es decir, el tamaño es n.