Coq证明助手中的依赖类型问题_Coq_Dependent Type

Coq证明助手中的依赖类型问题

coq

Coq证明助手中的依赖类型问题,coq,dependent-type,Coq,Dependent Type,考虑以下简单表达式语言： Inductive Exp : Set := | EConst : nat -> Exp | EVar : nat -> Exp | EFun : nat -> list Exp -> Exp. 其良好形式谓词： Definition Env := list nat. Inductive WF (env : Env) : Exp -> Prop := | WFConst : forall n, WF env (EConst n)

考虑以下简单表达式语言：

Inductive Exp : Set :=
| EConst : nat -> Exp
| EVar   : nat -> Exp
| EFun   : nat -> list Exp -> Exp.

其良好形式谓词：

Definition Env := list nat.

Inductive WF (env : Env) : Exp -> Prop :=
| WFConst : forall n, WF env (EConst n)
| WFVar   : forall n, In n env -> WF env (EVar n)
| WFFun   : forall n es, In n env ->
                         Forall (WF env) es ->
                         WF env (EFun n es).

Definition WFDec (env : Env) : forall e, {WF env e} + {~ WF env e}.
   refine (fix wfdec e : {WF env e} + {~ WF env e} :=
             match e as e' return e = e' -> {WF env e'} + {~ WF env e'} with
             | EConst n => fun _ => left _ _
             | EVar n => fun _ =>
                      match in_dec eq_nat_dec n env with
                      | left _ _ => left _ _ 
                      | right _ _ => right _ _                    
                      end
             | EFun n es => fun _ =>
                      match in_dec eq_nat_dec n env with
                      | left _ _ => _
                      | right _ _ => right _ _                    
                      end  
             end (eq_refl e)) ; clear wfdec ; subst ; eauto.

它基本上说明了每个变量和函数符号都必须在环境中定义。现在，我想定义一个函数，它说明

WF

谓词的可判定性：

Definition Env := list nat.

Inductive WF (env : Env) : Exp -> Prop :=
| WFConst : forall n, WF env (EConst n)
| WFVar   : forall n, In n env -> WF env (EVar n)
| WFFun   : forall n es, In n env ->
                         Forall (WF env) es ->
                         WF env (EFun n es).

Definition WFDec (env : Env) : forall e, {WF env e} + {~ WF env e}.
   refine (fix wfdec e : {WF env e} + {~ WF env e} :=
             match e as e' return e = e' -> {WF env e'} + {~ WF env e'} with
             | EConst n => fun _ => left _ _
             | EVar n => fun _ =>
                      match in_dec eq_nat_dec n env with
                      | left _ _ => left _ _ 
                      | right _ _ => right _ _                    
                      end
             | EFun n es => fun _ =>
                      match in_dec eq_nat_dec n env with
                      | left _ _ => _
                      | right _ _ => right _ _                    
                      end  
             end (eq_refl e)) ; clear wfdec ; subst ; eauto.

问题在于如何声明

WF

谓词对

EFun

案例中的表达式列表有效或无效。我明显的猜测是：

     ...  

     match Forall_dec (WF env) wfdec es with

     ...

但是Coq拒绝了它，认为递归调用

wfdec

格式不正确。我的问题是：是否有可能在不改变表达式表示的情况下定义这种良好形式谓词的可判定性

完整的工作代码如下所示。

作为临时解决方案，您可以将

wf

定义为：

Definition wf (env : Env) := fix wf (e : Exp) : bool :=
  match e with
  | EConst _ => true
  | EVar v   => v \in env
  | EFun v l => [&& v \in env & all wf l]
  end.

这通常更方便使用。但是，由于Coq为

exp

生成了错误的归纳原则，因此该定义将非常无用，因为它无法检测列表。我通常做的是手动修正感应原理，但这是昂贵的。例如：

From Coq Require Import List.
From mathcomp Require Import all_ssreflect.

Set Implicit Arguments.
Unset Printing Implicit Defensive.
Import Prenex Implicits.

Section ReflectMorph.

Lemma and_MR P Q b c : reflect P b -> reflect Q c -> reflect (P /\ Q) (b && c).
Proof. by move=> h1 h2; apply: (iffP andP) => -[/h1 ? /h2 ?]. Qed.

