सख्त सकारात्मकता

सख्त सकारात्मकता की स्थिति ऐसी घोषणाओं को नियंत्रित करती है

data Bad : Set where
 bad : (Bad → Bad) → Bad
         A      B       C
 -- A is in a negative position, B and C are OK

नकारात्मक क्यों है? बी क्यों अनुमति दी है? मैं समझता हूं कि C को अनुमति क्यों है।

type-theory inductive-datatypes

— पुष्पा
स्रोत

मुझे यकीन नहीं है कि इसे "नकारात्मक" क्यों कहा जाता है, लेकिन यह आमतौर पर उत्पन्न होने वाली त्रुटि से अधिक जाना जाता है: स्टैक ओवरफ्लो :) यह कोड अनंत विस्तार का कारण हो सकता है Aऔर अंततः स्टैक-आधारित भाषाओं में स्टैक को विस्फोट कर सकता है ।

— wvxvw

वह हिस्सा मैं समझता हूं कि आप मनमानी बातें लिख सकते हैं और इसलिए गणना गैर-समाप्ति होगी। धन्यवाद

— पुष्पा

मुझे लगता है कि आपके प्रश्न के शरीर में गैर-समाप्ति का उल्लेख करना एक अच्छी बात होगी । मैंने आपकी टिप्पणी के आधार पर अपना उत्तर अपडेट कर दिया है।

— एंटोन ट्रूनोव

@wvxvw जरूरी नहीं है, यह स्टैक को उड़ाए बिना हमेशा के लिए चल सकता है, बशर्ते कंपाइलर इम्प्लिमेंट्स टेल रिकर्सनशन, उदाहरण के लिए नीचे OCaml में मेरा उदाहरण स्टैक को विस्फोट न करे।

— एंटोन ट्रूनोव

@AntonTrunov यकीन है, यह सटीक होने के प्रयास के बजाय साइट के नाम पर एक वाक्य का अधिक था।

— wvxvw

जवाबों:

पहले एक शब्दावली विवरण: नकारात्मक और सकारात्मक स्थिति तर्क से आती है। वे तार्किक संयोजनों में एक अस्मिता के बारे में हैं: में से अलग व्यवहार करता है । एक समान बात श्रेणी सिद्धांत में होती है, जहां हम कहते हैं कि नकारात्मक और सकारात्मक के बजाय क्रमशः, कंट्रावेरिएंट और सहसंयोजक हैं। भौतिक विज्ञान में वे मात्राओं की बात करते हैं जो "कोवरिएन्टली" और "कॉन्ट्रैरिएक्टिवली" भी व्यवहार करते हैं। इसलिए यह एक बहुत ही सामान्य घटना है। एक प्रोग्रामर उन्हें "इनपुट" और "आउटपुट" के रूप में सोच सकता है। $A \Rightarrow B$ $A$ $B$

अब आगमनात्मक डेटाटिप्स पर।

$T$ $T$ $T$

बीजगणित में यह प्रथागत है कि एक ऑपरेशन में तर्कों की एक सीमित संख्या होती है, और ज्यादातर मामलों में यह शून्य (निरंतर), एक (एकात्मक) या दो (बाइनरी) तर्क लेता है। डेटाटाइप्स के निर्माणकर्ताओं के लिए इसे सामान्यीकृत करना सुविधाजनक है। मान लीजिए कि cएक प्रारूपक के लिए एक निर्माणकर्ता है T:

अगर cएक स्थिर है तो हम इसे एक फ़ंक्शन के रूप में unit -> T, या समकक्ष रूप से सोच सकते हैं (empty -> T) -> T,
अगर cयह एकात्मक है तो हम इसे एक फ़ंक्शन के रूप में T -> Tया समकक्ष रूप से सोच सकते हैं (unit -> T) -> T,
अगर cहै द्विआधारी हम एक समारोह के रूप में यह सोच सकते हैं T -> T -> T, या समतुल्य T * T -> T, या समतुल्य (bool -> T) -> T,
यदि हम एक निर्माणकर्ता चाहते हैं cजो सात तर्क लेता है, तो हम इसे एक फ़ंक्शन के रूप में देख सकते हैं (seven -> T) -> Tजहां sevenकुछ सात तत्वों के साथ पहले से परिभाषित प्रकार है।
हमारे पास एक कंस्ट्रक्टर भी हो सकता है, cजो अनगिनत रूप से कई तर्कों को लेता है, जो एक फ़ंक्शन होगा (nat -> T) -> T।

ये उदाहरण बताते हैं कि एक निर्माणकर्ता का सामान्य रूप होना चाहिए

