यदि आपको कोई बाधा या पूर्वानुमान योग्य इनपुट है तो हॉल्टिंग समस्या को हल करना संभव है?

18

रुकने की समस्या को सामान्य मामले में हल नहीं किया जा सकता है। परिभाषित नियमों के साथ आना संभव है जो अनुमत इनपुट को प्रतिबंधित करते हैं और क्या उस विशेष मामले के लिए हॉल्टिंग समस्या को हल किया जा सकता है?

उदाहरण के लिए, यह संभावना प्रतीत होती है कि एक भाषा जो उदाहरण के लिए छोरों की अनुमति नहीं देती है, यह बताना बहुत आसान होगा कि क्या कार्यक्रम रुक जाएगा या नहीं।

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

— केन ली
स्रोत

10

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

प्रत्यावर्तन

स्क्रिप्टिंग भाषाओं में एक सामान्य प्रतिबंध पुनरावर्ती को गतिशील रूप से रोकने के लिए है: यदि A B कॉल C को कॉल करता है ... A को कॉल करता है, तो दुभाषिया (या चेकर, आपके मामले में) एक त्रुटि देता है या संकेत देता है, भले ही पुनरावृत्ति वास्तव में समाप्त हो जाए। दो ठोस उदाहरण:

C प्रीप्रोसेसर एक मैक्रो को बरकरार रखता है जबकि यह उस मैक्रो का विस्तार कर रहा है। एक फ़ंक्शन के आसपास एक आवरण को परिभाषित करने के लिए सबसे आम उपयोग है:
```
#define f(x) (printf("calling f(%d)\n", (x)), f(x))
f(3);
```
इसका विस्तार होता है
```
(printf("calling f(%d)\n", (3)), f(3))
```
पारस्परिक पुनरावृत्ति को भी संभाला जाता है। एक परिणाम यह है कि सी प्रीप्रोसेसर हमेशा समाप्त होता है, हालांकि उच्च रन-टाइम जटिलता के साथ मैक्रोज़ का निर्माण करना संभव है।
```
#define f0(x) x(x)x(x)
#define f1(x) f0(f0(x))
#define f2(x) f1(f1(x))
#define f3(x) f2(f2(x))
f3(x)
```
यूनिक्स के गोले एलियासेस का पुनरावर्ती रूप से विस्तार करते हैं, लेकिन केवल तब तक जब तक वे एक उपनाम का सामना नहीं करते हैं जो पहले से ही विस्तारित हो रहा है। फिर, प्राथमिक उद्देश्य समान रूप से नामित कमांड के लिए एक उपनाम को परिभाषित करना है।
```
alias ls='ls --color'
alias ll='ls -l'
```

$n$ $n$

यह साबित करने के लिए और अधिक सामान्य तकनीकें हैं कि पुनरावर्ती कॉल समाप्त हो जाते हैं, जैसे कि कुछ सकारात्मक पूर्णांक जो हमेशा एक पुनरावर्ती कॉल से घटते हैं, लेकिन ये पता लगाने के लिए काफी कठिन हैं। वे अक्सर सत्यापित करने के लिए कठिन हैं, अकेले अनुमान लगाते हैं।

लूप्स

for $m$ $n$

विशेष रूप से, लूप के लिए (साथ ही उचित भाषा निर्माण जैसे सशर्त), आप सभी आदिम पुनरावर्ती कार्य लिख सकते हैं , और इसके विपरीत। आप आदिम पुनरावर्ती कार्यों को वाक्यात्मक रूप से पहचान सकते हैं (यदि वे असंबद्ध तरीके से लिखे गए हैं), क्योंकि वे लूप या गोटो या पुनरावृत्ति या अन्य चाल का उपयोग नहीं करते हैं। आदिम पुनरावर्ती कार्यों को समाप्त करने की गारंटी है, और अधिकांश व्यावहारिक कार्य आदिम पुनरावृत्ति से परे नहीं जाते हैं।

— गिल्स 'SO- बुराई होना बंद करो'
स्रोत

4

टर्मिनेटर और AProVe देखें । वे उत्तराधिकार पर भरोसा करते हैं, और मुझे यकीन नहीं है कि यदि वे स्पष्ट रूप से उन कार्यक्रमों के वर्ग का वर्णन करते हैं जिनके लिए वे काम करते हैं। फिर भी, उन्हें अत्याधुनिक माना जाता है, इसलिए उन्हें आपके लिए अच्छे शुरुआती बिंदु होने चाहिए।

— rgrig
स्रोत

4