Lemma or_MR P Q b c : reflect P b -> reflect Q c -> reflect (P \/ Q) (b || c).
Proof. by move=> h1 h2; apply: (iffP orP) => -[/h1|/h2]; auto. Qed.

End ReflectMorph.

Section IN.
Variables (X : eqType).

Lemma InP (x : X) l : reflect (In x l) (x \in l).
Proof.
elim: l => [|y l ihl]; first by constructor 2.
by apply: or_MR; rewrite // eq_sym; exact: eqP.
Qed.

End IN.

Section FORALL.

Variables (X : Type) (P : X -> Prop).
Variables (p : X -> bool).

Lemma Forall_inv x l : Forall P (x :: l) -> P x /\ Forall P l.
Proof. by move=> U; inversion U. Qed.

Lemma ForallP l : (forall x, In x l -> reflect (P x) (p x)) -> reflect (Forall P l) (all p l).
Proof.
elim: l => [|x l hp ihl /= ]; first by constructor.
have/hp {hp}hp : forall x : X, In x l -> reflect (P x) (p x).
  by move=> y y_in; apply: ihl; right.
have {ihl} ihl := ihl _ (or_introl erefl).
by apply: (iffP andP) => [|/Forall_inv] [] /ihl hx /hp hall; constructor.
Qed.

End FORALL.

Inductive Exp : Type :=
| EConst : nat -> Exp
| EVar   : nat -> Exp
| EFun   : nat -> list Exp -> Exp.

Lemma Exp_rect_list (P : Exp -> Type) :
  (forall n : nat, P (EConst n)) ->
  (forall n : nat, P (EVar n)) ->
  (forall (n : nat) (l : seq Exp), (forall x, In x l -> P x) -> P (EFun n l)) ->
  forall e : Exp, P e.
Admitted.

Definition Env := list nat.

Definition wf (env : Env) := fix wf (e : Exp) : bool :=
  match e with
  | EConst _ => true
  | EVar v   => v \in env
  | EFun v l => [&& v \in env & all wf l]
  end.

Inductive WF (env : Env) : Exp -> Prop :=
| WFConst : forall n, WF env (EConst n)
| WFVar   : forall n, In n env -> WF env (EVar n)
| WFFun   : forall n es, In n env ->
                         Forall (WF env) es ->
                         WF env (EFun n es).

Lemma WF_inv env e (wf : WF env e ) :
  match e with
  | EConst n  => True
  | EVar n    => In n env
  | EFun n es => In n env /\ Forall (WF env) es
  end.
Proof. by case: e wf => // [n|n l] H; inversion H. Qed.

Lemma wfP env e : reflect (WF env e) (wf env e).
Proof.
elim/Exp_rect_list: e => [n|n|n l ihe] /=; try repeat constructor.
  by apply: (iffP idP) => [/InP|/WF_inv/InP //]; constructor.
apply: (iffP andP) => [[/InP ? /ForallP H]|/WF_inv[/InP ? /ForallP]].
  by constructor => //; exact: H.
by auto.
Qed.

问题在于标准库中的

Forall_dec

定义为不透明（即，使用

Qed

而不是

定义的）。因此，Coq不知道wfdec
的使用是否有效
您的问题的直接解决方案是重新定义all_dec的，使其透明。您可以通过打印Coq生成的校对术语并将其粘贴到源文件中来实现这一点。我在这里添加了一个完整的解决方案
不用说，这种方法会导致代码臃肿、难以阅读和维护。正如ejgallego在他的回答中指出的那样，在这种情况下，最好的选择可能是定义一个决定WF
的布尔函数，并使用它来代替WFDec
。正如他所说，他的方法唯一的问题是，你需要将你自己的归纳原则写入Exp
，以证明布尔版本确实决定归纳定义。Adam Chlipala的CPDT有一个关于归纳类型的概念，给出了这样一个归纳原理的例子；只需寻找“嵌套归纳类型”
 这是一个典型的问题，由于子列表的原因，exp
需要不同的归纳原则。我将尝试谷歌作为一个例子。