c : (A -> T) -> T

जहाँ हम फोन arity की और हम के बारे में सोच एक निर्माता है कि लेता है के रूप में प्रकार के -कई तर्क का एक तत्व का निर्माण करने के ।AccATT

यहां कुछ बहुत महत्वपूर्ण है: परिभाषित करने से पहले हमें परिभाषित किया जाना चाहिए T, अन्यथा हम यह नहीं बता सकते हैं कि निर्माणकर्ता क्या कर रहे हैं। अगर कोई कंस्ट्रक्टर करने की कोशिश करता है

broken: (T -> T) -> T

तो सवाल "कितने तर्क brokenलेता है?" कोई अच्छा जवाब नहीं है। हो सकता है कि आप इसे "यह Tतर्क-वितर्क के साथ" जवाब देने की कोशिश करें , लेकिन ऐसा नहीं होगा, क्योंकि Tअभी तक इसे परिभाषित नहीं किया गया है। हम एक प्रकार Tऔर एक इंजेक्शन फ़ंक्शन को खोजने के लिए फैंसी निश्चित-बिंदु सिद्धांत का उपयोग करके क्यूनड्रम से बाहर निकलने की कोशिश कर सकते हैं (T -> T) -> T, और सफल होंगे, लेकिन हम Tरास्ते के लिए प्रेरण सिद्धांत को भी तोड़ देंगे । इसलिए, इस तरह की कोशिश करना एक बुरा विचार है।

$\lambda$ $v$ $\lambda \cdot v$ cB

c : B * (A -> T) -> T

दरअसल, कई निर्माताओं को इस तरह से लिखा जा सकता है, लेकिन सभी नहीं, हम एक और कदम की जरूरत है, अर्थात् हम अनुमति चाहिए Aकरने के लिए निर्भर पर B:

c : (∑ (x : B), A x -> T) -> T

यह एक प्रेरक प्रकार के लिए एक निर्माता का अंतिम रूप है। यह भी ठीक है कि डब्ल्यू-प्रकार क्या हैं। फॉर्म इतना सामान्य है कि हमें केवल एक ही निर्माता की आवश्यकता है c! दरअसल, अगर हमारे पास उनमें से दो हैं

d' : (∑ (x : B'), A' x -> T) -> T
d'' : (∑ (x : B''), A'' x -> T) -> T

तब हम उन्हें एक में जोड़ सकते हैं

d : (∑ (x : B), A x -> T) -> T

कहाँ पे

B := B' + B''
A(inl x) := A' x
A(inr x) := A'' x

वैसे, यदि हम सामान्य रूप से करी करते हैं तो हम देखते हैं कि यह समान है

c : ∏ (x : B), ((A x -> T) -> T)

जो लोग वास्तव में प्रूफ असिस्टेंट में लिखते हैं उनके करीब है। प्रूफ सहायक हमें सुविधाजनक तरीके से कंस्ट्रक्टरों को लिखने की अनुमति देते हैं, लेकिन वे सामान्य रूप से ऊपर (व्यायाम) के बराबर हैं।

— प्रेमिका बाउर
स्रोत

मेरे लंच के बाद फिर से धन्यवाद, यह पचाने के लिए मेरे लिए सबसे मुश्किल काम होगा। चीयर्स।

— पुष्पा

की पहली घटना को Bad'नकारात्मक' कहा जाता है क्योंकि यह एक फ़ंक्शन तर्क का प्रतिनिधित्व करता है, अर्थात फ़ंक्शन तीर के बाईं ओर स्थित है ( फिलिप वाडलर द्वारा मुफ्त में पुनरावर्ती प्रकार देखें )। मुझे लगता है कि शब्द 'नकारात्मक स्थिति' की उत्पत्ति की धारणा की वजह से उपजी contravariance ( 'विपरीत' का मतलब विपरीत)।

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

हम दूसरी घटना की अनुमति देते हैं Badक्योंकि यह गैर-समाप्ति का कारण नहीं बनती है और हम Badएक पुनरावर्ती डेटाटाइप ( इसके निर्माता के अंतिम तीर से पहले ) में कुछ बिंदु पर परिभाषित किए जा रहे प्रकार का उपयोग करना चाहते हैं ।

यह समझना महत्वपूर्ण है कि निम्नलिखित परिभाषा सख्त सकारात्मकता के नियम का उल्लंघन नहीं करती है।

data Good : Set where
  good : Good → Good → Good

