การวนซ้ำเป็นโครงสร้างพีชคณิตที่ค่อนข้างง่าย มันเป็น tuple (G +)ที่Gเป็นชุดและ+เป็นผู้ประกอบการไบนารีG × G → G นั่นคือ+ใช้สององค์ประกอบจากGและส่งคืนองค์ประกอบใหม่ ผู้ประกอบการยังต้องปฏิบัติตามคุณสมบัติสองประการ

• การยกเลิก: สำหรับทุกaและbในGจะมีxและy ที่ไม่ซ้ำกันในGเช่นนั้น

  a + x = b
  y + a = b
  

• รหัสประจำตัว: มีเป็นอีในGดังกล่าวว่าสำหรับทุกในG

  e + a = a
  a + e = a
  

หากคุณคุ้นเคยกับแนวคิดของกลุ่มคุณอาจสังเกตเห็นว่าการวนซ้ำเป็นเพียงกลุ่มที่ไม่มีคุณสมบัติการเชื่อมโยง

ลูปนั้นค่อนข้างเรียบง่ายดังนั้นผู้คนจึงชอบเพิ่มกฎเพื่อสร้างโครงสร้างใหม่ที่น่าสนใจยิ่งขึ้น หนึ่งในโครงสร้างดังกล่าวคือห่วง Moufangซึ่งเป็นวงที่สอดคล้องกับสี่ตัวตนต่อไปนี้สำหรับx , yและzใน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)

ตัวอย่างเช่นตาราง Cayley ต่อไปนี้แสดงถึงการวนรอบ Moufang:

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

(หากคุณไม่คุ้นเคยกับตาราง Cayley เป็นตารางเมทริกซ์Mโดยที่M _{i, j}เท่ากับi + jมันเป็นวิธีที่สะดวกในการเป็นตัวแทนของตัวดำเนินการไบนารีในชุด)

0เราสามารถแสดงให้เห็นว่ามีความเป็นตัวตนค่อนข้างง่ายมันเป็น การยกเลิกเป็นเรื่องยากที่จะแสดง แต่วิธีการที่ดุร้ายกำลังให้ผลตารางนี้

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

องค์ประกอบของเราคือทางแก้ปัญหา

a + x = b = x + a

(คุณอาจสังเกตเห็นว่าตารางนี้เหมือนกับตาราง Cayley ของเราฉันจะปล่อยให้มันเป็นแบบฝึกหัดให้กับผู้อ่านเพื่อหาสาเหตุที่เป็นเช่นนี้สำหรับวง Moufang นี้)

ตอนนี้เราต้องยืนยันตัวตนของ Moufang สำหรับโครงสร้างของเรา มีสองวิธีในการทำสิ่งนี้สำหรับโครงสร้างเฉพาะวิธีแรกคือการตระหนักว่ามันเป็นแบบเชื่อมโยงและทำให้เป็นไปตามเกณฑ์โดยอัตโนมัติอย่างไรก็ตามสิ่งนี้จะไม่ทำงานโดยทั่วไปดังนั้นเราจึงค่อนข้างดุร้ายกำลังผล มีตัวแปรอิสระ 3 ตัวแต่ละตัวมีค่า 4 ค่าในทุกนิพจน์ที่นี่ ซึ่งหมายความว่าเราต้องทำการคำนวณ 7 * 4 ³หรือ 448 ฉันจะปล่อยออกมาคำนวณดิบ แต่นี่คือบางส่วน Haskell คุณสามารถใช้เพื่อตรวจสอบนี้

งาน

ป.ร. ให้ไว้เป็นจำนวนเต็มบวกnเป็นผลผลิตป้อนหมายเลขของลูป Moufang ที่มีการสั่งซื้อn (ลำดับของกลุ่มคือขนาดของชุด)

นี่คือcode-golfดังนั้นคำตอบจะได้คะแนนเป็นไบต์ด้วยจำนวนไบต์น้อยกว่าจะดีกว่า

กรณีทดสอบ

นี่คือจำนวนของ Moufang ที่ลูปสำหรับ71อินพุตแรก

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 ไบต์

ขอบคุณ Mr.Xcoder สำหรับบันทึกไบต์!

ใช้สมมาตรของสูตรเพื่อบันทึก 65 ไบต์ ใช่มันเยอะมาก

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

ลองออนไลน์!

บางคนandสามารถถูกแทนที่ด้วย*ผลลัพธ์ใน bytecount ที่ต่ำกว่า แต่ในเวลาที่การดำเนินการช้าลงอย่างมาก:

Python 3 , ??? ไบต์

[สิ่งที่ต้องใส่รหัสที่นี่]

(แน่นอนว่าไม่ใช่ทั้งหมดที่*ทำให้โปรแกรมช้าลงอย่างมากมีเพียงบางโปรแกรมเท่านั้นที่มีความสำคัญ)

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

ลองออนไลน์!

_{ไม่มีแถบเลื่อน ...}

คำอธิบาย:

โปรแกรมค่อนข้างง่าย

• "ตัวดำเนินการไบนารี" ที่เป็นไปได้แต่ละรายการแสดงโดยตาราง Cayley (การจัดทำดัชนี 0)
• คุณสมบัติ "เอกลักษณ์" แสดงถึงว่ามีอยู่eเช่นนั้นทั้งeแถวe'และคอลัมน์' เท่ากับ[0, 1, 2, ..., n-1]ซึ่งเป็นเงื่อนไขเดียวกับ

  ทั้งอาร์เรย์Tและ transpose [0, 1, 2, ..., n-1]ที่มีแถวเท่ากับ

• คุณสมบัติ "การยกเลิก" เทียบเท่า

  [0, 1, 2, ..., n-1]แถวทุกคนและทุกคอลัมน์มีการเปลี่ยนแปลงของ

ดังนั้นส่วนหนึ่ง

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

ของรหัสตรวจสอบว่า (สำหรับทุกแถวในอาเรย์TและทรานสโพAสของมันจะถูกเรียงลำดับเท่ากับrangeNและมีแถวในทั้งสองTและAที่เท่ากับตัวเองถูกเรียงลำดับ)

เงื่อนไขสี่ข้อของห่วง Mou Mou นั้นถูกตรวจสอบด้วยตนเอง

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)

ในรหัสจะแสดงเป็น(a + b) T[a][b](เนื่องจากการแสดงเป็นตาราง Cayley) (z + x) + (y + z)ใช้งูหลามผูกมัดเปรียบเทียบความเท่าเทียมกันในการทำสำเนาหลีกเลี่ยงของ

อย่างไรก็ตามเนื่องจากสูตรสมมาตร:

ถ้าเราสลับตัวถูกดำเนินการของ+ในสูตรแรกเราจะได้สูตรที่สอง และถ้าเราสลับตัวถูกดำเนินการของ+ในสูตรที่สามเราจะได้สูตรที่สี่ด้วยxและyเปลี่ยนตำแหน่ง

โปรดทราบว่าการย้ายตำแหน่งของตาราง Cayley นั้นเทียบเท่ากับตัวดำเนินการไบนารีที่มีตัวถูกดำเนินการสลับ ( x + y -> y + x)

ในที่สุดผู้สมัครทั้งหมดจะถูกเลือกจากตาราง Cayley

permutations(permutations(rangeN), n) 

เพื่อให้แต่ละแถวเป็นการเรียงสับเปลี่ยนของrangeN(ซึ่งคือ[0, 1, 2, ..., n-1]) และมีnแถวที่แตกต่างกัน