¿Por qué se necesitan tipos recursivos como primitivas para pruebas en sistemas de tipos dependientes?

Soy relativamente nuevo en teoría de tipos y programación dependiente. He estado estudiando el cálculo de construcciones (CoC) y otros sistemas de tipo puro. Estoy particularmente interesado en usarlo como una representación intermedia de preservación de pruebas para un sistema compilador.

Entiendo que los tipos (co) recursivos son representables , computacionalmente , usando como el único constructor de tipos. Sin embargo, he leído que no se pueden usar para crear pruebas por inducción (¡perdóname, no puedo encontrar dónde ahora!), Por ejemplo, que no podría probar que en CoC simple (aunque se puede escribir como ). $\Pi$ $0\neq 1$ $\texttt{Nat}$ $\Pi(\mathbb{N}:*).\Pi(S:\mathbb{N}\rightarrow\mathbb{N}).\Pi(Z:\mathbb{N}).\mathbb{N}$

Supongo que es por eso que construyeron el cálculo de las construcciones inductivas (CIC). ¿Es esto correcto? ¿Pero por qué? No pude encontrar ningún material que explicara por qué tales pruebas no se pueden representar sin usar tipos (co) inductivos como primitivos. Si esto no es cierto, ¿por qué agregarlos como primitivos en CIC?

type-theory dependent-types coq

— paulotorrens
fuente

No soy un experto, pero compartiré lo que entendí hasta ahora con un ejemplo.

Consideremos el tipo booleano en CoC, usando su codificación estándar: Podríamos esperar poder probar

\begin{array}{l} B = Π_{τ : *} τ \to τ \to τ \\ t t = λ τ : *, x : τ, y : τ . x \\ f f = λ τ : *, x : τ, y : τ . y \end{array}

$\begin{array}{l} \mathbb{B} = \Pi_{\tau:*} \tau \to \tau \to \tau \\ \mathsf{tt} = \lambda \tau:*,x:\tau,y:\tau.\ x \\ \mathsf{ff} = \lambda \tau:*,x:\tau,y:\tau.\ y \end{array}$

De hecho, esto se deduce rápidamente del principio de eliminación / inducción dependiente que tenemos, por ejemplo, en CiC

Π_{b : B} b = t t \lor b = f f (*)

$\Pi_{b : \mathbb{B}} b={\sf tt} \lor b = {\sf ff} \qquad(*)$

B_{i n d} : Π_{P : B \to *} P (t t) \to P (f f) \to Π_{b : B} P (b)

$\mathbb{B}_{ind} : \Pi_{P:\mathbb{B}\to*} P({\sf tt}) \rightarrow P({\sf ff}) \rightarrow \Pi_{b:\mathbb{B}} P(b)$

Sin embargo, no podemos esperar que (*) se mantenga en todos los modelos de CoC. Intuitivamente, un valor en debería ser aproximadamente una familia de funciones asigna a cada tipo un valor en la interpretación de . Pero esto no obliga a a ser uno entre los valores de . Podríamos tener, por ejemplo, (informalmente) $\mathbb{B}$ $\{f_\tau\}_{\tau}$ $\tau$ $\tau\to\tau\to\tau$ $f_\tau$ $\sf tt,ff$

f_{N} (n) (m) = n + m

$f_{\mathbb{N}}(n)(m) = n+m$

$\sf tt,ff$ $(*)$ $\mathbb{B}$

$(*)$ $(*)$ $\mathbb{B}_{ind}$

— chi
fuente

(λ (N a t : *) . (. . .)) (Π (N : *) . Π (S : N \to N) . Π (Z : N) . N)

$(\lambda(Nat:*).(...)) (\Pi(\mathbb{N}:*).\Pi(S:\mathbb{N}\rightarrow\mathbb{N}).\Pi(Z:\mathbb{N}).\mathbb{N})$

S

$S$

Z

$Z$

— paulotorrens

N a t

$Nat$

S, Z

$S,Z$

n

$n$

n (T) (S_{T}) (Z_{T}) = Z_{T}

$n(T)(S_T)(Z_T) = Z_T$

T

$T$

T = B

$T=\mathbb{B}$

n (B) (S) (Z) = S (Z)

$n(\mathbb{B})(S)(Z) = S(Z)$

n

$n$

λ T : * . i f T = B t h e n \dots

$\lambda T:*. {\sf if}\ T=\mathbb{B}\ {\sf then}\ \ldots$

n

$n$

Π_{T : *} T \to T

$\Pi_{T:*} T\to T$

v (T) (x) = x

$v(T)(x) = x$

T

$T$

T = N

$T=\mathbb{N}$

v (N) (x) = x + 1

$v(\mathbb{N})(x) = x+1$