Một vòng lặp là một cấu trúc đại số khá đơn giản. Nó là một tuple (G, +) nơi G là một tập hợp và + là một nhà điều hành nhị phân G × G → G . Đó là + lấy hai phần tử từ G và trả về một phần tử mới. Toán tử cũng được yêu cầu thực hiện hai thuộc tính

• Hủy bỏ: Với mỗi a và b trong G tồn tại x và y duy nhất trong G sao cho

  a + x = b
  y + a = b
  

• Danh tính: Có một e trong G sao cho mỗi a trong G

  e + a = a
  a + e = a
  

Nếu bạn quen thuộc với khái niệm nhóm, bạn có thể nhận thấy rằng vòng lặp chỉ là một nhóm không có thuộc tính kết hợp.

Vòng lặp khá đơn giản để mọi người thích thêm nhiều quy tắc để tạo ra các cấu trúc mới thú vị hơn. Một cấu trúc như vậy là một vòng lặp Mou Phường là một vòng lặp cũng thỏa mãn bốn danh tính sau đây cho x , y và z trong 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)

Ví dụ, bảng Cayley sau đây biểu thị một vòng lặp Mou Phường:

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

(Nếu bạn không quen thì bảng Cayley là ma trận vuông M trong đó M _{i, j} bằng i + j . Đây là một cách thuận tiện để biểu diễn các toán tử nhị phân trên một tập hợp.)

Chúng tôi có thể chỉ ra rằng có một bản sắc khá dễ dàng 0. Hủy bỏ là một chút khó khăn hơn để hiển thị nhưng một cách tiếp cận vũ phu mang lại bảng này

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

Yếu tố của chúng ta là giải pháp để

a + x = b = x + a

(Bạn có thể nhận thấy rằng bảng này giống hệt với bảng Cayley của chúng tôi. Tôi sẽ để nó như một bài tập cho người đọc để tìm hiểu lý do tại sao đây là trường hợp của vòng lặp Mou Phường này)

Bây giờ chúng tôi cần xác minh danh tính Mou Phường cho cấu trúc của chúng tôi. Có hai cách để làm điều này đối với cấu trúc cụ thể, cách đầu tiên là nhận ra rằng nó có tính kết hợp và do đó tự động đáp ứng các tiêu chí, tuy nhiên điều này sẽ không hoạt động nói chung vì vậy chúng tôi muốn buộc phải kết quả. Có 3 biến miễn phí, mỗi biến có tiềm năng 4 giá trị trong mỗi biểu thức ở đây. Điều này có nghĩa là chúng ta phải thực hiện tính toán 7 * 4 ³ hoặc 448. Tôi sẽ bỏ qua các tính toán thô nhưng đây là một số Haskell bạn có thể sử dụng để xác minh điều này .

Bài tập

Cho một số nguyên dương n là đầu ra đầu vào, số vòng lặp Mou Phường có thứ tự n . (thứ tự của một nhóm là kích thước của tập hợp)

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn.

Các trường hợp thử nghiệm

Đây là số vòng lặp Mou Phường cho 71 đầu vào đầu tiên

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

Cảm ơn Mr.Xcoder đã lưu một số byte!

Sử dụng tính đối xứng của công thức để lưu 65 byte. Vâng, đó là rất nhiều.

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

Hãy thử trực tuyến!

Một số andcó thể được thay thế bởi *, dẫn đến kết quả thấp hơn nhưng với chi phí thời gian thực hiện chậm hơn đáng kể:

Con trăn 3 , ??? byte

[TODO đặt mã ở đây]

(tất nhiên không phải tất cả *làm cho chương trình chậm hơn đáng kể, chỉ một số trong số đó là quan trọng)

Ung dung:

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

Hãy thử trực tuyến!

_{Không có thanh cuộn ...}

Giải trình:

Chương trình này khá đơn giản.

• Mỗi "toán tử nhị phân" có thể được biểu thị bằng bảng Cayley (lập chỉ mục 0).
• Thuộc tính "danh tính" ngụ ý rằng tồn tại esao cho cả ehàng thứ 'và ecột' đều bằng[0, 1, 2, ..., n-1] , đó là cùng một điều kiện như

  cả mảng Tvà chuyển vị của nó đều có một hàng bằng [0, 1, 2, ..., n-1].

• Tài sản "hủy bỏ" tương đương với

  Mỗi hàng và mỗi cột là một hoán vị của [0, 1, 2, ..., n-1].

Vì vậy, một phần

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

của mã kiểm tra rằng. (đối với tất cả các hàng trong mảng Tvà chuyển vị của nó A, nó được sắp xếp bằng rangeNvà và tồn tại một hàng trong cả hai TvàA tương đương với chính nó được sắp xếp)

Bốn điều kiện của một vòng lặp Mou Phường được kiểm tra bằng tay.

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)

Trong mã, (a + b)được đại diện là T[a][b]. (vì đại diện như bảng Cayley). Sử dụng so sánh bình đẳng chuỗi Python để tránh trùng lặp(z + x) + (y + z) .

Tuy nhiên, vì công thức là đối xứng:

Nếu chúng ta chuyển đổi toán hạng của +công thức đầu tiên, chúng ta sẽ có công thức thứ hai; và nếu chúng ta chuyển đổi toán hạng của +công thức thứ ba, chúng ta sẽ có công thức thứ tư với xvày vị trí hoán đổi.

Lưu ý rằng sự hoán vị của bảng Cayley tương đương với các toán tử nhị phân có toán hạng được hoán đổi. (x + y -> y + x )

Cuối cùng, tất cả các ứng cử viên bảng Cayley được chọn từ

permutations(permutations(rangeN), n) 

sao cho mỗi hàng là một hoán vị của rangeN(đó là [0, 1, 2, ..., n-1]) và có ncác hàng riêng biệt.