क्या ट्यूरिंग-पूर्णता के लिए एक डू-टाइम लूप पर्याप्त है?

Question

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

मुझे एहसास है कि यहाँ कुछ शब्दार्थ थोड़ा अस्पष्ट हो सकता है, इसलिए मुझे एक विशिष्ट उदाहरण के साथ वास्तविक प्रश्न का वाक्यांश देना चाहिए:

Brainfuck (BF) एक ट्यूरिंग टारपीट है जहां एकमात्र नियंत्रण प्रवाह एक डू-डू लूप है, जिसे इस रूप में दर्शाया जाता है [...](सवाल के तल पर एक पूर्ण भाषा युक्ति है, यदि आप Brainfuck से परिचित नहीं हैं)। आइए एक नई भाषा बीएफ * को परिभाषित करें, जहां ,.+-<>बीएफ के रूप में एक ही शब्दार्थ है, लेकिन इसके बजाय []हमारे पास {}एक डू-लूप है। यही है, बीएफ के लिए एकमात्र अंतर यह है कि प्रत्येक लूप को कम से कम एक बार निष्पादित किया जाता है इससे पहले कि पुनरावृत्तियों को छोड़ दिया जा सकता है।

क्या BF * ट्यूरिंग-पूर्ण है? यदि यह है, तो मैं दिलचस्पी लेता हूँ कि मैं BF से BF * में कैसे अनुवाद कर सकता हूँ। यदि ऐसा नहीं है, तो मैं यह कैसे साबित करूं?

मेरे स्वयं के कुछ अवलोकन:

• हर BF प्रोग्राम को BF * में ट्रांसलेट नहीं किया जा सकता है। उदाहरण के लिए, बीएफ * में एक प्रोग्राम लिखना असंभव है जो मूल्य को पढ़ या प्रिंट नहीं कर सकता है - यदि प्रोग्राम संभावित रूप से एक या अधिक मान प्रिंट करता है, तो यह हमेशा कम से कम एक प्रिंट करेगा। हालांकि, बीएफ का ट्यूरिंग-पूर्ण उपसमुच्चय हो सकता है जिसे बीएफ * में अनुवाद किया जा सकता है।
• हम केवल अनुवाद नहीं कर सकते हैं [f](जहां fकुछ मनमाना है, ब्रेनफक प्रोग्राम जिसमें केवल शामिल है +-[]<>) (पहले पुनरावृत्ति के प्रभाव को रद्द करने के प्रयास में), क्योंकि क) प्रत्येक कम्प्यूटेशनल फ़ंक्शन का एक कम्प्यूटेशनल उलटा और ख नहीं है) भले ही उन्होंने किया हो जरूरी नहीं है कि इस चरण को लागू करने की तुलना में कम लूप न हों, पहली जगह में समाप्त करने की गारंटी नहीं है।f-1{f}f-1f

---

यहां ब्रेनफक भाषा पर एक त्वरित अवलोकन है। ब्रेनफैक एक अनंत टेप पर संचालित होता है, जहां प्रत्येक सेल में एक बाइट मान होता है, शुरू में शून्य। ओवरफ्लो चारों ओर लपेटता है, इसलिए 255 की वृद्धि में 0 और इसके विपरीत देता है। भाषा में 8 निर्देश शामिल हैं:

+   Increment the current cell.
-   Decrement the current cell.
>   Move tape head to the right.
<   Move tape head to the left.
,   Input a character from STDIN into the current cell.
.   Output the current cell as a character to STDOUT.
[   If the current cell is zero, jump past the matching ].
]   If the current cell is non-zero, jump back to just behind the matching [.

Comments

बहुत ही समान प्रश्न ।

— राफेल

दिलचस्प है, लेकिन लगता है कि यह पूरी तरह से ध्यान से निर्मित नहीं है। []बीएफ में "लूप" करते समय बिल्कुल परिभाषित नहीं है। जैसा कि आपकी तालिका में बाएँ और दाएँ कोष्ठक वर्तमान सेल शून्य / नॉनज़रो का मूल्यांकन करते हैं। तो इसी {}ब्रेसिज़ मूल्यांकन तर्क का सटीक वर्णन क्या है ? कंप्यूटर विज्ञान चैट में आगे के संवाद / चर्चा का सुझाव दें । यह भी कि आपके "अवलोकनों" को बिना प्रमाण के "पोस्ट-डिजिट" या "प्रस्ताव" पसंद हैं।

— vzn

@vzn वे अच्छे अंक हैं। मुझे लगा कि स्पष्ट परिभाषा यह {}होगी {कि कुछ भी न करें और }जैसा है वैसा ही करें ]। अगले कुछ दिनों में मेरे पास ज्यादा समय नहीं होगा, लेकिन जब मैं कुछ समय पाऊंगा तो मैं आपसे चैट में शामिल हो जाऊंगा।

