Un loop è una struttura algebrica piuttosto semplice. Si tratta di una tupla (G, +) dove G è un set e + è un operatore binario G × G → G . Cioè + prende due elementi da G e restituisce un nuovo elemento. L'operatore è inoltre tenuto a soddisfare due proprietà

• Cancellazione: Per ogni un e b in G esiste unico x ed y in G tale che

  a + x = b
  y + a = b
  

• Identità: esiste una e in G tale che per ogni a in G

  e + a = a
  a + e = a
  

Se hai familiarità con il concetto di un gruppo potresti notare che un ciclo è solo un gruppo che non ha una proprietà associativa.

I loop sono piuttosto semplici, quindi alla gente piace aggiungere più regole per rendere le nuove strutture più interessanti. Una tale struttura è un ciclo Moufang che è un ciclo che anche soddisfa le seguenti quattro identità forall x , y e z in 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)

Ad esempio la seguente tabella Cayley rappresenta un ciclo Moufang:

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

(Se non si ha familiarità con una tabella Cayley è una matrice quadrata M in cui M _{i, j} è uguale a i + j . È un modo pratico per rappresentare operatori binari su un set.)

Possiamo dimostrare che esiste un'identità piuttosto facilmente 0. La cancellazione è un po 'più difficile da mostrare, ma un approccio a forza bruta produce questa tabella

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

Dove i nostri elementi sono le soluzioni

a + x = b = x + a

(Potresti notare che questo tavolo è identico al nostro tavolo Cayley. Lo lascerò come un esercizio al lettore per capire perché questo è il caso di questo ciclo Moufang)

Ora dobbiamo verificare le identità di Moufang per la nostra struttura. Esistono due modi per farlo per la particolare struttura, il primo modo è rendersi conto che è associativo e quindi soddisfa automaticamente i criteri, tuttavia questo non funzionerà in generale, quindi preferiremmo forzare il risultato con forza bruta. Ci sono 3 variabili libere ciascuna con un potenziale di 4 valori in ogni espressione qui. Ciò significa che dobbiamo eseguire calcoli 7 * 4 ³ o 448. Lascerò fuori i calcoli grezzi ma ecco alcuni Haskell che puoi usare per verificarlo .

Compito

Dato un numero intero positivo n come output di input, il numero di loop Moufang con ordine n . (l'ordine di un gruppo è la dimensione dell'insieme)

Questo è code-golf, quindi le risposte verranno classificate in byte con un numero inferiore di byte migliori.

Casi test

Ecco il numero di loop Moufang per i primi 71 input

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 byte

Grazie a Mr.Xcoder per aver salvato alcuni byte!

Utilizzare la simmetria della formula per salvare 65 byte. Sì, è molto.

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

Provalo online!

Alcuni andpossono essere sostituiti da *, si traduce in un numero inferiore di byte ma a costo di tempi di esecuzione significativamente più lenti:

Python 3 , ??? byte

[TODO inserisci il codice qui]

(ovviamente non tutti *rendono il programma significativamente più lento, solo alcuni sono critici)

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

Provalo online!

_{Nessuna barra di scorrimento ...}

Spiegazione:

Il programma è piuttosto semplice.

• Ogni possibile "operatore binario" è rappresentato da una tabella di Cayley (indicizzazione 0).
• La proprietà "identità" implica che esista in emodo che sia la e'riga che la ecolonna' siano uguali [0, 1, 2, ..., n-1], che è la stessa condizione di

  sia l'array Tche la sua trasposizione hanno una riga uguale a [0, 1, 2, ..., n-1].

• La proprietà "cancellazione" è equivalente a

  Ogni riga e ogni colonna sono una permutazione di [0, 1, 2, ..., n-1].

Quindi, la parte

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

del codice controlla che. (per tutte le righe dell'array Te la sua trasposizione A, l'ordinamento è uguale a rangeN, e esiste una riga in entrambi Te Auguale a se stesso ordinato)

Le quattro condizioni di un loop Moufang vengono controllate manualmente.

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)

Nel codice, (a + b)è rappresentato come T[a][b]. (a causa della rappresentazione come tavolo Cayley). Utilizzare il confronto di uguaglianza concatenamento Python per evitare la duplicazione di (z + x) + (y + z).

Tuttavia, poiché la formula è simmetrica:

Se cambiamo gli operandi +nella prima formula, otteniamo la seconda formula; e se cambiamo gli operandi +nella terza formula, otteniamo la quarta formula con xe yscambiamo il posto.

Si noti che la trasposizione della tabella Cayley è equivalente agli operatori binari che hanno scambiato gli operandi. ( x + y -> y + x)

Infine, vengono scelti tutti i candidati del tavolo Cayley

permutations(permutations(rangeN), n) 

in modo che ogni riga sia una permutazione di rangeN(che è [0, 1, 2, ..., n-1]) e ci siano nrighe distinte.