हाँ, एक छँटाई दिनचर्या के लिए एक सटीक प्रकार व्यक्त करना संभव है, जैसे कि उस प्रकार के किसी भी फ़ंक्शन को वास्तव में इनपुट सूची को सॉर्ट करना होगा।
जबकि एक और अधिक उन्नत और सुरुचिपूर्ण समाधान हो सकता है, मैं केवल एक प्रारंभिक स्केच करूँगा।
हम एक Coq जैसी संकेतन का उपयोग करेंगे। हम एक विधेय की आवश्यकता को परिभाषित करते हुए शुरू करते हैं जो कि f: nat -> natक्रमपरिवर्तन के रूप में कार्य करता है0 .. n - 1:
Definition permutation (n: nat) (f: nat -> nat): Prop :=
(* once restricted, its codomain is 0..n-1 *)
(forall m, m < n -> f m < n) /\
(* it is injective, hence surjective *)
(forall m1 m2, m1 < n -> m2 < n -> f m1 = f m2 -> m1 = m2) .
एक सरल लेम्मा आसानी से सिद्ध किया जा सकता है।
Lemma lem1: forall n f, permutation n f -> m < n -> f m < n.
... (* from the def *)
हम परिभाषित करते हैं कि क्या है मकिसी सूची की लंबाई वाला तत्व n। इस फ़ंक्शन को एक प्रमाण की आवश्यकता होती है, hजिसमें कहा गया हैम < n वास्तव में रखती है।
Definition nth {A} {n} (l: list A n) m (h : m < n): A :=
... (* recursion over n *)
एक आदेश देने पर A, हम यह व्यक्त कर सकते हैं कि एक सूची क्रमबद्ध है:
Definition ordering (A: Type) :=
{ leq: A->A->bool |
(* axioms for ordering *)
(forall a, leq a a = true) /\
(forall a b c, leq a b = true -> leq b c = true -> leq a c = true) /\
(forall a b, leq a b = true -> leq b a = true -> a = b)
} .
Definition sorted {A} {n} (o: ordering A) (l: list A n): Prop :=
...
अंत में यहाँ एक छँटाई एल्गोरिथ्म के लिए प्रकार है:
Definition mysort (A: Type) (o: ordering A) (n: nat) (l: list A n):
{s: list A n | sorted o s /\
exists f (p: permutation n f),
forall (m: nat) (h: m < n),
nth l m h = nth s (f m) (lem1 n f p h) } :=
... (* the sorting algorithm, and a certificate for its output *)
आउटपुट प्रकार बताता है कि परिणाम सूची sहैn तत्वों को लंबा, यह क्रमबद्ध किया गया है, और यह एक क्रमचय है 0 .. n- 1जो इनपुट सूची में तत्वों lको आउटपुट सूची में लोगों को दिखाता है s। ध्यान दें कि हमें साबित करने के लिए ऊपर दिए गए लेम्मा का आह्वान करना होगाच( m ) < n, जो आवश्यक है nth।
ध्यान दें कि यह उपयोगकर्ता है, अर्थात प्रोग्रामर, जिसे अपने सॉर्टिंग एल्गोरिदम को सही साबित करना है। संकलक यह सत्यापित नहीं करेगा कि छँटाई सही है: यह सब एक प्रदत्त प्रमाण की जाँच कर रहा है। वास्तव में, संकलक इससे अधिक नहीं कर सकता है: "इस कार्यक्रम को एक छँटाई एल्गोरिथ्म" जैसे अर्थ गुण अपरिहार्य (राइस प्रमेय द्वारा) हैं, इसलिए हम साबित कदम को पूरी तरह से स्वचालित बनाने की उम्मीद नहीं कर सकते हैं।
दूर के भविष्य में, हम अभी भी उम्मीद कर सकते हैं कि स्वचालित प्रमेय साबित करने वाले इतने स्मार्ट हो जाएं कि "सबसे अधिक" व्यावहारिक रूप से उपयोग किए गए एल्गोरिदम स्वचालित रूप से सही साबित हो सकें। राइस प्रमेय केवल यह बताता है कि यह सभी मामलों में नहीं किया जा सकता है। हम सभी के लिए उम्मीद कर सकते हैं एक सही, व्यापक रूप से लागू है, लेकिन स्वाभाविक रूप से अपूर्ण प्रणाली है।
अंतिम नोट के रूप में, यह कभी-कभी भूल जाता है कि सरल प्रकार के सिस्टम भी अधूरे हैं ! जैसे जावा में भी
int f(int x) {
if (x+2 != 2+x)
return "Houston, we have a problem!";
return 42;
}
शब्दार्थ रूप से सुरक्षित है (यह हमेशा पूर्णांक देता है), लेकिन टाइप चेकर अगम्य रिटर्न के बारे में शिकायत करेगा।