💻 computer science

Compositional Program Verification with Polynomial Functors in Dependent Type Theory

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

मूल लेखक: C. B. Aberlé

प्रकाशित 2026-04-03

📖 6 मिनट में पढ़ें🧠 गहराई से पढ़ें

CC BY 4.0

मूल लेखक: C. B. Aberlé

मूल पेपर CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/) के तहत लाइसेंस किया गया है। ✨ नीचे दिए गए पेपर की यह व्याख्या AI से तैयार की गई है। इसे लेखकों ने न तो लिखा है, न इसका समर्थन किया है। तकनीकी सटीकता के लिए मूल पेपर देखें। पूरा डिस्क्लेमर पढ़ें

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

यह शोध पत्र (paper) सॉफ्टवेयर बनाने और उसकी जाँच करने का एक नया तरीका प्रस्तावित करता है जो प्रोग्रामों को LEGO सेट्स या इलेक्ट्रॉनिक सर्किट की तरह मानता है। पूरी विशाल मशीन को एक साथ समझने के बजाय, हम इसे छोटे, स्वतंत्र बक्सों में तोड़ देते हैं, प्रत्येक बॉक्स की व्यक्तिगत रूप से जाँच करते हैं, और फिर उन्हें आपस में जोड़ देते हैं।

यहाँ सरल उपमाओं (analogies) का उपयोग करके इस शोध पत्र के विचारों का विवरण दिया गया है:

1. "इंटरफेस" बॉक्स (पॉलीनोमियल फंक्टर्स - Polynomial Functors)

सोचिए कि हर सॉफ्टवेयर का हिस्सा विशिष्ट पोर्ट्स (ports) वाला एक ब्लैक बॉक्स है।

इनपुट पोर्ट (The Input Port): काम करने के लिए इस बॉक्स को किस प्रकार के डेटा की आवश्यकता है? (जैसे, "मुझे संख्याओं की एक सूची चाहिए")।
आउटपुट पोर्ट (The Output Port): यह बॉक्स बदले में क्या डेटा देता है? (जैसे, "मैं आपको एक एकल संख्या दूँगा")।
निर्देश (The Directions): यदि किसी बॉक्स में कई अलग-अलग इनपुट पोर्ट हैं, तो वह आपको बताता है कि प्रत्येक के लिए कौन सा रास्ता लेना है।

शोध पत्र में, इन बक्सों को पॉलीनोमियल फंक्टर्स कहा जाता है। ये केवल इस बात को कहने का एक फैंसी गणितीय तरीका है कि, "इस बॉक्स के कनेक्शन पॉइंट्स का आकार कैसा है।"

2. "वायरिंग डायग्राम" (कंपोज़िशन - Composition)

अब, कल्पना कीजिए कि आपके पास एक बॉक्स है जो मेल (डाक) छाँटता है, और दूसरा बॉक्स है जो लिफाफों पर स्टैम्प लगाता है।

एक "मेल प्रोसेसिंग सिस्टम" बनाने के लिए, आप छाँटने या स्टैम्प लगाने के कोड को दोबारा नहीं लिखते।
आप बस "सॉर्टर" (Sorter) बॉक्स के आउटपुट को "स्टैम्पर" (Stamper) बॉक्स के इनपुट से वायर (wire) करते हैं।

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

3. "नियम पुस्तिका" (स्पेसिफिकेशन और डिपेंडेंट पॉलीनोमियल्स - Specifications & Dependent Polynomials)

सिर्फ इसलिए कि आप बक्सों को आपस में जोड़ सकते हैं, इसका मतलब यह नहीं है कि वे सही काम करेंगे। हो सकता है कि सॉर्टर बॉक्स खराब हो और पत्रों को फेंक दे।

इसे ठीक करने के लिए, लेखक हर बॉक्स के साथ एक नियम पुस्तिका (Specification) जोड़ते हैं।