हां, यह संभव हो सकता है। ऐसी समस्याओं को हल करने का एक सामान्य तरीका इनपुट के एक भाग के रूप में कोड के आधार पर एक अतिरिक्त (मोनोटोन) असुविधाजनक पैरामीटर पर विचार करना है । उस पैरामीटर की समस्या की जटिलता को गंभीर रूप से कम किया जा सकता है।

हम पैरामीटर की गणना नहीं कर सकते हैं, लेकिन यदि आप जानते हैं कि आपके द्वारा इनपुट इनपुट के छोटे पैरामीटर मान हैं, तो आप इसे कम संख्या में ठीक कर सकते हैं और एल्गोरिथ्म का उपयोग कर सकते हैं।

हॉल्टिंग और इसी तरह की समस्याओं की अवांछनीयता से निपटने के लिए औपचारिक-विधियों में इस और इसी तरह की चाल का उपयोग किया जाता है। लेकिन अगर आप जो तय करना चाहते हैं वह जटिल है, तो आपके एल्गोरिदम की जटिलता उन उदाहरणों पर एल्गोरिथ्म चलाने से बेहतर होने की संभावना नहीं है।

अन्य प्रश्न के संबंध में, यदि आप इनपुट को पर्याप्त रूप से प्रतिबंधित करते हैं, तो रुकने की समस्या आसान हो सकती है। उदाहरण के लिए, यदि आप जानते हैं कि इनपुट बहुपद समय एल्गोरिदम हैं, तो उनके लिए रुकने की समस्या का निर्णय तुच्छ है (चूंकि हर बहुपद समय एल्गोरिथ्म हाल्ट)।

औपचारिक-विधियों में आने वाली समस्याएं आम तौर पर अनिर्वाय हैं, आप साहित्य की जांच कर सकते हैं कि वे व्यवहार में इन समस्याओं से कैसे निपटते हैं।

— कावेह
स्रोत

4

औपचारिक रूप से कठोर जवाब नहीं, लेकिन यहाँ यह जाता है:

यह निर्धारित करने में समस्या है कि यह रुकता है या हमेशा के लिए बंद हो जाता है। एक समय में या संख्याओं के अंतराल के बीच एक तत्व को सीमित करने पर लूपिंग ठीक है। संपादित करें: जाहिर है, यह केवल तभी काम करेगा जब पुनरावृत्त संग्रह या अंतराल को बदलने के लिए निषिद्ध है (जैसे, अपरिवर्तनीयता) जब इसे पुनरावृत्त किया जा रहा है (या कम से कम, बढ़ने के लिए निषिद्ध)।

पुनरावृत्ति संभवत: ठीक नहीं है, जब तक कि आप इसे परिमित बनाने के लिए एक कलात्मक नियम निर्धारित नहीं करते हैं, जैसे कि अधिकतम स्टैक गहराई की अनुमति देना, या प्रत्येक पुनरावृत्ति में एक गैर-नकारात्मक पैरामीटर घट जाता है।

मनमाना गोटो आम तौर पर खराब होते हैं। बैकवर्ड-गेटोस को छोरों के लिए नेतृत्व करने की बहुत संभावना है जो अनंत हो सकते हैं।

Whiles और do-whiles स्टेटमेंट एक समस्या है, क्योंकि वे एक ऐसी स्थिति पर निर्भर करते हैं, जिसे निष्पादन के दौरान बदलने या न करने की गारंटी नहीं है। प्रतिबंधित करने के लिए एक संभव (लेकिन शायद बहुत असंतोषजनक) तरीका है कि अधिकतम संख्या में पुनरावृत्तियों को संभव बनाना है।

— विक्टर स्टैफ़ुसा
स्रोत

2

आपको अपनी स्क्रिप्ट भाषा की परिभाषा प्रदान करने की आवश्यकता है, और आपको स्क्रिप्ट लेखकों से "अपेक्षा" से क्या मतलब है।

यदि भाषा केवल रैखिक असाइनमेंट और रैखिक स्थिति की अनुमति दे रही है, तो यह रुकना बहुपद समय में कम या ज्यादा होता है ${\cal O}(n^\omega)$ ) मेरी टिप्पणी में तिवारी के पेपर द्वारा।

हारून आर। ब्रैडले, ज़ोहर मन्ना और हेनी बी। सिपमा द्वारा बहुपद कार्यक्रम के एक वर्ग के लिए एक समान परिणाम है। लेकिन AFAIK (मैं यहां गलत हो सकता है) रनटाइम दोगुना घातांक है (अनिवार्य रूप से ग्रोबनेर आधार की गणना करने के लिए आवश्यक समय)।