coq Set或Type如何成为命题

Question

我正在阅读关于Coq的教程。 它构造一个bool类型如下：

Coq < Inductive bool :  Set := true | false.
bool is defined
bool_rect is defined
bool_ind is defined
bool_rec is defined

然后它显示了这些东西正在使用“检查”。

Coq < Check bool_ind.
bool_ind
     : forall P : bool -> Prop, P true -> P false -> forall b : bool, P b

Coq < Check bool_rec.
bool_rec
     : forall P : bool -> Set, P true -> P false -> forall b : bool, P b

Coq < Check bool_rect.
bool_rect
     : forall P : bool -> Type, P true -> P false -> forall b : bool, P b

我理解bool_ind 。 它说，如果某些东西保持为true并且它保持为false ，那么它适用于bool所有b （因为那些是唯一的两个）。

但我不明白bool_rec或bool_rect的表达是什么意思。 看来，如果P true （这是一Set用于bool_rec和Type的bool_rect ）被视为一个命题值。 我在这里错过了什么？

Answer 1

你对bool_ind直觉bool_ind明显，但是考虑为什么bool_ind意味着你所说的可能有助于澄清其他两个。 我们知道

bool_ind : forall P : bool -> Prop,
             P true ->
             P false ->
             forall b : bool,
               P b

如果我们将其视为逻辑公式，我们会得到您所做的相同读数：

• 对于bool eans中的每个谓词P ，
  • 如果P true ，则
  • 如果P false成立，那么
  • 对于每个布尔值b ，
    • P b成立。

但这不仅仅是一个逻辑公式，而是一种类型。 具体来说，它是（依赖）函数类型。 作为一个函数类型，它说（如果你允许我为未命名的参数和结果发明名称的自由）：

• 给定值P : bool -> Prop ，
  • 值Pt : P true ，
  • 值Pf : P false ，和
  • 值b : bool ，
    • 我们可以构造一个值Pb : P b 。

（当然，这是一个curry函数，所以还有其他方法可以将类型分解为散文，但这对我们的目的来说是最清楚的。）

这里最重要的是，使Coq作为一个定理证明者而作为一种编程语言（反之亦然）的事情是Curry-Howard的对应关系 ：类型是命题，值是这些命题的证明。 例如，简单函数类型->对应于蕴涵，依赖函数类型forall对应于通用量化。 （符号很有启发性:-)）所以在Coq中，为了证明φ→ψ，我们必须构造一个φ -> ψ类型的值：一个取φ型值的函数（换句话说，一个证明命题φ）并用它来构造ψ类型的值（命题ψ的证明）。

在Coq中，我们可以通过这种方式考虑所有类型，无论这些类型是否存在于Set ， Type或Prop 。 （所以当你说“似乎P true（这是bool rec的设置和bool_rect的类型）被视为命题值时，”你是对的！）例如，让我们考虑一下我们是怎么做的我们自己实现bool_ind 。 我们首先列出函数的所有参数及其返回类型：

Definition bool_ind' (P  : bool -> Prop)
                     (Pt : P true)
                     (Pf : P false)
                     (b  : bool)
                     : P b :=

到现在为止还挺好。 在这一点上，我们想要返回P b类型的东西，但我们不知道b是什么。 所以，在这些情况下，我们总是模式匹配：

  match b with

现在有两个案例。 首先， b可能是true 。 在这种情况下，我们必须要返回P true类型为P true东西，幸运的是我们有这样的值： Pt 。

    | true  => Pt

false案件类似：

    | false => Pf
  end.

请注意，当我们实现bool_ind' ，它看起来并不“非常有用”，而是非常“程序化”。 当然，由于Curry-Howard的通信，这些都是一样的。 但请注意，完全相同的实现将足以满足其他两个功能：

Definition bool_rec' (P  : bool -> Set)
                     (Pt : P true)
                     (Pf : P false)
                     (b  : bool)
                     : P b :=
  match b with
    | true  => Pt
    | false => Pf
  end.

Definition bool_rect' (P  : bool -> Type)
                      (Pt : P true)
                      (Pf : P false)
                      (b  : bool)
                      : P b :=
  match b with
    | true  => Pt
    | false => Pf
  end.

看看这个计算定义揭示了另一种关于bool_ind ， bool_rec和bool_rect ：它们封装了你需要知道的东西来讨论bool 每个值 。 但不管怎样，我们正在打包那些信息：如果我知道某些事情是true ，而某些事情是false ，那么我知道所有的bool 。

bool_{ind,rec,rect}函数的定义通过我们在布尔值上编写函数的常规方式进行抽象：有一个参数对应于true分支，一个参数对应于false分支。 或者，换句话说：这些函数只是if语句。 在非依赖类型的语言中，它们可以具有更简单的类型forall S : Set, S -> S -> bool -> S ：

Definition bool_simple_rec (S : Set) (St : P) (Sf : P) (b : bool) : S :=
  match b with
    | true  => St
    | false => Sf
  end.

但是，因为类型可以依赖于值，所以我们必须通过各种类型来处理b 。 如果事实证明我们不希望这样，我们可以使用我们更通用的功能并告诉：

Definition bool_simple_rec' (S : Set) : S -> S -> bool -> S :=
  bool_rec (fun _ => S).

没有人说我们的P : bool -> Set必须使用 bool ！

对于递归类型，所有这些函数都更有趣。 例如，Coq具有以下类型的自然数：

Inductive nat : Set :=  O : nat | S : nat -> nat.

我们有

