Cosa rende un linguaggio (e il suo sistema di tipi) in grado di dimostrare teoremi sui propri termini?

Di recente ho tentato di implementare il Cedille-Core di Aaron , un linguaggio di programmazione minimalista in grado di dimostrare teoremi matematici sui suoi stessi termini. Ho anche dimostrato l'induzione per i tipi di dati con codifica λ, il che ha chiarito il motivo per cui le sue estensioni sarebbero state necessarie.

Nether meno, mi rimane ancora da chiedersi da dove vengano quelle estensioni. Perché sono quello che sono? Cosa li giustifica? So, ad esempio, che alcune estensioni, come la ricorsione, rovinano la lingua come sistema di prove. Se decidessi di estendere il CoC anche con altri primitivi, come potrei giustificare? Capisco che è necessaria una prova di normalizzazione, ma ciò non dimostra che quei primitivi "abbiano un senso".

In breve, che cosa specificamente qualifica una lingua (e il suo sistema di tipi) come un sistema in grado di dimostrare teoremi sui propri termini?

type-theory functional-programming constructive-mathematics

— MaiaVictor
fonte

Ho letto un blog correlato a questa domanda, ma non riesco a trovarlo ora :( Conteneva la frase "Il sistema T è abbastanza!" O qualcosa del genere e parlava di sistemi di tipo dipendente.

— Labbekak

Trovato: queuea9.wordpress.com/2010/01/17/… In realtà è stato scritto da Aaron Stump, quindi potresti già saperlo.

— Labbekak,

La ricorsione non custodita "rovina" il linguaggio come sistema di prova, la ricorsione non protetta. Per dimostrare che i primitivi hanno un senso, direi che costruisci un modello. E per dimostrare i teoremi sui propri termini, ha bisogno di una sorta di isomorfismo Curry-Howard e di un tipo dipendente in modo che le cose che dimostrate (tipi) possano parlare dei vostri termini.

— xavierm02

[Segue l'auto-pubblicità, ma penso che questo sia pertinente.]

Esistono diversi approcci possibili a questa domanda. Uno dei modi (che ho esplorato durante la mia tesi di dottorato nel contesto di un linguaggio di tipo ML) è quello di estendere il sistema di tipi con un livello di primo ordine, in modo che i termini del linguaggio possano essere manipolati come oggetti della logica sottostante . Naturalmente, devi anche includere alcuni predicati in modo che ci sia qualcosa da osservare. Nel caso del mio sistema, questi predicati sono equivalenze di termini. In particolare, se ed sono termini del linguaggio, allora il tipo è abitato solo se ed sono effettivamente (osservativamente) equivalente. È possibile utilizzare quantificatori del primo ordine per codificare proprietà come $t$ $u$ $t \equiv u$ $t$ $u$ $\forall v, (\lambda x.x)\;v \equiv v$ in tipi, e sono dimostrati costruendo programmi che li abitano.

Naturalmente puoi anche assumere equivalenze e ci sono diverse forme di quantificatori (tipizzati / non tipizzati, universali / esistenziali). Questo meccanismo può essere utilizzato per ragionare su qualsiasi programma (non è necessario che si dimostri di essere terminato o addirittura digitato). L'unico vincolo è che i programmi che vengono utilizzati come prove devono essere dimostrati terminando dal sistema (la ricorsione generale arbitraria porta a un'incoerenza).

Ecco un paio di riferimenti se vuoi dare un'occhiata:

https://lepigre.fr/files/docs/lepigre2017_pml2.pdf (documento recente con esempi)
https://tel.archives-ouvertes.fr/tel-01590363 (tesi di dottorato in inglese)
https://github.com/rlepigre/pml (implementazione del linguaggio)

— Rodolphe Lepigre
fonte