आगमनात्मक प्रकार की परिभाषा में "संरक्षित" नकारात्मक घटनाएं, हमेशा खराब होती हैं?


11

मुझे पता है कि कुछ नकारात्मक घटनाएं निश्चित रूप से खराब हो सकती हैं:

data False

data Bad a = C (Bad a -> a)

selfApp :: Bad a -> a
selfApp (x@(C x')) = x' x

yc :: (a -> a) -> a
yc f = selfApp $ C (\x -> f (selfApp x))

false :: False
false = yc id

हालांकि, मुझे यकीन नहीं है कि:

  • नकारात्मक घटनाओं के साथ सभी आगमनात्मक प्रकार गलत हो सकते हैं;

  • यदि हां, तो ऐसा करने का एक ज्ञात यांत्रिक तरीका है;

उदाहरण के लिए, मैं इस प्रकार को गलत बनाने की कोशिश कर रहा हूं:

type Not a = a -> False

data Bad2 a = C2 (Bad2 (Not a) -> a)

इस विषय पर साहित्य के किसी भी सूचक की सराहना की जाएगी।


1
क्या यह Coq है? हास्केल? छद्म प्रकार सिद्धांत? "गलत हो" से आपका क्या मतलब है?
डेव क्लार्क

@DaveClarke क्षमा करें, कोड हास्केल है, लेकिन चिंता कोक या एजडा जैसी भाषाओं के बारे में अधिक है जहां नकारात्मक घटनाओं की मनाही है। "गलत हो जाता है" से मेरा मतलब है कि एक शब्द जो कि डायवर्ज को लिखने में सक्षम है, इस प्रकार फासले को प्राप्त करने में सक्षम होने के नाते जैसा कि मैंने हास्केल में अपने उदाहरण में किया था।
Ptival

जवाबों:


10

नकारात्मक घटनाओं पर प्रतिबंध के कारण को नॉस्टर-टार्स्की प्रमेय के साथ सादृश्य द्वारा समझा जा सकता है। यह प्रमेय कहता है कि

यदि एक पूरा जाली और है : एल एल पर एक नीरस कार्य है एल , तो निश्चित अंक के सेट भी एक पूरा जाली है। विशेष रूप से, कम से कम निश्चित बिंदु μ f और सबसे बड़ी निश्चित बिंदु ν f हैLf:LLLfμfνf

पारंपरिक मॉडल सिद्धांत रूप में, lattices प्रस्ताव के रूप में देखी जा सकती है, और आदेश संबंध पी क्ष अनुलाग के रूप में समझा जा सकता है (यानी, कि क्ष की सच्चाई से अपरिहार्य है पी की सच्चाई)।Lpqqp

जब हम मॉडल थ्योरी से प्रूफ थ्योरी की ओर बढ़ते हैं, तो लैटिटास श्रेणियों के लिए सामान्य हो जाते हैं। प्रकारों को एक श्रेणी की वस्तुओं के रूप में देखा जा सकता है , और एक नक्शा : पी क्यू एक प्रमाण का प्रतिनिधित्व करता है कि क्यू को क्यू से प्राप्त किया जा सकता है ।Ce:PQQQ

जब हम पुनरावर्ती समीकरणों द्वारा परिभाषित प्रकारों की व्याख्या करने का प्रयास करते हैं, ee, , करने के लिए स्पष्ट बात यह है कि क्लेस्टर-टार्स्की प्रमेय के सामान्यीकरण के लिए देखना है। इसलिए एक जाली पर एक मोनोटोन फ़ंक्शन के बजाय, हम जानते हैं कि एकफ़ंक्टर एफ : सीसी चाहते हैं , जो वस्तुओं को वस्तुओं को भेजता है, लेकिन एकरूपता की स्थिति को सामान्य करता है ताकि हर नक्शा: पी क्यू को एक नक्शा एफ ( : एफ ) मिलता है ( पी ) एफ ( क्यू ) (सुसंगत परिस्थितियों के साथ कि एफ पहचान को पहचान भेजता है और रचनाओं को संरक्षित करता है ताकि एफN=μα.1+α F:CCe:PQF(e):F(P)F(क्यू)एफ )।एफ(जी)=एफ(जी)एफ()

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

भरोसेमंद रूप से टाइप की गई भाषाओं में, आपके पास अनुक्रमित और पैरामीटर प्रकार भी होते हैं, इसलिए आपका वास्तविक कार्य अधिक जटिल होता है। बॉब एटकी (जिन्होंने यहां और यहां इस बारे में ब्लॉग किया है ) मुझे बताते हैं कि कहानी देखने के लिए एक अच्छी जगह है:

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

एक जो मैं, व्यक्तिगत रूप से, बहुत उपयोग किया है बानाच का निश्चित बिंदु प्रमेय है, जो कहता है कि यदि आपके पास मीट्रिक स्थान पर कड़ाई से संकुचन कार्य है, तो इसका एक अनूठा निश्चित बिंदु है। इस विचार को (IIRC) मौरिस निवात द्वारा शब्दार्थ में पेश किया गया था, और अमेरिका और रूटेन द्वारा बड़े पैमाने पर अध्ययन किया गया था, और हाल ही में बिर्कडल और उनके सहयोगियों द्वारा एक लोकप्रिय परिचालन तकनीक से जुड़ा था जिसे "स्टेप-इंडेक्सिंग" कहा जाता है।

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


7

कभी-कभी आप "भाग्य द्वारा" पुनरावर्ती समीकरणों को हल कर सकते हैं।

मुझे लगता है कि आप इसे सेट्स में करना चाहते हैं (कुछ प्रकार के डोमेन सिद्धांत के विपरीत) यदि हम आपकी परिभाषा को प्रकट करते हैं और हास्केल एनोटेशन के बिना समीकरण को सीधे लिखते हैं, तो हमें आइए हम दो मामलों पर विचार करें:

()
  1. अगर का निवास है, यानी, यह कुछ होता है, तो एक , इसलिए समीकरण कम कर देता है के लिए एक एक 1. और वास्तव में, सिंगलटन सेट 1 हल समीकरण।

    1।
    1
  2. ()1

निष्कर्ष: दो समाधान हैं, खाली प्रकार (जिसे आपने बुलाया False) और इकाई प्रकार ()

(2)2,
data Cow a = Moo ((a -> Bool) -> Bool)

2222

एन22एन
2एन22एनInteger(Integer -> Bool) -> Bool

3

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

λ

महत्वपूर्ण संदर्भ निम्नलिखित है:

मेंडलर, एन। (1991)। दूसरे क्रम के लैम्ब्डा कैलकुलस में आगमनात्मक प्रकार और प्रकार की बाधाएँ। मुझे एक संदर्भ ऑनलाइन नहीं मिला है जो मुझे डर लगता है। बयान और सबूत हालांकि नक्स के पीएचडी शोध प्रबंध (एक अत्यधिक अनुशंसित पढ़ा!) में पाए जा सकते हैं ।

बी

बी=बी

λएक्स:बीएक्स एक्स:बी

इसलिए

(λएक्स:बीएक्स एक्स) (λएक्स:बीएक्स एक्स):

बी=एफ(बी)
एफ(एक्स)एक्सएफ(एक्स)

बेशक आप समान रूप से परिभाषित प्रकारों के साथ नहीं बल्कि निर्माणकर्ताओं के साथ काम कर रहे हैं , यानी आपके पास

data Bad = Pack (Bad -> A)

बल्कि सख्त समानता है। हालाँकि आप परिभाषित कर सकते हैं

unpack :: Bad -> (Bad -> A)
unpack (Pack f) = f

इस परिणाम के लिए पर्याप्त है जो कि जारी रहेगा:

 (\x:Bad -> unpack x x) (Pack (\x:Bad -> unpack x x))


आपके दूसरे उदाहरण में, चीजें थोड़ी अधिक कठिन हैं, क्योंकि आपके पास की तर्ज पर कुछ चीज़े हैं

बी=बी'

बी'बीबी बी (एनटी )

type Not a = a -> False

साथ में

data Not a = Not a

यह आसानी से हल हो जाएगा यदि हास्केल ने इस प्रकार की परिभाषाएं दी हैं:

type Acc = Not Acc

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

data Acc = D (Not Acc)

यहां परेशानी यह है कि एक समरूपता का निर्माण करना

Bad Acc <-> Bad (Not Acc)

आपको मिश्रित विचरण से निपटना होगा।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.