वादा (The Promise): "यदि आप मुझे एक पत्र (Input) देंगे, तो मैं वादा करता हूँ कि मैं आपको एक स्टैम्प किया हुआ पत्र (Output) दूँगा।"
शर्त (The Catch): नियम पुस्तिका स्मार्ट है। यह कहती है, "यदि पत्र 'बॉब' के नाम पर है, तो मैं वादा करता हूँ कि उसे लाल रंग से स्टैम्प करूँगा। यदि यह 'एलिस' के लिए है, तो मैं उसे नीला स्टैम्प करूँगा।"

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

4. "निरीक्षक" (वेरिफिकेशन - Verification)

यहाँ इस ढांचे की असली शक्ति है: कंपोजिशनल वेरिफिकेशन (Compositional Verification)।

आमतौर पर, पूरे सिस्टम को सुरक्षित साबित करने के लिए, आपको पूरे सिस्टम की हर एक लाइन के कोड की जाँच करनी पड़ती है। यह एक गगनचुंबी इमारत को यह साबित करने के लिए कि वह गिरेगी नहीं, हर एक ईंट की जाँच करने जैसा है।

यह शोध पत्र कहता है: नहीं, आपको ऐसा करने की आवश्यकता नहीं है।

"सॉर्टर" बॉक्स की उसकी नियम पुस्तिका के विरुद्ध जाँच करें। (पास!)
"स्टैम्पर" बॉक्स की उसकी नियम पुस्तिका के विरुद्ध जाँच करें। (पास!)
वायरिंग डायग्राम की जाँच करें ताकि यह सुनिश्चित हो सके कि एक का आउटपुट दूसरे के इनपुट से मेल खाता है। (पास!)

निष्कर्ष: क्योंकि हिस्से जाँचे गए हैं और कनेक्शन सही हैं, इसलिए पूरा सिस्टम सही होने की गारंटी है। प्रमाण (proof) ठीक वैसे ही जुड़ता है जैसे कि बॉक्स जुड़ते हैं।

5. "रोबोट" (मीली मशीन्स - Mealy Machines)

हम इन बक्सों को वास्तव में कैसे चलाते हैं? शोध पत्र मीली मशीन्स का उपयोग करता है।
एक मीली मशीन को याददाश्त वाले रोबोट के रूप में सोचें।

जब आप एक बटन दबाते हैं (Input), तो रोबोट अपनी याददाश्त देखता है, एक कार्य करता है, आपको एक परिणाम (Output) देता है, और अगली बार के लिए अपनी याददाश्त अपडेट करता है।
शोध पत्र दिखाता है कि आप इन "नियम पुस्तिका-जाँचे गए" बक्सों को इन रोबों में प्लग कर सकते हैं। यदि बॉक्स सत्यापित हैं, तो रोबोट का व्यवहार भी सत्यापित है।

6. "ट्रैफिक पुलिस" (कन्करेंसी - Concurrency)

शोध पत्र इस पर भी विचार करता है कि क्या होता है जब बक्सों को एक ही समय में चलता है (जैसे दो लोग एक ही प्रिंटर का उपयोग करने की कोशिश कर रहे हों)।

वे एक "पैरेलल सम" (Parallel Sum) पेश करते हैं जो एक ट्रैफिक पुलिस की तरह कार्य करता है।
यह सुनिश्चित करता है कि दो बॉक्स एक ही समय में एक ही संसाधन को पकड़ने की कोशिश न करें, जिससे सॉफ्टवेयर में "ट्रैफिक जाम" (race conditions) से बचा जा सके।

बड़ी तस्वीर (The Big Picture)

लेखक, सी.बी. एबर्ले (C.B. Aberlé) ने सॉफ्टवेयर इंजीनियरों के लिए एक गणितीय "लेगो किट" बनाई है।

पुराना तरीका: एक विशाल दीवार बनाएँ, फिर उसमें दरारें ढूँढने की कोशिश करें।
नया तरीका: पूर्ण, सत्यापित ईंटें बनाएँ। उन्हें एक डायग्राम के साथ जोड़ दें। यदि ईंटें अच्छी हैं और डायग्राम सही है, तो दीवार भी एकदम सही है।

