दो काउंटरों ऑटोमेटा के बारे में अनुमान


19

मैं निम्नलिखित अनुमान को साबित (या अस्वीकृत) करना चाहूंगा:

अनुमान : एक दो काउंटर ऑटोमेटा (2CA) निम्नलिखित भाषा तय नहीं कर सकता है:

n }L={n की त्रिगुट और बाइनरी अभ्यावेदन दोनों भी लंबाई या विषम लंबाई हैn}

एक 2CA आसानी से जांच सकता है कि क्या बाइनरी प्रतिनिधित्व में सम या विषम लंबाई है (बस दो से विभाजित करें और प्रत्येक विभाजन के बाद "यहां तक ​​कि लंबाई" ध्वज को अपडेट करें); उसी तरह से यह जांच सकता है कि क्या टर्नरी प्रतिनिधित्व में सम या विषम लंबाई है (बस तीन से विभाजित करें और प्रत्येक विभाजन के बाद "यहां तक ​​कि लंबाई" ध्वज को अपडेट करें)।

लेकिन उनमें से एक की गणना करने के लिए इसे अपने इनपुट को नष्ट करना होगा , और दूसरे की गणना करने के लिए इसे पुनर्प्राप्त नहीं किया जा सकता है; इसलिए ऐसा लगता है कि को तय करने का कोई तरीका नहीं है ।L

क्या आप एक ऐसी तकनीक जानते हैं जिसका उपयोग अनुमान को साबित करने के लिए किया जा सकता है?
या आप तय करने वाले 2CA के निर्माण पर रोक लगा सकते हैं ? L

मैंने इबारा के बाद उसी दृष्टिकोण की कोशिश की, यह साबित करने के लिए कि 2CA तय नहीं कर सकता है{n2n1} , लेकिन यह सही तरीका नहीं है।

नोट : सादगी के लिए 2CA एक प्रोग्राम के बराबर है जिसमें एक चर है जिसमें शुरू में इनपुट और निम्नलिखित निर्देश सेट है:c

  • INC : वैरिएबल में एक जोड़ें;
  • DEC : डेक्रिमेंट (केवल यदि यह शून्य से अधिक है);c
  • JZ lab c l l a b : यदि लेबल शून्य कूद है तो जारी रखें;clab
  • MULK सी के : कॉस्टेंट द्वारा गुणा ;cK
  • DIVK[,lab0,lab1,...,labK1] : निरंतर द्वारा विभाजित करें और भागफल को ( ) में ; संभवतः शेष ( ) के अनुसार अलग-अलग लेबल पर ;कश्मीर = सी / कश्मीर आधुनिक कश्मीरcKcc=c/KcmodK
  • गोटो lab : बिना शर्त कूद;
  • HALT स्वीकार करें। अस्वीकार : रोकें और स्वीकार करें या रोकें और अस्वीकार करें।

उदाहरण के लिए एक कार्यक्रम की जाँच करने के लिए कि n का द्विआधारी निरूपण लंबाई भी है:

   loop: JZ even   // test if n = 0
         DIV 2
         JZ odd    // test if n = 0
         DIV 2
         GOTO loop
   even: HALT Accept
    odd: HALT Reject

(हम एक बराबर 2CA का निर्माण कर सकते हैं)


2
मैं कैसे असंभव सबूत जाना पता नहीं है, लेकिन { | की त्रिगुट प्रतिनिधित्व अजीब लंबाई है} मामले है , व्याख्या करने योग्य, क्योंकि जब भी अपने इनपुट केवल अभाज्य गुणकों में जाना जाता है आप अपने घातांक (यहाँ n इलाज कर सकते हैं ) के रूप में कई काउंटरों (अतिरिक्त primes द्वारा सिम्युलेटेड) के साथ एक नकली automaton में काउंटरों के रूप में आप चाहते हैं, इस प्रकार ट्यूरिंग-पूरा। 2 एन2n2n
अर्जन जोहान्सन

