`Sort` è tipizzabile sulla logica affine elementare?

Il seguente termine λ, qui in forma normale:

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

Implementa un algoritmo di ordinamento per elenchi codificati in chiesa. Cioè, il risultato di:

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

Allo stesso modo,

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

Implementa anche l'ordinamento per gli stessi elenchi di cui sopra, tranne che è necessario fornire un argomento aggiuntivo con un limite per i numeri che prenderà in considerazione:

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

Sto cercando di determinare se quei termini sono tipizzabili sulla logica affine elementare. Dal momento che non conosco alcun verificatore di tipi EAL pubblicamente disponibile, questo si sta rivelando un compito più difficile di quanto mi aspettassi. Esiste un tipo sortnella logica affine elementare?

lo.logic lambda-calculus type-systems

— MaiaVictor
fonte

Ha un tipo "ordinario"? Cosa succede se lo colleghi a Haskell?

— 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^-$

Forse questi commenti possono essere trasformati in una risposta?

— Andrej Bauer,

Durante la lettura di domande. :-)

— Tayfun paga il

Penso che sort, come presentato lì, non sia tipizzabile su EAL. Non posso provarlo, ma non funziona sull'algoritmo astratto di Lamping senza l'oracolo. Inoltre, sebbene il termine sia in qualche modo intelligente e breve, utilizza strategie molto stravaganti che non sono compatibili con l'EAL.

Ma dietro questa domanda ce n'è una più interessante: "una funzione di ordinamento nat può essere implementata in EAL" ? All'epoca era una domanda molto difficile, ma ora sembra piuttosto banale. Sì, naturalmente. Ci sono molti modi più semplici per farlo. Per un esempio, si può semplicemente riempire un codice codificato NatSetda Scott con codici codificati da Church Nate quindi convertirlo in un elenco. Ecco una dimostrazione completa:

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

Ecco la forma normale indicizzata da Bruijn di una versione leggermente modificata di quanto sortsopra, che deve funzionare (x -> (x x))come primo argomento per funzionare (altrimenti non ha una forma normale):

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

Abbastanza semplice in retrospettiva.

— MaiaVictor
fonte