Come si ottiene il calcolo delle costruzioni dagli altri punti del cubo Lambda?

Si dice che il CoC sia il culmine di tutte e tre le dimensioni del Lambda Cube. Questo non mi è affatto evidente. Penso di capire le dimensioni individuali e la combinazione di due qualsiasi sembra tradursi in un'unione relativamente semplice (forse mi manca qualcosa?). Ma quando guardo il CoC, invece di sembrare una combinazione di tutti e tre, sembra una cosa completamente diversa. Da quale dimensione provengono i tipi, Prop e small / large? Dove sono scomparsi i prodotti dipendenti? E perché ci si concentra su proposizioni e prove anziché su tipi e programmi? C'è qualcosa di equivalente che si concentra su tipi e programmi?

Modifica: Nel caso in cui non sia chiaro, sto chiedendo una spiegazione di come il CoC è equivalente all'unione semplice delle dimensioni del Cubo Lambda. E c'è una vera unione di tutti e tre là fuori da qualche parte in cui posso studiare (cioè in termini di programmi e tipi, non di prove e proposizioni)? Questo è in risposta ai commenti sulla domanda, non a nessuna delle risposte attuali.

Innanzitutto, per ribadire uno dei punti del codice, il calcolo delle costruzioni induttive (su cui si basa il kernel di Coq) è molto diverso dal calcolo delle costruzioni. È meglio pensare che inizi dalla teoria dei tipi di Martin-Löf con gli universi, e poi aggiunga una specie di Prop in fondo alla gerarchia dei tipi. Questa è una bestia molto diversa dall'originale CoC, che è meglio pensare come una versione dipendente di F-omega. (Ad esempio, CiC ha modelli teorici stabiliti e il CoC no.)

Detto questo, il lambda-cubo (di cui il CoC è membro) viene in genere presentato come un sistema di tipo puro per ragioni di economia nel numero di regole di battitura. Trattando specie, tipi e termini come elementi della stessa categoria sintattica, puoi scrivere molte meno regole e anche le tue prove diventano un po 'meno ridondanti.

Tuttavia, per capire, può essere utile separare esplicitamente le diverse categorie. Possiamo introdurre tre categorie sintattiche, tipi (spaziati dal metavariabile k), tipi (spaziati dal metavariabile A) e termini (spaziati dal metavariabile e). Quindi tutti e otto i sistemi possono essere intesi come variazioni su ciò che è consentito a ciascuno dei tre livelli.

λ → (Calcolo lambda semplicemente digitato)

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

Questo è il calcolo lambda tipizzato di base. C'è un solo tipo ∗, che è il tipo di tipi. I tipi stessi sono tipi atomici pe tipi di funzione A → B. I termini sono variabili, astrazioni o applicazioni.

λω_ (STLC + operatori di tipo superiore)

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

L'STLC consente l'astrazione solo a livello di termini. Se lo aggiungiamo a livello di tipi, aggiungiamo un nuovo tipo k → kche è il tipo di funzioni a livello di tipo e anche astrazione λa:k.Ae applicazione A Ba livello di tipo. Quindi ora non abbiamo il polimorfismo, ma abbiamo operatori di tipo.

Se la memoria serve, questo sistema non ha più potenza computazionale di STLC; ti dà solo la possibilità di abbreviare i tipi.

λ2 (Sistema F)

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

Invece di aggiungere operatori di tipo, avremmo potuto aggiungere polimorfismo. A livello di tipo, aggiungiamo ∀a:k. Aquale è un tipo polimorfico precedente e, a livello di termine, aggiungiamo astrazione sui tipi Λa:k. ee l'applicazione del tipo e [A].

Questo sistema è molto più potente dell'STLC - è potente quanto l'aritmetica del secondo ordine.

λω (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]

Se abbiamo sia operatori di tipo che polimorfismo, otteniamo F-omega. Questo sistema è più o meno la teoria del tipo di kernel della maggior parte dei linguaggi funzionali moderni (come ML e Haskell). È anche molto più potente del Sistema F - è equivalente in termini di forza all'aritmetica di ordine superiore.

λP (LF)

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

Invece del polimorfismo, avremmo potuto andare nella direzione della dipendenza da un semplice calcolo lambda. Se hai permesso al tipo di funzione di lasciare che il suo argomento fosse usato nel tipo restituito (cioè scrivi Πx:A. B(x)invece di A → B), otterrai λP. Per renderlo davvero utile, dobbiamo estendere l'insieme di tipi con un tipo di operatori di tipo che prendono termini come argomenti Πx:A. k, e quindi dobbiamo aggiungere anche un'astrazione Λx:A.Be un'applicazione corrispondenti A [e]a livello di tipo.

Questo sistema viene talvolta chiamato LF o Edinburgh Logical Framework.

Ha la stessa forza computazionale del calcolo lambda tipizzato in modo semplice.

λP2 (nessun nome speciale)

 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]

Possiamo anche aggiungere polimorfismo a λP, per ottenere λP2. Questo sistema non viene spesso utilizzato, quindi non ha un nome particolare. (L'unico documento che ho letto che l'ha usato è l' induzione di Herman Geuvers non derivabile nella teoria del tipo dipendente dal secondo ordine .)

Questo sistema ha la stessa forza del sistema F.

λPω_ (nessun nome speciale)

 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 

Potremmo anche aggiungere operatori di tipo a λP, per ottenere λPω_. Ciò comporta l'aggiunta di un tipo Πa:k. k'per operatori di tipo e la corrispondente astrazione Λx:A.Be applicazione a livello di tipo A [e].

Dal momento che non c'è ancora nessun salto nella forza computazionale rispetto allo STLC, questo sistema dovrebbe anche costituire una base eccellente per un framework logico, ma nessuno lo ha fatto.

λPω (il calcolo delle costruzioni)

 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]

Infine, arriviamo a λPω, il calcolo delle costruzioni, prendendo λPω_ e aggiungendo un tipo polimorfico precedente ∀a:k.Ae astrazione a livello di termine Λa:k. ee applicazione e [A]per esso.

I tipi di questo sistema sono molto più espressivi che in F-omega, ma hanno la stessa forza computazionale.

$\lambda$

Ma prima, si dovrebbe probabilmente provare a districare vari problemi. Il prover del teorema interattivo di Coq si basa su una teoria dei tipi sottostante, a volte amorevolmente chiamata il calcolo delle costruzioni induttive con gli universi . Noterai che questo è più un boccone che semplicemente "Calculus of Constructions", e in effetti ci sono molte più cose lì oltre al solo CoC. In particolare, penso che tu sia confuso su quali caratteristiche siano nel proprio CoC. In particolare, la distinzione Set / Prop e gli universi non compaiono nel CoC.

Non fornirò una panoramica completa dei sistemi di tipo puro qui, ma l'importante regola (per PTS funzionali come il CoC) è la seguente

$$\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)\}$$

E quindi abbiamo 4 regole che corrispondono a 4 scopi diversi:

• $(*,*)$

• $(\square,\square)$

• $(\square,*)$

• $(*,\square)$

Spiegherò ciascuno di questi in modo più dettagliato.

---

$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 questi tipi e regole extra, ottieni qualcosa che non è un PTS, ma qualcosa di simile. Questo è (quasi) il calcolo esteso delle costruzioni , che è più vicino alla base di Coq. Il grande pezzo mancante qui sono i tipi induttivi, di cui non discuterò qui.

Modifica: c'è un bel riferimento che descrive varie caratteristiche dei linguaggi di programmazione nel quadro di PTS, descrivendo un PTS che è un buon candidato per una rappresentazione intermedia di un linguaggio di programmazione funzionale:

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