2
मैंने आपको कुछ "कोड" ईमेल किए, और किसी और को देखने की स्थिति में इसे अपनी वेबसाइट पर भी डाल दिया ।
अर्जन जोहान्सन

1
@joro विधि मैं वर्णित एक सख्त सीमा है: यह केवल इनपुट के परिमित कई प्रमुख कारकों संभाल कर सकते हैं समस्या है (यदि शेष के परीक्षण के लिए छोड़कर सभी 0 या नहीं कर रहे हैं।) है कि सामान्य समस्या है, के एक्स्पोनेंट्स सब प्रधानमंत्री कारकों की गणना। आप वास्तव में गणना कर सकते हैं या तो अपने या अपने समता अप करने के लिए है, लेकिन जहाँ तक मुझे पता है, वहाँ के लिए एक सामान्य इनपुट तुलना करने के लिए कोई रास्ता नहीं है या प्रक्रिया में नष्ट किए बिना, ताकि आप परीक्षण नहीं कर सकते अन्य एक बाद में। अभी मेरा कूबड़ यह है कि सामान्य समस्या एक 2CA के साथ अस्वीकार्य है। m 2 k 3 mkm2k3m
अर्जन जोहान्सन

1
@ VrjanJohansen: मैं vzn से सहमत हूँ: यदि आप चाहें, तो आप उत्तर को सरल प्रतिबंधित समस्या के समाधान के साथ पोस्ट कर सकते हैं (इनाम के :-)) और उन लोगों की मदद कर सकते हैं जो मूल समस्या में जल्दी आना चाहते हैं। आप यह भी संक्षेप में नोट कर सकते हैं कि इबारा का दृष्टिकोण सामान्य समस्या के लिए क्यों विफल हो जाता है, और सरल संस्करण का समाधान सामान्य के लिए विफल क्यों होता है (टिप्पणी को जोरो पर कॉपी-पेस्ट करें)।
मारजियो डी बियासी

1
धन्यवाद! इस समस्या में सभी रुचि / गतिविधि देखने के लिए महान / दुर्लभ। इस समस्या पर कुछ और टिप्पणियाँ / प्रश्न
vzn

जवाबों:


11

इसलिए लोग मुझे इसे पोस्ट करने के लिए परेशान करते रहते हैं भले ही यह समस्या का एक सरल संस्करण हल करता हो। ठीक है फिर :)

इसके अंत में, मैंने जो कुछ सीखा, वह मैंने इबारा और ट्रिज्म के पेपर से लिया था, और यह तरीका हमारी सामान्य समस्या पर क्यों टूटता है, लेकिन शायद अभी भी कुछ उपयोगी जानकारी देता है।

लेकिन पहले, हम सेट को तय करने की कोशिश की सरल समस्या पर ध्यान देंगे

2 n }L={2n त्रिगुट और की बाइनरी अभ्यावेदन दोनों भी लंबाई या विषम लंबाई है2n}

नोट यह कैसे है बजाय मूल समस्या के रूप में। विशेष रूप से यदि इनपुट नंबर 2 की शक्ति नहीं है, तो हम किसी भी आधार में इसकी लंबाई की गणना करने के प्रयास के बजाय इसे अस्वीकार करना चाहते हैं। एन2nn

यह बहुत मायने रखती है सरल: मूल संख्या लिखी गई है तो प्रधानमंत्री के रूप में factorized , तो सभी के लिए छोड़कर हम सिर्फ जांच करने की जरूरत है कि वे सभी ।v i v 2v23v35v57v7...viv20

यह हमें एक सरलीकृत स्थिति के एकल चर के प्रमुख गुणन के प्रमुख कारकों में मुठभेड़ आटोमैटोन की स्थिति को कूटने की पुरानी विधि (Minsky I मानकर) के चारों ओर एक आवरण का उपयोग करके इस सरलीकृत समस्या को हल करने की अनुमति देता है । जैसा कि ऊपर ओपी में उल्लेख किया गया है वह 2-काउंटर ऑटोमेटन के बराबर है।k