इस ढांचे का परीक्षण Agda (गणितीय रूप से सटीक कोड लिखने का एक टूल) नामक एक कंप्यूटर भाषा में किया गया है, जो यह सिद्ध करता है कि यह "लेगो दृष्टिकोण" वास्तव में वास्तविक दुनिया में काम करता है।

संक्षेप में: यह शोध पत्र हमें जटिल सॉफ्टवेयर बनाने का एक तरीका देता है जहाँ हम छोटे, सत्यापित टुकड़ों को आपस में जोड़ते हैं, जिससे यह सुनिश्चित होता है कि हर बार नया टुकड़ा जोड़ने पर पूरे सिस्टम को फिर से शुरू से जाँचने की आवश्यकता के बिना पूरा सिस्टम सुरक्षित और सही है।

यहाँ C.B. Aberlé के शोध पत्र "Compositional Program Verification with Polynomial Functors in Dependent Type Theory" का विस्तृत तकनीकी सारांश दिया गया है।

1. समस्या विवरण (Problem Statement)

बड़े पैमाने के सॉफ्टवेयर सिस्टम अक्सर अपारदर्शी (opaque) होते हैं, जिससे उनके व्यवहार को समग्र रूप से सत्यापित करना कठिन हो जाता है। पारंपरिक सत्यापन दृष्टिकोण मॉड्यूलरिटी (modularity) के लिए संघर्ष करते हैं: एक जटिल सिस्टम को सत्यापित करने के लिए अक्सर पूरे सिस्टम को फिर से सत्यापित करने की आवश्यकता होती है, बजाय इसके कि व्यक्तिगत घटकों (components) के प्रमाणों को संयोजित (compose) किया जाए।

यह शोध पत्र एक कंपोजिशनल फ्रेमवर्क (compositional framework) की आवश्यकता को संबोधित करता है जो:

जटिल प्रोग्रामों को सरल, स्वतंत्र रूप से सत्यापन योग्य मॉड्यूल में विभाजित करता है।
इन मॉड्यूल को संयोजित (wire together) करने की अनुमति देता है जबकि उनके शुद्धता के गारंटों (correctness guarantees) को सुरक्षित रखता है।
इंटरफेस (interfaces), इम्प्लीमेंटेशन (implementations), स्पेसिफिकेशन (specifications) (pre/post-conditions) और ऑपरेशनल सिमेंटिक्स (operational semantics) को एक ही गणितीय संरचना के भीतर एकीकृत करता है।
डिपेंडेंट टाइप थ्योरी (Dependent Type Theory) के भीतर कार्य करता है, जिससे स्पेसिफिकेशन रनटाइम वैल्यू और डेटा स्ट्रक्चर पर निर्भर हो सकते हैं।

2. कार्यप्रणाली (Methodology)

लेखक सॉफ्टवेयर सिस्टम को मॉडल करने के लिए डिपेंडेंट टाइप थ्योरी (विशेष रूप से Agda में औपचारिक रूप दिया गया) के संदर्भ में पॉलीनोमियल फंक्टर्स (Polynomial Functors) का उपयोग करते हैं। कार्यप्रणाली तीन मुख्य एब्स्ट्रैक्शन पर आधारित है:

A. इंटरफेस के रूप में पॉलीनोमियल फंक्टर्स (Polynomial Functors as Interfaces)

एक पॉलीनोमियल फंक्टर $P(y) = \sum_{a:A} y^{B(a)}$ एक प्रोग्राम इंटरफेस को दर्शाता है:

$A$ : पोजीशनों (positions) (इनपुट) का प्रकार।
$B(a)$ : दिए गए इनपुट के लिए डायरेक्शन्स (directions) (आउटपुट/रिस्पॉन्स) का प्रकार।
पॉलीनोमियल्स के बीच एक मॉर्फिज्म (morphism/lens) एक ऐसे प्रोग्राम को दर्शाता है जो दूसरे इंटरफेस को कॉल करके एक इंटरफेस को लागू करता है।

