क्या प्रारंभिक क्राइम लॉजिक पर `सॉर्ट` टाइप करने योग्य है?

Question

निम्नलिखित λ-टर्म, यहाँ सामान्य रूप में:

sort = (λabc.(a(λdefg.(f(d(λhij.(j(λkl.(k(λmn.(mhi))l))
       (h(λkl.l)i)))(λhi.(i(λjk.(bd(jhk)))(bd(h(λjk.(j
       (λlm.m)k))c)))))e))(λde.e)(λde.(d(λfg.g)e))c))

चर्च-एन्कोडेड सूचियों के लिए एक छँटाई एल्गोरिथ्म लागू करता है। इसका परिणाम यह है कि:

sort (λ c n . (c 3 (c 1 (c 2 n)))) β→ (λ c n . (c 1 (c 2 (c 3 n))))

इसी तरह,

sort_below = λabcd.a(λef.f(λghi.g(λj.h(λkl.kj(ikl)))(hi))e(λgh.h))
            (λe.d)(λe.b(λf.e(f(λghi.hg)(λgh.cfh))))

ऊपर की समान सूचियों के लिए छँटाई करने वाले उपकरणों के अलावा, आपको उन अतिरिक्त संख्याओं के लिए एक अतिरिक्त तर्क प्रदान करना होगा, जिन पर वह विचार करेगा:

sort_below 4 [5,1,3,2,4] → [1,2,3]

मैं यह निर्धारित करने की कोशिश कर रहा हूं कि क्या वे शब्द प्राथमिक चक्कर तर्क पर टाइप करने योग्य हैं। चूंकि मुझे कोई ईएएल टाइप-चेकर सार्वजनिक रूप से उपलब्ध नहीं है, इसलिए यह मेरी अपेक्षा से अधिक कठिन कार्य साबित हो रहा है। क्या sortप्राथमिक आत्मीय तर्क के लिए एक प्रकार है?

Comments

क्या इसका "सामान्य" प्रकार है? यदि आप इसे हास्केल में प्लग करते हैं तो क्या होता है?

— बाउर

$sort:\mathsf{NatList}\to\mathsf{NatList}$$\mathsf{NatList}:=\forall X.(\mathsf{Nat}\to X\to X)\to X\to X$

$(\cdot)^-$$t:A$$t^-:A^-$

हो सकता है कि इन टिप्पणियों को जवाब में बदल दिया जाए?

— एंड्रेज बॉयर

प्रश्नों के माध्यम से पढ़ते हुए। :-)

— तय्युन पे

Answer 1

मुझे लगता है sort, जैसा कि वहां प्रस्तुत किया गया है, ईएएल पर टाइप करने योग्य नहीं है। मैं यह साबित नहीं कर सकता, लेकिन यह ओरेकल के बिना लैम्पिंग एब्सट्रैक्ट एल्गोरिदम पर काम नहीं करता है। इसके अलावा, जबकि यह शब्द कुछ हद तक चालाक और संक्षिप्त है, यह बहुत निराला रणनीतियों का उपयोग करता है जो ईएएल-अनुकूल नहीं हैं।

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

-- sort_example.mel
-- Sorting a list of Church-encoded numbers on the untyped lambda calculus
-- with terms that can be executed by Lamping's Abstract Algorithm without
-- using the Oracle. Test by calling `mel sort_example.mel`, using Caramel,
-- from https://github.com/maiavictor/caramel

-- Constructors for Church-encoded Lists 
-- Haskell: `data List = Cons a (List a) | Nil`
Cons head tail = (cons nil -> (cons head (tail cons nil)))
Nil            = (cons nil -> nil)

-- Constructors for Church-encoded Nats
-- Haskell: `data Nat = Succ Nat | Zero`
Succ pred = (succ zero -> (succ (pred succ zero)))
Zero      = (succ zero -> zero)

---- Constructors for Scott-encoded NatMaps
---- Those work like lists, where `Yep` constructors mean
---- there is a number on that index, `Nah` constructors
---- mean there isn't, and `End` ends the list.
---- Haskell: `data NatMap = Yep NatMap | Nah NatMap | End`
Yep natMap = (yep nah end -> (yep natMap))
Nah natMap = (yep nah end -> (nah natMap))
End        = (yep nah end -> end)

---- insert :: Nat (Church) -> NatMap (Scott) -> NatMap (Scott)
---- Inserts a Church-encoded Nat into a Scott-encoded NatMap.
insert nat natMap    = (nat succ zero natMap)
    succ pred natMap = (natMap yep? nah? end?)
        yep? natMap  = (Yep (pred natMap))
        nah? natMap  = (Nah (pred natMap))
        end?         = (Nah (pred natMap))
    zero natMap      = (natMap Yep Yep (Yep End))

---- toList :: NatMap (Scott) -> List Nat (Church)
---- Converts a Scott-Encoded NatMap to a Church-encoded List
toList natMap        = (go go natMap 0)
    go go natMap nat = (natMap yep? nah? end?)
        yep? natMap  = (Cons nat (go go natMap (Succ nat)))
        nah? natMap  = (go go natMap (Succ nat))
        end?         = Nil

---- sort :: List Nat (Church) -> List Nat (Church)
---- Sorts a Church-encoded list of Nats in ascending order.
sort nats = (toList (nats insert End))

-- Test
main = (sort [1,4,5,2,3])

यहाँ sortउपरोक्त के थोड़े परिवर्तित संस्करण का ब्रूजन-अनुक्रमित सामान्य रूप है , जिसे काम करने (x -> (x x))के लिए पहले तर्क के रूप में प्राप्त करना होगा (अन्यथा इसका सामान्य रूप नहीं है):

λλ(((1 λλλ(((1 λλλ((1 3) (((((5 5) 2) λλ(1 ((5 1) 0))) 1) 0))) 
λ(((3 3) 0) λλ(1 ((3 1) 0)))) λλ0)) ((0 λλ(((1 λλ(((0 λλλλ(2 (
5 3))) λλλλ(1 (5 3))) λλλ(1 (4 3)))) λ(((0 λλλλ(2 3)) λλλλ(2 3
)) λλλ(2 λλλ0))) 0)) λλλ0)) λλ0)

रेट्रोस्पेक्ट में बहुत सरल है।