बहुरूपता और प्रेरक डेटाैटिप्स

Question

मैं उत्सुक हूँ। मैं इस datatype पर OCaml में काम कर रहा हूँ :

type 'a exptree =
  | Epsilon
  | Delta of 'a exptree * 'a exptree
  | Omicron of 'a
  | Iota of 'a exptree exptree

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

let rec map : 'a 'b. ('a -> 'b) -> 'a exptree -> 'b exptree =
  fun f ->
    begin function
    | Epsilon -> Epsilon
    | Delta (t1, t2) -> Delta (map f t1, map f t2)
    | Omicron t -> Omicron (f t)
    | Iota tt -> Iota (map (map f) tt)
    end

लेकिन मैं कभी भी इसे Coq में परिभाषित नहीं कर पाया :

Inductive exptree a :=
  | epsilon : exptree a
  | delta : exptree a -> exptree a -> exptree a
  | omicron : a -> exptree a
  | iota : exptree (exptree a) -> exptree a
.

कोयल रो रही है। यह अंतिम रचनाकार को पसंद नहीं करता है, और ऐसा कुछ कहता है जिसे मैं पूरी तरह से नहीं समझता या इससे सहमत हूं:

Error: Non strictly positive occurrence of "exptree" in "exptree (exptree a) -> exptree a".

मैं जो समझ सकता हूं, वह यह है कि आगमनात्मक प्रकारों का उपयोग उनकी परिभाषा के अंदर एक नकार का उपयोग करते हुए type 'a term = Constructor ('a term -> …)खारिज कर दिया जाता है, क्योंकि वे बदसूरत गैर-स्थापित जानवरों की तरह होंगे (अनकैप्ड) λ-terms। हालाँकि यह विशेष रूप से exptreeडेटाटाइप सहज रूप से पर्याप्त लगता है: इसकी OCaml परिभाषा को देखते हुए, इसके तर्क 'aका उपयोग कभी भी नकारात्मक स्थिति में नहीं किया जाता है।

ऐसा लगता है कि यहाँ पर Coq ज्यादा व्यस्त है। तो क्या वास्तव में इस विशेष प्रेरक डेटाटाइप के साथ कोई समस्या है? या कोक यहाँ कुछ और अधिक अनुमति दे सकता है?

इसके अलावा, अन्य सबूत सहायकों के बारे में क्या, वे इस तरह के एक प्रेरक परिभाषा (प्राकृतिक तरीके से) का सामना करने में सक्षम हैं?

Answer 1

यह कई बार कॉक मेलिंग सूची में आया है, लेकिन मैंने कभी भी निर्णायक जवाब नहीं देखा। Coq उतना सामान्य नहीं है जितना यह हो सकता है; (Coquand, 1990) और (Giménez, 1998) (और उनकी PhD थीसिस) के नियम अधिक सामान्य हैं और सख्त सकारात्मकता की आवश्यकता नहीं है। सकारात्मकता पर्याप्त नहीं है, हालांकि, जब आप बाहर जाते हैं Set; यह उदाहरण कई चर्चाओं में आया :

Inductive Big : Type := B : ((B -> Prop) -> Prop) -> Big.

आपके जैसे सादे डेटा संरचनाओं के साथ, आगमनात्मक प्रकार कार्यान्वयन को और अधिक जटिल बनाने के अलावा अन्य समस्याओं का कारण नहीं होगा।

$$F = \epsilon + \delta\, (F \times F) + \omicron\, \mathrm{id} + F \circ F$$

$\mathrm{exptree} : a \mapsto \mathrm{exptree}(a)$$\mathrm{exptree}, \mathrm{exptree} \circ \mathrm{exptree}, \mathrm{exptree} \circ \mathrm{exptree} \circ \mathrm{exptree}, \ldots$$\mathrm{exptree}^0(a) = a$$\mathrm{exptree}^1(a) = \mathrm{exptree}(a)$$\mathrm{exptree}^2(a) = \mathrm{exptree}(\mathrm{exptree}(a))$$a$$\mathrm{exptree}^0(a) = a$

