您如何从Lambda多维数据集的其他方面获得构造微积分？

据说CoC是Lambda Cube的所有三个维度的顶点。这一点对我来说一点都不明显。我想我了解各个方面，并且任何两个方面的结合似乎都导致相对简单的结合（也许我缺少了什么？）。但是，当我看CoC时，与其看起来像是这三者的结合，不如说是完全不同的事情。类型，属性和小型/大型字体来自哪个维度？依赖产品消失在哪里？为何为什么只关注命题和证明而不是类型和程序呢？是否有一些针对类型和程序的等效项？

编辑：如果不清楚，我要求解释CoC如何等效于Lambda Cube尺寸的直接结合。在我可以研究的某个地方是否存在所有这三个方面的实际结合（就程序和类型而言，而不是证明和命题）？这是对问题的评论，而不是当前的答案。

首先，重申一下科迪的观点之一，归纳构造微积分（Coq的内核所基于）与构造微积分有很大不同。最好想到的是从具有宇宙的Martin-Löf类型理论开始，然后在类型层次结构的底部添加一个排序Prop。这是与原始CoC完全不同的野兽，最好将其视为F-omega的从属版本。（例如，CiC具有集合理论模型，而CoC没有。）

就是说，Lambda多维数据集（CoC是其成员）通常出于简化打字规则的原因而被视为纯类型系统。通过将种类，类型和术语视为同一句法类别的元素，您可以写下更少的规则，并且证明也少了很多冗余。

但是，为理解起见，明确地区分出不同的类别可能会有所帮助。我们可以介绍三种语法类别，种类（由metavariable覆盖k），类型（由metavariable覆盖A）和术语（由metavariable覆盖e）。然后，可以将所有八个系统理解为三个级别中每个级别所允许的变化。

λ→（简单型λ演算）

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

这是基本的lambda演算。有一个单一的种类∗，即种类。类型本身是原子类型p和函数类型A → B。术语是变量，抽象或应用程序。

λω_（STLC +更高种类的运算符）

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

STLC仅允许在术语级别进行抽象。如果我们在类型级别添加它，那么我们将添加一种新类型k → k，即类型级别函数的类型，以及在类型级别上的抽象λa:k.A和应用程序A B。所以现在我们没有多态性，但是我们有类型运算符。

如果有内存，则该系统的计算能力不会超过STLC；它只是使您能够缩写类型。

λ2（系统F）

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

代替添加类型运算符，我们可以添加多态性。在类型级别，我们添加∀a:k. A一个多态类型模型，在术语级别，我们添加对类型Λa:k. e和类型application的抽象e [A]。

该系统比STLC强大得多-它与二阶算术一样强大。

λω（系统F-ω）

 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]

如果我们同时拥有类型运算符和多态性，则可以得到F-omega。该系统或多或少是大多数现代功能语言（例如ML和Haskell）的内核类型理论。它也比系统F强大得多-强度等效于高阶算术。

λP（低频）

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

代替多态性，我们本来可以从简单类型的lambda演算转向依赖关系。如果允许函数类型在返回类型中使用其参数（即，写Πx:A. B(x)而不是A → B），则得到λP。为了使它真正有用，我们必须使用以术语作为参数的类型运算符来扩展种类集Πx:A. k，因此我们也必须在类型级别添加相应的抽象Λx:A.B和应用程序A [e]。

该系统有时称为LF或爱丁堡逻辑框架。

它具有与简单型Lambda微积分相同的计算强度。

λP2（无特殊名称）

 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]

我们还可以将多态性添加到λP中，以获得λP2。该系统不经常使用，因此没有特定名称。（我读过的一篇使用它的论文是Herman Geuvers的归纳法在二阶从属类型理论中不可推导。）

该系统具有与系统F相同的强度。

λPω_（无特殊名称）

 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 

我们还可以在λP中添加类型运算符，以获得λPω_。这涉及Πa:k. k'为类型运算符添加一种，以及相应的类型级别的抽象Λx:A.B和应用程序A [e]。

由于再次没有超越STLC的计算能力，因此该系统也应该为逻辑框架奠定良好的基础，但没人能做到。

