Bir döngü oldukça basit bir cebirsel yapıdır. Bu demet bir (G *) G, bir dizi ve + ikili bir operatördür G x G → G . Yani + , G'den iki öğe alır ve yeni bir öğe döndürür. Operatörün ayrıca iki özelliği yerine getirmesi gerekir

• İptal: Her için a ve b olarak G benzersiz vardır x ve y de G şekildedir

  a + x = b
  y + a = b
  

• Kimlik: Bir yoktur e de G öyle ki her için a içinde G

  e + a = a
  a + e = a
  

Bir grup kavramını biliyorsanız, bir döngünün yalnızca ilişkilendirilebilir özelliği olmayan bir grup olduğunu fark edebilirsiniz.

Döngüler oldukça basittir, bu yüzden insanlar daha ilginç yeni yapılar yapmak için daha fazla kural eklemeyi severler. Bu tür bir yapı, a, Moufang döngü de tatmin dört kimlikleri forall'dır takip eden bir döngü x , y ve z içinde G

z + (x + (z + y)) = ((z + x) + z) + y
((y + z) + x) + z = y + (z + (x + z))
(z + x) + (y + z) = (z + (x + y)) + z
(z + x) + (y + z) = z + ((x + y) + z)

Örneğin, aşağıdaki Cayley tablosu bir Moufang döngüsünü temsil eder:

0  1  2  3
1  0  3  2
2  3  0  1
3  2  1  0

(Tanıdık değilse bir Cayley tablo kare matris M E _{i, j} eşittir i + j . Bu bir dizi ikili operatörler temsil için kullanışlı bir yöntemdir.)

Oldukça kolay bir kimlik olduğunu gösterebiliriz 0. İptalin gösterilmesi biraz daha zordur, ancak kaba kuvvet yaklaşımı bu tabloyu verir

b a → 0 1 2 3
↓
0     0 1 2 3
1     1 0 3 2
2     2 3 0 1
3     3 2 1 0

Öğelerimizin çözüm olduğu yerler

a + x = b = x + a

(Bu tablonun Cayley masamıza özdeş olduğunu fark edebilirsiniz. Bu Moufang döngüsünün neden böyle olduğunu anlamak için okuyucuya bir alıştırma olarak bırakacağım)

Şimdi yapımız için Moufang kimliklerini doğrulamamız gerekiyor. Belirli bir yapı için bunu yapmanın iki yolu vardır, ilk yol, ilişkisel olduğunu ve böylece kriterleri otomatik olarak yerine getirdiğini anlamaktır, ancak bu genel olarak işe yaramaz, bu yüzden sonucu kaba kuvvetle tercih ederiz. Buradaki her ifadede her biri 4 değer potansiyeline sahip 3 serbest değişken vardır. Bu, 7 * 4 ³ veya 448 hesaplama yapmamız gerektiği anlamına gelir . Ham hesaplamaları dışarıda bırakacağım ama işte bunu doğrulamak için kullanabileceğiniz bazı Haskell .

Görev

Pozitif bir tam sayı verilen n sipariş bilgisi Moufang döngü sayısı giriş çıkış olarak n . (bir grubun sırası kümenin boyutudur)

Bu kod golftür, bu nedenle cevaplar daha az bayt daha iyi olacak şekilde bayt cinsinden puanlanır.

Test senaryoları

İşte ilk 71 için Moufang döngü sayısı giriş

1,1,1,2,1,2,1,5,2,2,1,6,1,2,1,19,1,5,1,6,2,2,1,20,2,2,5,5,1,4,1,122,1,2,1,18,1,2,2,19,1,7,1,5,2,2,1,103,2,5,1,6,1,17,2,17,2,2,1,18,1,2,4,4529,1,4,1,6,1,4,1

Python 3 , 475 410 bayt

Bayt'ı kurtardığı için Mr.Xcoder'a teşekkürler!

65 bayt kaydetmek için formülün simetrisini kullanın. Evet, bu çok fazla.

