Question

我fold_length定义如下：

Inductive list (X: Type) : Type :=
  | nil : list X
  | cons : X -> list X -> list X.

Arguments nil {X}.
Arguments cons {X} _ _.

Notation "x :: y" := (cons x y)
                     (at level 60, right associativity).
Notation "[ ]" := nil.

Fixpoint fold {X Y:Type} (f: X -> Y -> Y) (l:list X) (b:Y) : Y :=
  match l with
  | nil => b
  | h :: t => f h (fold f t b)
  end.

Definition fold_length {X : Type} (l : list X) : nat :=
  fold (fun _ n => S n) l 0.

我必须证明一个定理，到目前为止这是我的代码：

Theorem fold_length_correct : forall X (l : list X),
  fold_length l = length l.
Proof.
  intros X l.
  induction l as [| n l' IHl'].
  - simpl.
    unfold fold_length.
    simpl.
    reflexivity.
  - simpl.
    unfold fold_length.
    simpl.

现在，我的目标看起来像这样：

  X : Type
  n : X
  l' : list X
  IHl' : fold_length l' = length l'
  ============================
   S (fold (fun (_ : X) (n0 : nat) => S n0) l' 0) = S (length l')

现在我想使用(fold (fun (_ : X) (n0 : nat) => S n0) l' 0)的定义将表达式fold_length l'转换为fold_length。有没有办法在Coq中做到这一点（在Coq中似乎有一些名为fold的战术。可以实现这一点。）？

另外，有没有办法在不使用unfold和fold策略的情况下证明上述定理？

Answer 1

要回答您的第一个问题，是的，fold策略可以在这里用S (fold_length l')替换等式的左侧。通常，对于函数f，fold f的功能不足以检测它可以折叠的内容。但是如果你指定整个术语，就像这里fold (fold_length l')一样，它就可以了。

关于您的第二个问题，请注意reflexivity或assumption等策略可以得出结论，如果所涉及的术语相当于一些简化。在这里，归纳的基本情况可以只是reflexivity。对于第二种情况，假设fold为List.fold_right，simpl可以令人惊讶地简化而不展开，您也不需要unfold或fold。

展开后向后折叠

1 个答案: