View source for होरे तर्क

{{short description|Rules to verify computer program correctness}}
'''होरे तर्क''' (फ्लोयड-होरे तर्क या होरे नियम के रूप में भी जाना जाता है) [[कंप्यूटर प्रोग्राम की शुद्धता]] के बारे में दृढ़ता से तर्क करने के लिए तार्किक नियमों के एक क्रम के साथ [[औपचारिक प्रणाली]] है। यह 1969 में ब्रिटिश कंप्यूटर वैज्ञानिक और [[गणितीय तर्क|तर्कशास्त्री]] [[टोनी होरे]] द्वारा प्रस्तावित किया गया था, और बाद में होरे और अन्य शोधकर्ताओं द्वारा परिष्कृत किया गया था।<ref name="hoare">{{Cite journal
 |last1=Hoare 
 |first1=C. A. R. 
 |authorlink1=C.A.R. Hoare 
 |title=An axiomatic basis for computer programming 
 |doi=10.1145/363235.363259 
 |journal=[[Communications of the ACM]] 
 |volume=12 
 |issue=10 
 |pages=576&ndash;580 
 |date=October 1969 
 |s2cid=207726175 
 |url=https://dl.acm.org/doi/pdf/10.1145/363235.363259
 }}</ref> मूल विचार रॉबर्ट डब्ल्यू फ़्लॉइड के काम से उत्पन्न हुए थे, जिन्होंने [[प्रवाह संचित्र|फ्लोचार्ट]] के लिए समान प्रणाली<ref>[[Robert W. Floyd|R. W. Floyd]]. "[https://www.cs.tau.ac.il/~nachumd/term/FloydMeaning.pdf Assigning meanings to programs.]" Proceedings of the American Mathematical Society Symposia on Applied Mathematics. Vol. 19, pp. 19–31. 1967.</ref> प्रकाशित की थी।

== होरे त्रिगुण ==
होरे तर्क की केंद्रीय विशेषता होरे त्रिगुण है। त्रिगुण बताता है कि कोड के एक टुकड़े का निष्पादन कैसे गणना की स्थिति को बदलता है। होरे त्रिगुण का रूप है

: <math>\{P\} C \{Q\}</math>
जहां <math>P</math> और <math>Q</math> अभिकथन हैं और <math>C</math> कमांड है।<ref group="note">Hoare originally wrote "<math>P\{C\}Q</math>" rather than "<math>\{P\}C\{Q\}</math>".</ref> <math>P</math> को पूर्व अवस्था और <math>Q</math> को [[पोस्टकंडिशन|पश्च अवस्था]] नाम दिया गया है- जब पूर्व अवस्था पूर्ण हो जाती है, तो कमांड निष्पादित करने से पश्च अवस्था स्थापित हो जाती है। [[विधेय तर्क]] में अभिकथन सूत्र हैं।

होरे तर्क साधारण [[अनिवार्य प्रोग्रामिंग]] भाषा के सभी निर्माणों के लिए [[स्वयंसिद्ध]] और [[अनुमान नियम]] प्रदान करता है। होरे के मूल पेपर में सरल भाषा के नियमों के अलावा, होरे और कई अन्य शोधकर्ताओं द्वारा तब से अन्य भाषा निर्माणों के लिए नियम विकसित किए गए हैं। समवर्ती, प्रक्रियाओं, व्यतिक्रम, और संकेत के लिए नियम हैं। 

== आंशिक और [[कुल शुद्धता]] ==

मानक होरे तर्क का उपयोग करते हुए, केवल [[आंशिक शुद्धता]] ही सिद्ध की जा सकती है। कुल शुद्धता के लिए अतिरिक्त रूप से [[समाप्ति विश्लेषण|समाप्ति]] की आवश्यकता होती है, जिसे अलग से या जबकि नियम के विस्तारित संस्करण के साथ सिद्ध किया जा सकता है।<ref name="Reynolds.2009">{{cite book |title=प्रोग्रामिंग भाषाओं का सिद्धांत|author=John C. Reynolds |author-link=John C. Reynolds |publisher=Cambridge University Press |year=2009}}) Here: Sect. 3.4, p. 64.</ref> इस प्रकार होरे त्रिगुण का सहज ज्ञान युक्त पठन है- जब भी <math>P</math>, <math>C</math> के निष्पादन से पहली अवस्था को धारण करता है, तो <math>Q</math> बाद में धारण करेगा, या <math>C</math> समाप्त नहीं होता है। बाद की स्थिति में, कोई "बाद" नहीं है, इसलिए <math>Q</math> कोई भी कथन हो सकता है। वास्तव में, यह व्यक्त करने के लिए कि <math>C</math> समाप्त नहीं होता है, असत्य होने के लिए कोई भी <math>Q</math> चुन सकता है।

यहाँ और इस लेख के अन्य भागों में "समाप्ति" का अर्थ व्यापक अर्थों में है कि गणना अंततः समाप्त हो जाएगी, अर्थात यह अनंत छोरों की अनुपस्थिति का अर्थ है यह कार्यान्वयन सीमा के उल्लंघन (जैसे शून्य से विभाजन) की अनुपस्थिति को प्रोग्राम को समय से पहले रोकना नहीं दर्शाता है। अपने 1969 के पेपर में, होरे ने समाप्ति की एक संकीर्ण धारणा का उपयोग किया, जिसमें कार्यान्वयन सीमा के उल्लंघन की अनुपस्थिति भी सम्मिलित थी, और समाप्ति की व्यापक धारणा के लिए अपनी प्राथमिकता व्यक्त की क्योंकि यह कार्यान्वयन-स्वतंत्र होने का दावा करता है-<ref>Hoare (1969), p.578-579</ref>

{{quote|ऊपर उद्धृत सिद्धांतों और नियमों में एक और कमी यह है कि वे इस बात के प्रमाण के लिए कोई आधार नहीं देते हैं कि प्रोग्राम सफलतापूर्वक समाप्त हो गया है। समाप्त करने में विफलता अनंत लूप के कारण हो सकती है या यह कार्यान्वयन-परिभाषित सीमा के उल्लंघन के कारण हो सकता है, उदाहरण के लिए, संख्यात्मक संकार्य की सीमा, स्टोरेज का आकार, या ऑपरेटिंग सिस्टम की समय सीमा। इस प्रकार अंकन “<math>P\{Q\}R</math>” की व्याख्या की जानी चाहिए "बशर्ते कि कार्यक्रम सफलतापूर्वक समाप्त हो जाए, इसके परिणामों के गुणों को <math>R</math> द्वारा वर्णित किया गया है।" स्वयंसिद्धों को अनुकूलित करना काफी आसान है ताकि उन्हें गैर-समाप्ति प्रोग्रामों के "परिणामों" की भविष्यवाणी करने के लिए उपयोग नहीं किया जा सके लेकिन स्वयंसिद्धों का वास्तविक उपयोग अब कई कार्यान्वयन-निर्भर विशेषताओं के ज्ञान पर निर्भर करेगा, उदाहरण के लिए, कंप्यूटर का आकार और गति, संख्याओं की सीमा और अतिप्रवाह तकनीक का विकल्प। अनंत लूप से बचने के प्रमाण के अलावा, किसी प्रोग्राम की "सशर्त" शुद्धता को सिद्ध करना और चेतावनी देने के लिए कार्यान्वयन पर भरोसा करना सम्भवतः बेहतर है, यदि इसे कार्यान्वयन सीमा के उल्लंघन के परिणामस्वरूप प्रोग्राम के निष्पादन को त्यागना पड़ा हो।}}

== नियम ==

=== रिक्त कथन स्वयंसिद्ध स्कीमा ===

रिक्त कथन नियम यह दावा करता है कि स्किप कथन प्रोग्राम की स्थिति को नहीं बदलता है, इस प्रकार स्किप से पहले जो भी सही है वह बाद में भी सही रहेगा।<ref group="note">This article uses a [[natural deduction]] style notation for rules. For example, <math>\dfrac{\alpha,\beta}{\phi}</math> informally means "If both {{mvar|&alpha;}} and {{mvar|&beta;}} hold, then also {{mvar|&phi;}} holds"; {{mvar|&alpha;}} and {{mvar|&beta;}} are called antecedents of the rule, {{mvar|&phi;}} is called its succedent. A rule without antecedents is called an axiom, and written as <math>\dfrac{}{\quad\phi\quad}</math>.</ref>
: <math>\dfrac{}{\{P\}\texttt{skip}\{P\}}</math>
=== नियत कार्य स्वयंसिद्ध स्कीमा ===