λPω（构造演算）

 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]

最后，通过取λPω_并添加一个多态类型的模型∀a:k.A和术语级抽象Λa:k. e及其应用，来获得构造微积分λPω e [A]。

该系统的类型比F-omega更具表现力，但是具有相同的计算强度。

我经常想尝试总结多维数据集的每个维度及其表示的内容，因此我将对此进行一下介绍。$\lambda$

但是首先，人们可能应该尝试解决各种问题。Coq互动定理证明者基于一种基础类型理论，有时也被称为具有宇宙的归纳结构的演算。您会注意到，这不仅仅是简单的“构造演算”，而且确实有很多东西，而不仅仅是CoC。特别是，我认为您对CoC固有的确切功能感到困惑。特别是，集合/属性区别和Universe不会出现在CoC中。

在这里，我不会对Pure Type系统进行完整的概述，但是重要的规则（对于像CoC这样的功能性PTS）如下：

$$\frac{\Gamma\vdash A:s\qquad \Gamma,x:A\vdash B:k}{\Gamma\vdash \Pi x:A.B\ :\ k}\ (s,k)\in R$$

其中是一组固定的元件小号的种类，以及一对（小号，ķ ）是在一组固定的- [R对的小号，叫做规则。$s,k$$S$$(s,k)$$R$$S$

关键的见解是，仔细选择和[R做出什么样的产品类型差异巨大Π X ：一。B实际上代表！$S$$R$$\Pi x:A.B$

特别地，在构造的演算中，排序集为 { ∗ ，◻ }， 通常称为Prop and Type（尽管由于我稍后将要讨论的原因，该术语对Coq用户有点混乱），以及一组规则： R = { （* ，∗ ），（◻ ，◻ ），（◻ ，∗ ），（∗ ，◻ ）$S$

$$\{*, \square\}$$ $$R=\{(*,*),(\square,\square),(\square,*),(*,\square)\}$$

因此，我们有4条规则，分别对应4个不同的目的：

• ：功能类型$(*,*)$

• $(\square,\square)$

• $(\square,*)$

• $(*,\square)$

我将更详细地解释每一个。

---

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

$*$$*$) has some restrictions: no large eliminations, and datatypes should live in Set or Type, which don't have the analogue of the $(\square, *)$ rule. Prop without large eliminations is consistent with the law of excluded middle.

Useful to note: in the presence of $(\square,\square)$, you can even write things like:

$$\Pi c:*\rightarrow *.\ \ c\ \mathrm{nat}\rightarrow c\ \mathrm{nat}$$ if you like, which is useful for, say, writing generic code over a monad, as often happens in Haskell.

Dependent types: This is how you get the propositions-as-types paradigm to work. Indeed, you want to have a type that represents all possible proofs of, say $0=1$. To make sense of this, you want equality to be of type

$$=\ :\ \mathrm{nat}\rightarrow\mathrm{nat}\rightarrow *$$ or you might want to be polymorphic $$=\ :\ \Pi t:*.\ t\rightarrow t\rightarrow *$$ In any case, you can't write $\mathrm{nat}\rightarrow\mathrm{nat}\rightarrow *$ without the rule $(*,\square)$.

Ok, but what about universes? It turns out that in the CoC, you can't actually write things like $\square \rightarrow \square$, because there are no types to give $\square$ and a fortiori no rules involving those types. A pretty natural thing to do is to index $\square$ by a natural number, getting $\square_i$ for $i=1,2,3,\ldots$ and having $\square_i:\square_{i+1}$.

What rules do we want for this? One natural rule is $(\square_i, \square_i)$, but that rule isn't very useful in the absence of the subsumption rule

$$\frac{\Gamma\vdash A:\square_i}{\Gamma\vdash A:\square_j}\ i\leq j$$

With these extra sorts and rules, you get something that is not a PTS, but something close. This is (almost) the Extended Calculus of Constructions, which is closer to the basis of Coq. The big missing piece here is the inductive types, which I won't discuss here.

Edit: There's a rather nice reference that describes various features of programing languages in the framework of PTSes, by describing a PTS which is a good candidate for an intermediate representation of a functional programing language:

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