nat_ind : forall P : nat -> Prop,
            P O ->
            (forall n' : nat, P n' -> P (S n')) ->
            forall n : nat,
              P n

连同相应的nat_rec和nat_rect 。 （为读者练习：直接实现这些功能。）

乍一看，这只是数学归纳的原理。 但是，它也是我们在nat上编写递归函数的方式; 他们是一回事。 通常， nat递归函数如下所示：

fix f n => match n with
             | O    => ...
             | S n' => ... f n' ...
           end

O （基本情况）之后的匹配臂只是PO类型的值。 S n'之后的匹配臂（递归情况）是传递给类型forall n' : nat, P n' -> P (S n')的函数forall n' : nat, P n' -> P (S n') ： n'是相同的，并且P n'值是递归调用f n' 。

考虑_rec和_ind函数之间的等价性的另一种方法，然后 - 我认为在无限类型上比在bool上更清楚 - 它与数学ind （在Prop中发生）和（和）之间的等价性相同结构） rec ursion（发生在Set和Type ）。

---

让我们充满热情并使用这些功能。 我们将定义一个简单的函数，将布尔值转换为自然数，我们将直接和bool_rec一起bool_rec 。 编写此函数的最简单方法是使用模式匹配：

Definition bool_to_nat_match (b : bool) : nat :=
  match b with
    | true  => 1
    | false => 0
  end.

另一种定义是

Definition bool_to_nat_rec : bool -> nat :=
  bool_rec (fun _ => nat) 1 0.

这两个功能是一样的：

Goal bool_to_nat_match = bool_to_nat_rec.
Proof. reflexivity. Qed.

（注意：这些函数在语法上是相同的 。这比简单地做同样的事情更强大。）

在这里， P : bool -> Set很fun _ => nat ; 它给我们返回类型，它不依赖于参数。 我们的Pt : P true是1 ，当我们给出true时计算的东西; 同样，我们的Pf : P false为0 。

如果我们想要使用依赖项，我们必须编写一个有用的数据类型。 怎么样

Inductive has_if (A : Type) : bool -> Type :=
  | has   : A -> has_if A true
  | lacks : has_if A false.

根据这个定义， has_if A true与A同构，而has_if A false是与unit同构的。 然后我们可以有一个函数，当且仅当它被传递为true时才保留它的第一个参数。

Definition keep_if_match' (A : Type) (a : A) (b : bool) : has_if A b :=
  match b with
    | true  => has A a
    | false => lacks A
  end.

另一种定义是

Definition keep_if_rect (A : Type) (a : A) : forall b : bool, has_if A b :=
  bool_rect (has_if A) (has A a) (lacks A).

他们又是一样的：

Goal keep_if_match = keep_if_rect.
Proof. reflexivity. Qed.

在这里，函数的返回类型取决于参数b ，所以我们的P : bool -> Type实际上做了什么。

这是一个更有趣的例子，使用自然数和长度索引列表。 如果你还没有看到长度索引列表，也称为矢量，它们就像他们在锡上所说的那样; vec A n是n A的列表。

Inductive vec (A : Type) : nat -> Type :=
  | vnil  : vec A O
  | vcons : forall n, A -> vec A n -> vec A (S n).
Arguments vnil  {A}.
Arguments vcons {A n} _ _.

（ Arguments机制处理隐式参数。）现在，我们想要生成一个特定元素的n副本的列表，因此我们可以使用fixpoint编写它：

Fixpoint vreplicate_fix {A : Type} (n : nat) (a : A) : vec A n :=
  match n with
    | O    => vnil
    | S n' => vcons a (vreplicate_fix n' a)
  end.

或者，我们可以使用nat_rect ：

Definition vreplicate_rect {A : Type} (n : nat) (a : A) : vec A n :=
  nat_rect (vec A) vnil (fun n' v => vcons a v) n.

请注意，由于nat_rect捕获递归模式，因此vreplicate_rect本身不是固定点。 需要注意的一点是nat_rect的第三个参数：

fun n' v => vcons a v

v在概念上是对vreplicate_rect n' a的递归调用的结果; nat_rect抽象出递归模式，因此我们不需要直接调用它。 n'与vreplicate_fix的n'确实相同，但现在看来我们不需要明确提及它。 它为什么传入？ 如果我们写出我们的类型，那就很明显了：

fun (n' : nat) (v : vec A n') => vcons a v : vec A (S n')

我们需要n'所以我们知道v有什么类型，结果是什么类型的结果。

让我们看看这些功能在起作用：

Eval simpl in vreplicate_fix  0 tt.
Eval simpl in vreplicate_rect 0 tt.
  (* both => = vnil : vec unit 0 *)

Eval simpl in vreplicate_fix  3 true.
Eval simpl in vreplicate_rect 3 true.
  (* both => = vcons true (vcons true (vcons true vnil)) : vec bool 3 *)

事实上，他们是一样的：

(* Note: these two functions do the same thing, but are not syntactically
   equal; the former is a fixpoint, the latter is a function which returns a
   fixpoint.  This sort of equality is all you generally need in practice. *)
Goal forall (A : Type) (a : A) (n : nat),
       vreplicate_fix n a = vreplicate_rect n a.
Proof. induction n; [|simpl; rewrite IHn]; reflexivity. Qed.

上面，我提出重新实现nat_rect和朋友的练习。 这是答案：

Fixpoint nat_rect' (P         : nat -> Type)
                   (base_case : P 0)
                   (recurse   : forall n', P n' -> P (S n'))
                   (n         : nat)
                   : P n :=
  match n with
    | O    => base_case
    | S n' => recurse n' (nat_rect' P base_case recurse n')
  end.

这有希望清楚地表明 nat_rect 如何抽象递归模式，以及为什么它足够通用。