from itertools import*
n=int(input())
P=permutations
R=[*range(n)]
u=[]
A=all
S=sorted
for T in P(P(R),n):u+=[T]*(A(A(R==S(x)for x in
t)and any([*x]==S(x)for x in t)and
A(t[z][t[x][t[z][y]]]==t[t[t[z][x]][z]][y]and
t[t[z][x]][t[y][z]]==t[t[z][t[x][y]]][z]for x in R
for y in R for z in R)for t
in(T,[*zip(*T)]))and A(A(1-A(p[T[i][j]]==U[p[i]][p[j]]for i in R
for j in R)for p in P(R))for U in u))
print(len(u))

Çevrimiçi deneyin!

Bazıları andile değiştirilebilir *, daha düşük bayt ile sonuçlanır, ancak önemli ölçüde daha yavaş yürütme süresi pahasına:

Python 3 , ??? bayt

[TODO kodu buraya koydu]

(elbette hepsi *programı önemli ölçüde yavaşlatmaz, sadece bazıları kritiktir)

Ungolfed:

from itertools import *
n = 4 # int(input())
rangeN = list(range(n))

def is_moufang_loop(T):
    A = tuple(zip(*T))
    return all(
        all(sorted(x) == rangeN for x in t)
        and any(list(x) == sorted(x) for x in t)
        and all(
                T[z][T[x][T[z][y]]] == T[T[T[z][x]][z]][y]
            and T[T[z][x]][T[y][z]] == T[T[z][T[x][y]]][z]
            for x in rangeN for y in rangeN for z in rangeN)
        for t in (T, A)
    )

def isomorphic(loop1, loop2):
    for p in permutations(rangeN):
        if all(
            p[loop1[i][j]] == loop2[p[i]][p[j]]
            for i in rangeN
            for j in rangeN
        ): return True
    return False

unique_moufang_loops = []
for x in [
        cayley_table 
        for cayley_table in permutations(permutations(rangeN), n)
        if is_moufang_loop(cayley_table)
]:
    if all(not isomorphic(x, y) for y in unique_moufang_loops):
        unique_moufang_loops.append(x)

print(len(unique_moufang_loops))

Çevrimiçi deneyin!

_{Kaydırma çubuğu yok ...}

Açıklama:

Program oldukça basit.

• Her olası "ikili operatör" bir Cayley tablosu (0-indeksleme) ile temsil edilir.
• "Kimlik" özelliği e, hem e"satır" hem de " esütun" a eşit olacak şekilde [0, 1, 2, ..., n-1]var olduğunu belirtir.

  hem dizi hem de Tonun devrik değeri eşittir [0, 1, 2, ..., n-1].

• "İptal" özelliği şuna eşdeğerdir:

  Her satır ve her sütun bir permütasyon [0, 1, 2, ..., n-1].

Yani, bölüm

all(
        all(sorted(x) == rangeN for x in t) 
        and any(list(x) == sorted(x) for x in t) 
        for t in (T, A))

kodu kontrol eder. (dizideki Tve sırasının tüm satırları Aiçin, sıralanmak eşittir rangeNve her ikisinde de bir satır vardır Tve Abu da sıralanmaya eşittir)

Bir Moufang döngülerinin dört koşulu manuel olarak kontrol edilir.

z + (x + (z + y)) = ((z + x) + z) + y
((y + z) + x) + z = y + (z + (x + z))
(z + x) + (y + z) = (z + (x + y)) + z
(z + x) + (y + z) = z + ((x + y) + z)

Kodda, (a + b)olarak temsil edilir T[a][b]. (Cayley tablosu olarak gösterilmesi nedeniyle). Yinelenmesini önlemek için Python zincirleme eşitlik karşılaştırmasını kullanın (z + x) + (y + z).

Ancak, formül simetrik olduğu için:

+İlk formülde işlenenleri değiştirirsek , ikinci formülü alırız; ve +üçüncü formülde işlenenleri değiştirirsek , dördüncü formülü alır xve ydeğiştiririz.

Cayley tablosunun aktarımının, işlenenler değiştirilen ikili işleçlere eşdeğer olduğuna dikkat edin. (x + y -> y + x )

Son olarak, Cayley tablosundaki tüm adaylar

permutations(permutations(rangeN), n) 

böylece her satır bir permütasyon rangeN(yani [0, 1, 2, ..., n-1]) ve nfarklı satırlar vardır.