Eine Schleife ist eine ziemlich einfache algebraische Struktur. Es ist ein Tupel (G, +), wobei G eine Menge ist und + ein binärer Operator G × G → G ist . Das heißt, + nimmt zwei Elemente von G und gibt ein neues Element zurück. Der Betreiber muss außerdem zwei Eigenschaften erfüllen

• Stornierung: Für jedes a und b in G gibt es eindeutige x und y in G, so dass

  a + x = b
  y + a = b
  

• Identität: Es gibt ein e in G, so dass für jedes a in G

  e + a = a
  a + e = a
  

Wenn Sie mit dem Konzept einer Gruppe vertraut sind, stellen Sie möglicherweise fest, dass eine Schleife nur eine Gruppe ohne assoziative Eigenschaft ist.

Loops sind ziemlich einfach, daher fügen die Leute gerne mehr Regeln hinzu, um neue Strukturen interessanter zu gestalten. Eine solche Struktur ist eine Moufang-Schleife, die auch die folgenden vier Identitäten für alle x , y und z in G erfüllt

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)

Die folgende Cayley-Tabelle repräsentiert beispielsweise eine Moufang-Schleife:

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

(Wenn Sie nicht vertraut sind, ist eine Cayley-Tabelle eine quadratische Matrix M, wobei M _{i, j} gleich i + j ist . Dies ist eine praktische Möglichkeit, Binäroperatoren für eine Menge darzustellen.)

Wir können zeigen, dass es eine Identität gibt, die ziemlich einfach ist 0. Stornierung ist etwas schwieriger zu zeigen, aber ein Brute-Force-Ansatz liefert diese Tabelle

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

Wo unsere Elemente die Lösungen für sind

a + x = b = x + a

(Möglicherweise stellen Sie fest, dass diese Tabelle mit unserer Cayley-Tabelle identisch ist. Ich überlasse sie dem Leser als Übung, um herauszufinden, warum dies für diese Moufang-Schleife der Fall ist.)

Jetzt müssen wir die Moufang-Identitäten für unsere Struktur überprüfen. Es gibt zwei Möglichkeiten, dies für die jeweilige Struktur zu tun. Die erste besteht darin, zu erkennen, dass sie assoziativ ist und somit automatisch die Kriterien erfüllt. Dies wird jedoch im Allgemeinen nicht funktionieren, sodass wir das Ergebnis eher brachial erzwingen möchten. Hier gibt es 3 freie Variablen mit einem Potential von jeweils 4 Werten in jedem Ausdruck. Dies bedeutet, dass wir 7 * 4 ³ oder 448 Berechnungen durchführen müssen. Ich lasse die rohen Berechnungen weg, aber hier ist ein Haskell, mit dem Sie dies überprüfen können .

Aufgabe

Bei einer positiven Ganzzahl n als Eingabe wird die Anzahl der Moufang-Schleifen mit der Ordnung n ausgegeben . (Die Reihenfolge einer Gruppe ist die Größe des Sets)

Dies ist Codegolf, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes besser sind.

Testfälle

Hier ist die Anzahl der Moufang-Schleifen für die ersten 71 Eingänge

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 Bytes

Vielen Dank an Mr.Xcoder für das Speichern einiger Bytes!

Verwenden Sie die Symmetrie der Formel, um 65 Bytes zu sparen. Ja, das ist viel.

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))

Probieren Sie es online!

Einige andkönnen durch ersetzt werden *, was zu einer geringeren Bytecount-Anzahl führt, jedoch auf Kosten einer erheblich langsameren Ausführungszeit:

Python 3 , ??? Bytes

[TODO Code hier einfügen]

(Natürlich *macht nicht alles das Programm wesentlich langsamer, nur einige von ihnen sind kritisch)

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))

Probieren Sie es online!

_{Keine Bildlaufleisten ...}

Erläuterung:

Das Programm ist ziemlich einfach.

• Jeder mögliche "Binäroperator" wird durch eine Cayley-Tabelle dargestellt (0-Indizierung).
• Die "Identität" -Eigenschaft impliziert, dass es eine esolche gibt, dass sowohl die e'te Zeile als auch die e' te Spalte gleich sind[0, 1, 2, ..., n-1] , was die gleiche Bedingung ist wie

  Sowohl das Array Tals auch seine Transponierte haben eine Zeile gleich [0, 1, 2, ..., n-1].

• Die Eigenschaft "Stornierung" entspricht

  Jede Zeile und jede Spalte ist eine Permutation von [0, 1, 2, ..., n-1].

Also das Teil

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

des Codes prüft das. (Für alle Zeilen im Array Tund seine Transponierung Aist die Sortierung gleich rangeN, und in beiden Tund ist eine Zeile vorhandenA das entspricht sich die sortiert werden)

Die vier Bedingungen eines Moufang-Loops werden manuell überprüft.

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)

Im Code (a + b)wird dargestellt als T[a][b]. (wegen der Darstellung als Cayley-Tabelle). Verwenden Sie den Python-Verkettungsgleichheitsvergleich, um eine Duplizierung von zu vermeiden(z + x) + (y + z) .

Da die Formel jedoch symmetrisch ist:

Wenn wir die Operanden +der ersten Formel umschalten , erhalten wir die zweite Formel; und wenn wir die Operanden +der dritten Formel tauschen, erhalten wir die vierte Formel mit xundy vertauschen die Stelle.

Beachten Sie, dass die Umsetzung der Cayley-Tabelle den binären Operatoren mit vertauschten Operanden entspricht. ( x + y -> y + x)

Schließlich werden alle Kandidaten Cayley Tisch ausgewählt

permutations(permutations(rangeN), n) 

so dass jede Zeile eine Permutation von rangeNist [0, 1, 2, ..., n-1]und es nunterschiedliche Zeilen gibt.