B. इम्प्लीमेंटेशन के रूप में फ्री मोनाड्स (Free Monads as Implementations)

जहाँ एक इंटरफेस को शून्य, एक, या कई बार कॉल किया जाता है, वहाँ अनुक्रमिक संयोजन (sequential composition) को मॉडल करने के लिए, फ्रेमवर्क पॉलीनोमियल फंक्टर पर फ्री मोनाड (Free Monad) ( $Free\ P$ ) का उपयोग करता है।

इंटरफेस $p$ का एक इम्प्लीमेंटेशन जो इंटरफेस $q$ पर निर्भर है, वह $p \Rightarrow Free\ q$ है।
यह संरचना "assume-guarantee" तर्क को स्वाभाविक रूप से मॉडल करती है: $q$ के इम्प्लीमेंटेशन को मानते हुए, हम $p$ के इम्प्लीमेंटेशन की गारंटी देते हैं।

C. स्पेसिफिकेशन के रूप में डिपेंडेंट पॉलीनोमियल्स (Dependent Polynomials as Specifications)

इम्प्लीमेंटेशन से सत्यापन (verification) की ओर बढ़ने के लिए, शोध पत्र डिपेंडेंट पॉलीनोमियल्स पेश करता है।

एक डिपेंडेंट पॉलीनोमियल $P=(A, B)$ $P = (A, B)$ में शामिल है:
- प्रीकंडीशन (Preconditions): इनपुट पर एक फैमिली $C: A \to Set$ ।
- पोस्टकंडीशन (Postconditions): आउटपुट पर एक फैमिली $D: (a:A) \to C(a) \to B(a) \to Set$ ।
यह एक होअर ट्रिपल (Hoare triple) के समान अनुबंध (contract) को एनकोड करता है: यदि इनपुट $a$ $C(a)$ को संतुष्ट करता है, तो आउटपुट को $D(a, \dots)$ को संतुष्ट करना चाहिए।
डिपेंडेंट फ्री मोनाड्स ($FreeDep$) का उपयोग इन स्पेसिफिकेशन्स को कंप्यूटेशन के स्तर तक उठाने के लिए किया जाता है, जिससे यह प्रमाण मिलता है कि एक कंप्यूटेशन अपने डिपेंडेंसीज़ के अनुरूप होने की धारणा पर अपने स्पेसिफिकेशन का सम्मान करता है।

D. मीली मशीनों के माध्यम से ऑपरेशनल सिमेंटिक्स (Operational Semantics via Mealy Machines)

शोध पत्र मीली मशीनों (Mealy Machines) (स्टेटफुल ऑटोमेटा) का उपयोग करके ऑपरेशनल सिमेंटिक्स को परिभाषित करता है।

इंटरफेस $P$ के लिए एक मीली मशीन एक इनपुट लेती है, एक आउटपुट उत्पन्न करती है, और एक नए स्टेट (state) में ट्रांज़िशन करती है।
महत्वपूर्ण बात यह है कि मीली मशीनें इफेक्ट्स (effects) के रनर (runners) के रूप में कार्य करती हैं। यदि कोई प्रोग्राम एक इंटरफेस $q$ (जैसे, एक स्टेट इफेक्ट) का उपयोग करता है, तो $q$ के लिए एक मीली मशीन उस इफेक्ट का ठोस इम्प्लीमेंटेशन प्रदान करती है।
फ्रेमवर्क यह सिद्ध करता है कि एक प्रोग्राम मॉड्यूल को मीली मशीन के साथ संयोजित करने से उस मॉड्यूल के इंटरफेस के लिए एक नई मीली मशीन प्राप्त होती है।

3. प्रमुख योगदान (Key Contributions)

1. वायरिंग डायग्राम के माध्यम से कंपोजिशनल वेरिफिकेशन (Compositional Verification via Wiring Diagrams)