— मार्टिन एंडर

इसलिए यह स्पष्ट रूप से पूछने के लिए कुछ सूक्ष्म है और यहां दो बिल्कुल अलग प्रश्न प्रतीत होते हैं। (1) किसी भी ट्यूरिंग भाषा को थोड़ी देर के लूप (और "अन्य सामान") के साथ दिया जाता है, क्या इसे ट्यूरिंग पूरी भाषा में केवल डो-लूप के बजाय परिवर्तित किया जा सकता है। लेकिन फिर किसी को जवाब देने के लिए "अन्य सामान" के बारे में अधिक जानने की जरूरत है। (2) दिए गए बीएफ और एक नई बीएफ * की दी गई परिभाषा {}और दूर ले जाने के साथ [], बीएफ * ट्यूरिंग पूर्ण है। समझ है कि बीएफ साथ []एक निर्माण है केवल करने के लिए कुछ हद तक की तरह / अनुरूप कुछ पूरा भाषाओं ट्यूरिंग में एक पाश जबकि-से करते हैं।

— vzn

@vzn हिस्सा (1) केवल TL था; मेरे सवाल का DR हिस्सा। मैं पूरी तरह से जानता हूं कि "कुछ भाषा" के लिए उत्तर देना असंभव है। यही कारण है कि मैंने एक बहुत ही सरल खिलौना भाषा (BF) के संदर्भ में वास्तविक प्रश्न को संक्षिप्त कर दिया है ताकि यह लूप के व्यवहार को कम कर सके (क्योंकि मुझे लगा कि BF * को टीसी दिखाया जा सकता है जो इसे सरल बना देगा। अन्य भाषाओं के लिए इसे दिखाने के लिए जो केवल करते हैं-जबकि लूप्स)। मुझे यकीन नहीं है कि आप कैसे सोचते हैं कि बीएफ लूप अन्य भाषा के समय के लूप से अलग हैं।

— मार्टिन एंडर

Answer 1

मैं ब्रेनफॉक नहीं जानता, इसलिए आपको मेरे छद्मकोड से कुछ अनुवाद करना होगा। लेकिन, यह मानते हुए कि ब्रेनफक समझदारी से व्यवहार करता है (हा!), नीचे दी गई हर चीज को लागू होना चाहिए।

do-जबकि, जबकि-do के बराबर है। do X while Yके बराबर है X; while Y do Xऔर, आपके पास सशर्त है, while Y do Xके बराबर है if Y then (do X while Y)।

यदि आपके पास सशर्त नहीं हैं तो जीवन थोड़ा कठिन है। यदि आपके पास समय है, तो आप if Y then Xइस तरह से कुछ का उपयोग करके अनुकरण कर सकते हैं :

B := true
while (Y and B) do
    X
    B := false
endwhile

लेकिन क्या होगा अगर आप केवल करते हैं? मेरा दावा है कि निम्नलिखित अनुकरण करता है if Y then X, यह मानते हुए कि Xचर का वर्तमान मूल्य दिया गया है। (यह गारंटी नहीं है: कार्यक्रम if y=0 then loopforeverसमाप्त हो जाता है y != 0, भले ही Xचर के किसी भी मूल्य के लिए छोरों)। चलो V1, ..., Vnचर द्वारा संशोधित किया Xऔर जाने X'जा Xहै कि यह प्रयोग करता है ताकि संशोधित Vi'करने के बजाय Viवे चर से प्रत्येक के लिए। swap(A,B)स्पष्ट कोड को दर्शाता है जो चर को स्वैप करता है Aऔर B।

V1' := V1; ...; Vn' := Vn
V1'' := V1; ...; Vn'' := Vn
C := 0
do
    X'
    swap (V1',V1''); ...; swap (Vn',Vn'')
    C := C+1
while Y and C<2
V1 := V1'; ...; Vn := Vn'

