Question

我正在尝试使用Function来定义使用度量的递归定义，并且我收到错误：

Error: find_call_occs : Prod

我在底部发布了整个源代码，但我的功能是

Function kripke_sat (M : kripke) (s : U) (p : formula) {measure size p}: Prop :=
match p with
| Proposition p'  => L M (s)(p')
| Not p' => ~ kripke_sat M s p'
| And p' p''   => kripke_sat M s p' /\ kripke_sat M s p''
| Or p' p''  => kripke_sat M s p' \/ kripke_sat M s p''
| Implies p' p''  => ~kripke_sat M s p' \/  kripke_sat M s p''
| Knows a p' =>  forall t, ~(K M a) s t \/ kripke_sat M t p' 
| EvKnows p' => forall i, kripke_sat M s (Knows i p' ) 
end.

我知道问题是由于foralls：如果我用True替换它们，它可以工作。一世如果我的右手边使用含义（ - ＆gt;），也知道我得到了同样的错误。 Fixpoint适用于foralls，但不允许我定义一个度量。

有什么建议吗？

正如所承诺的，我的完整代码是：

Module Belief.

Require Import Arith.EqNat.
Require Import Arith.Gt.
Require Import Arith.Plus.
Require Import Arith.Le.
Require Import Arith.Lt.
Require Import Logic.
Require Import Logic.Classical_Prop.
Require Import Init.Datatypes.

Require Import funind.Recdef.

(* Formalization of a variant of a logic of knowledge, as given in Halpern 1995 *)

Section Kripke.

  Variable n : nat.
  (* Universe of "worlds" *)
  Definition U := nat.
  (* Universe of Principals *)
  Definition P := nat.
  (* Universe of Atomic propositions *)
  Definition A := nat.

  Inductive prop : Type := 
  | Atomic : A -> prop.

  Definition beq_prop (p1 p2 :prop) : bool :=
    match (p1,p2) with
      | (Atomic p1', Atomic p2') => beq_nat p1' p2'
    end.

  Inductive actor : Type :=
  | Id : P -> actor.

  Definition beq_actor (a1 a2: actor) : bool :=
    match (a1,a2) with
      | (Id a1', Id a2') => beq_nat a1' a2'
    end.

  Inductive formula : Type :=
  | Proposition : prop -> formula
  | Not : formula -> formula
  | And :  formula  -> formula -> formula
  | Or :  formula -> formula -> formula
  | Implies :  formula -> formula ->formula
  | Knows : actor -> formula -> formula
  | EvKnows :  formula -> formula (*me*)
    .

  Inductive con : Type :=
  | empty : con
  | ext : con -> prop -> con.

  Notation " C # P " := (ext C P) (at level 30).

  Require Import Relations.

  Record kripke : Type := mkKripke {
    K : actor -> relation U; 
    K_equiv: forall y, equivalence _ (K y);
    L : U -> (prop -> Prop)
  }.

Fixpoint max (a b: nat) : nat :=
   match a, b with
   | 0, _ => a
   | _, 0 => b
   | S(a'), S(b') => 1 + max a' b'
end.

Fixpoint length (p: formula) : nat :=
  match p with
     | Proposition p' => 1
     | Not p' => 1 + length(p')
     | And p' p'' => 1 + max (length p') (length p'')
     | Or p' p''  => 1 + max (length p') (length p'')
     | Implies p' p'' => 1 + max  (length p') (length p'')
     | Knows a p'  => 1 + length(p')
     | EvKnows p' => 1 + length(p')
end.

Fixpoint numKnows (p: formula): nat :=
  match p with
 | Proposition p' => 0
 | Not p' => 0 + numKnows(p')
 | And p' p'' => 0 + max (numKnows p') (numKnows p'')
 | Or p' p''  => 0 + max (numKnows p') (numKnows p'')
 | Implies p' p'' => 0 + max  (numKnows p') (numKnows p'')
 | Knows a p'  => 0 + numKnows(p')
 | EvKnows p' => 1 + numKnows(p')
end.

Definition size (p: formula): nat :=
(numKnows p) + (length p).

Definition twice (n: nat) : nat :=
n + n.

Theorem duh: forall a: nat, 1 + a > a.
Proof.   induction a. apply gt_Sn_O.
apply gt_n_S in IHa. unfold plus in *. apply IHa. Qed.

Theorem eq_lt_lt: forall (a b c d: nat), a = b -> c<d -> a+ c< b+d.
Proof. intros. apply plus_le_lt_compat. 
apply eq_nat_elim with (n:=a) (m := b). apply le_refl.
apply eq_nat_is_eq. apply H.  apply H0. Qed.


Function kripke_sat (M : kripke) (s : U) (p : formula) {measure size p}: Prop :=
  match p with
| Proposition p'  => L M (s)(p')
| Not p' => ~ kripke_sat M s p'
| And p' p''   => kripke_sat M s p' /\ kripke_sat M s p''
| Or p' p''  => kripke_sat M s p' \/ kripke_sat M s p''
| Implies p' p''  => ~kripke_sat M s p' \/  kripke_sat M s p''
| Knows a p' =>   forall t, ~(K M a) s t \/ kripke_sat M t p'
| EvKnows p' =>  forall i, kripke_sat M s (Knows i p' )  
 end.

Answer 1

“功能”插件仍然非常实验性。在您可以找到的文档中

term0必须构建为纯模式匹配树（匹配...），只有在每个分支的末尾才有λ抽象和应用程序。

但我不得不同意这个错误信息远非明确（通常这样的错误消息应该以“请报告”结束或者是更多用户友好，我认为这是一个错误）。这意味着不允许在函数体中使用foralls（我不知道这种行为是否有理论上的原因）。

因此，您需要在没有帮助的情况下“手动”进行定义功能。这是一个可以适应您的开发的小例子。祝好运！


Inductive form : Set := 
  | T : form 
  | K : nat -> form -> form
  | eK : form -> form.

Fixpoint size (f : form) : nat := match f with 
  | T => 1 
  | K _ f => S (size f)
  | eK f => S (S (size f))
end.

Require Import Wf.
Require Import Wf_nat.

Definition R x y := size x < size y.
Lemma R_wf : well_founded R.
  apply well_founded_ltof.
Qed.

Lemma lem1 : 
  forall x n, R x (K n x).
unfold R; intuition.
Qed.

Lemma lem2 : 
   forall x n, R (K n x) (eK x).
unfold R; intuition.
Qed.


Definition interpret : form -> Prop.
(* we use the well_founded_induction instead of Function *)
refine (well_founded_induction_type R_wf (fun _ => Prop) (fun x f => _)).
destruct x.
exact True.                                     (* ⟦T⟧ ≡ True *)
exact (n = 2 /\ f x (lem1 x n)).                (* ⟦K n F⟧ ≡ (n = 2) ∧ ⟦F⟧ *)
exact (forall n:nat, f (K n x) (lem2 x n)).     (* ⟦eK F⟧ ≡ ∀n:nat,⟦K n F⟧ *)
Defined.

PS：我将使用以下更简单的代码版本填写错误报告。

  Require Import Recdef.

  Inductive I : Set := 
  | C  : I.

  Definition m (_ : I) := 0.

  Function f (x : I)  {measure m x} : Type := match x with 
  | C => nat -> nat end.

Answer 2

Coq 8.4中的错误消息已更改但问题仍然存在。新的错误消息是：“错误：找到了产品。无法处理这样的术语”

此错误消息的更改也会导致Marc的错误被关闭： http://www.lix.polytechnique.fr/coq/bugs/show_bug.cgi?id=2457

在递归函数定义中使用forall

2 个答案: