¿Cómo se obtiene el cálculo de construcciones de los otros puntos en el Cubo Lambda?

Se dice que el CoC es la culminación de las tres dimensiones del Cubo Lambda. Esto no es aparente para mí en absoluto. Creo que entiendo las dimensiones individuales, y la combinación de cualquiera de los dos parece resultar en una unión relativamente sencilla (¿tal vez me falta algo?). Pero cuando miro el CoC, en lugar de parecer una combinación de los tres, parece una cosa completamente diferente. ¿De qué dimensión provienen Type, Prop y los tipos pequeño / grande? ¿Dónde desaparecieron los productos dependientes? ¿Y por qué hay un enfoque en proposiciones y pruebas en lugar de tipos y programas? ¿Hay algo equivalente que se centre en tipos y programas?

Editar: en caso de que no esté claro, solicito una explicación de cómo el CoC es equivalente a la unión directa de las dimensiones del Cubo Lambda. ¿Y hay una unión real de los tres en algún lugar que pueda estudiar (es decir, en términos de programas y tipos, no de pruebas y proposiciones)? Esto es en respuesta a los comentarios sobre la pregunta, no a las respuestas actuales.

Primero, para reiterar uno de los puntos de Cody, el cálculo de construcciones inductivas (en el que se basa el núcleo de Coq) es muy diferente del cálculo de construcciones. Es mejor pensar que comienza en la teoría de tipos Martin-Löf con universos, y luego agrega una especie de Prop en la parte inferior de la jerarquía de tipos. Esta es una bestia muy diferente al CoC original, que se considera mejor como una versión dependiente de F-omega. (Por ejemplo, CiC tiene modelos teóricos de conjuntos y el CoC no).

Dicho esto, el cubo lambda (del cual el CoC es miembro) generalmente se presenta como un sistema de tipo puro por razones de economía en el número de reglas de escritura. Al tratar las clases, los tipos y los términos como elementos de la misma categoría sintáctica, puede escribir muchas menos reglas y sus pruebas también serán un poco menos redundantes.

Sin embargo, para comprender, puede ser útil separar las diferentes categorías explícitamente. Podemos introducir tres categorías sintácticas, tipos (ordenados por la metavariable k), tipos (ordenados por la metavariable A) y términos (ordenados por la metavariable e). Entonces, los ocho sistemas pueden entenderse como variaciones de lo que está permitido en cada uno de los tres niveles.

λ → (cálculo lambda de tipo simple)

 k ::= ∗
 A ::= p | A → B
 e ::= x | λx:A.e | e e

Este es el cálculo básico tipo lambda. Hay un solo tipo ∗, que es el tipo de tipos. Los tipos en sí son tipos atómicos py tipos de funciones A → B. Los términos son variables, abstracciones o aplicaciones.

λω_ (STLC + operadores de tipo de tipo superior)

 k ::= ∗ | k → k
 A ::= a | p | A → B | λa:k.A | A B
 e ::= x | λx:A.e | e e

El STLC solo permite la abstracción a nivel de términos. Si lo agregamos a nivel de tipos, entonces agregamos un nuevo tipo k → kque es el tipo de funciones de nivel de tipo, y la abstracción λa:k.Ay aplicación también A Ba nivel de tipo. Entonces ahora no tenemos polimorfismo, pero tenemos operadores de tipo.

Si la memoria sirve, este sistema no tiene más potencia computacional que el STLC; solo te da la capacidad de abreviar tipos.

λ2 (Sistema F)

 k ::= ∗
 A ::= a | p | A → B  | ∀a:k. A 
 e ::= x | λx:A.e | e e | Λa:k. e | e [A]

En lugar de agregar operadores de tipo, podríamos haber agregado polimorfismo. En el nivel de tipo, agregamos ∀a:k. Acuál es un formador de tipo polimórfico, y en el nivel de término, agregamos abstracción sobre tipos Λa:k. ey aplicación de tipo e [A].

Este sistema es mucho más poderoso que el STLC: es tan fuerte como la aritmética de segundo orden.

λω (Sistema F-omega)

 k ::= ∗ | k → k 
 A ::= a | p | A → B  | ∀a:k. A | λa:k.A | A B
 e ::= x | λx:A.e | e e | Λa:k. e | e [A]

Si tenemos operadores tipo y polimorfismo, obtenemos F-omega. Este sistema es más o menos la teoría del tipo de núcleo de la mayoría de los lenguajes funcionales modernos (como ML y Haskell). También es mucho más poderoso que el Sistema F: es equivalente en fuerza a la aritmética de orden superior.

λP (LF)

 k ::= ∗ | Πx:A. k 
 A ::= a | p | Πx:A. B | Λx:A.B | A [e]
 e ::= x | λx:A.e | e e

En lugar del polimorfismo, podríamos haber ido en la dirección de la dependencia del cálculo lambda de tipo simple. Si permitiste que el tipo de función permitiera que su argumento se usara en el tipo de retorno (es decir, escribir en Πx:A. B(x)lugar de A → B), entonces obtienes λP. Para que esto sea realmente útil, tenemos que extender el conjunto de tipos con un tipo de operadores de tipo que toman términos como argumentos Πx:A. k, por lo que también tenemos que agregar una abstracción Λx:A.By aplicación correspondiente A [e]en el nivel de tipo.

Este sistema a veces se llama LF, o el Marco lógico de Edimburgo.

Tiene la misma fuerza computacional que el cálculo lambda de tipo simple.