Inductive et : nat -> Type -> Type :=
  | alpha : forall a, a -> et 0 a                      (*injection*)
  | omicron : forall n a, et n a -> et (S n) a         (**)
  | epsilon : forall (S n) a, et (S n) a
  | delta : forall n a, et (S n) a -> et (S n) a -> et (S n) a
  | iota : forall n a, et (S (S n)) a -> et (S n) a
.

आप मूल्यों को परिभाषित करने और उन पर काम करने के लिए आगे बढ़ सकते हैं। Coq अक्सर घातांक का अनुमान लगाने में सक्षम होगा। Set Implicit Argumentsइन परिभाषाओं को सुंदर बना देगा।

Definition exptree := et 1.
Definition et1 : exptree nat :=
  delta _ _ (omicron _ _ (alpha _ 42)) (epsilon _ _).
Definition et2 : exptree nat := iota _ _ (omicron _ _ et1).

exptreeet 0S n$a$$a$

Inductive et : nat -> Type -> Type :=
  | omicron_0 : forall a, a -> et 0 a
  | omicron_S : forall n a, et n a -> et (S n) a
  | epsilon : forall n a, et n a
  | delta : forall n a, et n a -> et n a -> et n a
  | iota : forall n a, et (S n) a -> et n a
.
Definition exptree := et 0.
Definition et1 : exptree nat :=
  delta _ _ (omicron_0 _ 42) (epsilon _ _).
Definition et2 : exptree nat :=
  (iota _ _ (omicron_S _ _ et1)).

मुझे लगता है कि यह वही सिद्धांत है जिसे राल्फ मैट द्वारा अधिक सामान्य रूप में प्रस्तावित किया गया है ।

संदर्भ

थिएरी कोक्लैंड और क्रिस्टीन पॉलिन। अनिश्चित रूप से परिभाषित प्रकार । में COLOG'88 की कार्यवाही , LNCS 417, 1990 [ स्प्रिंगर ] [ गूगल ]

एडुआर्डो गिमनेज़। टाइप थ्योरी में संरचनात्मक पुनरावर्ती परिभाषाएँ । में ICALP'98: 25 वीं ऑटोमेटा, बोली और प्रोग्रामिंग पर अंतर्राष्ट्रीय वार्तालाप की कार्यवाही। स्प्रिंगर-वर्लग, 1998. [ PDF ]

Answer 2

राल्फ मैथेस ने वर्णन किया है कि "ए डाटस्ट्रक्चर फॉर इटरनेटेड पॉवर्स" ( कोड , पेपर ) में इस तरह के रूप में कोक में अनुकरण कैसे करें ।

Answer 3

Coq द्वारा की जाने वाली पहली चीजों में से एक इंडक्शन सिद्धांत का निर्माण करना है, जिसमें इंडक्टिव टाइप आप सिर्फ परिभाषित करते हैं और अंतर्निहित इंडक्शन सिद्धांत को समझना एक अच्छा व्यायाम है।

उदाहरण के लिए O : nat | S : nat -> natप्रेरण सिद्धांत उत्पन्न करेगा P O -> (∀ n, P n -> P (S n)) -> ∀ n, P n।

इंडक्शन सिद्धांत किसके अनुरूप होगा iota? ऐसा लगता है कोई विधेय है कि वहाँ Pकि इस बारे में बात करने में सक्षम होगा P tऔर P (iota t), क्योंकि इस बारे में बात करनी चाहिए exptree a, exptree (exptree a), exptree (exptree (exptree a))...

साथ Omicronही समान कार्य भी करता है लेकिन हर बार प्रकार छोटा होता है। आपको यह महसूस करना चाहिए कि छोटे प्रकार और बड़े प्रकार दोनों का संदर्भ होने से चीजें गड़बड़ हो जाएंगी। (यह कहा, Omicronसही तरीका है)

यह सटीक मापदंड नहीं है जो कहता है कि परिभाषा को क्यों स्वीकार नहीं किया जाना चाहिए लेकिन यह बताता है कि यह मेरे लिए गलत क्यों लगता है।

exptreeऐसा लगता है जैसे आप भावों के लिए एक व्याकरण का निर्माण कर रहे हैं, वह चीज जो आम तौर पर उस पुनरावर्ती नहीं होती है । क्या आप इसके साथ कुछ मदद चाहते हैं?