पीटीएस / सीओसी में चर्च-एन्कोडेड प्रकार पर निर्भर प्रकार

मैं विशेष रूप से सबसे शक्तिशाली एक, कंस्ट्रक्शंस के पथरी के साथ, बेंड्रिग्रेट के लैम्ब्डा क्यूब में शुद्ध प्रकार की प्रणालियों के साथ प्रयोग कर रहा हूं। इस प्रणाली के प्रकार *और हैं BOX। केवल रिकॉर्ड के लिए, नीचे मैं Morteउपकरण के कंक्रीट सिंटैक्स का उपयोग कर रहा हूं https://github.com/Gabriel439/Haskell-Morte-Library जो कि क्लासिकल लैम्ब्डा कैलकुलस के करीब है।

मैं देख रहा हूं कि हम कुछ प्रकार के चर्च-जैसे एन्कोडिंग (उर्फ बोहेम-बरार्डुसी आइसोमॉर्फिज्म बीजीय डेटा प्रकारों के लिए) का अनुकरण कर सकते हैं। एक साधारण उदाहरण के लिए, मैं Bool = ∀(t : *) -> t -> t -> tकंस्ट्रक्टर्स के साथ टाइप का उपयोग करता हूं True = λ(t : *) -> λ(x : t) -> λ(y : t) -> xऔर False = λ(t : *) -> λ(x : t) -> λ(y : t) -> y।

मैं देख रहा हूं कि फ़ंक्शन के माध्यम से शास्त्रीय मोडुलो पैरामीट्रिकिटी के साथ Bool -> Tप्रकार के जोड़े के लिए शब्द-प्रकार के फ़ंक्शन का प्रकार isomorphic है जो वास्तव में पहचान है।Product T TProduct = λ(A : *) -> λ(B : *) -> ∀(t : *) -> (A -> B -> t) -> tif : Bool -> λ(t : *) -> t -> t -> t

नीचे सभी प्रश्न आश्रित प्रकार के अभ्यावेदन के बारे में होंगे Bool -> *।

मैं और की D : Bool -> *जोड़ी में विभाजित कर सकता हूं । क्या फिर से बनाने के लिए विहित तरीका है ? मैं टाइप स्तर पर फ़ंक्शन के एक एनालॉग द्वारा आइसोमोफिज़्म को पुन: उत्पन्न करना चाहता हूं, लेकिन मैं इस फ़ंक्शन को मूल के रूप में सरल नहीं लिख सकता क्योंकि हम प्रकारों के प्रकारों में तर्क पारित नहीं कर सकते।D TrueD FalseDBool -> T = Product T Tifif
मैं प्रश्न (1) को हल करने के लिए दो अवरोधकों के साथ एक प्रकार के एक प्रेरक प्रकार का उपयोग करता हूं। उच्च स्तरीय विवरण (अगड़ा-शैली) निम्न प्रकार है (टाइप-स्तर के बजाय प्रयोग किया जाता है if)
```
data BoolDep (T : *) (F : *) : Bool -> * where
  DepTrue : T -> BoolDep T F True
  DepFalse : F -> BoolDep T F False
```
PTS / CoC में निम्नलिखित एन्कोडिंग के साथ:
```
λ(T : *) -> λ(F : *) -> λ(bool : Bool ) ->
∀(P : Bool -> *) ->
∀(DepTrue : T -> P True ) ->
∀(DepFalse : F -> P False ) ->
P bool
```
क्या मेरा एन्कोडिंग सही है?
मैं BoolDepइस कोड के लिए कंस्ट्रक्टरों को इस तरह लिख सकता हूं DepTrue : ∀(T : *) -> ∀(F : *) -> T -> BoolDep T F True:
```
λ(T : *) ->  λ(F : *) ->  λ(arg : T ) ->
λ(P : Bool -> *) ->
λ(DepTrue : T -> P True ) ->
λ(DepFalse : F -> P False ) ->
DepTrue arg
```

लेकिन मैं उलटा फ़ंक्शन (या उलटा दिशा में कोई फ़ंक्शन) लिख नहीं सकता। क्या यह संभव है? या क्या मुझे BoolDepआइसोमोर्फिज्म उत्पन्न करने के लिए किसी अन्य प्रतिनिधित्व का उपयोग करना चाहिए BoolDep T F True = T?