शोध पत्र प्रदर्शित करता है कि इम्प्लीमेंटेशन और उनके सत्यापन (verifications) वायरिंग डायग्राम के साथ संयोजित होते हैं।

प्रमेय (Theorem): मॉड्यूल्स के एक वायरिंग डायग्राम और प्रत्येक बॉक्स के लिए सत्यापित इम्प्लीमेंटेशन को देखते हुए, संयुक्त सिस्टम (composite system) के पास बाहरी इंटरफेस के लिए एक सत्यापित इम्प्लीमेंटेशन होता है।
यह फ्री मोनाड और उसके डिपेंडेंट एनालॉग के लिए क्लेइसली कंपोजिशन (Kleisli composition) के माध्यम से प्राप्त किया जाता है। प्रमाण इस तथ्य पर निर्भर करता है कि डिपेंडेंट पॉलीनोमियल्स योग (coproducts) के तहत बंद (closed) हैं, जिससे सब-मॉड्यूल्स के स्पेसिफिकेशन को पूरे के लिए एक स्पेसिफिकेशन में संयोजित किया जा सकता है।

2. एकीकृत कैटेगोरिकल संरचना (Unified Categorical Structure)

लेखक इस फ्रेमवर्क के अंतर्निहित अमूर्त कैटेगोरिकल संरचना की पहचान करते हैं:

इंटरफेस ($Int$): एक मोनोइडल कैटेगरी (पॉलीनोमियल पर फ्री मोनाड की क्लेइसली कैटेगरी)।
स्पेसिफिकेशन ($Spec$): जोड़े (Polynomial, Dependent Polynomial) की एक मोनोइडल कैटेगरी।
प्रीशीव्स (Presheaves): इंटरफेस को मीली मशीनों का असाइनमेंट एक लैक्स मोनोइडल प्रीशीफ (lax monoidal presheaf) बनाता है।
नेचुरल ट्रांसफॉर्मेशन (Natural Transformation): सत्यापित सिस्टम्स ($DepMealy $) के प्रीशीफ से सिस्टम्स ($ Mealy$) के प्रीशीफ के बीच एक मोनोइडल नेचुरल ट्रांसफॉर्मेशन मौजूद है, जो फॉलगेबल फंक्टर (forgetful functor) के माध्यम से होता है।
यह एब्स्ट्रैक्शन इस फ्रेमवर्क को अन्य श्रेणियों और मोनोइडल उत्पादों (जैसे, कंकरेंसी) में सामान्यीकृत करने की अनुमति देता है।

3. वेरिफिकेशन के लिए ऑपरेशनल सिमेंटिक्स (Operational Semantics for Verification)

शोध पत्र स्टैटिक वेरिफिकेशन और डायनेमिक निष्पादन (execution) के बीच के अंतर को पाटता है। यह दिखाता है कि डिपेंडेंट मीली मशीनें (सत्यापन साक्ष्य के साथ सुसज्जित मीली मशीनें) संयोजन के लिए बंद (closed) हैं। इसका अर्थ है कि एक सत्यापित स्टेट मशीन पर चलने वाला एक सत्यापित प्रोग्राम, संयुक्त सिस्टम के लिए एक सत्यापित स्टेट मशीन प्रदान करता है।

4. कंकरेंसी और रिलेशनल वेरिफिकेशन के लिए विस्तार (Extension to Concurrency and Relational Verification)

परिशिष्ट (Appendix) में, फ्रेमवर्क को मानक कोप्रोडक्ट ( $\oplus$ ) के बजाय पैरेलल सम ( $\|$ ) का उपयोग करके कंकरेंट मॉड्यूल्स (concurrent modules) के लिए विस्तारित किया गया है।

