Wie erhält man die Konstruktionsrechnung von den anderen Punkten im Lambda-Würfel?

Der CoC soll der Höhepunkt aller drei Dimensionen des Lambda-Würfels sein. Das ist mir überhaupt nicht klar. Ich glaube, ich verstehe die einzelnen Dimensionen, und die Kombination von beiden scheint zu einer relativ einfachen Vereinigung zu führen (vielleicht fehlt mir etwas?). Aber wenn ich mir das CoC ansehe, anstatt wie eine Kombination aus allen dreien auszusehen, sieht es ganz anders aus. Aus welcher Dimension stammen Type, Prop und Small / Large-Typen? Wohin sind abhängige Produkte verschwunden? Und warum wird der Fokus auf Aussagen und Beweise anstatt auf Typen und Programme gelegt? Gibt es eine Entsprechung, die sich auf Typen und Programme konzentriert?

Bearbeiten: Falls es nicht klar ist, bitte ich um eine Erklärung, wie der CoC der einfachen Vereinigung der Lambda-Würfel-Dimensionen entspricht. Und gibt es irgendwo, wo ich studieren kann, eine tatsächliche Vereinigung aller drei (dh in Bezug auf Programme und Typen, nicht in Bezug auf Beweise und Sätze)? Dies ist eine Antwort auf Kommentare zu der Frage, nicht auf aktuelle Antworten.

Erstens, um einen von Codys Punkten zu wiederholen, unterscheidet sich der Calculus of Inductive Constructions (auf dem Coqs Kernel basiert) stark vom Calculus of Constructions. Es wird am besten angenommen, dass Sie mit der Martin-Löf-Typentheorie mit Universen beginnen und dann eine Sortierstütze am Ende der Typhierarchie hinzufügen. Dies ist ein ganz anderes Biest als das ursprüngliche CoC, das man sich am besten als abhängige Version von F-Omega vorstellen kann. (Zum Beispiel hat CiC satztheoretische Modelle und das CoC nicht.)

Allerdings wird der Lambda-Würfel (dem der CoC angehört) aus Gründen der Wirtschaftlichkeit in Bezug auf die Anzahl der Schreibregeln in der Regel als reines Typensystem dargestellt. Indem Sie Sorten, Typen und Terme als Elemente derselben syntaktischen Kategorie behandeln, können Sie viel weniger Regeln aufschreiben und Ihre Beweise werden auch einiges weniger redundant.

Zum besseren Verständnis kann es jedoch hilfreich sein, die verschiedenen Kategorien explizit voneinander zu trennen. Wir können drei syntaktische Kategorien einführen, Arten (die von der Metavariable überlagert werden k), Typen (die von der Metavariable überlagert werden A) und Ausdrücke (die von der Metavariable überlagert werden e). Dann können alle acht Systeme als Variationen dessen verstanden werden, was auf jeder der drei Ebenen erlaubt ist.

λ → (einfach eingegebene Lambda-Rechnung)

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

Dies ist die grundlegende typisierte Lambda-Rechnung. Es gibt eine einzige Art ∗, nämlich die Art der Typen. Die Typen selbst sind atomare Typen pund Funktionstypen A → B. Begriffe sind Variablen, Abstraktionen oder Anwendungen.

λω_ (STLC + Operatoren höherer Art)

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

Die STLC erlaubt nur Abstraktion auf der Ebene von Begriffen. Wenn wir es auf der Ebene der Typen hinzufügen, fügen wir eine neue Art hinzu k → k, nämlich die Art der Funktionen auf Typebene und die Abstraktion λa:k.Aund Anwendung auch A Bauf Typebene. Wir haben also keinen Polymorphismus, aber wir haben Typoperatoren.

Wenn Speicher zur Verfügung steht, verfügt dieses System über keine größere Rechenleistung als die STLC. Es gibt Ihnen nur die Möglichkeit, Typen abzukürzen.

λ2 (System F)

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

Anstatt Typoperatoren hinzuzufügen, hätten wir auch Polymorphismus hinzufügen können. Auf der Typebene fügen wir hinzu, ∀a:k. Awas ein polymorpher Typbildner ist, und auf der Begriffsebene fügen wir Abstraktion über Typen Λa:k. eund Typanwendung hinzu e [A].

Dieses System ist viel leistungsfähiger als das STLC - es ist so stark wie Arithmetik zweiter Ordnung.

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

Wenn wir sowohl Typoperatoren als auch Polymorphismus haben, erhalten wir F-Omega. Dieses System ist mehr oder weniger die Kernel-Typ-Theorie der meisten modernen funktionalen Sprachen (wie ML und Haskell). Es ist auch weitaus leistungsfähiger als System F - es entspricht in seiner Stärke einer Arithmetik höherer Ordnung.

λP (LF)

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

Anstelle von Polymorphismus hätten wir uns in Richtung Abhängigkeit von einfach typisierter Lambda-Rechnung bewegen können. Wenn Sie dem Funktionstyp erlaubt haben, sein Argument im Rückgabetyp zu verwenden (dh Πx:A. B(x)statt zu schreiben A → B), erhalten Sie λP. Um dies wirklich nützlich zu machen, müssen wir die Menge der Arten mit einer Art von Typoperatoren erweitern, die Terme als Argumente verwenden Πx:A. k, und daher müssen wir auch auf der Typebene eine entsprechende Abstraktion Λx:A.Bund Anwendung hinzufügen A [e].

Dieses System wird manchmal als LF oder Edinburgh Logical Framework bezeichnet.

Es hat die gleiche Rechenstärke wie der einfach typisierte Lambda-Kalkül.

λP2 (kein spezieller Name)

 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]

Wir können auch Polymorphismus zu λP hinzufügen, um λP2 zu erhalten. Dieses System wird nicht oft verwendet und hat daher keinen bestimmten Namen. (Das eine Papier, in dem ich gelesen habe, dass es die Induktion von Herman Geuvers ist, lässt sich nicht in der Theorie abhängiger Typen zweiter Ordnung herleiten .)

Dieses System hat die gleiche Stärke wie System F.

λPω_ (kein spezieller Name)

 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 

Wir könnten auch Typoperatoren zu λP hinzufügen, um λPω_ zu erhalten. Dazu gehört das Hinzufügen einer Art Πa:k. k'für Typoperatoren sowie die entsprechende Abstraktion Λx:A.Bund Anwendung auf Typebene A [e].

Da es im Vergleich zum STLC wieder keinen Sprung in der Rechenleistung gibt, sollte dieses System auch eine gute Basis für ein logisches Framework bilden, aber niemand hat es getan.

λPω (Konstruktionsrechnung)

 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]

Schließlich kommen wir zu λPω, der Berechnung von Konstruktionen, indem wir λPω_ nehmen und einen polymorphen Typbildner und eine ∀a:k.AAbstraktion Λa:k. eund Anwendung e [A]auf Termebene hinzufügen .

Die Typen dieses Systems sind viel ausdrucksvoller als bei F-Omega, aber es hat die gleiche Rechenstärke.

Ich wollte oft versuchen, jede Dimension des Würfels und deren Repräsentation zusammenzufassen, also gebe ich diesem einen Versuch .$\lambda$

Aber zuerst sollte man wahrscheinlich versuchen, verschiedene Themen zu entwirren. Der interaktive Theorembeweiser von Coq basiert auf einer zugrunde liegenden Typentheorie, die manchmal liebevoll als Berechnung induktiver Konstruktionen mit Universen bezeichnet wird . Sie werden feststellen, dass dies mehr als nur ein "Calculus of Constructions" ist, und in der Tat gibt es viel mehr Dinge als nur das CoC. Ich bin insbesondere der Meinung, dass Sie sich nicht sicher sind, welche Funktionen in CoC korrekt sind. Insbesondere werden die Unterscheidung von Set / Prop und Universen in CoC nicht angezeigt.

Ich werde hier keinen vollständigen Überblick über Pure Type Systems geben, aber die wichtige Regel (für funktionierende PTS wie das CoC) ist die folgende

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

Und so haben wir 4 Regeln, die 4 verschiedenen Zwecken entsprechen:

• $(*,*)$

• $(\square,\square)$

• $(\square,*)$

• $(*,\square)$

Ich werde jede dieser Details näher erläutern.

---

$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$$

Mit diesen zusätzlichen Sortierungen und Regeln erhalten Sie etwas, das kein PTS ist, sondern etwas Nahes. Dies ist (fast) die erweiterte Konstruktionsrechnung , die näher an der Basis von Coq liegt. Das große fehlende Stück hier sind die induktiven Typen, auf die ich hier nicht näher eingehen werde.

Bearbeiten: Es gibt eine nette Referenz, die verschiedene Merkmale von Programmiersprachen im Rahmen von PTS beschreibt, indem sie ein PTS beschreibt, das ein guter Kandidat für eine Zwischendarstellung einer funktionalen Programmiersprache ist:

Henk: Eine typisierte Zwischensprache , SP Jones & E. Meijer.