type-theory type-systems dependent-type

— ZeitRaffer
स्रोत

Product T T

$\text{Product T T}$

Bool \to T

$\text{Bool} \to T$

Bool \to T

$\text{Bool} \to T$

(\forall (t : *) \to (t \to t \to t)) \to T

$(\forall (t : *) \to (t \to t \to t)) \to T$

Product T T

$\text{Product} T T$

\forall (t : *) \to ((T \to T \to t) \to t)

$\forall (t : *) \to ((T \to T \to t) \to t)$

@Giorgio Mossa cstheory.stackexchange.com/questions/30923/… - देखें - यदि आपके पास समरूपता है (सभी मॉडलों में नहीं है, लेकिन प्रारंभिक (संश्लिष्ट) एक में) तो आपके पास समरूपतावाद है।

— ZeitRaffer

आप इसके लिए पारंपरिक चर्च एन्कोडिंग का उपयोग नहीं कर सकते हैं Bool:

#Bool = ∀(Bool : *) → ∀(True : Bool) → ∀(False : Bool) → Bool

... क्योंकि आप टाइप का एक उपयोगी (उपयोगी) कार्य नहीं लिख सकते हैं:

#Bool → *

इस कारण से, जैसा कि आपने उल्लेख किया है, यह है कि आप *पहले तर्क के रूप में पारित नहीं कर सकते #Bool, जिसका अर्थ है कि तर्क Trueऔर Falseतर्क टाइप नहीं हो सकते।

इसे हल करने के लिए कम से कम तीन तरीके हैं:

प्रेरक निर्माणों की गणना का उपयोग करें। तो आप के प्रकार को सामान्य कर सकते हैं #Bool:
```
#Bool = ∀(n : Nat) → ∀(Bool : *ₙ) → ∀(True : Bool) → ∀(False : Bool) → Bool
```
... और फिर आप का दृष्टांत हैं nकरने के लिए 1है, जो साधन आप पास कर सकता है *₀-टाइप जांच दूसरा तर्क है, जो होगा क्योंकि के रूप में:
```
*₀ : *₁
```
... तो आप #Boolदो प्रकारों के बीच चयन करने के लिए उपयोग कर सकते हैं ।
एक और प्रकार जोड़ें:
```
* : □ : △
```
फिर आप एक अलग #Bool₂प्रकार को परिभाषित करेंगे :
```
#Bool₂ = ∀(Bool : □) → ∀(True : Bool) → ∀(False : Bool) → Bool
```
यह अनिवार्य रूप से आगमनात्मक निर्माणों के कलन का एक विशेष मामला है, लेकिन कम पुन: प्रयोज्य कोड का उत्पादन करता है क्योंकि अब हमें दो अलग-अलग परिभाषाओं को बनाए रखना चाहिए #Bool, प्रत्येक के लिए एक जिसे हम समर्थन करना चाहते हैं।
#Bool₂गणना के भीतर सीधे सांकेतिक शब्दों में बदलना :
```
#Bool₂ = ∀(True : *) → ∀(False : *) → *
```

यदि लक्ष्य का उपयोग सीधे अनमॉडिफाइड में करना है morteतो केवल # 3 काम करेगा।

— गेब्रियल गोंजालेज
स्रोत

जैसा कि मैं देख सकता हूं, हम # बूलो -> # बूलो को परिवर्तित नहीं कर सकते?

— 17

@ZeitRaffer यह सही है। आप से परिवर्तित नहीं कर सकते #Bool₁करने के लिए#Bool₂

— गेब्रियल गोंजालेज

हम्म ... IIUC आप "कैलकुलस ऑफ इंडक्टिव कंस्ट्रक्शंस" को एक कैलकुलस टाइप की एक अनन्त श्रेणीबद्धता के साथ कहते हैं, लेकिन AFAIK के मूल CIC में ऐसी कोई बात नहीं थी (इसने केवल CoC के लिए Inductive प्रकार जोड़े)। आप लुओ के ईसीसी (निर्माणों की विस्तारित गणना) के बारे में सोच रहे होंगे?

— स्टीफन