Qu'est-ce qui rend un langage (et son système de types) capable de prouver des théorèmes sur ses propres termes?

J'ai récemment tenté d'implémenter le Cedille-Core d' Aaron , un langage de programmation minimaliste capable de prouver des théorèmes mathématiques sur ses propres termes. J'ai également prouvé l'induction de types de données codés λ dessus, ce qui a permis de comprendre pourquoi ses extensions seraient nécessaires.

Nether Nether, je me demande toujours d'où viennent ces extensions. Pourquoi sont-ils ce qu'ils sont? Qu'est-ce qui les justifie? Je sais, par exemple, que certaines extensions, comme la récursivité, ruinent le langage comme système de preuves. Si je décidais d'étendre également CoC avec d'autres primitives, comment pourrais-je justifier? Je comprends qu'une preuve de normalisation est nécessaire, mais cela ne prouve pas que ces primitives "ont du sens".

Bref, qu'est-ce qui qualifie précisément une langue (et son système de types) comme un système capable de prouver des théorèmes sur ses propres termes?

[L'auto-publicité suit, mais je pense que cela est pertinent.]

$t$$u$$t \equiv u$$t$$u$$\forall v, (\lambda x.x)\;v \equiv v$

Bien sûr, vous pouvez également supposer des équivalences, et il existe plusieurs formes différentes de quantificateurs (typés / non typés, universels / existentiels). Ce mécanisme peut être utilisé pour raisonner sur n'importe quel programme (il n'est pas nécessaire de prouver qu'il se termine ou même de le taper). La seule contrainte est que les programmes utilisés comme preuves doivent être prouvés se terminant par le système (une récursion générale arbitraire entraîne une incohérence).

Voici quelques références si vous souhaitez vérifier cela:

• https://lepigre.fr/files/docs/lepigre2017_pml2.pdf (article récent avec exemples)
• https://tel.archives-ouvertes.fr/tel-01590363 (thèse de doctorat en anglais)
• https://github.com/rlepigre/pml (implémentation du langage)