Question

我对术语有以下定义：

Inductive term : Type :=
  | Var : variable -> term
  | Func : function_symbol -> list term -> term.

和一个函数pos_list获取术语列表并返回每个子项的“位置”列表。例如，对于[Var "e"; Func "f" [Var "x"; Func "i" [Var "x"]]]，我应该得到[[1]; [2]; [2; 1]; [2; 2]; [2; 2; 1]]，其中每个元素代表子树的树层次结构中的位置。

Definition pos_list (args:list term) : list position :=
  let fix pos_list_aux ts is head :=
    let enumeration := enumerate ts in
      let fix post_enumeration ts is head :=
        match is with
        | [] => []
        | y::ys =>
          let new_head := (head++y) in
          match ts with
          | [] => []
          | (Var _)::xs => [new_head] ++ (post_enumeration xs ys head)
          | (Func _ args')::xs =>
            [new_head] ++
            (pos_list_aux args' [] new_head) ++
            (post_enumeration xs ys head)
          end
        end
      in post_enumeration ts enumeration head
  in pos_list_aux args [] [].

使用上面的代码我得到错误

错误：无法猜测fix
的减少参数

关于第一个let fix构造，但在我看来，对(pos_list_aux args' [] new_head)的调用（导致问题）采用args'作为参数(Func _ args')的子项这本身就是ts的一个子项。

有什么问题？

Answer 1

term是嵌套的归纳类型（因为list term构造函数中的Func）并且它经常需要一些额外的工作来向Coq解释您的函数是完全的。这个chapter的CPDT解释了如何处理这种情况（参见“嵌套归纳类型”部分）：

术语“嵌套归纳型”暗示了这个特定问题的解决方案。正如相互归纳类型需要相互递归的归纳原则一样，嵌套类型需要嵌套递归。

这是我尝试解决您的问题。首先，让我们添加一些导入和定义，以便编译所有内容：

Require Import Coq.Lists.List.
Import ListNotations.
Require Import Coq.Strings.String.
Require Import Coq.Strings.Ascii.

Definition variable := string.
Definition function_symbol := string.
Definition position := list nat.

Inductive term : Type :=
  | Var : variable -> term
  | Func : function_symbol -> list term -> term.

我们首先实现一个为单个term完成工作的函数。请注意，我们定义了一个嵌套函数pos_list_many_aux，它几乎就是您想要的：

Definition pos_list_one (i : nat) (t : term) : list position :=
  let fix pos_list_one_aux (i : nat) (t : term) {struct t} : list position :=
      match t with
      | Var _ => [[i]]
      | Func _ args =>
          [i] :: map (cons i)
                     ((fix pos_list_many_aux i ts :=
                         match ts with
                         | [] => []
                         | t::ts =>
                             pos_list_one_aux i t ++ pos_list_many_aux (S i) ts
                         end) 1 args).     (* hardcoded starting index *)
      end
  in pos_list_one_aux i t.

现在，我们需要一个辅助函数mapi（名称来自OCaml的stdlib）。它类似于map，但映射函数也接收当前列表元素的索引。

Definition mapi {A B : Type} (f : nat -> A -> B) (xs : list A) : list B :=
  let fix mapi i f xs :=
    match xs with
    | [] => []
    | x::xs => (f i x) :: mapi (S i) f xs
    end
  in mapi 0 f xs.

现在一切都准备好定义pos_list功能：

Definition pos_list (args : list term) : list position :=
  concat (mapi (fun i t => pos_list_one (S i) t) args).

让我们进行测试：

Section Test.
  Open Scope string_scope.

  Compute pos_list [Var "e"; Func "f" [Var "x"; Func "i" [Var "x"]]].
  (*
   = [[1]; [2]; [2; 1]; [2; 2]; [2; 2; 1]] : list position
   *)
End Test.

Answer 2

如果您明确告诉Coq您正在递归哪个参数，则会收到更多信息性错误消息。

let fix pos_list_aux ts is head {struct ts} :=

现在Coq说

Recursive call to pos_list_aux has principal argument equal to "args'" instead of
"xs".

如果你改用{struct is}，Coq说

Recursive call to pos_list_aux has principal argument equal to "[]" instead of
a subterm of "is".

确定递归是否合理的简单语法规则要求您使用来自使用match is with ... end破坏参数的术语进行递归。

使用从head元素中获取的内容（args'），甚至在is上使用[]递归的情况下，使用[]并不是一件好事。例如，也许您创建了一个无限循环，您可以使用args'作为递归参数来调用自己。类型检查员需要防止这种情况发生。

句法规则很简单＆＃34;并且在这种情况下不适用，即使递归是显而易见的＆＃34;在这种情况下，在结构上较小的组件上。所以你必须以一种更为复杂的方式说服typechecker，Program没问题。

也许其他人可以提供一种优雅的方式来做到这一点？我的第一次尝试是看this.GetComponent<Renderer>().enabled=true;是否处理了这个问题（但它并没有）。

无法猜测在Coq

2 个答案: