यह कौन सा परिमित समूह है?

12

विवरण

एक फ़ंक्शन लिखें जो f(m, G)अपने तर्कों को मानचित्रण के रूप में स्वीकार करता है m, और एक सेट / अलग, गैर-नकारात्मक पूर्णांक की सूची G।

mGनए पूर्णांकों में पूर्णांकों के जोड़े को मैप करना चाहिए G। ( ) G, mएक परिमित एबेलियन समूह बनाने की गारंटी है , लेकिन किसी भी तत्व की Gपहचान हो सकती है।

एक महत्वपूर्ण प्रमेय है जो कहता है:

[प्रत्येक परिमित एबेलियन समूह] प्राइम पावर ऑर्डर के चक्रीय समूहों के प्रत्यक्ष उत्पाद के लिए आइसोमोर्फिक है।

f[p1, ... pn]आरोही क्रम में प्रमुख शक्तियों की सूची वापस करनी चाहिएG isomorphic से Z_p1 बार ... काल Z_pn है

उदाहरण

  • f((a, b) → (a+b) mod 4, [0, 1, 2, 3])वापस आना चाहिए [4], क्योंकि पैरामीटर समूह Z 4 का वर्णन करते हैं ।

  • f((a, b) → a xor b, [0, 1, 2, 3])वापस आना चाहिए [2, 2], क्योंकि पैरामीटर Z 2 × Z 2 के लिए एक समूह आइसोमोर्फिक का वर्णन करते हैं ।

  • f((a, b) → a, [9])लौट जाना चाहिए [], क्योंकि पैरामीटर तुच्छ समूह का वर्णन करते हैं; यानी, शून्य चक्रीय समूहों का उत्पाद।

  • mनिम्नानुसार परिभाषित करें :

    (a, b) → (a mod 3 + b mod 3) mod 3
       + ((floor(a / 3) + floor(b / 3)) mod 3) * 3
       + ((floor(a / 9) + floor(b / 9)) mod 9) * 9

    फिर f(m, [0, 1, ..., 80])वापस आ जाना चाहिए [3, 3, 9], क्योंकि यह समूह Z 3 × Z 3 × Z 9 के लिए आइसोमोर्फिक है

नियम

  • mया तो एक फ़ंक्शन हो सकता है (या कुछ फ़ंक्शन के लिए फ़ंक्शन पॉइंटर) Int × Int → Int, या G × Gनए तत्वों के लिए एक शब्दकोश मैपिंग जोड़े G।

  • fइसके मापदंडों को विपरीत क्रम में ले सकते हैं, यानी आप भी लागू कर सकते हैं f(G, m)।

  • आपका कार्यान्वयन सैद्धांतिक रूप से बड़े पैमाने पर इनपुट के लिए काम करना चाहिए , लेकिन वास्तव में कुशल होने की आवश्यकता नहीं है।

  • किसी भी तरह के बिल्ट-इन का उपयोग करने पर कोई सीमा नहीं है।

  • मानक कोड-गोल्फ नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड जीतता है।

लीडरबोर्ड

आपके स्कोर बोर्ड पर दिखाई देने के लिए, यह इस प्रारूप में होना चाहिए:

# Language, Bytes

कोड स्निपेट दिखाएं

code-golf  math  abstract-algebra 
— लिन
स्रोत
यदि mआपको एक शब्दकोश बनाने की अनुमति है, तो क्या आप परीक्षण मामलों को भी शब्दकोश प्रदान कर सकते हैं?
— मार्टिन एंडर
मैंने इस पर विचार किया, लेकिन वे बहुत बड़े हैं, विशेष रूप से आखिरी मामला (हज़ारों कुंजी-मूल्य जोड़े), और मैं उनके लिए बहुत अच्छे प्रारूप के बारे में नहीं सोच सकता। यह संभव है कि उत्तरदाताओं के लिए फ़ंक्शन परिभाषाओं की प्रतिलिपि बनाना आसान हो, और फिर खुद ही शब्दकोशों का निर्माण करें (जैसे कुछ के साथ for a in G: for b in G: d[(a, b)] = m(a, b))।
— लिन
मुझे लगता है कि यह सही है। मैं आपके पेस्ट के बारे में अच्छी तरह से समझ नहीं पा रहा हूं कि क्या चल रहा है, लेकिन यह साबित करना चाहिए: bpaste.net/show/5821182a9b48
— Lynn
इसके चारों ओर अपने सिर को लपेटने में मदद करने के लिए: यह प्रारूप में ट्रिट्स के साथ टर्नरी नंबरों पर काम करता है AABC, उन्हें ट्रिपल के रूप में मानते हुए, जोड़दार जोड़ मोडुलो के (A, B, C)साथ (9, 3, 3)।
— लिन
ओह, मुझे बस अपनी (बहुत बेवकूफ) गलती का एहसास हुआ। अपने स्निपेट के लिए धन्यवाद!
— दोष

जवाबों:

5

मतलाब, 326 बाइट्स

कुछ समूह सिद्धांत के साथ विचार काफी सरल है: यहां टीएल; डीआर समूह के तत्वों के सभी संभावित आदेशों की गणना करता है। फिर एक निश्चित प्राइम पावर ऑर्डर का सबसे बड़ा उपसमूह ढूंढें और इसे समूह से बाहर निकाल दें, कुल्ला, दोहराएं।

function r=c(h,l)

                            %factorize group order
N=numel(L);
f=factor(N);
P=unique(f);                %prime factors
for k=1:numel(P);
    E(k)=sum(f==P(k));    %exponents of unique factors
end;

                            %calculate the order O of each element
O=L*0-1; 
l=L;
for k=2:N+1;

    l=h(l,L);

    O(l==L & O<0)=k-1
end;

%%

O=unique(O);               % (optional, just for speedupt)
R=[];
                           % for each prime,find the highest power that
                           % divides any of the orders of the element, and
                           % each time substract that from the remaining
                           % exponent in the prime factorization of the
                           % group order
for p=1:nnz(P);                          % loop over primes
    while E(p)>1;                        % loop over remaining exponent
        for e=E(p):-1:1;                 % find the highest exponent
            B=mod(O,P(p)^e)==0;          
            if any(B)
                R=[R,P(p)^e];            % if found, add to list
                O(B)=O(B)/(P(p)^e);
                E(p)=E(p)-e;
                break;
            end;
        end;
    end;
    if E(p)==1;
        R=[R,P(p)];
    end;
end;
r=sort(R)

उदाहरण इनपुट:

L = 0:3;
h=@(a,b)mod(a+b,4);
h=@(a,b)bitxor(a,b);
L = 0:80;
h=@(a,b)mod(mod(a,3)+mod(b,3),3)+mod(floor(a/3)+floor(b/3),3)*3+ mod(floor(a/9)+floor(b/9),9)*9;

गोल्फ संस्करण:

function r=c(h,l);N=numel(L);f=factor(N);P=unique(f);for k=1:numel(P);E(k)=sum(f==P(k));end;O=L*0-1;l=L;for k=2:N+1;l=h(l,L);O(l==L&O<0)=k-1;end;R=[];for p=1:nnz(P);while E(p)>1;for e=E(p):-1:1;B=mod(O,P(p)^e)==0; if any(B);R=[R,P(p)^e]; O(B)=O(B)/(P(p)^e);E(p)=E(p)-e;break;end;end;end;if E(p)==1;R=[R,P(p)];end;end;r=sort(R)
— flawr
स्रोत
1

जीएपी , 159 111 बाइट्स

जीएपी हमें केवल एक गुणन तालिका द्वारा एक समूह बनाने की अनुमति देता है और इसके एबेलियन इन्वर्टर की गणना करता है:

ai:=    # the golfed version states the function w/o assigning it
function(m,G)
  local t;
  t:=List(G,a->List(G,b->Position(G,m(a,b))));
  # t is inlined in the golfed version
  return AbelianInvariants(GroupByMultiplicationTable(t));
end;

पुराना संस्करण

जनरेटर जी और संबंधों के साथ बारी-बारी से प्रस्तुत समूह एक * बी = एम (ए, बी) (सभी के लिए, जी से बी) वह समूह है (जी, एम) जिसके साथ हमने शुरुआत की थी। हम इसे बना सकते हैं और GAP के साथ इसके एबेलियन आक्रमणकारियों की गणना कर सकते हैं:

ai:=    # the golfed version states the function w/o assigning it
function(m,G)
  local F,n,rels;
  n:=Size(G);
  F:=FreeGroup(n);
  rels:=Union(Set([1..n],i->
                Set([1..n],j->
                  F.(i)*F.(j)/F.(Position(G,m(G[i],G[j]))) ) ));
  # rels is inlined in the golfed version
  return AbelianInvariants(F/rels);
end;

उदाहरण

m1:=function(a,b) return (a+b) mod 4; end;
# I don't feel like implementing xor
m3:=function(a,b) return 9; end;
m4:=function(a,b)
  return (a+b) mod 3 # no need for inner mod
         + ((QuoInt(a,3)+QuoInt(b,3)) mod 3) * 3
         + ((QuoInt(a,9)+QuoInt(b,9)) mod 9) * 9;
  end;

अब हम कर सकते हैं:

gap> ai(m1,[0..3]);
[ 4 ]

दरअसल, हम पूर्णांकों की सूची का उपयोग करने के लिए प्रतिबंधित नहीं हैं। सही डोमेन का उपयोग करके, हम केवल सामान्य प्लस का उपयोग कर सकते हैं:

ai(\+,List(Integers mod 4));
[ 4 ]

इसलिए मैं अनिवार्य रूप से दूसरे उदाहरण का उपयोग कर सकता हूं कि इसका समूह 2 तत्वों के साथ क्षेत्र में 2 आयामी वेक्टर अंतरिक्ष के योजक समूह के लिए आइसोमोर्फिक है:

gap> ai(\+,List(GF(2)^2));
[ 2, 2 ]

और शेष उदाहरण:

gap> ai(m3,[9]);
[  ]
gap> ai(m4,[0..80]);
[ 3, 3, 9 ]

अतिरिक्त टिप्पणी

पुराने संस्करण में, m को G. if (a, b) = m (a, c) के लिए एक समूह रचना को परिभाषित करने की आवश्यकता नहीं थी, बस यही कहता है कि b = c। तो हम ai(m1,[0..5])और कर सकते थे ai(m3,[5..15])। नया संस्करण इन मामलों में भयानक रूप से विफल हो जाएगा, क्योंकि दोनों संस्करण होंगे यदि एम रिटर्न मान जो कि जी में नहीं है।

यदि (G, m) एबेलियन नहीं है, तो हमें इसके संक्षिप्त संस्करण का वर्णन मिलता है, जो इसका सबसे बड़ा एबेलियन कारक समूह है:

gap> ai(\*,List(SymmetricGroup(4)));
[ 2 ]

यह वही है जो AbelianInvariantsआमतौर पर इस्तेमाल किया जाता है, हम सामान्य रूप से सिर्फ कॉल करेंगे AbelianInvariants(SymmetricGroup(4))।

गोल्फ संस्करण

function(m,G)return AbelianInvariants(GroupByMultiplicationTable(List(G,a->List(G,b->Position(G,m(a,b))))));end
— क्रिश्चियन सिवर्स
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.