सबसे पहले, हम एक की जरूरत -counter आटोमैटिक मशीन रैप करने के लिए। हम 3 काउंटर, नामित उपयोग करेगा , और ।v 2 v 3 v 5kv2v3v5

ऑटोमेटन प्रारंभिक काउंटर मानों के लिए iff को स्वीकार करेगा, के टर्नरी और बाइनरी प्रतिनिधित्व दोनों की लंबाई या विषम लंबाई है, और और दोनों शून्य हैं। जब यह स्वीकार करेगा तो यह पहले अपने सभी काउंटरों को शून्य कर देगा। वी 3 वी 52v2v3v5

यहां ओपी के समान एक विधानसभा प्रारूप में, इसके लिए कुछ कोड है (मैंने निर्देशों में केवल चर जोड़ा है)। मैंने वास्तव में इसका परीक्षण नहीं किया है, क्योंकि मेरे पास इसे चलाने के लिए कुछ भी नहीं है, लेकिन मैं इसे एक औपचारिकता मानता हूं: 3-काउंटर ऑटोमेटा अच्छी तरह से ट्यूरिंग-पूर्ण होने के लिए जाना जाता है, और उनमें से किसी एक के किसी भी कम्प्यूटेशनल फ़ंक्शन का निर्माण करने में सक्षम होने के लिए प्रारंभिक मूल्य।

// Check that v3 and v5 are both zero.
                JZ v3, check5
                GOTO reject
check5:         JZ v5, init3
                GOTO reject
// Decrement v2 until it is zero, constructing 2^n in the process.  If 2^n
// was even, we will then pass to even2 with 2^n in v3; If 2^n was odd, we
// will pass to odd2 with 2^n in v5.
init3:          INC v3          // Set v3 to 1 = 2^0 to start with.
even1:          // We have decremented v2 an even number of times so far.
                // 2^decremented amount is in v3.
                JZ v2, odd2
                DEC v2
dup3to5:        JZ v3, odd1
                DEC v3
                INC v5
                INC v5
                GOTO dup3to5
odd1:           // We have decremented v2 an odd number of times so far.
                // 2^decremented amount is in v5.
                JZ v2, even2
                DEC v2
dup5to3:        JZ v5, even1
                DEC v5
                INC v3
                INC v3
                GOTO dup5to3
// The second part checks the ternary length of 2^n, which starts out in v3
// or v5 according to whether the *binary* length of 2^n (i.e. n+1) was odd
// or even.
odd2:           // v3 needs to have odd ternary length to accept.
                // It is simplest to consider 0 to have even length in both
                // binary and ternary.  This works out as long as we're
                // consistent.
                JZ v3, reject
trisect3to5:    DEC v3
                DEC v3
                JZ v3, even2
                DEC v3
                INC v5
                GOTO trisect3to5
even2:          // v5 needs to have even ternary length to accept
                JZ v5, accept
trisect5to3:    DEC v5
                DEC v5
                JZ v5, odd2
                DEC v5
                INC v3
                GOTO trisect5to3
accept:         HALT Accept
reject:         HALT Reject

अगला चरण एक एकल चर ऑटोमोबेटन के घातांक में उपरोक्त को फिर से एनकोड करना है। जैसा कि परिणाम बहुत लंबा है, मैं सिर्फ सामान्य विधि का वर्णन करूंगा, लेकिन एक पूर्ण संस्करण (स्पॉट में थोड़ा "अनुकूलित") मेरी वेबसाइट पर है।

                JZ vp, label
                DEC vp
next:           ...

बन जाता है (मूल रूप से p से विभाजित होता है, और तब विभाजन पूर्ववत नहीं होता है तो पूर्ववत करें):

                DIV p, next, ..., newlabel.fp-1
newlabel.f1:    MUL p
                GOTO newlabel.i1