नियत कार्य स्वयंसिद्ध कहता है कि, नियत कार्य के बाद, कोई भी विधेय जो पहले नियत कार्य के दाईं ओर के लिए सही था, अब चर के लिए मान्य है। औपचारिक रूप से, मान लीजिए कि {{mvar|P}} अभिकथन है जिसमें चर {{mvar|x}} [[मुक्त चर और बाध्य चर|मुक्त]] है। तब-
: <math>\dfrac{}{\{P[E/x]\} x := E \{P\}}</math>
जहां <math>P[E/x]</math> अभिकथन {{mvar|P}} को दर्शाता है जिसमें {{mvar|x}} की प्रत्येक मुक्त घटना को अभिव्यक्ति {{mvar|E}} द्वारा [[प्रतिस्थापन (तर्क)|प्रतिस्थापित]] किया गया है। 

नियत कार्य स्वयंसिद्ध योजना का अर्थ है कि <math>P[E/x]</math> का सत्य {{mvar|P}} के बाद के नियत कार्य सत्य के बराबर है। इस प्रकार <math>P[E/x]</math> नियत कार्य से पहले सत्य थे, नियत कार्य स्वयंसिद्ध द्वारा, फिर {{mvar|P}} जिसके बाद सत्य होगा। इसके विपरीत, <math>P[E/x]</math> असत्य (अर्थात <math>\neg P[E/x]</math> सत्य) नियत कार्य कथन से पहले थे, {{mvar|P}} को बाद में असत्य होना चाहिए।

मान्य त्रिगुण के उदाहरणों में सम्मिलित हैं-
:*<math>\{ x+1 = 43 \}   y := x + 1   \{ y = 43 \}</math>
:*<math>\{ x + 1 \leq N \}  x := x  + 1  \{ x \leq N \}</math>
सभी पूर्व अवस्था जो अभिव्यक्ति द्वारा संशोधित नहीं की जाती हैं उन्हें पश्च अवस्था पर ले जाया जा सकता है। प्रथम उदाहरण में, <math>y:=x+1</math> निर्दिष्ट करने से यह तथ्य नहीं बदलता है कि <math>x+1=43</math> है, इसलिए दोनों कथन पश्च अवस्था में दिखाई दे सकते हैं। औपचारिक रूप से, यह परिणाम {{mvar|P}} के साथ स्वयंसिद्ध स्कीमा को लागू करके प्राप्त किया जाता है (<math>y=43</math> और <math>x+1=43</math>), जो <math>P[(x+1)/y]</math> को (<math>x+1=43</math> और <math>x+1=43</math>) की उपज देता है, जिसे बदले में दिए गए पूर्व अवस्था <math>x+1=43</math> के लिए सरलीकृत किया जा सकता है। नियत कार्य स्वयंसिद्ध योजना यह कहने के बराबर है कि पूर्व अवस्था को खोजने के लिए, पहले पश्च-अवस्था को लें और नियत कार्य के बाएं हाथ की सभी घटनाओं को नियत कार्य के दाईं ओर के साथ बदल दें। सावधान रहें कि सोचने के इस गलत तरीके से पालन करके यह पीछे की ओर करने की कोशिश न करें- <math>\{P\} x:=E \{P[E/x]\}</math> यह नियम निरर्थक उदाहरणों की ओर जाता है जैसे-
: <math>\{ x = 5 \} x := 3 \{ 3 = 5 \}</math>
पहली नज़र में लुभाने वाली एक और गलत नियम <math>\{P\} x:=E \{P \wedge x=E\}</math> है, यह निरर्थक उदाहरणों की ओर जाता है जैसे-
: <math>\{ x = 5 \}   x := x + 1   \{ x = 5 \wedge x = x + 1 \}</math>
जबकि दिए गए पश्च अवस्था {{mvar|P}} विशिष्ट रूप से पूर्व अवस्था <math>P[E/x]</math> को निर्धारित करता है, इसका विपरीत सत्य नहीं है। उदाहरण के लिए-
:*<math>\{ 0 \leq y\cdot y \wedge y\cdot y \leq 9 \}   x := y \cdot y   \{ 0 \leq x \wedge x \leq 9 \}</math>,
:*<math>\{ 0 \leq y\cdot y \wedge y\cdot y \leq 9 \}   x := y \cdot y   \{ 0 \leq x \wedge y\cdot y \leq 9 \}</math>,
:*<math>\{ 0 \leq y\cdot y \wedge y\cdot y \leq 9 \}   x := y \cdot y   \{ 0 \leq y\cdot y \wedge x \leq 9 \} </math>, और
:*<math>\{ 0 \leq y\cdot y \wedge y\cdot y \leq 9 \}   x := y \cdot y   \{ 0 \leq y\cdot y \wedge y\cdot y \leq 9 \}</math>
नियत कार्य स्वयंसिद्ध योजना के मान्य उदाहरण हैं। 

