Temel afinite mantığında "sort" yazılabilir mi?

Aşağıdaki λ terimi, burada normal biçimde:

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))

Kilise kodlu listeler için bir sıralama algoritması uygular. Yani, sonucu:

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

Benzer şekilde,

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))))

Ayrıca, yukarıdaki gibi aynı listeler için sıralama uygular, ancak dikkate alacağı sayılar için bir sınır ile ek bir bağımsız değişken sağlamanız gerekir:

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

Bu terimlerin temel afinite mantığında yazılabilir olup olmadığını belirlemeye çalışıyorum. Halka açık herhangi bir EAL tipi denetleyici bilmediğimden, bu beklediğimden daha zor bir iş olduğunu kanıtlıyor. sortTemel afinite mantığında bir tür var mı ?

lo.logic lambda-calculus type-systems

— MaiaVictor
kaynak

"Sıradan" bir türü var mı? Haskell'e takarsanız ne olur?

— Andrej Bauer

s o r t : N a t L i s t \to N a t L i s t

$sort:\mathsf{NatList}\to\mathsf{NatList}$

N a t L i s t := \forall X . (N a t \to X \to X) \to X \to X

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

(\cdot)^{-}

$(\cdot)^-$

t : A

$t:A$

t^{-} : A^{-}

$t^-:A^-$

Belki bu yorumlar bir cevaba dönüşebilir?

— Andrej Bauer

Soruları okurken. :-)

— Tayfun Pay

Sanırım sortorada sunulduğu gibi, EAL'de yazılamaz. Bunu kanıtlayamıyorum, ama o kehanet olmadan Lamping'in Soyut Algoritması üzerinde çalışmaz. Dahası, terim biraz akıllı ve kısa olsa da, EAL dostu olmayan çok tuhaf stratejiler kullanır.

Ancak bu sorunun arkasında daha ilginç bir soru var: "EAL'de nat-sorting fonksiyonu uygulanabilir mi? " O zamanlar bu çok zor bir soruydu, ama şimdi oldukça önemsiz görünüyor. Evet tabi ki. Bunu yapmanın birçok basit yolu var. Örneğin, bir Scott kodlanmış NatSetChurch- Nats kodlanmış s ile doldurabilir ve daha sonra bir listeye dönüştürebilirsiniz. İşte tam bir gösteri:

-- 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])

sortYukarıda (x -> (x x))çalışmak için ilk argüman olarak alması gereken yukarıdakinin biraz değiştirilmiş bir versiyonunun bruijn endeksli normal formu (aksi takdirde normal bir formu yoktur):

λλ(((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)

Geçmişe bakıldığında oldukça basit.

— MaiaVictor
kaynak