¿Es `sort` tipificable en lógica afín elemental?

El siguiente término λ, aquí en forma normal:

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 de clasificación para listas codificadas por la iglesia. Es decir, el resultado de:

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

Similar,

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

También implementa la clasificación para las mismas listas que anteriormente, excepto que debe proporcionar un argumento adicional con un límite para los números que considerará:

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

Estoy tratando de determinar si esos términos se pueden escribir en lógica afín elemental. Como no conozco ningún verificador de tipo EAL disponible públicamente, esto está resultando una tarea más difícil de lo que esperaba. ¿Hay un tipo para sorten lógica afín elemental?

lo.logic lambda-calculus type-systems

— MaiaVictor
fuente

¿Tiene un tipo "ordinario"? ¿Qué sucede si lo conectas 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^-$

¿Quizás estos comentarios pueden convertirse en una respuesta?

— Andrej Bauer

Mientras lee las preguntas. :-)

— Tayfun paga el

Creo que sort, como se presenta allí, no se puede escribir en EAL. No puedo probar eso, pero no funciona en el algoritmo abstracto de Lamping sin el oráculo. Además, aunque el término es algo inteligente y breve, utiliza estrategias muy extrañas que no son compatibles con EAL.

Pero detrás de esta pregunta hay una más interesante: "¿se puede implementar una función de clasificación nat en EAL" ? Esa era una pregunta muy difícil en aquel entonces, pero ahora parece bastante trivial. Sí, por supuesto. Hay muchas formas más simples de hacerlo. Por ejemplo, uno puede llenar un s codificado por Scott con s codificado NatSetpor Church Nat, y luego convertirlo en una lista. Aquí hay una demostración 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])

Aquí está la forma normal indexada por bruijn de una versión ligeramente alterada de lo sortanterior, que debe recibir (x -> (x x))como primer argumento para funcionar (de lo contrario, no tiene una forma normal):

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

Bastante simple en retrospectiva.

— MaiaVictor
fuente