होरे द्वारा प्रस्तावित नियत कार्य स्वयंसिद्ध तब लागू नहीं होता है जब एक से अधिक नाम एक ही संग्रहीत मान को संदर्भित कर सकते हैं। उदाहरण के लिए,
: <math>\{ y = 3 \}   x := 2   \{ y = 3 \}</math>
यदि {{mvar|x}} और {{mvar|y}} एक ही चर ([[अलियासिंग (कंप्यूटिंग)|उपनाम]]) को संदर्भित करते हैं, तो यह गलत है, हालांकि यह नियत कार्य स्वयंसिद्ध योजना (<math>\{P\}</math>और <math>\{P[2/x]\}</math> दोनों के साथ <math>\{y=3\}</math>) का उचित उदाहरण है।

=== रचना का नियम ===

{| align=right class="wikitable collapsible collapsed"
|-
! Verifying swap-code<BR>without auxiliary variables
|-
|
{| style="border:1px solid grey;"
|+ The three statements below (line 2, 4, 6) exchange the values of the variables {{mvar|a}} and {{mvar|b}}, without needing an auxiliary variable. In the verification proof, the initial value of {{mvar|a}} and {{mvar|b}} is denoted by the constant {{mvar|A}} and {{mvar|B}}, respectively. The proof is best read backwards, starting from line 7; for example, line 5 is obtained from line 7 by replacing {{mvar|a}} (target expression in line 6) by <math>a-b</math> (source expression in line 6). Some arithmetical simplifications are used tacitly, viz. <math>a-(a-b) = b</math> (line 5→3), and <math>a+b-b = a</math> (line 3→1).
|-
| '''Nr''' || '''Code''' || COLSPAN=6 | '''Assertions'''
|-
| '''1:''' &nbsp; &nbsp; &nbsp; || || <math>\{a  = A \wedge b = B \}</math>
|-
| '''2:''' || <math>a := a + b;</math> &nbsp; &nbsp; &nbsp; 
|-
| '''3:''' || || <math>\{ a - b = A \wedge b = B \}</math>
|-
| '''4:''' || <math>b := a - b;</math>
|-
| '''5:''' || || <math>\{b=A\wedge a-b=B\}</math>
|-
| '''6:''' || <math>a := a - b</math>
|-
| '''7:''' || || <math>\{b= A\wedge a = B \}</math>
|}
|}
होरे की रचना का नियम क्रमिक रूप से निष्पादित प्रोग्रामों {{mvar|S}} और {{mvar|T}} पर लागू होता है, जहां {{mvar|S}} {{mvar|T}} से पहले निष्पादित करता है और <math>S;T</math> को लिखा जाता है ({{mvar|Q}} को मध्य अवस्था कहा जाता है)-<ref>{{cite book|first1=Michael|last1=Huth|first2=Mark|last2=Ryan|publisher=CUP|url=http://www.cs.bham.ac.uk/research/projects/lics/|isbn=978-0521543101|title=कंप्यूटर विज्ञान में तर्क|edition=second |pages= 276|date=2004-08-26}}</ref>
:<math>\dfrac{\{P\} S \{Q\}\quad,\quad   \{Q\} T \{R\}}{\{P\} S;T \{R\}}</math>
उदाहरण के लिए, नियत कार्य स्वयंसिद्ध के निम्नलिखित दो उदाहरणों पर विचार करें-

:<math>\{ x + 1 = 43 \}   y := x + 1   \{ y = 43 \}</math>
और

:<math>\{ y = 43 \}   z := y   \{ z = 43 \}</math>
अनुक्रमण नियम द्वारा, एक निष्कर्ष निकाला गया-

:<math>\{ x + 1 = 43 \}   y := x + 1; z := y   \{ z = 43 \}</math>
एक अन्य उदाहरण सही बॉक्स में दिखाया गया है।

=== सशर्त नियम ===

:<math>\dfrac{\{B \wedge P\} S \{Q\}\quad,\quad \{\neg B \wedge P \} T \{Q\}}{\{P\} \texttt{if}\ B\ \texttt{then}\ S\ \texttt{else}\ T\ \texttt{endif} \{Q\}}</math>
सशर्त नियम में कहा गया है कि पश्च अवस्था {{mvar|Q}} सामान्य है और अन्य भाग भी पूरे की पश्च अवस्था है यदि ...यदि अंत कथन।<ref>{{cite journal |last1=Apt |first1=Krzysztof R. |last2=Olderog |first2=Ernst-Rüdiger |title=होरे के तर्क के पचास साल|journal=Formal Aspects of Computing |date=December 2019 |volume=31 |issue=6 |page=759 |doi=10.1007/s00165-019-00501-3|s2cid=102351597 |url=https://ir.cwi.nl/pub/29146 }}</ref> तत्कालीन और अन्य भाग में, अनपेक्षित और ऋणात्मक स्थिति {{mvar|B}} को क्रमशः पूर्व अवस्था {{mvar|P}} में जोड़ा जा सकता है। स्थिति, {{mvar|B}}, के दुष्प्रभाव नहीं होने चाहिए। अगले भाग में उदाहरण दिया गया है।

यह नियम होरे के मूल प्रकाशन में निहित नहीं था।<ref name="hoare"/> हालांकि, कथन के बाद से
:<math>\texttt{if}\ B\ \texttt{then}\ S\ \texttt{else}\ T\ \texttt{endif}</math>
एक-बार के लूप निर्माण के समान प्रभाव होते है
:<math>\texttt{bool}\ b:=\texttt{true};   \texttt{while}\ B\wedge b\ \texttt{do}\ S; b:=\texttt{false}\ \texttt{done};   b:=\texttt{true};   \texttt{while}\ \neg B\wedge b\ \texttt{do}\ T; b:=\texttt{false}\ \texttt{done}</math>
सशर्त नियम अन्य होरे नियमों से व्युत्पन्न किया जा सकता है। इसी तरह, अन्य व्युत्पन्न प्रोग्राम निर्माणों के लिए नियम, जैसे लूप के लिए, लूप तक करें, स्विच करें, ब्रेक करें, जारी रखें को होरे के मूल पेपर से नियमों में परिवर्तन करके कम किया जा सकता है। 

=== परिणाम नियम ===

:<math>\dfrac{P_1 \rightarrow P_2\quad   ,\quad   \{P_2\} S \{Q_2\}\quad   ,\quad   Q_2 \rightarrow Q_1}{\{P_1\} S \{Q_1\}}</math>
यह नियम पूर्व अवस्था <math>P_2</math> को मजबूत करने और/या पश्च अवस्था <math>Q_2</math> को कमजोर करने की अनुमति देता है। इसका उपयोग किया जाता है उदाहरणार्थ तत्कालीन और अन्य भाग के लिए शाब्दिक रूप से समान पश्च अवस्था प्राप्त करना।

उदाहरण के लिए, का प्रमाण है
:<math>\{0 \leq x \leq 15 \}\texttt{if}\ x<15\ \texttt{then}\ x:=x+1\ \texttt{else}\ x:=0\ \texttt{endif} \{0 \leq x \leq 15 \}</math>
सशर्त नियम को लागू करने की आवश्यकता है, जिसे सिद्ध करने की आवश्यकता है
:<math>\{0 \leq x \leq 15 \wedge x < 15 \}   x:=x+1   \{ 0 \leq x \leq 15 \}</math>,   या सरलीकृत
:<math>\{0 \leq x < 15 \}   x:=x+1   \{0 \leq x \leq 15 \}</math>
तत्कालीन भाग के लिए, और
:<math>\{0 \leq x \leq 15 \wedge x \geq 15\}   x:=0   \{0 \leq x \leq 15\}</math>,   या सरलीकृत
:<math>\{x=15\}   x:=0   \{0 \leq x \leq 15 \}</math>
दूसरे भाग के लिए।

हालाँकि, तत्कालीन भाग के लिए असाइनमेंट नियम को {{mvar|P}} को <math>0\leq x \leq 15</math> के रूप में चुनने की आवश्यकता है नियम लागू होता है इसलिए उत्पन्न होती हैl
:<math>\{0 \leq x+1 \leq 15\}   x:=x+1   \{0 \leq x \leq 15\}</math>,  जो तार्किक रूप से समतुल्य हैl
:<math>\{-1 \leq x < 15\}   x:=x+1   \{0 \leq x \leq 15\}</math>.
सशर्त नियम के लिए आवश्यक पूर्व अवस्था <math>\{-1 \leq x < 15\}</math> को नियत कार्य नियम से <math>\{0 \leq x < 15\}</math> तक दृढ़ करने के लिए परिणाम नियम की आवश्यकता है।

इसी प्रकार, दूसरे भाग के लिए, नियत कार्य नियम उत्पन्न करता है
:<math>\{0 \leq 0 \leq 15\}   x:=0   \{0 \leq x \leq 15\}</math>,   या समकक्ष
:<math>\{\texttt{true}\}   x:=0   \{0 \leq x \leq 15\}</math>,
इसलिए परिणाम नियम को <math>P_1</math> और <math>P_2</math> क्रमशः <math>\{x=15\}</math> और <math>\{\texttt{true}\}</math> के साथ लागू करना होगा, पूर्व अवस्था को फिर से दृढ़ करने के लिए।

अनौपचारिक रूप से, परिणाम नियम का प्रभाव "भूल जाना" है कि <math>\{x=15\}</math> अन्य भाग के प्रवेश पर जाना जाता है, क्योंकि अन्य भाग के लिए उपयोग किए जाने वाले नियत कार्य नियम को उस जानकारी की आवश्यकता नहीं है।  

=== जबकि नियम ===

:<math>\dfrac{\{P \wedge B\} S \{P\}}{\{P\} \texttt{while}\ B\ \texttt{do}\ S\ \texttt{done} \{\neg B \wedge P\}}</math>
यहाँ {{mvar|P}} [[ पाश अपरिवर्तनीय |लूप अचर]] है, जिसे लूप बॉडी {{mvar|S}} द्वारा संरक्षित किया जाना है। लूप समाप्त होने के बाद, यह अचर {{mvar|P}} अभी भी धारण करता है, और इसके अलावा <math>\neg B</math> ने लूप को समाप्त करने का कारण बना दिया होगा। जैसा कि सशर्त नियम में है, {{mvar|B}} के दुष्प्रभाव नहीं होने चाहिए। 

उदाहरण के लिए, का प्रमाण
:<math>\{x \leq 10\} \texttt{while}\ x<10\ \texttt{do}\ x:=x+1\ \texttt{done} \{\neg x < 10 \wedge x \leq 10\}</math>
जबकि नियम द्वारा सिद्ध करने की आवश्यकता है
:<math>\{x \leq 10 \wedge x < 10\}   x := x + 1   \{x \leq 10 \}</math>,   या सरलीकृत
:<math>\{x < 10\}   x := x + 1   \{x \leq 10 \}</math>,

जो नियत कार्य नियम द्वारा आसानी से प्राप्त हो जाता है। अंत में, पश्च अवस्था <math>\{\neg x <10 \wedge x\leq 10\}</math> को <math>\{x=10\}</math> में सरलीकृत किया जा सकता है।

एक अन्य उदाहरण के लिए, जबकि नियम का उपयोग निम्नलिखित असामान्य प्रोग्राम को औपचारिक रूप से सत्यापित करने के लिए किया जा सकता है ताकि किसी मनमानी संख्या {{mvar|a}} के सटीक वर्गमूल {{mvar|x}} की गणना की जा सके, भले ही {{mvar|x}} एक पूर्णांक चर हो और {{mvar|a}} वर्ग संख्या न हो-
:<math>\{\texttt{true}\}   \texttt{while}\ x\cdot x \neq a\ \texttt{do}\ \texttt{skip}\ \texttt{done}   \{x \cdot x = a \wedge \texttt{true}\}</math>
{{mvar|P}} के सत्य होने के साथ, जबकि नियम लागू करने के बाद, यह सिद्ध करना शेष रह जाता है
:<math>\{\texttt{true} \wedge x\cdot x \neq a\}   \texttt{skip}   \{\texttt{true}\}</math>,
जो स्किप नियम और परिणाम नियम से अनुसरण करता है। 

वास्तव में, असामान्य प्रोग्राम आंशिक रूप से सही है- यदि यह समाप्त हो गया, तो यह निश्चित है कि {{mvar|x}} में (संयोग से) {{mvar|a}} के वर्गमूल का मान होना चाहिए। अन्य सभी स्थितियों में, यह समाप्त नहीं होगा इसलिए यह पूरी तरह से सही नहीं है।

=== कुल शुद्धता के लिए जबकि नियम ===

यदि उपरोक्त सामान्य जबकि नियम को निम्नलिखित द्वारा प्रतिस्थापित किया जाता है, तो होरे गणना का उपयोग कुल शुद्धता, अर्थात समाप्ति के साथ-साथ आंशिक शुद्धता को सिद्ध करने के लिए भी किया जा सकता है। प्रायः प्रोग्राम शुद्धता की विभिन्न धारणाओं को इंगित करने के लिए धनु कोष्ठकों के स्थान पर वर्ग कोष्ठकों का उपयोग किया जाता है।

:<math>\dfrac{<\ \text{is a well-founded ordering on the set}\ D\quad,\quad [P \wedge B \wedge t \in D \wedge t = z]   S   [P \wedge t \in D \wedge t < z ]}{[P \wedge t \in D]   \texttt{while}\ B\ \texttt{do}\ S\ \texttt{done}   [\neg B \wedge P \wedge t \in D]}</math>
इस नियम में, लूप अचर को बनाए रखने के अलावा, एक अभिव्यक्ति {{mvar|t}} के माध्यम से [[ समाप्ति प्रमाण |समापन]] भी सिद्ध होता है, जिसे [[लूप वेरिएंट|लूप चर]] कहा जाता है, जिसका मान प्रत्येक पुनरावृत्ति के दौरान कुछ क्षेत्र क्रम {{mvar|D}} पर [[अच्छी तरह से स्थापित संबंध]] {{mvar|<}} के संबंध में दृढ़ता से घटता है। चूंकि {{mvar|<}} अच्छी तरह से स्थापित है, {{mvar|D}} के सदस्यों की दृढ़ता से घटती [[श्रृंखला (आदेश सिद्धांत)|श्रृंखला]] में केवल परिमित लंबाई हो सकती है, इसलिए {{mvar|t}} सदैव के लिए घटता नहीं रह सकता है। (उदाहरण के लिए, सामान्य क्रम {{mvar|<}} धनात्मक [[पूर्णांक]] <math>\mathbb{N}</math> पर अच्छी तरह से स्थापित है, लेकिन न तो पूर्णांक <math>\mathbb{Z}</math> पर और न ही धनात्मक वास्तविक संख्याओं <math>\mathbb{R}^+</math>पर ये सभी क्रम गणितीय अर्थ में हैं, कंप्यूटिंग अर्थ में नहीं, ये सभी विशेष रूप से अनंत हैं।) 

लूप अचर {{mvar|P}} को देखते हुए, स्थिति {{mvar|B}} को यह बताना चाहिए कि {{mvar|t}}, {{mvar|D}} का [[न्यूनतम तत्व]] नहीं है, अन्यथा निकाय {{mvar|S}} आगे {{mvar|t}} को कम नहीं कर सकता है, अर्थात नियम का आधार असत्य होगा। (यह कुल शुद्धता के लिए विभिन्न संकेतन में से एक है।){{#tag:ref| Hoare's 1969 paper didn't provide a total correctness rule; cf. his discussion on p.579 (top left). For example Reynolds' textbook<ref name="Reynolds.2009"/>  gives the following version of a total correctness rule: <math>\dfrac{P \wedge B \rightarrow 0\leq t\quad ,\quad   [P \wedge B \wedge t=z] S [P \wedge t<z]}{[P] \texttt{while}\ B\ \texttt{do}\ S\ \texttt{done} [P \wedge \neg B]}</math>  when {{mvar|z}} is an integer variable that doesn't occur free in {{mvar|P}}, {{mvar|B}}, {{mvar|S}}, or {{mvar|t}}, and {{mvar|t}} is an integer expression (Reynolds' variables renamed to fit with this article's settings). |group=note}}

कुल शुद्धता के प्रमाण के लिए पिछले अनुभाग के प्रथम उदाहरण को फिर से प्रारम्भ करना
:<math>[x \leq 10]\texttt{while}\ x < 10\ \texttt{do}\ x:=x+1\ \texttt{done} [\neg x < 10 \wedge x \leq 10]</math>
कुल शुद्धता के लिए जबकि नियम लागू किया जा सकता है उदाहरण- {{mvar|D}} सामान्य क्रम के साथ गैर-ऋणात्मक पूर्णांक है, और अभिव्यक्ति {{mvar|t}}, <math>10 - x</math> है, जिसे बाद में सिद्ध करने की आवश्यकता होती है
:<math>[x \leq 10 \wedge x < 10 \wedge 10-x \geq 0 \wedge 10-x = z] x:= x+1 [x \leq 10 \wedge 10-x \geq 0 \wedge 10-x < z]</math>
अनौपचारिक रूप से, हमें यह सिद्ध करना होगा कि प्रत्येक लूप चक्र में <math>10-x</math> की दूरी घट जाती है, जबकि यह सदैव गैर-ऋणात्मक रहती है, यह प्रक्रिया केवल सीमित संख्या में चक्रों के लिए ही चल सकती है।

पिछले प्रमाण लक्ष्य को सरल बनाया जा सकता है
:<math>[x < 10 \wedge 10-x = z]   x:=x+1   [x \leq 10 \wedge 10-x < z]</math>,
जिसे इस प्रकार सिद्ध किया जा सकता है-
:<math>[x+1 \leq 10 \wedge 10-x-1 < z]   x:=x+1   [x \leq 10 \wedge 10-x < z]</math> नियत कार्य नियम द्वारा प्राप्त किया जाता है, और
:<math>[x+1 \leq 10 \wedge 10-x-1 < z]</math> को दृढ़ किया जा सकता है <math> [x < 10 \wedge 10-x = z]</math> परिणाम नियम द्वारा है।
:पिछले खंड के दूसरे उदाहरण के लिए, निश्चित रूप से कोई अभिव्यक्ति {{mvar|t}} नहीं पाई जा सकती है जो रिक्त लूप निकाय से कम हो जाती है, इसलिए समाप्ति सिद्ध नहीं की जा सकती हैl

== यह भी देखें ==

{{columns-list|colwidth=20em|
* [[अभिकथन (सॉफ्टवेयर विकास)]]
* [[सांकेतिक अर्थ विज्ञान]]
* [[अनुबंध द्वारा डिजाइन]]
* [[गतिशील तर्क (modal logic)|गतिशील तर्क]]
* [[औपचारिक सत्यापन]]
* [[लूप अपरिवर्तनीय]]
* [[विधेय परिवर्तक अर्थ विज्ञान]]
* [[स्थैतिक प्रोग्राम विश्लेषण]]
}}

== टिप्पणियाँ ==
{{reflist|group=note}}
== संदर्भ ==
{{Reflist|30em}}
== अग्रिम पठन ==

* Robert D. Tennent. ''[http://www.cs.queensu.ca/home/specsoft/ Specifying Software]'' (a textbook that includes an introduction to Hoare logic, written in 2002) {{ISBN|0-521-00401-2}}
== बाहरी संबंध==
* [https://web.archive.org/web/20071117054808/http://www.key-project.org/download/hoare/ KeY-Hoare] is a semi-automatic verification system built on top of the [[KeY]] theorem prover. It features a Hoare calculus for a simple while language.
* [http://j-algo.binaervarianz.de/index.php?language=en j-Algo-modul Hoare calculus] &mdash; A visualisation of the Hoare calculus in the algorithm visualisation program j-Algo

[[Category:Created On 02/03/2023]]
[[Category:Lua-based templates]]
[[Category:Machine Translated Page]]
[[Category:Multi-column templates]]
[[Category:Pages using div col with small parameter]]
[[Category:Pages with script errors]]
[[Category:Short description with empty Wikidata description]]
[[Category:Templates Vigyan Ready]]
[[Category:Templates that add a tracking category]]
[[Category:Templates that generate short descriptions]]
[[Category:Templates using TemplateData]]
[[Category:Templates using under-protected Lua modules]]
[[Category:Wikipedia fully protected templates|Div col]]
[[Category:कंप्यूटिंग में 1969]]
[[Category:कार्यक्रम तर्क]]
[[Category:स्थैतिक कार्यक्रम विश्लेषण]]