λP2 (sin nombre especial)

 k ::= ∗ | Πx:A. k 
 A ::= a | p | Πx:A. B | ∀a:k.A | Λx:A.B | A [e]
 e ::= x | λx:A.e | e e | Λa:k. e | e [A]

También podemos agregar polimorfismo a λP, para obtener λP2. Este sistema no se usa con frecuencia, por lo que no tiene un nombre en particular. (El único artículo que he leído que lo usó es la inducción de Herman Geuvers no es derivable en la teoría del tipo dependiente de segundo orden ).

Este sistema tiene la misma fuerza que el Sistema F.

λPω_ (sin nombre especial)

 k ::= ∗ | Πx:A. k | Πa:k. k'
 A ::= a | p | Πx:A. B | Λx:A.B | A [e] | λa:k.A | A B 
 e ::= x | λx:A.e | e e 

También podríamos agregar operadores de tipo a λP, para obtener λPω_. Esto implica agregar un tipo Πa:k. k'para operadores de tipo, y la abstracción Λx:A.By aplicación de nivel de tipo correspondiente A [e].

Dado que nuevamente no hay un salto en la fuerza computacional sobre el STLC, este sistema también debería ser una buena base para un marco lógico, pero nadie lo ha hecho.

λPω (el cálculo de las construcciones)

 k ::= ∗ | Πx:A. k | Πa:k. k'
 A ::= a | p | Πx:A. B | ∀a:k.A | Λx:A.B | A [e] | λa:k.A | A B 
 e ::= x | λx:A.e | e e | Λa:k. e | e [A]

Finalmente, llegamos a λPω, el cálculo de construcciones, tomando λPω_ y agregando una ∀a:k.Aabstracción de tipo polimórfico y una abstracción a nivel de término Λa:k. ey su aplicación e [A].

Los tipos de este sistema son mucho más expresivos que en F-omega, pero tiene la misma fuerza computacional.

$\lambda$

Pero primero, uno probablemente debería tratar de desenredar varios problemas. El probador de teoremas interactivo de Coq se basa en una teoría de tipos subyacente, a veces llamada amorosamente cálculo de construcciones inductivas con universos . Notarás que esto es más bocado que simplemente "Cálculo de construcciones", y de hecho, hay muchas más cosas allí que solo el CoC. En particular, creo que está confundido acerca de qué características están en CoC propiamente dicho. En particular, la distinción Set / Prop y los universos no aparecen en CoC.

No daré una descripción completa de Pure Type Systems aquí, pero la regla importante (para PTS funcionales como el CoC) es la siguiente

$$\frac{\Gamma\vdash A:s\qquad \Gamma,x:A\vdash B:k}{\Gamma\vdash \Pi x:A.B\ :\ k}\ (s,k)\in R$$

$s,k$$S$$(s,k)$$R$$S$

$S$$R$$\Pi x:A.B$

$S$

$$\{*, \square\}$$ $$R=\{(*,*),(\square,\square),(\square,*),(*,\square)\}$$

Y entonces tenemos 4 reglas que corresponden a 4 propósitos diferentes:

• $(*,*)$

• $(\square,\square)$

• $(\square,*)$

• $(*,\square)$

Explicaré cada uno de estos con más detalle.

---

$A\rightarrow B$$\Pi x:A.B$$x$$B$

$*$$\mathrm{nat}$$\mathrm{bool}$$x=y$$x$$y$$*$

$\mathrm{list}$$\mathrm{list}:*\rightarrow *$$\mathrm{list}_{\mathrm{nat}}, \mathrm{list}_{\mathrm{bool}}$$*\rightarrow *$$(\square,\square)$

$$\Pi t:*.\ t\rightarrow t$$ $\lambda (t:*)(x:t).x$$\Pi t:*.\_$$(\square, *)$$t\rightarrow t$$(*,*)$

$$A\wedge B := \Pi t:*.\ (A \rightarrow B\rightarrow t)\rightarrow t$$ $$A\vee B := \Pi t:*.\ (A \rightarrow t)\rightarrow(B\rightarrow t)\rightarrow t$$ $$\bot := \Pi t:*.\ t$$ $$\top := \Pi t:*.\ t\rightarrow t$$ $$\exists x:A.\ P(x):= \Pi t:*.\ (\Pi y: A.\ P(y)\rightarrow t)\rightarrow t$$ $(*,\square)$

$*$$*$$(\square, *)$

$(\square,\square)$

$$\Pi c:*\rightarrow *.\ \ c\ \mathrm{nat}\rightarrow c\ \mathrm{nat}$$

$0=1$

$$=\ :\ \mathrm{nat}\rightarrow\mathrm{nat}\rightarrow *$$ $$=\ :\ \Pi t:*.\ t\rightarrow t\rightarrow *$$ $\mathrm{nat}\rightarrow\mathrm{nat}\rightarrow *$$(*,\square)$

$\square \rightarrow \square$$\square$ $\square$$\square_i$$i=1,2,3,\ldots$$\square_i:\square_{i+1}$

$(\square_i, \square_i)$

$$\frac{\Gamma\vdash A:\square_i}{\Gamma\vdash A:\square_j}\ i\leq j$$

Con estos tipos y reglas adicionales, obtienes algo que no es un PTS, sino algo cercano. Este es (casi) el cálculo extendido de construcciones , que está más cerca de la base de Coq. La gran pieza que falta aquí son los tipos inductivos, que no discutiré aquí.

Editar: Hay una referencia bastante agradable que describe varias características de los lenguajes de programación en el marco de los PTS, al describir un PTS que es un buen candidato para una representación intermedia de un lenguaje de programación funcional:

Henk: A Typed Intermediate Language , SP Jones y E. Meijer.