C
Introdução
Como comentado por David Carraher, a maneira mais simples de analisar o lado a lado do hexágono parecia ser tirar proveito de seu isomorfismo com o Diagrama Jovem tridimensional, essencialmente um quadrado x, y preenchido com barras de altura inteiras cujas alturas z devem permanecer iguais ou aumentar à medida que o eixo z é aproximado.
Comecei com um algoritmo para encontrar os totais que são mais passíveis de adaptação para contagem de simetria do que o algoritmo publicado, que é baseado em um viés para um dos três eixos cartesianos.
Algoritmo
Começo preenchendo as células dos planos x, ye z com 1's, enquanto o restante da área contém zeros. Feito isso, construo o padrão camada por camada, com cada camada contendo as células que têm uma distância de Manhattan em 3D comum da origem. Uma célula pode conter apenas 1 se as três células abaixo também contiverem um 1. Se alguma delas contiver 0, a célula deverá ser 0.
A vantagem de construir o padrão dessa maneira é que cada camada é simétrica em relação à linha x = y = z. Isso significa que cada camada pode ser verificada independentemente para simetria.
Verificação de simetria
As simetrias do sólido são as seguintes: rotação de 3 vezes em torno da linha x = y = z -> rotação de 3 vezes em torno do centro do hexágono; e 3 x reflexões sobre os 3 planos que contêm a linha x = y = z e cada um dos eixos x, y, z -> reflexão sobre as linhas através dos cantos do hexágono.
Isso adiciona apenas 6 vezes a simetria. Para obter a simetria completa do hexágono, outro tipo de simetria deve ser considerado. Cada sólido (construído a partir de 1s) possui um sólido complementar (construído a partir de 0s). Onde N é ímpar, o sólido complementar deve ser diferente do sólido original (porque não é possível que eles tenham o mesmo número de cubos). No entanto, quando o sólido complementar é girado em volta, verifica-se que sua representação 2D como um diamante é idêntica (exceto para uma operação de simetria 2 vezes) ao sólido original. Onde N é par, é possível que o sólido seja auto-inverso.
Isso pode ser visto nos exemplos de N = 2 na pergunta. Se visto da esquerda, o primeiro hexágono parece um cubo sólido com 8 cubos pequenos, enquanto o último hexágono parece uma concha vazia com 0 cubos pequenos. Se visto da direita, o inverso é verdadeiro. O 3º, 4º e 5º hexágonos e os 16º, 17º e 18º hexágonos parecem conter 2 ou 6 cubos e, portanto, se complementam em 3 dimensões. Eles estão relacionados entre si em duas dimensões por uma operação de simetria de duas vezes (rotação de duas vezes ou reflexão sobre um eixo através das bordas do hexágono). Por outro lado, os hexágonos 9, 10, 11 e 12 mostram padrões 3D que são seus próprios complementos e, portanto, têm uma simetria mais alta (esses são, portanto, os únicos padrões com multiplicidade ímpar).
Observe que ter (N ^ 3) / 2 cubos é uma condição necessária para o auto-complemento, mas, em geral, não é uma condição suficiente se N> 2. O resultado de tudo isso é que, para N ímpar, as inclinações sempre ocorrem em pares (N ^ 3) / 2 cubos devem ser cuidadosamente inspecionados.
Código atual (gera o total correto para N = 1,2,3,5. Erro conforme discutido para N = 4).
int n; //side length
char t[11][11][11]; //grid sized for N up to 10
int q[29][192], r[29]; //tables of coordinates for up to 10*3-2=28 layers
int c[9]; //counts arrangements found by symmetry class. c[8] contains total.
//recursive layer counting function. m= manhattan distance, e= number of cells in previous layers, s=symmetry class.
void f(int m,int e,int s){
int u[64], v[64], w[64]; //shortlists for x,y,z coordinates of cells in this layer
int j=0;
int x,y,z;
for (int i=r[m]*3; i; i-=3){
// get a set of coordinates for a cell in the current layer.
x=q[m][i-3]; y= q[m][i-2]; z= q[m][i-1];
// if the three cells in the previous layer are filled, add it to the shortlist u[],v[],w[]. j indicates the length of the shortlist.
if (t[x][y][z-1] && t[x][y-1][z] && t[x-1][y][z]) u[j]=x, v[j]=y, w[j++]=z ;
}
// there are 1<<j possible arrangements for this layer.
for (int i = 1 << j; i--;) {
int d = 0;
// for each value of i, set the 1's bits of t[] to the 1's bits of i. Count the number of 1's into d as we go.
for (int k = j; k--;) d+=(t[u[k]][v[k]][w[k]]=(i>>k)&1);
// we have no interest in i=0 as it is the empty layer and therefore the same as the previous recursion step.
// Still we loop through it to ensure t[] is properly cleared.
if(i>0){
int s1=s; //local copy of symmetry class. 1's bit for 3 fold rotation, 2's bit for reflection in y axis.
int sc=0; //symmetry of self-complement.
//if previous layers were symmetrical, test if the symmetry has been reduced by the current layer
if (s1) for (int k = j; k--;) s1 &= (t[u[k]][v[k]][w[k]]==t[w[k]][u[k]][v[k]]) | (t[u[k]][v[k]][w[k]]==t[w[k]][v[k]][u[k]])<<1;
//if exactly half the cells are filled, test for self complement
if ((e+d)*2==n*n*n){
sc=1;
for(int A=1; A<=(n>>1); A++)for(int B=1; B<=n; B++)for(int C=1; C<=n; C++) sc&=t[A][B][C]^t[n+1-A][n+1-B][n+1-C];
}
//increment counters for total and for symmetry class.
c[8]++; c[s1+(sc<<2)]++;
//uncomment for graphic display of each block stacking with metadata. not recommended for n>3.
//printf("m=%d j=%d i=%d c1=%d-2*%d=%d c3=%d cy=%d(cs=%d) c3v=%d ctot=%d\n",m,j,i,c[0],c[2],c[0]-2*c[2],c[1],c[2],c[2]*3,c[3],c[8]);
//printf("m=%d j=%d i=%d C1=%d-2*%d=%d C3=%d CY=%d(CS=%d) C3V=%d ctot=%d\n",m,j,i,c[4],c[6],c[4]-2*c[6],c[5],c[6],c[6]*3,c[7],c[8]);
//for (int A = 0; A<4; A++, puts(""))for (int B = 0; B<4; B++, printf(" "))for (int C = 0; C<4; C++) printf("%c",34+t[A][B][C]);
//recurse to next level.
if(m<n*3-2)f(m + 1,e+d,s1);
}
}
}
main()
{
scanf("%d",&n);
int x,y,z;
// Fill x,y and z planes of t[] with 1's
for (int a=0; a<9; a++) for (int b=0; b<9; b++) t[a][b][0]= t[0][a][b]= t[b][0][a]= 1;
// Build table of coordinates for each manhattan layer
for (int m=1; m < n*3-1; m++){
printf("m=%d : ",m);
int j=0;
for (x = 1; x <= n; x++) for (y = 1; y <= n; y++) {
z=m+2-x-y;
if (z>0 && z <= n) q[m][j++] = x, q[m][j++] = y, q[m][j++]=z, printf(" %d%d%d ",x,y,z);
r[m]=j/3;
}
printf(" : r=%d\n",r[m]);
}
// Set count to 1 representing the empty box (symmetry c3v)
c[8]=1; c[3]=1;
// Start searching at f=1, with 0 cells occupied and symmetry 3=c3v
f(1,0,3);
// c[2 and 6] only contain reflections in y axis, therefore must be multiplied by 3.
// Similarly the reflections in x and z axis must be subtracted from c[0] and c[4].
c[0]-=c[2]*2; c[2]*=3;
c[4]-=c[6]*2; c[6]*=3;
int cr[9];cr[8]=0;
printf("non self-complement self-complement\n");
printf("c1 %9d/12=%9d C1 %9d/6=%9d\n", c[0], cr[0]=c[0]/12, c[4], cr[4]=c[4]/6);
if(cr[0]*12!=c[0])puts("c1 division error");if(cr[4]*6!=c[4])puts("C1 division error");
printf("c3 %9d/4 =%9d C3 %9d/2=%9d\n", c[1], cr[1]=c[1]/4, c[5], cr[5]=c[5]/2);
if(cr[1]*4!=c[1])puts("c3 division error");if(cr[5]*2!=c[5])puts("C3 division error");
printf("cs %9d/6 =%9d CS %9d/3=%9d\n", c[2], cr[2]=c[2]/6, c[6], cr[6]=c[6]/3);
if(cr[2]*6!=c[2])puts("cs division error");if(cr[6]*3!=c[6])puts("CS division error");
printf("c3v %9d/2 =%9d C3V %9d/1=%9d\n", c[3], cr[3]=c[3]/2, c[7], cr[7]=c[7]);
if(cr[3]*2!=c[3])puts("c3v division error");
for(int i=8;i--;)cr[8]+=cr[i];
printf("total =%d unique =%d",c[8],cr[8]);
}
Resultado
O programa gera uma tabela de saída com 8 entradas, de acordo com as 8 simetrias do sólido. O sólido pode ter qualquer uma das 4 simetrias da seguinte forma (notação Schoenflies)
c1: no symmetry
c3: 3-fold axis of rotation (produces 3-fold axis of rotation in hexagon tiling)
cs: plane of reflection (produces line of reflection in hexagon tiling)
c3v both of the above (produces 3-fold axis of rotation and three lines of reflection through the hexagon corners)
Além disso, quando o sólido possui exatamente metade das células com 1 e metade com 0, existe a possibilidade de inverter todos os 1 e 0, invertendo as coordenadas pelo centro do espaço do cubo. Isso é o que estou chamando de auto-complemento, mas um termo mais matemático seria "antissimétrico em relação a um centro de inversão".
Esta operação de simetria fornece um eixo de rotação 2 vezes no ladrilho hexagonal.
Os padrões que possuem essa simetria são listados em uma coluna separada. Eles ocorrem apenas onde N é par.
Minha contagem parece estar um pouco baixa para N = 4. Em discussão com Peter Taylor, parece que não estou detectando inclinações que têm apenas uma simetria de uma linha através das arestas do hexágono. Provavelmente, isso é porque eu não testei o auto-complemento (anti-simetria) para operações além de (inversão) x (identidade.) Teste de auto-complemento para as operações (inversão) x (reflexão) e (inversão) x (rotação de três vezes ) pode descobrir as simetrias ausentes. Eu esperaria que a primeira linha dos dados para N = 4 se parecesse com esta (16 menos em c1 e 32 mais em C1):
c1 224064/12=18672 C1 534/6=89
Isso alinharia os totais com a resposta de Peter e https://oeis.org/A066931/a066931.txt
saída atual é a seguinte.
N=1
non self-complement self-complement
c1 0/12= 0 C1 0/6= 0
c3 0/4 = 0 C3 0/2= 0
cs 0/6 = 0 CS 0/3= 0
c3v 2/2 = 1 C3V 0/1= 0
total =2 unique =1
non self-complement self-complement
N=2
c1 0/12= 0 C1 0/6= 0
c3 0/4 = 0 C3 0/2= 0
cs 12/6 = 2 CS 3/3= 1
c3v 4/2 = 2 C3V 1/1= 1
total =20 unique =6
N=3
non self-complement self-complement
c1 672/12=56 C1 0/6= 0
c3 4/4 = 1 C3 0/2= 0
cs 288/6 =48 CS 0/3= 0
c3v 16/2 = 8 C3V 0/1= 0
total =980 unique =113
N=4 (errors as discussed)
non self-complement self-complement
c1 224256/12=18688 C1 342/6=57
c3 64/4 =16 C3 2/2= 1
cs 8064/6 =1344 CS 54/3=18
c3v 64/2 =32 C3V 2/1= 2
total =232848 unique =20158
N=5
non self-complement self-complement
c1 266774112/12=22231176 C1 0/6= 0
c3 1100/4 =275 C3 0/2= 0
cs 451968/6 =75328 CS 0/3= 0
c3v 352/2 =176 C3V 0/1= 0
total =267227532 unique =22306955
Lista de tarefas (atualizada)
Arrume o código atual.
Feito, mais ou menos
Implemente a verificação de simetria para a camada atual e passe um parâmetro para a simetria da camada anterior (não faz sentido verificar se a última camada era assimétrica).
Concluído, os resultados para N ímpares concordam com os dados publicados
Adicione uma opção para suprimir a contagem de figuras assimétricas (deve correr muito mais rápido)
Isso pode ser feito adicionando outra condição à chamada de recursão: if(s1 && m<n*3-2)f(m + 1,e+d,s1)reduz o tempo de execução para N = 5 de 5 minutos para cerca de um segundo. Como resultado, a primeira linha da saída se torna lixo total (assim como os totais totais), mas se o total já for conhecido da OEIS, o número de inclinações assimétricas pode ser reconstituído, pelo menos para N. ímpar.
Mas, mesmo para N, o número de sólidos assimétricos (de acordo com as simetrias c3v) que são autocomplemento seria perdido. Nesse caso, um programa separado dedicado a sólidos com exatamente (N ** 3) / 2 células com 1 pode ser útil. Com isso disponível (e contando corretamente), pode ser possível tentar N = 6, mas levará muito tempo para ser executado.
Implemente a contagem de células para reduzir a pesquisa em até (N ^ 3) / 2 cubos.
Não feito, a economia deve ser marginal
Implemente a verificação de simetria (sólido complementar) para padrões contendo exatamente (N ^ 3) / 2 cubos.
Feito, mas parece ter omissões, veja N = 4.
Encontre uma maneira de escolher a figura lexicamente mais baixa de uma assimétrica.
Não se espera que a economia seja tão boa. A supressão de números assimétricos elimina a maior parte disso. A única reflexão que é verificada é o plano através do eixo y (x e z são calculados posteriormente multiplicando por 3.) Figuras com apenas simetria rotacional são contadas em ambas as suas formas enantioméricas. Talvez fosse quase duas vezes mais rápido se apenas um fosse contado.
Para facilitar isso, possivelmente melhore a maneira como as coordenadas em cada camada são listadas (elas formam grupos degenerados de 6 ou 3, com possivelmente um grupo de 1 no centro exato da camada).
Interessante, mas provavelmente existem outras perguntas no site a serem exploradas.
N = 6fornece uma saída de mais de 10 ^ 12, é quase certamente necessária uma solução não construtiva para chegar tão longe.