पैरेलल सम एक साथ कई इंटरफेस को कॉल करने की अनुमति देता है।
यह संरचना स्पेसिफिकेशन्स को यूनरी (unary) भागों और कंकरेंट घटकों के इनपुट/आउटपुट को संबंधित करने वाले रिलेशनल भागों में विभाजित करके रिलेशनल वेरिफिकेशन (जैसे, नॉन-इंटरफेरेंस, मोनोटोनिसिटी) का समर्थन करती है।
पैरेलल सम को एफाइन (affine) दिखाया गया है (यह डिज़ाइन द्वारा रेस कंडीशंस को रोकता है, क्योंकि एक वायर का उपयोग दो स्थानों पर एक साथ नहीं किया जा सकता है)।

4. परिणाम (Results)

औपचारिकीकरण (Formalization): पूरे फ्रेमवर्क को, परिभाषाओं, प्रमेयों और उदाहरणों सहित, Agda में पूरी तरह से औपचारिक रूप दिया गया है।
केस स्टडीज (Case Studies):
- लिस्ट ऑपरेशंस (List Operations): फ्रेमवर्क सफलतापूर्वक fold, append, और concat ऑपरेशंस को मॉडल और सत्यापित करता है। यह यह प्रदर्शित करता है कि कैसे बेस और स्टेप केस को सत्यापित करके append को सत्यापित किया जाता है।
- स्टेट के साथ फाइबोनैची (Fibonacci with State): एक फाइबोनैची जनरेटर को स्टेट इफेक्ट का उपयोग करके लागू किया गया है। शोध पत्र सत्यापित करता है कि मशीन सही ढंग से फाइबोनैची नंबरों की गणना करती है और एक स्टेट इनवेरिएंट (कि स्टेट लगातार फाइबोनैची नंबरों का प्रतिनिधित्व करता है) को बनाए रखती है।
कंपोजिशनलिटी (Compositionality): प्रमाण पुष्टि करते हैं कि सत्यापन का प्रयास पूरे सिस्टम की जटिलता के साथ नहीं, बल्कि घटकों की संख्या के साथ रैखिक रूप से (linearly) बढ़ता है, बशर्ते घटकों को स्वतंत्र रूप से सत्यापित किया गया हो।

5. महत्व (Significance)

सिद्धांत और व्यवहार को जोड़ना: शोध पत्र पॉलीनोमियल फंक्टर्स (इंटरेक्शन थ्योरी) के अमूर्त सिद्धांत को डिपेंडेंट टाइप थ्योरी में व्यावहारिक प्रोग्राम वेरिफिकेशन के साथ जोड़ता है।
स्केलेबिलिटी (Scalability): वास्तविक कंपोजिशनल वेरिफिकेशन को सक्षम करके, फ्रेमवर्क औपचारिक विधियों (formal methods) की स्केलेबिलिटी समस्या का समाधान करता है, जिससे सत्यापित "ब्लैक बॉक्स" से बड़े सिस्टम बनाए जा सकते हैं।
एकीकृत दृष्टिकोण: यह इंटरफेस, कोड, स्पेक्स और निष्पादन (execution) के लिए एक एकल गणितीय भाषा प्रदान करता है, जो सत्यापन उपकरणों में पाई जाने वाली विखंडन (fragmentation) को कम करता है।
भविष्य की दिशाएं: इसका अमूर्त कैटेगोरिकल फॉर्मूलेशन निम्नलिखित के अनुप्रयोग के द्वार खोलता है:
- कंकरेंसी (Concurrency): रेस कंडीशंस के बिना समानांतर सिस्टम को सत्यापित करना।
- सुरक्षा (Security): अपारदर्शी घटकों (APIs, ML मॉडल्स) वाले सिस्टम में सूचना प्रवाह नीतियों (information flow policies) को सत्यापित करना।
- स्वचालन (Automation): फ्रेमवर्क की कंपोजिशनल प्रकृति यह सुझाव देती है कि वेरिफिकेशन को प्रूफ असिस्टेंट्स में टैक्टिक्स (tactics) के माध्यम से स्वचालित किया जा सकता है, जिससे उपयोगकर्ता का बोझ स्थानीय मॉड्यूल प्रमाणों तक सीमित हो जाता है।

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