नियम केवल कंस्ट्रक्टर के तर्कों पर लागू होता है (जो Goodइस मामले में दोनों हैं ) और न ही एक कंस्ट्रक्टर के लिए (यह भी देखें कि एडम चिप्पला के " डिपेंडेंट टाइप्स के साथ सर्टिफाइड प्रोग्रामिंग ")।

सख्त सकारात्मकता का उल्लंघन करने वाला एक और उदाहरण:

data Strange : Set where
  strange : ((Bool → Strange) → (ℕ → Strange)) → Strange
                       ^^     ^
            this Strange is   ...this arrow
            to the left of...

आप नकारात्मक स्थितियों के बारे में इस उत्तर को जांचना भी चाह सकते हैं ।

गैर-समाप्ति पर अधिक ... आपके संदर्भित पृष्ठ में कुछ स्पष्टीकरण शामिल हैं (हास्केल में एक उदाहरण के साथ):

गैर-सख्ती से सकारात्मक घोषणाओं को अस्वीकार कर दिया जाता है क्योंकि कोई भी उनका उपयोग करके एक गैर-समाप्ति समारोह लिख सकता है। ऊपर से खराब डेटाटाइप का उपयोग करके कोई लूपिंग परिभाषा कैसे लिख सकता है, यह देखने के लिए, BadInHaskell देखें ।

यहाँ Ocaml में एक अनुरूप उदाहरण दिया गया है, जो यह बताता है कि बिना पुनरावर्ती का उपयोग किए बिना पुनरावर्ती व्यवहार को कैसे लागू किया जाए ?

type boxed_fun =
  | Box of (boxed_fun -> boxed_fun)

(* (!) in Ocaml the 'let' construct does not permit recursion;
   one have to use the 'let rec' construct to bring 
   the name of the function under definition into scope
*)
let nonTerminating (bf:boxed_fun) : boxed_fun =
  match bf with
    Box f -> f bf

let loop = nonTerminating (Box nonTerminating)

nonTerminatingसमारोह "unpacks" अपने तर्क और सेब यह मूल तर्क से एक समारोह। यहां जो महत्वपूर्ण है वह यह है कि अधिकांश प्रकार की प्रणालियां स्वयं को पासिंग फ़ंक्शंस की अनुमति नहीं देती हैं, इसलिए कोई शब्द f fटाइपेकिट नहीं होगा, क्योंकि टाइपसेकर fको संतुष्ट करने के लिए कोई प्रकार नहीं है । एक प्रकार की प्रणाली शुरू की गई थी जिसका कारण है स्व-अनुप्रयोग को अक्षम करना ( यहां देखें )।

हमारे द्वारा शुरू किए गए एक की तरह रैपिंग डेटाैटिप्स का उपयोग इस सड़क को असंगतता के रास्ते पर दरकिनार करने के लिए किया जा सकता है।

मैं जोड़ना चाहता हूं कि गैर-समाप्ति संगणनाएँ तर्क प्रणालियों में विसंगतियों का परिचय देती हैं। एजडा और कोक के मामले में Falseआगमनात्मक डेटाटाइप के पास कोई कंस्ट्रक्टर नहीं है, इसलिए आप कभी भी गलत प्रकार के प्रमाण शब्द का निर्माण नहीं कर सकते हैं। लेकिन अगर गैर-समाप्ति कम्प्यूटिंग की अनुमति दी गई थी, तो कोई इसे इस तरह से कर सकता है (Coq में):

Fixpoint loop (n : nat) : False = loop n

फिर loop 0टाइपकास्ट देना होगा loop 0 : False, इसलिए करी-हावर्ड पत्राचार के तहत इसका मतलब होगा कि हमने एक गलत प्रस्ताव साबित किया है।

अपशॉट : प्रेरक परिभाषाओं के लिए सख्त सकारात्मकता नियम गैर-समाप्ति संगणना को रोकता है जो तर्क के लिए विनाशकारी हैं।

— एंटोन ट्रूनोव
स्रोत

अब मैं उलझन में हूँ। विशेष रूप से अच्छा डेटा: जहाँ अच्छा सेट करें: अच्छा → अच्छा →। हम एक घंटे में समझने और समझने की कोशिश करेंगे /

— पुष्पा '

यह नियम केवल कंस्ट्रक्टर पर ही लागू नहीं होता है, केवल इसके तर्कों के लिए, यानी एक कंस्ट्रक्टर परिभाषा के शीर्ष स्तर पर तीर कोई मायने नहीं रखते। मैंने एक और (अप्रत्यक्ष) उदाहरण का भी उल्लंघन किया।

— एंटोन ट्रूनोव