विचार निम्नलिखित है। पहले, मान लीजिए कि Yझूठ है। हम Xएक बार अनुकरण करते हैं , और परिणामों को स्टोर करते हैं V1'', ..., Vn''; V1', ..., Vn'के मूल मानों को पकड़ो V1, ..., Vn। फिर, हम असाइन करते हैं V1 := V1'; ...; Vn := Vn', जो कुछ भी नहीं करता है। इसलिए, अगर Yगलत है, तो हमने कुछ नहीं किया है। अब, मान लीजिए कि Yयह सच है। अब हम X दो बार अनुकरण करेंगे , दोनों "प्राइमेड" और "डबल-प्रिमेड" वेरिएबल्स में परिणाम स्टोर करेंगे । तो, अब, लूप के अंत में असाइनमेंट का प्रभाव है जो Xएक बार गणना की गई थी। ध्यान दें कि Yकेवल "अप्रकाशित" चर पर निर्भर करता है, इसलिए लूप को बार-बार चलाने से इसका मूल्य प्रभावित नहीं होता है।

ठीक है, तो क्या होगा यदि Xचर के वर्तमान मूल्य के लिए समाप्त नहीं किया जा सकता है? (इस संभावना को इंगित करने के लिए मार्टिन एंडर के लिए धन्यवाद।) उस मामले में, हमें Xनिर्देश-दर-निर्देश अनुकरण करने की आवश्यकता है , जो ऊपर दिए गए समान विचारों का उपयोग करते हैं। प्रत्येक निर्देश निश्चित रूप से समाप्त हो जाता है, इसलिए हम ifउपर्युक्त सिमुलेशन का उपयोग निर्देश डिकोडिंग करने के लिए कर सकते हैं , "यदि ओपोड फू है, तो ऐसा करें; यदि यह बार है, तो ऐसा करें ..."। इसलिए, अब, हम Xइंस्ट्रक्शन पॉइंटर का उपयोग करते हुए, निर्देश के माध्यम से पुनरावृति करने के लिए एक लूप का उपयोग करते हैं और इसी तरह कि हम जानते हैं कि किस निर्देश को आगे निष्पादित करना है। लूप के प्रत्येक पुनरावृत्ति के अंत में, जांचें Yऔर जांचें कि क्या Xअभी तक रुका हुआ है। यदि Yगलत है, तो स्वैपिंग तकनीक हमें इसके प्रभावों को पूर्ववत करने की अनुमति देती हैXपहला निर्देश।

Comments

यह एक साफ विचार है, लेकिन मुझे लगता है कि यहां एक मुद्दा है: उस मामले पर विचार करें जहां Yझूठा है लेकिन Xचर मानों के वर्तमान सेट पर समाप्त नहीं होता है। if Y then Xसमाप्त होता है, लेकिन आपका अनुवाद नहीं होता है, क्योंकि इसे हमेशा X'कम से कम एक बार निष्पादित करने की आवश्यकता होती है ।

— मार्टिन एंडर

@ मार्टिनबटनर अर्ग। आप सही हे। इसलिए हमें Xनिर्देश-दर-निर्देश और Yप्रत्येक निर्देश के बाद जांच करने के लिए लूप का उपयोग करने की आवश्यकता है । प्रत्येक निर्देश को समाप्त करने की गारंटी है, इसलिए सब कुछ काम करेगा। लेकिन यह लिखने के लिए एक दर्द है।

— डेविड रिचेर्बी

मुझे पूरी तरह से यकीन नहीं है कि अगर यह संभव है Xकि इस तरह से फिर से बनाना है अगर यह थोड़ी देर के साथ शुरू होता है / सशर्त। मुझे इस बारे में कुछ और सोचना होगा।

— मार्टिन एंडर

इसके अलावा "तो, अब, हम एक इंस्ट्रक्टर पॉइंटर का उपयोग करके X के निर्देशों के माध्यम से पुनरावृति करने के लिए एक लूप का उपयोग करते हैं और इतने पर कि हम जानते हैं कि आगे किस निर्देश को निष्पादित करना है।" मुझे लगता है कि यह अपने आप में किसी प्रकार की सशर्त आवश्यकता हो सकती है।

— मार्टिन एंडर

मैं अभी भी पूरी तरह से निश्चित नहीं हूं कि यदि X'आप गैर-रैखिक हैं तो आप "प्रत्येक निर्देश" को कैसे परिभाषित करेंगे । क्या आप एक साधारण लेकिन गैर-तुच्छ खिलौने के लिए कुछ और विस्तार सहित मन करेंगे X? जैसे do (while A do B) while C? (बाहर से do whileआता है while doकि हम वर्तमान में अनुवाद कर रहे हैं)

— मार्टिन एंडर