Un ejemplo donde el término lambda normal más pequeño no es el más rápido

Deje que los términos $size$ de $\lambda$ se definan de la siguiente manera:

• $size(x) = 1$ ,
• $size(λx.t) = size(t) + 1$ ,
• $size(t s) = size(t) + size(s) + 1$ .

Deje que la complejidad de un $\lambda$ -term $t$ se defina como el número de reducciones beta paralelas desde $t x$ a su forma normal (utilizando un evaluador óptimo en el sentido de Levy).

Estoy buscando un ejemplo de dos términos \ lambda normales para la misma función donde el término más grande tiene menor complejidad.$\lambda$

...

Editar para mayor claridad

Como parece que no es obvio lo que pregunto, intentaré dar un ejemplo sólido. A menudo se cree que la definición "ingenua" / "más simple" de una función es lenta y no óptima. Un mejor rendimiento aumenta la complejidad del término, ya que necesita estructuras de datos adicionales, fórmulas, etc. Un buen ejemplo es fibonacci, que puede definirse "ingenuamente" como:

-- The fixed fibonacci definition
fib_rec fib n =
    if (is_zero x) 
        then 1 
        else fib (n - 1) + f (n - 2)

-- Using church numbers instead of the λ-combinator to get a normal form
fib n = n fib_rec 0 n 

Esto a menudo se considera como la definición "más simple" de fib, y es muy lenta (exponencial). Si ampliamos las dependencias de fib(las definiciones habituales para la suma de números de iglesia, pred, is_zero) y la normalizamos, obtenemos este término:

fib = (λa.(a(λbc.(c(λdef.f)(λde.d)(λde.(de))
      (λde.(b(λfg.(c(λhi.(i(hf)))(λh.g)(λh.h)))
      d(b(λfg.(c(λhi.(i(h(λjk.(k(jf))))))(λhi.g)
      (λh.h)(λh.h)))de)))))(λbc.c)a))

Las mejoras, como las tablas de memorización, ampliarían este término. Sin embargo, existe un término diferente que es mucho más pequeño ...

fib = (λa.(a(λb.(b(λcde.(e(λfg.(cf(dfg)))c))))
      (λb.(b(λcd.(cd))(λcd.d)))(λbc.b)))

y, curiosamente, también es asintóticamente superior al ingenuo, corriendo O(N). De todas las definiciones que conozco, esta es la más rápida y la más simple . El mismo efecto ocurre con sort. Las definiciones "ingenuas" como el ordenamiento de burbujas y el ordenamiento por inserción a menudo se amplían a términos enormes (más de 20 líneas de largo), pero existe una pequeña definición:

-- sorts a church list (represented as the fold) of church numbers
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

Que también resulta ser más rápido, asintóticamente, que cualquier otra definición que conozco. Esta observación me lleva a creer que, a diferencia de la creencia común, el término más simple, con la menor complejidad de Kolmogorov, suele ser el más rápido. Mi pregunta es básicamente si hay alguna evidencia de lo contrario, aunque me resultaría difícil formalizarlo.

El teorema de aceleración de Blum generalmente se establece en el lenguaje de funciones parcialmente recursivas, pero hasta diferencias triviales en notación, funciona igual en el lenguaje de cálculo .$\lambda$

Dice que dada cualquier medida de complejidad razonable (por ejemplo, el número óptimo de reducciones como en la pregunta) y una función recursiva (por ejemplo, ), podemos encontrar un predicado recursivo tal que:$M$$f(x,y)$$2^y$$P(x)$

Para cada algoritmo (es decir, -term en forma normal aquí) computando , hay otro algoritmo para que tiene velocidad sobre : $\lambda$$g$$P$$h$$P$$f$$g$

$$f(x,M(h,x))\le M(g,x)\text{ for all large enough inputs }x,$$

donde indica la complejidad del cálculo de en la entrada según medir .$M(g,x)$$g$$x$$M$

Por consiguiente:

• $P$ no tiene un algoritmo asintóticamente óptimo en la medida dada

• en particular, el algoritmo más corto para no es asintóticamente óptimo$P$

• para cualquier algoritmo para , hay un algoritmo asintóticamente más rápido cuya forma normal es más larga (porque hasta el cambio de nombre de las variables, solo hay muchos términos normales de una longitud determinada)$P$