5

関数を使用してメジャーを使用して再帰的定義を定義しようとしていますが、エラーが発生します:

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に置き換えると、それは機能します。また、右側で含意(->)を使用すると、同じエラーが発生することもわかっています。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.
4

2 に答える 2

6

「関数」プラグインはまだ非常に実験的です。ドキュメントで見つけることができます

term0は、各ブランチの最後にのみλ抽象化とアプリケーションを備えた純粋なパターンマッチングツリー(match ... with)として構築する必要があります。

しかし、私はこのエラーメッセージが明確ではないことに同意する必要があります(通常、このようなエラーメッセージは「報告してください」で終わるか、よりユーザーフレンドリーである必要があります。これはバグと見なします)。これは、関数の本体でforallが許可されていないことを意味します(この動作の理論的な理由があるかどうかはわかりません)。

したがって、関数を使用せずに「手動で」定義を行う必要があります。これは、開発に適応できる小さな例です。幸運を !


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.
于 2010-12-14T00:39:45.347 に答える
0

エラーメッセージはCoq8.4で変更されましたが、問題はまだあります。新しいエラーメッセージは次のとおりです。「エラー:製品が見つかりました。そのような用語を処理できません」

このエラーメッセージの変更により、Marcのバグも閉じられます: http ://www.lix.polytechnique.fr/coq/bugs/show_bug.cgi?id = 2457

于 2012-08-14T14:29:46.697 に答える