मऊफंग लूप्स की गिनती

Question

एक लूप एक बहुत ही सरल बीजीय संरचना है। यह एक tuple (G, +) है जहां G एक सेट है और + एक बाइनरी ऑपरेटर G × G → G है । यही कारण है + से दो तत्वों लेता है जी और एक नए तत्व देता है। दो संपत्तियों को पूरा करने के लिए ऑपरेटर की भी आवश्यकता होती है

• रद्द: हर के लिए एक और ख में जी वहाँ अद्वितीय मौजूद एक्स और वाई में जी ऐसा है कि

  a + x = b
  y + a = b
  

• पहचान: वहाँ एक है ई में जी ऐसा है कि हर एक के लिए एक में जी

  e + a = a
  a + e = a
  

यदि आप एक समूह की अवधारणा से परिचित हैं, तो आप देख सकते हैं कि एक लूप सिर्फ एक समूह है जिसके पास एक सहयोगी संपत्ति नहीं है।

लूप बहुत सरल होते हैं इसलिए लोग नई संरचनाओं को बनाने के लिए अधिक नियमों को जोड़ना पसंद करते हैं जो अधिक दिलचस्प हैं। ऐसा ही एक ढांचा एक मफैंग लूप है, जो एक लूप है जो जी में निम्नलिखित चार पहचानों x , y और z को संतुष्ट करता है।

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)

उदाहरण के लिए निम्नलिखित केली तालिका एक मोउफैंग लूप का प्रतिनिधित्व करती है:

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

(यदि आप परिचित नहीं हैं तो केली टेबल एक वर्ग मैट्रिक्स एम है जहां एम _{आई, जे} आई + जे के बराबर है । यह एक सेट पर बाइनरी ऑपरेटरों का प्रतिनिधित्व करने का एक आसान तरीका है।)

हम दिखा सकते हैं कि एक पहचान है बल्कि आसानी से है 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

(आप देख सकते हैं कि यह तालिका हमारी केली तालिका के समान है। मैं इसे पाठक के लिए एक अभ्यास के रूप में छोड़ दूंगा कि यह इस मोउफांग लूप के लिए क्यों है)

अब हमें अपनी संरचना के लिए Moufang पहचान को सत्यापित करने की आवश्यकता है। विशेष संरचना के लिए ऐसा करने के दो तरीके हैं पहला तरीका यह महसूस करना है कि यह साहचर्य है और इस प्रकार स्वचालित रूप से मानदंडों को पूरा करता है, हालांकि यह सामान्य रूप से काम नहीं करेगा, इसलिए हम परिणाम को बाध्य करेंगे। यहां प्रत्येक अभिव्यक्ति में 4 मूल्यों की क्षमता वाले 3 मुक्त चर हैं। इसका मतलब है कि हमें 7 * 4 ³ या 448 गणना करनी है । मैं कच्चे संगणनों को छोड़ दूँगा लेकिन यहाँ कुछ हास्केल हैं जिनका उपयोग आप इसे सत्यापित करने के लिए कर सकते हैं ।

कार्य

इनपुट आउटपुट के रूप में पॉजिटिव पूर्णांक n को देखते हुए Moufang छोरों की संख्या जो ऑर्डर n है । (समूह का क्रम सेट का आकार है)

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

परीक्षण के मामलों

यहां पहले 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

Comments

" G × G " क्या है ?

— एर्ग आउटफेलर

मैंने इस चुनौती को अस्वीकार कर दिया, क्योंकि इसमें शामिल गणित काफी शराबी है और हर उस व्यक्ति के लिए सुलभ नहीं है जो इस चुनौती को पढ़ता है। शायद, एक काम किया गया उदाहरण सहायक होगा (जैसे, यह बताते हुए कि 8 वें इनपुट का परिणाम 5 में क्यों है)? यदि आप एक जोड़ते हैं तो मुझे लगता है कि मैं अपना वोट वापस ले लूंगा, लेकिन निश्चित रूप से यह आपके ऊपर है।

@ IanGödel क्या आप स्पष्ट कर सकते हैं कि आपका क्या मतलब है? यह निश्चित रूप से एक अधिक उन्नत गणितीय विषय है लेकिन मुझे नहीं लगता कि हमें पीपीसीजी पर गणित से दूर भागना चाहिए। मैं एक मोउफांग लूप का काम किया उदाहरण जोड़ूंगा, लेकिन हाथ से पूरे इनपुट की गणना करना शायद चुनौती को अव्यवस्थित कर देगा।

— पोस्ट रॉक गार्फ हंटर

@WheatWizard "शराबी" के रूप में, शायद, "उन्नत"। संपादित करें: मैंने पद छोड़ दिया, लेकिन अभी भी एक उदाहरण की प्रतीक्षा कर रहा हूं।

@Giuseppe बहुत बुरा मत मानो, मैंने भी गलती की है जब आपका सुधार कर रहा हूँ यह 12नहीं है 11। मुझे एहसास होना चाहिए कि क्योंकि 11प्राइम नंबर है।

— पोस्ट रॉक गार्फ हंटर

Answer 1

पायथन 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द्वारा प्रतिस्थापित किया जा सकता है *, कम बायटेकाउंट में परिणाम लेकिन काफी धीमी निष्पादन समय की लागत पर:

अजगर 3 , ??? बाइट्स

[TODO ने यहां कोड डाला]

(बेशक सभी *कार्यक्रम को काफी धीमा नहीं बनाते हैं, केवल उनमें से कुछ महत्वपूर्ण हैं)

---

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

इसे ऑनलाइन आज़माएं!

_{कोई स्क्रॉल बार नहीं ...}

---

स्पष्टीकरण:

कार्यक्रम बहुत सरल है।

• प्रत्येक संभव "बाइनरी ऑपरेटर" एक केली टेबल (0-इंडेक्सिंग) द्वारा दर्शाया गया है।
• "पहचान" संपत्ति का तात्पर्य है कि eऐसी मौजूद है जो e'वीं पंक्ति और e' वें स्तंभ के बराबर है [0, 1, 2, ..., n-1], जो एक ही स्थिति है

  एरे Tऔर इसके ट्रांसपोज़ दोनों की एक पंक्ति समान है [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यह अपने आप हल होने के बराबर है)

Moufang छोरों की चार शर्तों को मैन्युअल रूप से जांचा जाता है।

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]। (केली तालिका के रूप में प्रतिनिधित्व के कारण)। नकल से बचने के लिए समानता की तुलना में पायथन का उपयोग करें (z + x) + (y + z)।

हालाँकि, क्योंकि सूत्र सममित है:

यदि हम +पहले सूत्र में ऑपरेंड को बदलते हैं , तो हमें दूसरा सूत्र मिलता है; और अगर हम के ऑपरेंड स्विच +तीसरे सूत्र में, हम साथ चौथे सूत्र मिल xऔर yबदली जगह।

ध्यान दें कि केली टेबल का ट्रांसपोज़ेशन बाइनरी ऑपरेटर्स के बराबर होता है जिसमें ऑपरेंड स्वैप होते हैं। ( x + y -> y + x)

अंत में, सभी उम्मीदवारों केली तालिका से चुना गया है

permutations(permutations(rangeN), n) 

ताकि प्रत्येक पंक्ति एक क्रमपरिवर्तन हो rangeN(जो है [0, 1, 2, ..., n-1]) और nअलग - अलग पंक्तियाँ हैं।