...
newlabel.fp-1:  MUL p
                INC
newlabel.ip-2:  INC
...
newlabel.i1:    INC
                GOTO label
next:           ...

INC vpबन जाता है MUL p। व्यक्तिगत JZऔर DECसबसे पहले संयुक्त रूप में बदला जा सकता है। GOTO labelऔर HALT Rejectअपरिवर्तित हैं।

HALT Acceptअपरिवर्तित होगा, इसके अलावा कि हमारे मामले में हम अभी भी करने के लिए एक अंतिम जाँच की है: हम यह सुनिश्चित करने की संख्या में कोई प्रधानमंत्री कारक हैं कि जरूरत अन्य 2,3 और 5 हमारे विशेष 3-काउंटर automaton शून्य चूंकि यह काउंटर से जब यह स्वीकार करता है तो इसका उपयोग किया जाता है, यह सरल है: बस परीक्षण करें कि अंतिम चर 1 है, जो कोड पर कूदकर किया जा सकता है

                DEC     // BTW it cannot be zero before this.
                JZ accept
                HALT Reject
accept:         HALT Accept

मेरी वेबसाइट के कोड में एक प्रारंभिक जांच भी है कि संख्या शून्य नहीं है, जो मुझे अभी पता चला है कि v3, v5 शून्य चेक, ओह अच्छी तरह से बेमानी है।

जैसा कि मैंने उल्लेख किया है, उपरोक्त विधि सरलीकृत समस्या के लिए काम करती है, लेकिन इसमें वास्तव में सामान्य व्यक्ति के लिए काम करने का कोई मौका नहीं है , क्योंकि: सामान्य समस्या में प्रत्येक सामान्य प्रतिपादक का सटीक मूल्य उसके सामान्य आकार को तय करने के लिए मायने रखता है और इस प्रकार जो इसे लंबा करता है विभिन्न ठिकानों में है। इस का मतलब है कि:

  • हमारे पास काउंटरों के लिए उपयोग करने के लिए कोई "निशुल्क" प्राइम नहीं है।
  • यहां तक कि अगर हम किया था काउंटरों के लिए मुफ्त अभाज्य संख्या है, हम वास्तव में सभी असीम कई अन्य अभाज्य जिसका प्रतिपादक मूल्यों से आवश्यक जानकारी निकालने के लिए एक तरीका मौजूद नहीं है कर बात।

तो आइये उपरोक्त लिंक किए गए कागज से इबारा और ट्रिम् (सामान्य रूप से डाउनलोड करने योग्य संस्करण ) से सामान्य पद्धति के सार की व्याख्या करते हैं कि कैसे साबित किया जाए कि कुछ समस्याएँ 2CA द्वारा हल नहीं की जा सकती हैं, और यह हमारे अंदर कैसे टूट जाती है। मामला।

s

फिर, वे इस ऑटोमेटन का विश्लेषण करते हैं ताकि यह निष्कर्ष निकाला जा सके कि वे संख्याओं के कुछ अंकगणितीय अनुक्रमों का निर्माण कर सकते हैं जिनका व्यवहार जुड़ा हुआ है। सटीक होना (इनमें से कुछ को प्रमेय के रूप में नहीं बताया गया है, लेकिन उनके दो मुख्य उदाहरणों के प्रमाण में निहित है):

  1. vixi sD>0x+nDn0
  2. Xs2+1xXivixsp,rXK1,K2

    • n0p+nK1r+nK2

(विचार:

  • x>sxX
  • इसमें से अधिकांश को अस्वीकार किए गए नंबरों के लिए भी पकड़ना चाहिए , जब तक कि अस्वीकृति नॉनटर्म के बजाय स्पष्ट रूप से रुक रही है))।

D,K1,K2>s

K1=K2=6kkpr2k3kp+6knq+6kn

K1K2


1
बहुत अच्छा और स्पष्ट जवाब!
मार्जियो डी बियासी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.